Rozpoznawanie mowy AI z użyciem TensorFlow Lite dla mikrokontrolerów i SparkFun Edge

1. Wprowadzenie

Co utworzysz

W tym ćwiczeniu w Codelabs nauczysz się używać TensorFlow Lite For Microcontrollers do uruchamiania modelu głębokiego uczenia na płytce deweloperskiej SparkFun Edge. Będziemy korzystać z wbudowanego w płytkę modelu wykrywania mowy, który używa konwolucyjnej sieci neuronowej do wykrywania słów „tak” i „nie” wypowiadanych przez 2 mikrofony płytki.

bf256d403a1821af.gif

Uczenie maszynowe na mikrokontrolerach

Systemy uczące się mogą być wykorzystywane do tworzenia inteligentnych narzędzi, które ułatwiają użytkownikom życie, takich jak Asystent Google. Często jednak wymagają one dużej mocy obliczeniowej lub zasobów, takich jak wydajny serwer w chmurze lub komputer stacjonarny. Obecnie można jednak uruchamiać wnioskowanie uczenia maszynowego na małych urządzeniach o niskim poborze mocy, takich jak mikrokontrolery.

Mikrokontrolery są bardzo popularne, tanie, wymagają bardzo mało energii i są bardzo niezawodne. Są one częścią różnego rodzaju urządzeń domowych, takich jak sprzęt AGD, samochody i zabawki. Każdego roku produkuje się około 30 miliardów urządzeń z mikrokontrolerami.

1360b61fbfa33657.jpeg

Dzięki zastosowaniu uczenia maszynowego w przypadku małych mikrokontrolerów możemy zwiększyć inteligencję miliardów urządzeń, których używamy w życiu codziennym, bez konieczności korzystania z drogiego sprzętu czy niezawodnych połączeń internetowych. Wyobraź sobie inteligentne urządzenia, które dostosowują się do Twojej codziennej rutyny, inteligentne czujniki przemysłowe, które odróżniają problemy od normalnej pracy, oraz magiczne zabawki, które pomagają dzieciom uczyć się w zabawny i przyjemny sposób.

TensorFlow Lite For Microcontrollers (Software)

358ffdb9eb758b90.png

TensorFlow to platforma uczenia maszynowego typu open source od Google, która służy do trenowania i uruchamiania modeli. TensorFlow Lite to platforma oprogramowania, zoptymalizowana wersja TensorFlow, przeznaczona do uruchamiania modeli TensorFlow na małych, stosunkowo słabych urządzeniach, takich jak telefony komórkowe.

TensorFlow Lite For Microcontrollers to platforma oprogramowania, zoptymalizowana wersja TensorFlow, która umożliwia uruchamianie modeli TensorFlow na małych, energooszczędnych urządzeniach, takich jak mikrokontrolery. Spełnia ona wymagania dotyczące tych środowisk wbudowanych, tzn.ma mały rozmiar binarny, nie wymaga obsługi systemu operacyjnego, żadnych standardowych bibliotek C ani C++ ani dynamicznej alokacji pamięci itp.

SparkFun Edge (sprzęt)

SparkFun Edge to platforma oparta na mikrokontrolerze, czyli mały komputer na jednej płytce drukowanej. Ma procesor, pamięć i sprzęt wejścia/wyjścia, który umożliwia wysyłanie i odbieranie sygnałów cyfrowych do innych urządzeń. Ma 4 diody LED sterowane oprogramowaniem w Twoich ulubionych kolorach Google.

aa4493835a2338c6.png

W przeciwieństwie do komputera mikrokontroler nie ma systemu operacyjnego. Zamiast tego napisane przez Ciebie programy działają bezpośrednio na sprzęcie. Kod piszesz na komputerze i pobierasz go na mikrokontroler za pomocą urządzenia zwanego programatorem.

Mikrokontrolery nie są wydajnymi komputerami. Mają one małe procesory i niewiele pamięci. Ponieważ są one zaprojektowane tak, aby były jak najprostsze, mikrokontroler może zużywać bardzo mało energii. W zależności od tego, co robi program, SparkFun Edge może działać przez kilka tygodni na jednej baterii pastylkowej.

Czego się nauczysz

  • Skompiluj przykładowy program dla SparkFun Edge na komputerze.
  • Wdrażanie programu na urządzeniu
  • Wprowadzanie zmian w programie i ponowne wdrażanie

Czego potrzebujesz

Potrzebujesz tych urządzeń:

Potrzebne będzie to oprogramowanie:

  • Git (sprawdź, czy jest zainstalowany, uruchamiając git w wierszu poleceń).
  • Python 3 (sprawdź, czy jest zainstalowany, uruchamiając polecenie python3 lub python --version w wierszu poleceń).
  • Pip dla Pythona 3 ( przydatna odpowiedź na StackOverflow)
  • Make w wersji 4.2.1 lub nowszej (sprawdź, czy jest zainstalowana, wpisując make --version w wierszu poleceń).
  • Sterowniki SparkFun Serial Basic

2. Konfigurowanie sprzętu

Mikrokontroler SparkFun Edge ma fabrycznie zainstalowany plik binarny, który może uruchamiać model mowy. Zanim zastąpimy go naszą wersją, najpierw uruchommy ten model.

Zasilanie tablicy:

  1. Włóż baterię pastylkową do złącza baterii z tyłu płytki (stroną „+” do góry). Jeśli bateria jest już włożona, wyjmij plastikową zakładkę i dopchnij baterię, aby upewnić się, że jest dobrze włożona.

25a6cc6b208e8a4e.png

  1. Jeśli nie masz baterii pastylkowej, możesz użyć programatora SparkFun USB-C Serial Basic do zasilania płytki. Aby przymocować to urządzenie do tablicy, wykonaj te czynności:
  • Znajdź 6-pinowe złącze z boku SparkFun Edge.
  • Podłącz SparkFun USB-C Serial Basic do tych pinów, upewniając się, że piny oznaczone jako „BLK” i „GRN” na każdym urządzeniu są prawidłowo ustawione.
  • Połącz SparkFun USB-C Serial Basic z komputerem za pomocą kabla USB-C.

b140822f0019f92a.png

Po włączeniu płytki przez włożenie baterii lub podłączenie programatora USB płytka zostanie wybudzona i zacznie nasłuchiwać za pomocą mikrofonów. Niebieskie światło powinno zacząć migać.

Model uczenia maszynowego na płytce jest trenowany pod kątem rozpoznawania słów „yes” i „no” oraz wykrywania obecności i braku mowy. Wyniki są sygnalizowane przez zapalanie kolorowych diod LED. W tabeli poniżej znajdziesz opis poszczególnych kolorów diody LED:

Wynik wykrywania

Kolor diody LED

„Tak”

Żółty

„Nie”

Czerwony

Nieznana mowa

Zielony

Nie wykryto mowy

Żadna dioda LED się nie świeci

Wypróbuj

Przytrzymaj tablicę przy ustach i kilka razy powiedz „tak”. Żółta dioda LED zacznie migać. Jeśli po wypowiedzeniu słowa „tak” nic się nie dzieje, spróbuj wykonać te czynności:

  • Trzymaj tablicę w odległości około 25 cm od ust.
  • Unikaj nadmiernego szumu w tle
  • Powtórz „tak” kilka razy z rzędu (spróbuj powiedzieć „tak tak tak”).

3. Konfigurowanie oprogramowania

Teraz pobierzemy, zainstalujemy i uruchomimy model mowy na mikrokontrolerze. W tym celu najpierw pobierzemy kod źródłowy tego programu i zależności potrzebne do jego skompilowania. Program jest napisany w języku C++, który przed pobraniem na płytkę musi zostać skompilowany do pliku binarnego. Plik binarny to plik zawierający program w formie, którą można uruchomić bezpośrednio na sprzęcie SparkFun Edge.

Poniższe instrukcje dotyczą systemów Linux i macOS.

Pobieranie repozytorium TensorFlow

Kod jest dostępny w repozytorium TensorFlow na GitHubie w tej lokalizacji:

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

Otwórz terminal na komputerze, przejdź do katalogu, w którym zwykle przechowujesz projekty związane z kodowaniem, pobierz repozytorium TensorFlow i otwórz utworzony katalog, jak pokazano poniżej:

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

Pobieranie zależności Pythona

Do przygotowania pliku binarnego i sflashowania go na urządzeniu użyjemy Pythona 3. Skrypty Pythona wymagają dostępności określonych bibliotek. Aby zainstalować te zależności, uruchom to polecenie:

pip3 install pycrypto pyserial --user

4. Tworzenie i przygotowywanie pliku binarnego

Skompilujemy plik binarny i uruchomimy polecenia, które przygotują go do pobrania na urządzenie.

Kompilowanie pliku binarnego

Aby pobrać wszystkie wymagane zależności i utworzyć plik binarny, uruchom to polecenie:

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

Jeśli kompilacja się powiedzie, ostatni wiersz danych wyjściowych powinien wyglądać tak:

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

Aby sprawdzić, czy plik binarny został utworzony, uruchom to polecenie:

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"

W konsoli powinna się wyświetlić wartość Binary was successfully created. Jeśli widzisz symbol Binary is missing, oznacza to, że wystąpił problem z procesem kompilacji, który wymaga debugowania.

Przygotowywanie pliku binarnego

Aby można było wdrożyć plik binarny na urządzeniu, musi on być podpisany kluczami kryptograficznymi. Teraz uruchomimy kilka poleceń, które podpiszą nasz plik binarny, aby można go było pobrać na SparkFun Edge.

Aby skonfigurować przykładowe klucze kryptograficzne, których możemy używać na potrzeby programowania, wpisz to polecenie:

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

Teraz uruchom to polecenie, aby utworzyć podpisany plik binarny:

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

Spowoduje to utworzenie pliku main_nonsecure_ota.bin. Teraz uruchomimy kolejne polecenie, aby utworzyć ostateczną wersję pliku, którego można użyć do flashowania urządzenia za pomocą skryptu programu rozruchowego, którego użyjemy w następnym kroku:

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

W katalogu, w którym zostały uruchomione polecenia, powinien pojawić się plik o nazwie main_nonsecure_wire.bin. To plik, który zostanie wgrany na urządzenie.

5. Przygotuj się na flashowanie pliku binarnego

Co to jest miganie?

SparkFun Edge przechowuje aktualnie uruchomiony program w 512 kilobajtach pamięci flash. Jeśli chcemy, aby płytka uruchomiła nowy program, musimy go do niej wysłać. Zostanie on zapisany w pamięci flash, zastępując poprzedni program.

Ten proces nazywa się „flashowaniem” i użyjemy go do przesłania programu na płytkę.

Podłączanie programatora do płytki

Do pobierania nowych programów na płytkę będziemy używać programatora szeregowego SparkFun USB-C Serial Basic. To urządzenie umożliwia komputerowi komunikację z mikrokontrolerem przez USB.

Aby przymocować to urządzenie do tablicy, wykonaj te czynności:

  1. Znajdź 6-pinowe złącze z boku SparkFun Edge.
  2. Podłącz SparkFun USB-C Serial Basic do tych pinów, upewniając się, że piny oznaczone jako „BLK” i „GRN” na każdym urządzeniu są prawidłowo ustawione.

b140822f0019f92a.png

Podłącz programator do komputera

Połączymy tablicę z komputerem za pomocą kabla USB. Aby zaprogramować tablicę, musimy znać nazwę, pod jaką urządzenie jest widoczne na komputerze. Najlepiej jest sporządzić listę wszystkich urządzeń komputera przed podłączeniem i po podłączeniu, a następnie sprawdzić, które urządzenie jest nowe.

Przed podłączeniem urządzenia przez USB uruchom to polecenie:

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

Powinna się wyświetlić lista podłączonych urządzeń podobna do tej:

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

Teraz podłącz programator do portu USB komputera. Ponownie wpisz to polecenie:

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

W danych wyjściowych powinien pojawić się dodatkowy element, jak w przykładzie poniżej. Nowy produkt może mieć inną nazwę. Nowy element to nazwa urządzenia.

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

Najpierw utworzymy zmienną środowiskową, która będzie zawierać nazwę urządzenia:

export DEVICENAME=put your device name here

Następnie utworzymy zmienną środowiskową, aby określić szybkość transmisji, czyli szybkość, z jaką dane będą wysyłane do urządzenia:

export BAUD_RATE=921600

6. Flashowanie pliku binarnego

Uruchom skrypt, aby flashować płytkę

Aby flashować płytę, musimy wprowadzić ją w specjalny stan „programu rozruchowego”, który przygotuje ją do otrzymania nowego pliku binarnego. Następnie uruchomimy skrypt, aby wysłać plik binarny na płytę.

Poznajmy te przyciski na tablicy:

64c620570b9d2f83.png

Aby zresetować i sflashować płytkę:

  1. Sprawdź, czy płytka jest podłączona do programatora, a cały zestaw jest połączony z komputerem przez USB.
  2. Zacznij od przytrzymania przycisku oznaczonego symbolem 14 na planszy. Przytrzymaj go do kroku 6.
  3. Nadal przytrzymując przycisk oznaczony symbolem 14, kliknij przycisk oznaczony symbolem RST, aby zresetować płytkę i przywrócić ją do stanu programu rozruchowego.
  4. Przytrzymując przycisk oznaczony symbolem 14, wklej w Terminalu to polecenie i naciśnij Enter, aby je uruchomić (dla wygody możesz wkleić to polecenie w Terminalu, zanim zaczniesz przytrzymywać przycisk, ale nie naciskaj Entera, dopóki nie przejdziesz do tego kroku).
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
  1. Przytrzymując przycisk oznaczony symbolem 14, zobaczysz na ekranie coś podobnego do tego:
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...]
  1. Przestań przytrzymywać przycisk oznaczony symbolem 14 na tablicy po zobaczeniu symbolu Sending Data Packet of length 8180 (ale możesz go nadal przytrzymywać). Program będzie nadal drukować wiersze na terminalu. Ostatecznie będzie wyglądać mniej więcej tak:
[...lots more Sending Data Packet of length  8180...]
Sending Data Packet of length  8180
Sending Data Packet of length  6440
Sending Reset Command.
Done.

Jeśli zobaczysz Done, oznacza to udane miganie. Jeśli wynik programu kończy się błędem, sprawdź, czy został wydrukowany znak Sending Reset Command. Jeśli tak, mimo błędu prawdopodobnie udało się przeprowadzić flashowanie.

Na komputerze z systemem Linux może pojawić się znak NoResponse Error. Dzieje się tak, ponieważ sterownik szeregowy ch34x został zainstalowany obok istniejącego sterownika szeregowego. Możesz to rozwiązać w ten sposób:

Krok 1. Zainstaluj ponownie prawidłową wersję biblioteki ch34x. Podczas instalacji urządzenie musi być odłączone od komputera.

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

Krok 2. Podłącz płytkę przez USB i uruchom:

dmesg | grep "ch34x"

Wyświetli się komunikat podobny do tego:

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

Jeśli używany sterownik nie jest sterownikiem „ch34x” (np. ch341), spróbuj wyłączyć inny sterownik, uruchamiając to polecenie:

rmmod <non-ch34x driver name>

Odłącz i ponownie podłącz urządzenie. Sprawdź, czy używany sterownik to „ch34x”.

7. Prezentacja

Wypróbuj program

Gdy płytka zostanie zaprogramowana, kliknij przycisk oznaczony .

RST, aby ponownie uruchomić tablicę i rozpocząć program. Jeśli niebieska dioda LED zacznie migać, instalacja się powiodła. Jeśli nie, przewiń w dół do sekcji „Co zrobić, jeśli to nie zadziała?”.

bf256d403a1821af.gif

Model uczenia maszynowego na płytce jest trenowany pod kątem rozpoznawania słów „yes” i „no” oraz wykrywania obecności i braku mowy. Wyniki są sygnalizowane przez diody LED w różnych kolorach. W tabeli poniżej znajdziesz opis poszczególnych kolorów diody LED:

Wynik wykrywania

Kolor diody LED

„Tak”

Żółty

„Nie”

Czerwony

Nieznana mowa

Zielony

Nie wykryto mowy

Żadna dioda LED się nie świeci

Wypróbuj

Przytrzymaj tablicę przy ustach i kilka razy powiedz „tak”. Żółta dioda LED zacznie migać. Jeśli po wypowiedzeniu słowa „tak” nic się nie dzieje, spróbuj wykonać te czynności:

  • Trzymaj tablicę w odległości około 25 cm od ust.
  • Unikaj nadmiernego szumu w tle
  • Powtórz „tak” kilka razy z rzędu (spróbuj powiedzieć „tak tak tak”).

Co zrobić, jeśli to nie zadziała?

Oto niektóre możliwe problemy i sposoby ich rozwiązywania:

Problem: po flashowaniu żadna dioda LED się nie włącza.

Rozwiązanie: spróbuj nacisnąć przycisk RST lub odłączyć i ponownie podłączyć płytkę do programatora. Jeśli żadna z tych czynności nie rozwiąże problemu, spróbuj ponownie wgrać oprogramowanie na płytkę.

Problem: niebieska dioda LED świeci, ale bardzo słabo.

Rozwiązanie: wymień baterię, ponieważ jest bliska wyczerpania. Płytę można też zasilać z komputera za pomocą programatora i kabla.

8. Odczytaj dane wyjściowe debugowania (opcjonalnie)

Zapoznaj się z tą sekcją, jeśli masz problemy i musisz szczegółowo debugować kod. Aby dowiedzieć się, co się dzieje na mikrokontrolerze podczas działania kodu, możesz wydrukować informacje na potrzeby debugowania za pomocą połączenia szeregowego płytki. Za pomocą komputera łączysz się z tablicą i wyświetlasz dane, które ona wysyła.

Otwieranie połączenia szeregowego

Domyślnie nasz przykładowy kod SparkFun Edge rejestruje wszystkie wypowiedziane polecenia wraz z ich wiarygodnością. Aby zobaczyć dane wyjściowe płytki, możesz uruchomić to polecenie:

screen ${DEVICENAME} 115200

Początkowo możesz zobaczyć dane wyjściowe podobne do tych poniżej (pojawiają się one tylko wtedy, gdy płytka zostanie zresetowana po podłączeniu; w przeciwnym razie możesz zacząć widzieć informacje o debugowaniu):

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Spróbuj wydać kilka poleceń, mówiąc „tak” lub „nie”. Dla każdego polecenia powinny być widoczne informacje o debugowaniu drukowania tablicy:

 Heard yes (202) @65536ms

W powyższym logu yes oznacza polecenie. Liczba 202 odnosi się do poziomu pewności, że polecenie zostało usłyszane (200 to minimum). 65536ms to czas, który upłynął od ostatniego zresetowania mikrokontrolera.

Aby przestać wyświetlać dane wyjściowe debugowania, naciśnij kolejno klawisze Ctrl+A, K i Y.

Zapisywanie dzienników debugowania

Kod, który rejestruje te informacje, znajdziesz w pliku command_responder.cc, z którym właśnie pracujesz:

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

Aby rejestrować dane, możesz wywołać metodę error_reporter->Report(). Obsługuje standardowe tokeny printf do interpolacji ciągów znaków, których możesz używać do umieszczania w logach ważnych informacji:

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

Ta metoda przyda Ci się, gdy w następnej sekcji będziesz wprowadzać własne zmiany w kodzie.

9. Przedłuż kod (opcjonalnie)

Teraz, gdy wiesz już, jak skompilować i flashować oprogramowanie na SparkFun Edge, możesz zacząć eksperymentować z kodem i wdrażać go na urządzeniu, aby zobaczyć wyniki.

Odczytaj kod

Dobrym miejscem na rozpoczęcie czytania kodu jest ten plik: command_responder.cc.

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

Plik możesz zobaczyć na GitHubie tutaj.

Metoda w tym pliku, RespondToCommand, jest wywoływana, gdy zostanie wykryte polecenie głosowe. Obecny kod włącza inną diodę LED w zależności od tego, czy usłyszano polecenie „tak”, „nie” czy nieznane. Poniższy fragment kodu pokazuje, jak to działa:

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);
}

Argument found_command zawiera nazwę wykrytego polecenia. Sprawdzając pierwszy znak, ten zestaw if instrukcji określa, która dioda LED ma się świecić.

Metoda RespondToCommand jest wywoływana z kilkoma argumentami:

void RespondToCommand(tflite::ErrorReporter* error_reporter,
    int32_t current_time, const char* found_command,
    uint8_t score, bool is_new_command) {
  • error_reporter służy do rejestrowania informacji na potrzeby debugowania (więcej informacji znajdziesz poniżej).
  • current_time oznacza czas wykrycia polecenia.
  • found_command informuje, które polecenie zostało wykryte.
  • score informuje nas, na ile jesteśmy pewni, że wykryliśmy polecenie.
  • is_new_command informuje nas, czy polecenie zostało usłyszane po raz pierwszy.

score to liczba całkowita z zakresu 0–255, która reprezentuje prawdopodobieństwo wykrycia polecenia. Przykładowy kod uznaje polecenie za prawidłowe tylko wtedy, gdy wynik jest większy niż 200. Z naszych testów wynika, że większość prawidłowych poleceń mieści się w zakresie 200–210.

Modyfikowanie kodu

Płytka SparkFun Edge ma 4 diody LED. Obecnie migamy niebieską diodą LED, aby wskazać, że trwa rozpoznawanie. Możesz to sprawdzić w pliku 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);
}

Mamy 4 diody LED, więc zmodyfikujmy program, aby używać ich jako wizualnego wskaźnika score danego polecenia. Niski wynik będzie oznaczał jedną zapaloną diodę LED, a rekord – kilka.

Aby mieć pewność, że program działa, zamiast niebieskiej diody LED będzie migać czerwona. Sąsiednie diody LED w kolorze niebieskim, zielonym i żółtym będą wskazywać siłę ostatniego score. Dla uproszczenia włączymy diody LED tylko wtedy, gdy zostanie wypowiedziane słowo „tak”. Jeśli zostanie wykryte inne słowo, diody LED zgasną.

Aby wprowadzić tę zmianę, zastąp cały kod w pliku command_responder.cc tym fragmentem:

#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);
      }
    }
  }
}

Jeśli zostanie wykryte nowe polecenie, wartość is_new_command będzie wynosić „true”. Wyłączymy diody LED niebieską, zieloną i żółtą, a następnie włączymy je ponownie w zależności od wartości found_command i score.

Ponowne tworzenie i flashowanie

Po wprowadzeniu zmian w kodzie przetestuj go, wykonując wszystkie czynności z sekcji Kompilowanie i przygotowywanie pliku binarnego.

10. Następne kroki

Gratulujemy! Udało Ci się utworzyć pierwszy detektor mowy na mikrokontrolerze.

Mamy nadzieję, że to krótkie wprowadzenie do programowania za pomocą TensorFlow Lite dla mikrokontrolerów było dla Ciebie przydatne. Koncepcja deep learningu na mikrokontrolerach jest nowa i ekscytująca, dlatego zachęcamy do eksperymentowania.

Dokumentacja

26699b18f2b199f.png

Dziękujemy i życzymy udanego budowania!