Pengenalan Ucapan AI dengan TensorFlow Lite untuk Microcontrollers dan SparkFun Edge

1. Pengantar

Yang akan Anda bangun

Dalam codelab ini, kita akan mempelajari cara menggunakan TensorFlow Lite untuk Mikrokontroler guna menjalankan model deep learning di SparkFun Edge Development Board. Kita akan menggunakan model deteksi ucapan bawaan board, yang menggunakan jaringan neural konvolusional untuk mendeteksi kata "ya" dan "tidak" yang diucapkan melalui dua mikrofon board.

Machine Learning di Microcontroller

Machine learning dapat digunakan untuk membuat alat cerdas yang mempermudah hidup pengguna, seperti Asisten Google. Namun, sering kali pengalaman ini memerlukan banyak komputasi atau resource yang dapat mencakup server cloud atau desktop yang canggih. Namun, sekarang inferensi machine learning dapat dijalankan di hardware kecil berdaya rendah, seperti mikrokontroler.

Mikrokontroler sangat umum, murah, memerlukan sangat sedikit energi, dan sangat andal. Chip ini merupakan bagian dari semua jenis perangkat rumah tangga: mulai dari peralatan, mobil, hingga mainan. Faktanya, sekitar 30 miliar perangkat yang ditenagai mikrokontroler diproduksi setiap tahun.

Dengan menghadirkan machine learning ke mikrokontroler kecil, kita dapat meningkatkan kecerdasan miliaran perangkat yang kita gunakan dalam hidup kita, tanpa mengandalkan hardware mahal atau koneksi internet yang andal. Bayangkan peralatan pintar yang dapat beradaptasi dengan rutinitas harian Anda, sensor industri cerdas yang dapat memahami perbedaan antara masalah dan operasi normal, serta mainan ajaib yang dapat membantu anak-anak belajar dengan cara yang menyenangkan dan menarik.

TensorFlow Lite untuk Mikrokontroler (Software)

TensorFlow adalah framework machine learning open source Google untuk melatih dan menjalankan model. TensorFlow Lite adalah framework software, versi TensorFlow yang dioptimalkan, yang ditujukan untuk menjalankan model TensorFlow di perangkat kecil yang relatif berdaya rendah seperti ponsel.

TensorFlow Lite untuk Mikrokontroler adalah framework software, versi TensorFlow yang dioptimalkan, yang ditujukan untuk menjalankan model TensorFlow di hardware kecil berdaya rendah seperti mikrokontroler. Library ini mematuhi batasan yang diperlukan di lingkungan sematan ini, yaitu memiliki ukuran biner yang kecil, tidak memerlukan dukungan sistem operasi, library C atau C++ standar, atau alokasi memori dinamis, dll.

SparkFun Edge (Hardware)

SparkFun Edge adalah platform berbasis mikrokontroler: komputer kecil pada satu papan sirkuit. Perangkat ini memiliki prosesor, memori, dan hardware I/O yang memungkinkannya mengirim dan menerima sinyal digital ke perangkat lain. Perangkat ini memiliki empat LED yang dapat dikontrol software, dalam warna Google favorit Anda.

Tidak seperti komputer, mikrokontroler tidak menjalankan sistem operasi. Sebagai gantinya, program yang Anda tulis berjalan langsung di hardware. Anda menulis kode di komputer dan mendownloadnya ke mikrokontroler melalui perangkat yang disebut programmer.

Mikrokontroler bukanlah komputer yang canggih. Perangkat ini memiliki prosesor kecil dan tidak banyak memori. Namun, karena didesain sesederhana mungkin, mikrokontroler dapat menggunakan sangat sedikit energi. Bergantung pada fungsi program Anda, SparkFun Edge dapat berjalan selama berminggu-minggu dengan satu baterai sel koin.

Yang akan Anda pelajari

Kompilasi program contoh untuk SparkFun Edge di komputer Anda
Men-deploy program ke perangkat Anda
Lakukan perubahan pada program dan deploy lagi

Yang Anda butuhkan

Anda akan memerlukan hardware berikut:

Komputer Linux atau MacOS
Board SparkFun Edge
Pemrogram SparkFun USB-C Serial Basic
Kabel USB-C ke USB-A (Jika Anda menggunakan komputer USB-C, dapatkan kabel USB-C ke USB-C)
(opsional) Baterai litium sel koin 3V 20 mm (CR2032) untuk menjalankan inferensi tanpa programmer dan kabel

Anda akan memerlukan software berikut:

Git (periksa apakah sudah diinstal dengan menjalankan git di command line)
Python 3 (periksa apakah sudah diinstal dengan menjalankan python3 atau python --version di command line)
Pip untuk Python 3 ( jawaban StackOverflow yang bermanfaat)
Make 4.2.1 atau yang lebih baru (periksa apakah sudah diinstal dengan menjalankan make --version di command line)
Driver SparkFun Serial Basic

2. Menyiapkan hardware

Mikrokontroler SparkFun Edge dilengkapi dengan biner yang telah diinstal sebelumnya yang dapat menjalankan model ucapan. Sebelum menimpanya dengan versi kita sendiri, mari kita jalankan model ini terlebih dahulu.

Aktifkan papan Anda dengan:

Memasukkan baterai sel koin ke konektor baterai di bagian belakang papan (dengan sisi "+" baterai menghadap ke atas. Jika board Anda dilengkapi dengan baterai yang sudah dimasukkan, tarik tab plastik, dan dorong baterai untuk memastikan baterai dimasukkan sepenuhnya)

Jika tidak memiliki baterai koin, Anda dapat menggunakan perangkat programmer SparkFun USB-C Serial Basic untuk memberi daya pada board. Untuk melampirkan perangkat ini ke papan, lakukan langkah-langkah berikut:

Temukan header enam pin di samping SparkFun Edge.
Colokkan SparkFun USB-C Serial Basic ke pin ini, pastikan pin berlabel "BLK" dan "GRN" di setiap perangkat sejajar dengan benar.
Hubungkan kabel USB-C antara SparkFun USB-C Serial Basic dan komputer Anda.

Setelah Anda mengaktifkan board dengan memasukkan baterai atau menghubungkan pemrogram USB, board akan aktif dan mulai mendengarkan dengan mikrofonnya. Lampu biru akan mulai berkedip.

Model machine learning di papan dilatih untuk mengenali kata "ya" dan "tidak", serta mendeteksi ada dan tidaknya ucapan. Hasilnya dikomunikasikan dengan menyalakan LED berwarna. Tabel berikut menunjukkan arti setiap warna LED:

Hasil deteksi	Warna LED
"Ya"	Kuning
"Tidak"	Merah
Ucapan tidak diketahui	Hijau
Tidak ada ucapan yang terdeteksi	Tidak ada LED yang menyala

Cobalah

Dekatkan papan ke mulut Anda dan ucapkan "ya" beberapa kali. Anda akan melihat LED kuning berkedip. Jika tidak ada yang terjadi saat Anda mengucapkan "ya", berikut beberapa hal yang dapat dicoba:

Pegang papan sekitar 25 cm dari mulut Anda
Hindari suara bising di latar belakang yang berlebihan
Ulangi "ya" beberapa kali secara berurutan dengan cepat (coba ucapkan "ya ya ya")

3. Menyiapkan software Anda

Sekarang kita akan mendownload, menginstal, dan menjalankan model ucapan di mikrokontroler sendiri. Untuk melakukannya, kita akan mendownload kode sumber untuk program ini dan dependensi yang diperlukan untuk membangunnya terlebih dahulu. Program ini ditulis dalam C++, yang harus dikompilasi menjadi biner sebelum didownload ke papan. Biner adalah file yang berisi program dalam bentuk yang dapat dijalankan langsung oleh hardware SparkFun Edge.

Petunjuk berikut ditulis untuk Linux atau MacOS.

Download repo TensorFlow

Kode tersedia di repositori TensorFlow di GitHub, di lokasi berikut:

https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro

Buka terminal di komputer Anda, ubah ke direktori tempat Anda biasanya menyimpan project coding, download repositori TensorFlow, lalu masukkan direktori yang dibuat, seperti yang ditunjukkan di bawah ini:

cd ~  # change into your home (or any other) directory
git clone --depth 1 https://github.com/tensorflow/tensorflow.git
cd tensorflow

Mendownload dependensi Python

Kita akan menggunakan Python 3 untuk menyiapkan biner dan mem-flash-nya ke perangkat. Skrip Python bergantung pada ketersediaan library tertentu. Jalankan perintah berikut untuk menginstal dependensi ini:

pip3 install pycrypto pyserial --user

4. Membangun dan menyiapkan biner

Kita akan membuat biner dan menjalankan perintah yang menyiapkannya untuk didownload ke perangkat.

Membangun biner

Untuk mendownload semua dependensi yang diperlukan dan membuat program biner, jalankan perintah berikut:

make -f tensorflow/lite/micro/tools/make/Makefile TARGET=sparkfun_edge micro_speech_bin

Jika build berhasil, baris terakhir output akan muncul seperti berikut:

arm-none-eabi-objcopy tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin -O binary

Untuk mengonfirmasi bahwa program biner berhasil dibuat, jalankan perintah berikut:

test -f \
tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin && \
 echo "Binary was successfully created" || echo "Binary is missing"

Anda akan melihat Binary was successfully created dicetak ke konsol. Jika Anda melihat Binary is missing, berarti ada masalah dengan proses build yang memerlukan proses debug.

Menyiapkan biner

Biner harus ditandatangani dengan kunci kriptografi agar dapat di-deploy ke perangkat. Sekarang kita akan menjalankan beberapa perintah yang akan menandatangani biner kita sehingga dapat didownload ke SparkFun Edge.

Masukkan perintah berikut untuk menyiapkan beberapa kunci kriptografi dummy yang dapat kita gunakan untuk pengembangan:

cp tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info0.py tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info.py

Sekarang, jalankan perintah berikut untuk membuat program biner bertanda tangan:

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_image_blob.py \
--bin tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin \
--load-address 0xC000 \
--magic-num 0xCB \
-o main_nonsecure_ota \
--version 0x0

Tindakan ini akan membuat file main_nonsecure_ota.bin. Sekarang kita akan menjalankan perintah lain untuk membuat versi akhir file yang dapat digunakan untuk mem-flash perangkat dengan skrip bootloader yang akan kita gunakan pada langkah berikutnya:

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_wireupdate_blob.py \
--load-address 0x20000 \
--bin main_nonsecure_ota.bin \
-i 6 \
-o main_nonsecure_wire \
--options 0x1

Sekarang Anda akan memiliki file bernama main_nonsecure_wire.bin di direktori tempat Anda menjalankan perintah. Ini adalah file yang akan kita flash ke perangkat.

5. Bersiap untuk mem-flash biner

Apa itu flashing?

SparkFun Edge menyimpan program yang sedang dijalankan dalam memori flash 512 kilobyte. Jika ingin menjalankan program baru, kita harus mengirimkannya ke board, yang akan menyimpannya dalam memori flash, menggantikan program yang sebelumnya disimpan.

Proses ini disebut "flashing", dan kita akan menggunakannya untuk mengirim program ke papan.

Hubungkan pemrogram ke board

Untuk mendownload program baru ke board, kita akan menggunakan pemrogram serial SparkFun USB-C Serial Basic. Perangkat ini memungkinkan komputer Anda berkomunikasi dengan mikrokontroler melalui USB.

Untuk melampirkan perangkat ini ke papan, lakukan langkah-langkah berikut:

Temukan header enam pin di samping SparkFun Edge.
Colokkan SparkFun USB-C Serial Basic ke pin ini, pastikan pin berlabel "BLK" dan "GRN" di setiap perangkat sejajar dengan benar.

Hubungkan pemrogram ke komputer Anda

Kita akan menghubungkan board ke komputer Anda melalui USB. Untuk memprogram board, kita perlu mengetahui nama yang diberikan komputer Anda ke perangkat. Cara terbaik untuk melakukannya adalah dengan mencantumkan semua perangkat komputer sebelum dan setelah menghubungkannya, lalu melihat perangkat mana yang baru.

Sebelum menghubungkan perangkat melalui USB, jalankan perintah berikut:

If you are using Linux: ls /dev/tty*
If you are using MacOS: ls /dev/cu*

Perintah ini akan menghasilkan daftar perangkat terhubung yang terlihat seperti berikut:

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.MALS
/dev/cu.SOC

Sekarang, hubungkan pemrogram ke port USB komputer Anda. Masukkan kembali perintah berikut:

If you are using Linux: ls /dev/tty*
If you are using MacOS: ls /dev/cu*

Anda akan melihat item tambahan di output, seperti dalam contoh di bawah. Item baru Anda mungkin memiliki nama yang berbeda. Item baru ini adalah nama perangkat.

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.MALS
/dev/cu.SOC
/dev/cu.wchusbserial-1450

Pertama, kita akan membuat variabel lingkungan untuk mengidentifikasi nama perangkat:

export DEVICENAME=put your device name here

Selanjutnya, kita akan membuat variabel lingkungan untuk menentukan kecepatan transfer data, yaitu kecepatan pengiriman data ke perangkat:

export BAUD_RATE=921600

6. Flash biner

Jalankan skrip untuk mem-flash board Anda

Untuk mem-flash board, kita harus memasukkannya ke status "bootloader" khusus yang mempersiapkannya untuk menerima biner baru. Kemudian, kita akan menjalankan skrip untuk mengirimkan biner ke board.

Mari kita kenali tombol-tombol berikut di papan:

Lakukan langkah-langkah berikut untuk mereset dan mem-flash board:

Pastikan board Anda terhubung ke programmer, dan seluruh penyiapan terhubung ke komputer Anda melalui USB.
Mulai menahan tombol yang ditandai 14 di papan. Terus tahan hingga Langkah 6.
Sambil tetap menahan tombol yang bertanda 14, untuk mereset board ke status bootloader, klik tombol yang bertanda RST untuk mereset board.
Sambil tetap menahan tombol yang bertanda 14, tempel perintah berikut ke terminal Anda, lalu tekan enter untuk menjalankannya (Untuk mempermudah, Anda dapat menempelkan perintah ini ke terminal sebelum mulai menahan tombol, tetapi jangan tekan enter hingga Anda mencapai langkah ini)

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/uart_wired_update.py -b ${BAUD_RATE} ${DEVICENAME} -r 1 -f main_nonsecure_wire.bin -i 6

Sambil tetap menahan tombol yang ditandai dengan 14, Anda akan melihat sesuatu seperti berikut muncul di layar:

Connecting with Corvette over serial port /dev/cu.usbserial-1440...
Sending Hello.
Received response for Hello
Received Status
length =  0x58
version =  0x3
Max Storage =  0x4ffa0
Status =  0x2
State =  0x7
AMInfo =
0x1
0xff2da3ff
0x55fff
0x1
0x49f40003
0xffffffff
[...lots more 0xffffffff...]
Sending OTA Descriptor =  0xfe000
Sending Update Command.
number of updates needed =  1
Sending block of size  0x158b0  from  0x0  to  0x158b0
Sending Data Packet of length  8180
Sending Data Packet of length  8180
[...lots more Sending Data Packet of length  8180...]

Berhenti menahan tombol yang bertanda 14 di papan setelah melihat Sending Data Packet of length 8180 (tetapi tidak masalah jika Anda terus menahannya). Program akan terus mencetak baris di terminal. Pada akhirnya akan terlihat seperti berikut:

[...lots more Sending Data Packet of length  8180...]
Sending Data Packet of length  8180
Sending Data Packet of length  6440
Sending Reset Command.
Done.

Jika Anda melihat Done, berarti berhasil berkedip. Jika output program berakhir dengan error, periksa apakah Sending Reset Command dicetak. Jika ya, flashing kemungkinan berhasil meskipun terjadi error.

Di mesin Linux, Anda mungkin mengalami NoResponse Error. Hal ini karena driver serial ch34x telah diinstal bersama dengan driver serial yang ada, yang dapat diselesaikan sebagai berikut:

Langkah 1: Instal ulang library ch34x versi yang benar. Pastikan perangkat dicabut dari komputer selama penginstalan.

git clone https://github.com/juliagoda/CH341SER.git
cd CH341SER/
make
sudo insmod ch34x.ko
sudo rmmod ch341

Langkah 2: Colokkan USB board dan jalankan:

dmesg | grep "ch34x"

Anda akan melihat pesan seperti ini:

[ 1299.444724]  ch34x_attach+0x1af/0x280 [ch34x]
[ 1299.445386] usb 2-13.1: ch34x converter now attached to ttyUSB0

Jika driver yang digunakan bukan "ch34x" (misalnya: ch341), coba nonaktifkan driver lain dengan menjalankan:

rmmod <non-ch34x driver name>

Cabut dan colokkan kembali perangkat, lalu pastikan driver yang digunakan adalah "ch34x".

7. Demo

Coba programnya

Setelah board Anda berhasil di-flash, tekan tombol yang bertanda

RST untuk memulai ulang papan dan memulai program. Jika LED biru mulai berkedip, flashing berhasil. Jika tidak, scroll ke bawah ke bagian "Bagaimana jika tidak berhasil?" di bawah.

Hasil deteksi	Warna LED
"Ya"	Kuning
"Tidak"	Merah
Ucapan tidak diketahui	Hijau
Tidak ada ucapan yang terdeteksi	Tidak ada LED yang menyala

Cobalah

Dekatkan papan ke mulut Anda dan ucapkan "ya" beberapa kali. Anda akan melihat LED kuning berkedip. Jika tidak ada yang terjadi saat Anda mengucapkan "ya", berikut beberapa hal yang dapat dicoba:

Pegang papan sekitar 25 cm dari mulut Anda
Hindari suara bising di latar belakang yang berlebihan
Ulangi "ya" beberapa kali secara berurutan dengan cepat (coba ucapkan "ya ya ya")

Bagaimana jika tidak berhasil?

Berikut adalah beberapa kemungkinan masalah dan cara men-debugnya:

Masalah: Setelah flashing, tidak ada LED yang menyala.

Solusi: Coba tekan tombol RST, atau putuskan sambungan dan sambungkan kembali board dari programmer. Jika tidak ada yang berhasil, coba flash ulang board.

Masalah: LED biru menyala, tetapi sangat redup.

Solusi: Ganti baterai karena sudah hampir habis. Atau, board dapat ditenagai oleh komputer menggunakan programmer dan kabel.

8. Baca output debug (opsional)

Tinjau bagian ini jika Anda mengalami masalah dan perlu men-debug kode secara mendetail. Untuk memahami apa yang terjadi di mikrokontroler saat kode Anda berjalan, Anda dapat mencetak informasi pen-debug-an melalui koneksi serial board. Anda menggunakan komputer untuk terhubung ke board dan menampilkan data yang dikirimkan board.

Membuka koneksi serial

Secara default, kode contoh SparkFun Edge kami mencatat perintah lisan apa pun, beserta tingkat keyakinannya. Untuk melihat output board, Anda dapat menjalankan perintah berikut:

screen ${DEVICENAME} 115200

Awalnya, Anda mungkin melihat output yang terlihat seperti berikut: (Output ini hanya muncul jika papan direset setelah terhubung, jika tidak, Anda mungkin mulai melihat informasi debug)

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Coba berikan beberapa perintah dengan mengucapkan "ya" atau "tidak". Anda akan melihat informasi debug pencetakan papan untuk setiap perintah:

 Heard yes (202) @65536ms

Dalam log di atas, yes merujuk pada perintah. Angka 202 mengacu pada tingkat keyakinan bahwa perintah didengar (dengan 200 sebagai minimum). Terakhir, 65536ms mengacu pada jumlah waktu yang telah berlalu sejak mikrokontroler terakhir direset.

Untuk berhenti melihat output debug, tekan Ctrl+A, segera diikuti dengan tombol K, lalu tekan tombol Y.

Menulis log debug

Anda dapat melihat kode yang mencatat informasi ini dalam file command_responder.cc yang baru saja Anda gunakan:

tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc

Untuk mencatat data, Anda dapat memanggil metode error_reporter->Report(). Objek ini mendukung token printf standar untuk interpolasi string, yang dapat Anda gunakan untuk menyertakan informasi penting dalam log Anda:

error_reporter->Report("Heard %s (%d) @%dms", found_command, score, current_time);

Metode ini akan berguna saat Anda membuat perubahan sendiri pada kode di bagian berikutnya.

9. Perluas kode (opsional)

Setelah mengetahui cara membuat dan mem-flash SparkFun Edge, Anda dapat mulai bereksperimen dengan kode dan men-deploy-nya ke perangkat untuk melihat hasilnya.

Membaca kode

Tempat yang tepat untuk mulai membaca kode adalah file berikut, command_responder.cc.

tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc

Anda dapat melihat file di GitHub di sini.

Metode dalam file ini, RespondToCommand, dipanggil saat perintah suara terdeteksi. Kode yang ada menyalakan LED yang berbeda, bergantung pada apakah perintah "ya", "tidak", atau perintah yang tidak diketahui terdengar. Cuplikan berikut menunjukkan cara kerjanya:

if (found_command[0] == 'y') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
if (found_command[0] == 'n') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
}
if (found_command[0] == 'u') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}

Argumen found_command berisi nama perintah yang terdeteksi. Dengan memeriksa karakter pertama, kumpulan pernyataan if ini menentukan LED mana yang akan menyala.

Metode RespondToCommand dipanggil dengan beberapa argumen:

void RespondToCommand(tflite::ErrorReporter* error_reporter,
    int32_t current_time, const char* found_command,
    uint8_t score, bool is_new_command) {

error_reporter digunakan untuk mencatat informasi debug (selengkapnya akan dibahas nanti).
current_time menunjukkan waktu saat perintah terdeteksi.
found_command memberi tahu kita perintah mana yang terdeteksi.
score memberi tahu kita seberapa yakin kita bahwa kita mendeteksi perintah.
is_new_command memberi tahu kita apakah ini pertama kalinya perintah didengar.

score adalah bilangan bulat dari 0-255 yang merepresentasikan probabilitas bahwa perintah terdeteksi. Contoh kode hanya menganggap perintah valid jika skornya lebih besar dari 200. Berdasarkan pengujian kami, sebagian besar perintah yang valid berada dalam rentang 200-210.

Ubah kode

Board SparkFun Edge memiliki empat LED. Saat ini, kami mengedipkan LED biru untuk menunjukkan bahwa pengenalan sedang terjadi. Anda dapat melihatnya di file command_responder.cc:

static int count = 0;

// Toggle the blue LED every time an inference is performed.
++count;
if (count & 1) {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
} else {
  am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
}

Karena kita memiliki empat LED, mari kita ubah program untuk menggunakannya sebagai indikator visual score dari perintah tertentu. Skor rendah akan menghasilkan satu LED yang menyala, dan skor tinggi akan menghasilkan beberapa lampu.

Untuk memastikan kita memiliki cara untuk mengetahui bahwa program sedang berjalan, kita akan membuat LED merah berkedip terus-menerus, bukan biru. LED biru, hijau, dan kuning yang berdekatan akan digunakan untuk menunjukkan kekuatan score terbaru kita. Untuk mempermudah, kita hanya akan menyalakan LED tersebut jika kata "ya" diucapkan. Jika kata lain terdeteksi, LED akan hilang.

Untuk melakukan perubahan ini, ganti semua kode dalam file command_responder.cc Anda dengan cuplikan berikut:

#include "tensorflow/lite/micro/examples/micro_speech/command_responder.h"

#include "am_bsp.h"

// This implementation will light up the LEDs on the board in response to different commands.
void RespondToCommand(tflite::ErrorReporter* error_reporter,
                      int32_t current_time, const char* found_command,
                      uint8_t score, bool is_new_command) {
  static bool is_initialized = false;
  if (!is_initialized) {
    // Setup LEDs as outputs
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_RED, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_BLUE, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_GREEN, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_YELLOW, g_AM_HAL_GPIO_OUTPUT_12);
    // Ensure all pins are cleared
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
    is_initialized = true;
  }
  static int count = 0;

   // Toggle the red LED every time an inference is performed.
   ++count;
   if (count & 1) {
     am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
   } else {
     am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
   }

  if (is_new_command) {
    // Clear the last three LEDs
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
    error_reporter->Report("Heard %s (%d) @%dms", found_command, score,
                           current_time);
    // Only indicate a 'yes'
    if (found_command[0] == 'y') {
      // Always light the blue LED
      am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
      // Light the other LEDs depending on score
      if (score >= 205) {
        am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
      }
      if(score >= 210) {
        am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
      }
    }
  }
}

Jika perintah baru terdeteksi, is_new_command akan bernilai benar (true). Kita akan mematikan LED biru, hijau, dan kuning, lalu menyalakannya kembali bergantung pada nilai found_command dan score.

Membangun ulang dan mem-flash

Setelah melakukan perubahan kode, uji dengan menjalankan semua langkah dari Build dan siapkan biner.

10. Langkah Berikutnya

Selamat, Anda telah berhasil membuat detektor ucapan pertama Anda di mikrokontroler.

Kami harap Anda menikmati pengantar singkat tentang pengembangan dengan TensorFlow Lite untuk Mikrokontroler ini. Ide deep learning pada mikrokontroler adalah hal baru dan menarik, dan kami mendorong Anda untuk bereksperimen.

Dokumen referensi

Latih model Anda sendiri untuk memahami berbagai perintah, setelah Anda memiliki pengalaman bekerja dengan program dasar. Catatan: Pelatihan akan memerlukan waktu beberapa jam.
Pelajari lebih lanjut TensorFlow Lite untuk Microcontroller ( Situs, GitHub).
Coba contoh lainnya dan coba jalankan di SparkFun Edge, jika didukung.
Lihat buku O'Reilly TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers, yang memperkenalkan machine learning di perangkat kecil dan membahas beberapa project menarik. Codelab ini didasarkan pada Bab 7 dan 8 buku tersebut.

Terima kasih, dan selamat membangun!