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

1. Wprowadzenie

Co utworzysz

W ramach tego ćwiczenia w programie nauczymy się używać TensorFlow Lite dla mikrokontrolerów do uruchomienia modelu deep learning na platformie SparkFun Edge Development Board. Będziemy pracować nad wbudowanym modelem wykrywania mowy na tablicy, który używa splotowej sieci neuronowej do wykrywania słów „tak”. i „nie” mówione przez dwa mikrofony na tablicy.

Systemy uczące się na mikrokontrolerach

Uczenie maszynowe można wykorzystać do tworzenia inteligentnych narzędzi, tak jak Asystent Google. Często jednak wymagają one dużych nakładów obliczeniowych lub zasobów, którymi może być potężny serwer w chmurze lub komputer. Jednak obecnie możliwe jest wnioskowanie przez systemy uczące się na małych urządzeniach o niskiej mocy, np. mikrokontrolerach.

Mikrokontrolery są niezwykle powszechne, tanie, bardzo niezawodne i wymagają niewiele energii. Są częścią wszelkiego rodzaju urządzeń domowych: urządzeń, samochodów i zabaw. Każdego roku produkowane jest około 30 miliardów urządzeń zasilanych z mikrokontrolerów.

Dzięki wprowadzeniu systemów uczących się w małych mikrokontrolerach możemy zwiększyć inteligencję miliardów urządzeń, których używamy w życiu, bez konieczności korzystania z drogiego sprzętu czy niezawodnego połączenia z internetem. Wyobraź sobie inteligentne urządzenia, które dostosowują się do codziennych czynności, inteligentne czujniki przemysłowe, które rozumieją różnice między problemami a normalnym działaniem, oraz magiczne zabawki, które pomagają dzieciom podczas nauki przez zabawny i przyjemny sposób.

TensorFlow Lite do mikrokontrolerów (oprogramowanie)

TensorFlow to opracowana przez Google platforma systemów uczących się typu open source do trenowania i uruchamiania modeli. TensorFlow Lite to platforma oprogramowania, zoptymalizowana wersja TensorFlow, przeznaczona do uruchamiania modeli Tensorflow na małych urządzeniach o słabej wydajności, takich jak telefony komórkowe.

TensorFlow Lite For Microcontrollers to platforma oprogramowania, zoptymalizowana wersja TensorFlow, przeznaczona do uruchamiania modeli Tensorflow na niewielkich urządzeniach o niskim poborze energii, takich jak mikrokontrolery. Jest ona zgodna z ograniczeniami wymaganymi w tych osadzonych środowiskach – ma mały rozmiar pliku binarnego, nie wymaga obsługi systemu operacyjnego, żadnych standardowych bibliotek C lub C++, dynamicznego przydzielania pamięci itp.

SparkFun Edge (sprzęt)

SparkFun Edge to platforma oparta na mikrokontrolerach – niewielki komputer na płycie obwodu drukowanego. Ma procesor, pamięć i sprzęt I/O, które pozwalają wysyłać sygnały cyfrowe do innych urządzeń i je odbierać. Ma 4 sterowane programowo diody LED w ulubionych kolorach Google.

W przeciwieństwie do komputera mikrokontroler nie obsługuje systemu operacyjnego. Zamiast tego napisane przez Ciebie programy są uruchamiane bezpośrednio na sprzęcie. Piszesz kod na komputerze i pobierasz go do mikrokontrolera za pomocą urządzenia zwanego programistą.

Mikrokontrolery nie są potężnymi komputerami. Mają małe procesory i małą pamięć. Zaprojektowano je tak, aby były jak najprostsze, dlatego mikrokontroler może zużywać bardzo mało energii. W zależności od tego, do czego służy Twój program, SparkFun Edge może pracować przez kilka tygodni na baterii guzikowej.

Czego się nauczysz

• Skompiluj na komputerze przykładowy program do SparkFun Edge
• Wdrażanie programu na urządzeniu
• Wprowadź zmiany w programie i wdróż go ponownie.

Czego potrzebujesz

Potrzebujesz tego sprzętu:

• Komputer z systemem Linux lub MacOS
• Tablica SparkFun Edge
• Programista SparkFun USB-C Serial Basic
• Kabel USB-C na USB-A (jeśli używasz komputera ze złączem USB-C, użyj kabla USB-C na USB-C).
• (Opcjonalnie) Bateria litowo-ogniwowa 3 V 20 mm (CR2032) do wnioskowania bez programisty i kabla

Potrzebujesz tego oprogramowania:

• Git (sprawdź, czy program jest zainstalowany, uruchamiając w wierszu poleceń git)
• Python 3 (sprawdź, czy jest zainstalowany, uruchamiając python3 lub python --version w wierszu poleceń)
• Pip dla Pythona 3 ( przydatna odpowiedź StackOverflow)
• Wersja 4.2.1 lub nowsza (sprawdź, czy aplikacja jest zainstalowana, uruchamiając make --version w wierszu poleceń)
• SparkFun Serial Basic sterowniki

2. Konfigurowanie sprzętu

Mikrokontroler SparkFun Edge ma fabrycznie zainstalowany plik binarny, który może uruchamiać model mowy. Zanim zastąpimy tę wersję własną wersją, uruchommy ten model.

Zasilanie planszy:

1. Włóż baterię guzikową do złącza baterii z tyłu płytki (stroną „+” skierowaną do góry. Jeśli bateria jest już włożona, wyjmij plastikowy pasek i pchnij baterię, aby mieć pewność, że jest całkowicie włożona).

Uwaga: tablica SparkFun Edge nie ma przełącznika, więc należy ją wyjąć, gdy nie jest używana. W tym celu użyj małego narzędzia, takiego jak długopis, ołówek lub szczypcem, aby wycisnąć baterię z łącznika. Uważaj, aby nie uszkodzić płytki i nie złączyć do siebie obu stron baterii.

2. Jeśli nie masz baterii na monety, do zasilania płytki możesz użyć programatora SparkFun USB-C Serial Basic. Aby podłączyć to urządzenie do tablicy, wykonaj te czynności:

• Znajdź 6-pinowy nagłówek z boku SparkFun Edge.
• Podłącz SparkFun USB-C Serial Basic do tych styków, upewniając się, że styki są oznaczone etykietą „BLK” i „GRN” na każdym urządzeniu są ułożone w odpowiednich miejscach.
• Podłącz kabel USB-C między urządzeniem SparkFun USB-C Serial Basic a komputerem.

Po podłączeniu płytki do zasilania przez włożenie baterii lub podłączenie programatora USB, płytka włączy się i zacznie nasłuchiwać przy użyciu mikrofonów. Niebieskie światło powinno zacząć migać.

Model systemów uczących się na tablicy został wytrenowany do rozpoznawania słów „tak” i „nie” oraz wykrywanie obecności i braku mowy. Informuje o wynikach za pomocą kolorowych diod LED. Tabela poniżej pokazuje znaczenie każdego koloru diody LED:

Wynik wykrywania	Kolor diody LED
„Tak”	Żółty
„Nie”	Czerwony
Nieznana mowa	Zielony
Nie wykryto mowy	Nie świecą się diody LED

Wypróbuj

Zbliż tablicę do ust i powiedz „tak” kilka razy. Dioda LED zacznie migać na żółto. Jeśli powiesz „tak”, nic się nie zmieni, wypróbuj te czynności:

• Trzymaj tablicę około 30 cm z ust
• Unikaj nadmiernego szumu w tle
• Powtórz „tak” kilka razy w krótkich odstępach (powiedz „tak, tak, tak”)

3. Konfigurowanie oprogramowania

Teraz sami pobierzemy, zainstalujemy i uruchomimy model mowy na mikrokontrolerze. W tym celu najpierw pobieramy kod źródłowy tego programu i zależności potrzebne do jego utworzenia. Program jest napisany w języku C++, który przed pobraniem na tablicę musi zostać skompilowany w plik binarny. Plik binarny to plik zawierający program w formacie, który może być uruchamiany bezpośrednio przez sprzęt 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 kodu, pobierz repozytorium TensorFlow i wprowadź 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

Pobierz zależności Pythona

Za pomocą języka Python 3 przygotujemy plik binarny i wgramy go na urządzeniu. Skrypty Pythona zależą od dostępności określonych bibliotek. Aby zainstalować te zależności, uruchom to polecenie:

pip3 install pycrypto pyserial --user

4. Kompilowanie i przygotowywanie pliku binarnego

Utworzymy plik binarny i uruchomimy polecenia przygotowujące 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ę uda, 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 powinien pojawić się numer Binary was successfully created. Jeśli widzisz komunikat Binary is missing, oznacza to, że wystąpił problem z procesem kompilacji, który wymaga debugowania.

Przygotowywanie pliku binarnego

Aby plik binarny został wdrożony na urządzeniu, musi być podpisany kluczami kryptograficznymi. Teraz uruchomimy kilka poleceń podpisujących plik binarny w celu pobrania go do SparkFun Edge.

Wpisz następujące polecenie, aby skonfigurować fikcyjne klucze kryptograficzne, których możemy użyć na potrzeby programowania:

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. Uruchomimy teraz kolejne polecenie, aby utworzyć ostateczną wersję pliku, której będzie można użyć do flashowania naszego urządzenia przy użyciu skryptu rozruchowego, który wykorzystamy 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 uruchamiano polecenia, powinien się teraz znajdować plik o nazwie main_nonsecure_wire.bin. To jest plik, który będziemy flashować na urządzeniu.

5. Przygotuj się do dodania pliku binarnego

Co to jest miganie?

SparkFun Edge przechowuje aktualnie uruchomiony program w pamięci flash o pojemności 512 kilobajtów. Jeśli chcemy uruchomić nowy program na tablicy, musimy go wysłać do płytki, która zapisze go w pamięci flash, zastępując dowolny wcześniej zapisany program.

Proces ten nazywa się „miganiem” i użyjemy go do przesłania naszego programu na tablicę.

Podłącz programator do tablicy

Aby pobrać nowe programy na płytkę, użyjemy programatora szeregowego SparkFun USB-C Serial Basic. To urządzenie umożliwia komunikowanie się komputera z mikrokontrolerem przez USB.

Aby podłączyć to urządzenie do tablicy, wykonaj te czynności:

1. Znajdź 6-pinowy nagłówek z boku SparkFun Edge.
2. Podłącz SparkFun USB-C Serial Basic do tych styków, upewniając się, że styki są oznaczone etykietą „BLK” i „GRN” na każdym urządzeniu są ułożone w odpowiednich miejscach.

Podłącz programator do komputera

Połączymy tablicę z Twoim komputerem przez USB. Aby zaprogramować tablicę, musimy znać nazwę nadaną urządzeniu przez komputer. W tym celu wymień wszystkie urządzenia przed i po podłączeniu komputera i sprawdź, które z nich są nowe.

Zanim podłączysz urządzenie przez USB, uruchom to polecenie:

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

To powinno spowodować wyświetlenie listy podłączonych urządzeń, która będzie wyglądać mniej więcej tak:

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

Podłącz programator do portu USB komputera. Wpisz ponownie 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, tak jak w przykładzie poniżej. Nowy produkt może mieć inną nazwę. Ten nowy element będzie nazwą urządzenia.

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

Uwaga: niektórzy użytkownicy zgłosili, że na liście znajdują się 2 urządzenia. Jeśli widzisz 2 urządzenia, właściwe będzie zaczynać się od liter „wch”, na przykład „/dev/wchusbserial-1450”.

Najpierw tworzymy zmienną środowiskową identyfikującą nazwę urządzenia:

export DEVICENAME=put your device name here

Uwaga: w tym przykładzie polecenie wygląda tak: export DEVICENAME=/dev/cu.wchusbserial-1450

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

export BAUD_RATE=921600

Uwaga: jeśli Twoja tablica SparkFun Edge dotarła do Ciebie podczas konferencji TensorFlow Dev Summit, to znaczy, że masz wczesną wersję sprzętu komunikacyjnego z inną szybkością transmisji bitów. Zamiast tego użyj tego polecenia:

export BAUD_RATE=115200

6. Zainstaluj plik binarny

Uruchom skrypt, aby załadować tablicę

Aby przeprowadzić aktualizację, musimy umieścić ją w specjalnym programie rozruchowym. który przygotowuje go do otrzymania nowego pliku binarnego. Następnie uruchomimy skrypt, który wyśle plik binarny na kartę.

Przyjrzyjmy się przyciskom na planszy:

Wykonaj następujące czynności, aby zresetować i zamontować tablicę:

1. Upewnij się, że Twoja płytka jest podłączona do programatora, a cała konfiguracja jest podłączona do komputera przez USB.
2. Zacznij, naciskając przycisk z oznaczeniem 14 na planszy. Przytrzymaj go do kroku 6.
3. Wciąż trzymając przycisk oznaczony jako 14, kliknij przycisk RST, aby przywrócić płytę do stanu programu rozruchowego i ją zresetować.
4. Nadal trzymając przycisk oznaczony jako 14, wklej poniższe polecenie w terminalu i naciśnij Enter, aby je uruchomić. Możesz je najpierw wkleić w terminalu, zanim zaczniesz przytrzymywać przycisk, ale nie naciskaj Enter, 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

5. Gdy wciąż przytrzymujesz przycisk oznaczony jako 14, na ekranie powinien wyświetlić się taki komunikat:

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...]

6. Zatrzymaj, przytrzymując przycisk oznaczony 14 na planszy po zobaczeniu Sending Data Packet of length 8180 (ale nie martw się, jeśli trzymasz ten przycisk). Program będzie nadal drukował na terminalu linie tekstu. 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 widzisz symbol Done, oznacza to, że miganie jest udało się. Jeśli dane wyjściowe programu kończą się błędem, sprawdź, czy dokument Sending Reset Command został wydrukowany. Jeśli tak, to prawdopodobnie udało się przeprowadzić aktualizację pomimo błędu.

Uwaga: te materiały są przeznaczone tylko dla użytkowników, którzy mają komputer z systemem Linux i nie mogli zaprogramować pamięci urządzenia. W przeciwnym razie przejdź do następnej sekcji.

Na komputerze z systemem Linux możesz zobaczyć plik NoResponse Error. Dzieje się tak, ponieważ sterownik szeregowy ch34x został zainstalowany wraz z istniejącym sterownikiem szeregowym. Problem ten można rozwiązać w ten sposób:

Krok 1. Ponownie zainstaluj prawidłową wersję biblioteki ch34x. Podczas instalacji upewnij się, że urządzenie jest 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łytę USB i uruchom:

dmesg | grep "ch34x"

Powinien 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 to „ch34x” (np. ch341) wyłącz drugi sterownik, uruchamiając polecenie:

rmmod <non-ch34x driver name>

Odłącz urządzenie i podłącz je ponownie, upewniając się, że używany jest sterownik „ch34x”.

7. Prezentacja

Wypróbuj program

Po pomyślnym zaprojektowaniu tablicy naciśnij przycisk oznaczony

RST, aby ponownie uruchomić tablicę i uruchomić program. Jeśli niebieska dioda LED zacznie migać, oznacza to, że to oznacza. Jeśli nie, przewiń w dół do sekcji „Co, jeśli to nie zadziała?” poniżej.

Model systemów uczących się na tablicy został wytrenowany do rozpoznawania słów „tak” i „nie” oraz wykrywanie obecności i braku mowy. Informuje o wynikach za pomocą kolorowych diod LED. Tabela poniżej pokazuje znaczenie każdego koloru diody LED:

Wynik wykrywania	Kolor diody LED
„Tak”	Żółty
„Nie”	Czerwony
Nieznana mowa	Zielony
Nie wykryto mowy	Nie świecą się diody LED

Wypróbuj

Zbliż tablicę do ust i powiedz „tak” kilka razy. Dioda LED zacznie migać na żółto. Jeśli powiesz „tak”, nic się nie zmieni, wypróbuj te czynności:

• Trzymaj tablicę około 30 cm z ust
• Unikaj nadmiernego szumu w tle
• Powtórz „tak” kilka razy w krótkich odstępach (powiedz „tak, tak, tak”)

Co zrobić, jeśli się nie udało?

Oto kilka możliwych problemów i sposoby ich debugowania:

Problem: po miganiu nie zapaliła się żadna z diod LED.

Rozwiązanie: naciśnij przycisk RST lub odłącz i ponownie podłącz tablicę od programatora. Jeśli żadne z tych rozwiązań nie zadziała, spróbuj ponownie przeprowadzić aktualizację tablicy.

Problem: niebieska dioda LED świeci się, ale jest bardzo przyciemniona.

Rozwiązanie: wymień baterię, ponieważ jest bliska wyczerpania. Płytkę można też zasilać przez komputer, korzystając z programu i kabla.

8. Odczytywanie danych wyjściowych debugowania (opcjonalnie)

Zapoznaj się z tą sekcją, jeśli napotkasz problemy i chcesz szczegółowo debugować kod. Aby zrozumieć, co dzieje się z mikrokontrolerem podczas uruchamiania kodu, możesz wydrukować informacje na potrzeby debugowania, korzystając z połączenia szeregowego płytki. Użyj komputera, aby połączyć się z płytką i wyświetlić przesyłane przez nią dane.

Otwieranie połączenia szeregowego

Domyślnie nasz przykładowy kod SparkFun Edge rejestruje wszystkie polecenia głosowe wraz z ich poziomem ufności. Aby wyświetlić dane wyjściowe tablicy, możesz uruchomić to polecenie:

screen ${DEVICENAME} 115200

Dane wyjściowe mogą wyglądać mniej więcej tak:

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Powiedz „tak”, aby wydać polecenia lub „nie”. W przypadku każdego polecenia powinny wyświetlić się informacje o debugowaniu drukowania tablicy:

 Heard yes (202) @65536ms

W powyższym dzienniku yes odnosi się do polecenia. Liczba 202 oznacza poziom pewności, że polecenie zostało usłyszane (minimalna wartość 200). 65536ms oznacza czas, który upłynął od ostatniego resetowania mikrokontrolera.

Aby zatrzymać wyświetlanie danych wyjściowych debugowania, naciśnij Ctrl+A, bezpośrednio po tym klawiszu K, a następnie naciśnij klawisz Y.

Zapisywanie dzienników debugowania

Kod, który rejestruje te informacje, znajdziesz w używanym przed chwilą pliku Command_responder.cc:

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

Aby zapisać dane, możesz wywołać metodę error_reporter->Report(). Obsługuje standardowe tokeny printf na potrzeby interpolacji ciągów znaków, dzięki czemu możesz umieścić ważne informacje w dziennikach:

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

Metoda ta może być przydatna podczas wprowadzania własnych zmian w kodzie opisanych w następnej sekcji.

9. Rozszerz kod (opcjonalnie)

Wiesz już, jak utworzyć i zainstalować SparkFun Edge, więc możesz zacząć zabawę z kodem i wdrażać go na urządzeniu, aby zobaczyć wyniki.

Odczytywanie kodu

Dobrym miejscem na odczytanie kodu jest następujący plik: command_responder.cc.

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

Ten plik znajdziesz w GitHubie tutaj.

Metoda zawarta w tym pliku (RespondToCommand) jest wywoływana po wykryciu polecenia głosowego. Dotychczasowy kod włącza inną diodę LED w zależności od tego, czy słyszysz „tak”, „nie” lub jakieś nieznane polecenie. 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. Po zaznaczeniu pierwszego znaku ten zestaw instrukcji if określa, którą dioda LED ma zapalić.

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 o debugowaniu (więcej na ten temat później).
• current_time wskazuje godzinę wykrycia polecenia.
• found_command informuje, które polecenie zostało wykryte.
• score informuje o naszej pewności, że wykryliśmy polecenie.
• is_new_command informuje nas, czy to polecenie słyszy po raz pierwszy.

score jest liczbą całkowitą z zakresu od 0 do 255, która wskazuje 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łyta SparkFun Edge ma 4 diody LED. Obecnie miga na niebiesko, aby wskazać, że proces rozpoznawania jest włączony. W pliku command_responder.cc znajdziesz te informacje:

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

Ponieważ mamy bank 4 diod LED, zmodyfikujmy program, aby używać ich jako wizualnego wskaźnika score danego polecenia. Niski wynik oznacza jedną zapaloną diodę LED, a wysoki wynik – kilka świateł.

Aby mieć pewność, że program działa, będziemy migać na czerwono zamiast na niebiesko. Sąsiadujące ze sobą diody LED (niebieskie, zielone i żółte) pokazują siłę naszego ostatniego urządzenia score. Dla uproszczenia będziemy zapalać te diody tylko wtedy, gdy zgodzimy się z wyrazem „Tak”. jest wypowiadana. 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, is_new_command ma wartość true (prawda). Usuniemy niebieskie, zielone i żółte diody LED, a następnie ponownie je oświetlimy w zależności od wartości found_command i score.

Odbudowywanie i flashowanie

Gdy wprowadzisz zmiany w kodzie, przetestuj go, wykonując wszystkie kroki z sekcji Kompilowanie i przygotowywanie pliku binarnego.

10. Następne kroki

Gratulacje, udało Ci się zbudować pierwszy wykrywacz mowy z mikrokontrolerem.

Mamy nadzieję, że podobało Ci się to krótkie wprowadzenie do programowania z użyciem TensorFlow Lite dla mikrokontrolerów. Idea deep learning na mikrokontrolerach jest nowa i ekscytująca, dlatego zachęcamy do eksperymentowania.

Dokumentacja

• Teraz, gdy masz już doświadczenie w pracy z podstawowym programem, wytrenuj własny model, aby rozumieć różne polecenia. Uwaga: szkolenie potrwa kilka godzin.
• Dowiedz się więcej o TensorFlow Lite dla mikrokontrolerów ( strona internetowa, GitHub).
• Wypróbuj inne przykłady i uruchom je w SparkFun Edge, jeśli są obsługiwane.
• Zapoznaj się z książką O'Reilly TinyML: Machine Learning with TensorFlow na Arduino i mikrokontrolerami o bardzo małej mocyTinyML, która przedstawia systemy uczące się na małych urządzeniach i przedstawia kilka ciekawych projektów. To ćwiczenie w Codelabs opiera się na rozdziałach 7 i 8 książki.

Dziękujemy i życzymy udanej zabawy podczas budowania!