KI-Spracherkennung mit TensorFlow Lite für Mikrocontroller und SparkFun Edge

1. Einführung

Inhalt

In diesem Codelab lernen Sie, wie Sie mit TensorFlow Lite für Mikrocontroller ein Deep-Learning-Modell auf dem SparkFun Edge Development Board ausführen. Wir arbeiten mit dem integrierten Spracherkennungsmodell des Boards, das ein Convolutional Neural Network nutzt, um die Wörter „Ja“ zu erkennen. und „nein“ über die beiden Mikrofone der Tafel gesprochen.

Maschinelles Lernen auf Mikrocontrollern

Mit Machine Learning können Sie intelligente Tools entwickeln, den Alltag zu erleichtern, wie Google Assistant. Oft erfordern diese Anwendungen jedoch einen hohen Rechen- oder Ressourcenaufwand, beispielsweise mit einem leistungsstarken Cloud-Server oder einem Desktop-Computer. Es ist jedoch jetzt möglich, Inferenzen für maschinelles Lernen auf winziger, schwächerer Hardware wie Mikrocontrollern auszuführen.

Mikrocontroller sind äußerst gängig, kostengünstig, benötigen sehr wenig Energie und sind sehr zuverlässig. Sie gehören zu den verschiedensten Haushaltsgeräten: beispielsweise Haushaltsgeräte, Autos und Spielzeug. Jedes Jahr werden rund 30 Milliarden mikrocontrollerbasierte Geräte hergestellt.

Durch die Einführung von maschinellem Lernen in winzigen Mikrocontrollern können wir die Intelligenz von Milliarden von Geräten verbessern, die wir täglich nutzen, ohne auf teure Hardware oder zuverlässige Internetverbindungen angewiesen zu sein. Stellen Sie sich intelligente Geräte vor, die sich Ihrem Tagesablauf anpassen, intelligente Industriesensoren, die den Unterschied zwischen Problemen und dem normalen Betrieb erkennen, und magisches Spielzeug, das Kindern auf unterhaltsame und unterhaltsame Weise beim Lernen hilft.

TensorFlow Lite für Mikrocontroller (Software)

TensorFlow ist das Open-Source-Framework für maschinelles Lernen von Google zum Trainieren und Ausführen von Modellen. TensorFlow Lite ist ein Software-Framework, eine optimierte Version von TensorFlow, die darauf abzielt, Tensorflow-Modelle auf kleinen Geräten mit relativ geringer Leistung wie Smartphones auszuführen.

TensorFlow Lite For Microcontrollers ist ein Software-Framework, eine optimierte Version von TensorFlow, mit der Tensorflow-Modelle auf winziger, schwächerer Hardware wie Mikrocontrollern ausgeführt werden können. Es hält die in diesen eingebetteten Umgebungen erforderlichen Beschränkungen ein, d. h., es hat eine geringe Binärgröße, benötigt keine Betriebssystemunterstützung, Standard-C- oder C++-Bibliotheken, dynamische Speicherzuweisung usw.

SparkFun Edge (Hardware)

SparkFun Edge ist eine auf Mikrocontrollern basierende Plattform: ein winziger Computer mit nur einer Leiterplatte. Er verfügt über einen Prozessor, Arbeitsspeicher und eine E/A-Hardware, mit der er digitale Signale an andere Geräte senden und von diesen empfangen kann. Es verfügt über vier über Software gesteuerte LEDs in Ihren Lieblingsfarben von Google.

Im Gegensatz zu einem Computer führt ein Mikrocontroller kein Betriebssystem aus. Stattdessen werden die von Ihnen geschriebenen Programme direkt auf der Hardware ausgeführt. Sie schreiben Ihren Code auf einem Computer und laden ihn über ein Gerät, einen sogenannten Programmierer, auf den Mikrocontroller herunter.

Mikrocontroller sind keine leistungsfähigen Computer. Sie haben kleine Prozessoren und wenig Arbeitsspeicher. Da sie jedoch so einfach wie möglich konzipiert sind, verbraucht ein Mikrocontroller nur wenig Energie. Je nachdem, was Ihr Programm tut, kann SparkFun Edge wochenlang mit einer einzigen Knopfzelle ausgeführt werden!

Aufgaben in diesem Lab

• Kompilieren Sie das Beispielprogramm für SparkFun Edge auf Ihrem Computer
• Programm auf deinem Gerät bereitstellen
• Nehmen Sie Änderungen am Programm vor und stellen Sie es noch einmal bereit.

Voraussetzungen

Sie benötigen die folgende Hardware:

• Linux- oder MacOS-Computer
• SparkFun Edge-Board
• SparkFun USB-C Serial Basic-Programmierer
• USB-C-auf-USB-A-Kabel (Wenn Sie einen USB-C-Computer verwenden, nutzen Sie stattdessen das USB-C-auf-USB-C-Kabel)
• Optional: 3 V, 20 mm Knopfzelle Lithiumbatterie (CR2032), um Inferenz ohne Programmierer und Kabel auszuführen

Sie benötigen dafür folgende Software:

• Git (überprüfen Sie, ob es installiert ist, indem Sie git in der Befehlszeile ausführen)
• Python 3 (überprüfen Sie, ob es installiert ist, indem Sie python3 oder python --version in der Befehlszeile ausführen)
• Pip für Python 3 ( hilfreiche StackOverflow-Antwort)
• Entwickeln Sie 4.2.1 oder höher (prüfen Sie, ob es installiert ist, indem Sie make --version in der Befehlszeile ausführen).
• SparkFun Serial Basic-Treiber

2. Hardware einrichten

Der SparkFun Edge-Mikrocontroller wird mit einem vorinstallierten Binärprogramm geliefert, mit dem das Sprachmodell ausgeführt werden kann. Bevor wir dies mit unserer eigenen Version überschreiben, führen wir dieses Modell zuerst aus.

So kannst du dein Board mit Strom versorgen:

1. Stecken Sie eine Knopfzelle in den Anschlussstecker für die Batterie auf der Rückseite der Platine (mit der „+“-Seite der Batterie nach oben). Wenn im Lieferumfang Ihres Boards bereits eine Batterie eingelegt ist, ziehen Sie die Plastiklasche heraus und drücken Sie die Batterie, um sicherzustellen, dass sie vollständig eingelegt ist.)

Hinweis:Das SparkFun Edge-Board hat keinen Aus-Schalter. Daher sollten Sie den Akku bei Nichtgebrauch herausnehmen, um die Akkulaufzeit zu verlängern. Verwende dazu ein kleines Hilfsmittel wie einen Stift, einen Bleistift oder eine Pinzette, um den Akku aus dem Anschluss herauszuholen. Achte darauf, die Platine nicht zu beschädigen und die beiden Seiten der Batterie nicht zu verkürzen.

2. Wenn Sie keine Knopfzelle haben, können Sie die Karte mit dem Programmiergerät „SparkFun USB-C Serial Basic“ mit Strom versorgen. Führe die folgenden Schritte aus, um dieses Gerät an das Board zu befestigen:

• Suchen Sie die sechs Pin-Kopfzeilen an der Seite der SparkFun Edge.
• Stecken Sie die SparkFun USB-C Serial Basic in diese Pins. Achten Sie dabei darauf, dass die Pins mit „BLK“ gekennzeichnet sind. und „GRN“ auf jedem Gerät richtig ausgerichtet sind.
• Schließen Sie ein USB-C-Kabel zwischen dem SparkFun USB-C Serial Basic und Ihrem Computer an.

Sobald Sie Ihr Board durch Einlegen der Batterie oder das Anschließen des USB-Programmierprogramms mit Strom versorgt haben, wird das Board aktiviert und beginnt mit der Erfassung der Mikrofone. Das blaue Licht sollte zu blinken beginnen.

Das Modell für maschinelles Lernen auf dem Board ist darauf trainiert, die Wörter „Ja“ zu erkennen. und „Nein“ und um das Vorhandensein und Fehlen von Sprache zu erkennen. Die Ergebnisse werden durch das Anleuchten farbiger LEDs kommuniziert. In der folgenden Tabelle sehen Sie die Bedeutung der einzelnen LED-Farben:

Ergebnis der Erkennung	LED-Farbe
"Ja"	Gelb
"Nein"	Rot
Unbekannte Sprachausgabe	Grün
Keinen gesprochenen Text erkannt	Keine LEDs leuchten

Probieren Sie es aus!

Halte das Spielbrett vor den Mund und sag „Ja“ mehrere Male. Die gelbe LED blinkt. Wenn nichts passiert, wenn Sie „Ja“ sagen, probieren Sie Folgendes:

• Halte das Spiel ungefähr 10" aus deinem Mund
• Übermäßige Hintergrundgeräusche vermeiden
• „Ja“ wiederholen mehrmals hintereinander (versuchen Sie, „Ja, ja, ja“ zu sagen).

3. Software einrichten

Jetzt laden wir das Sprachmodell auf dem Mikrocontroller herunter, installieren es und führen es aus. Dazu laden wir zuerst den Quellcode für dieses Programm und die Abhängigkeiten herunter, die wir zu dessen Erstellung benötigen. Das Programm ist in C++ geschrieben, das vor dem Download auf das Board in ein Binärprogramm kompiliert werden muss. Eine Binärdatei ist eine Datei, die das Programm in einer Form enthält, die direkt von der SparkFun Edge-Hardware ausgeführt werden kann.

Die folgende Anleitung bezieht sich auf Linux und MacOS.

TensorFlow-Repository herunterladen

Der Code ist im TensorFlow-Repository auf GitHub unter folgendem Pfad verfügbar:

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

Öffnen Sie ein Terminal auf Ihrem Computer, wechseln Sie zu einem Verzeichnis, in dem Sie normalerweise Codierungsprojekte speichern, laden Sie das TensorFlow-Repository herunter und geben Sie das erstellte Verzeichnis ein, wie unten gezeigt:

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

Python-Abhängigkeiten herunterladen

Wir verwenden Python 3, um unser Binärprogramm vorzubereiten und es auf das Gerät zu flashen. Für die Python-Skripts müssen bestimmte Bibliotheken verfügbar sein. Führen Sie den folgenden Befehl aus, um diese Abhängigkeiten zu installieren:

pip3 install pycrypto pyserial --user

4. Binärprogramm erstellen und vorbereiten

Wir erstellen die Binärdatei und führen Befehle aus, die sie für den Download auf das Gerät vorbereiten.

Binärprogramm erstellen

Führen Sie den folgenden Befehl aus, um alle erforderlichen Abhängigkeiten herunterzuladen und die Binärdatei zu erstellen:

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

Wenn der Build erfolgreich funktioniert, sollte die letzte Zeile der Ausgabe so aussehen:

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

Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Binärdatei erfolgreich erstellt wurde:

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"

Binary was successfully created sollte in der Konsole angezeigt werden. Wenn Binary is missing angezeigt wird, ist ein Problem mit dem Build-Prozess aufgetreten, das ein Debugging erfordert.

Binärprogramm vorbereiten

Die Binärdatei muss mit kryptografischen Schlüsseln signiert sein, damit sie auf dem Gerät bereitgestellt werden kann. Wir führen nun einige Befehle aus, die unsere Binärdatei signieren, damit sie in den SparkFun Edge heruntergeladen werden kann.

Geben Sie den folgenden Befehl ein, um einige kryptografische Dummy-Schlüssel einzurichten, die wir für die Entwicklung verwenden können:

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

Führen Sie nun den folgenden Befehl aus, um eine signierte Binärdatei zu erstellen:

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

Dadurch wird die Datei main_nonsecure_ota.bin erstellt. Jetzt führen wir einen weiteren Befehl aus, um eine endgültige Version der Datei zu erstellen, die zum Flashen unseres Geräts mit dem Bootloader-Skript verwendet werden kann, das wir im nächsten Schritt verwenden:

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

Sie sollten jetzt eine Datei namens main_nonsecure_wire.bin in dem Verzeichnis haben, in dem Sie die Befehle ausgeführt haben. Diese Datei wird auf das Gerät geflasht.

5. Bereiten Sie sich auf das Flashen des Binärprogramms vor.

Was bedeutet Blinken?

SparkFun Edge speichert das aktuell ausgeführte Programm in seinem 512 Kilobyte großen Flash-Speicher. Wenn das Board ein neues Programm ausführen soll, müssen wir es an das Board senden, das es im Flash-Speicher speichert und jedes zuvor gespeicherte Programm überschreibt.

Dieser Prozess wird als „Flashing“ bezeichnet und wird verwendet, um unser Programm an den Board zu senden.

Programmierer an die Platine anschließen

Zum Herunterladen neuer Programme auf das Board verwenden wir den seriellen Programmierer SparkFun USB-C Serial Basic. Dieses Gerät ermöglicht Ihrem Computer die Kommunikation mit dem Mikrocontroller über USB.

Führe die folgenden Schritte aus, um dieses Gerät an das Board zu befestigen:

1. Suchen Sie die sechs Pin-Kopfzeilen an der Seite der SparkFun Edge.
2. Stecken Sie die SparkFun USB-C Serial Basic in diese Pins. Achten Sie dabei darauf, dass die Pins mit „BLK“ gekennzeichnet sind. und „GRN“ auf jedem Gerät richtig ausgerichtet sind.

Programmierer an Ihren Computer anschließen

Wir werden das Board über USB mit deinem Computer verbinden. Zur Programmierung des Boards benötigen wir den Namen, den Ihr Computer dem Gerät gibt. Am besten listen Sie vor und nach dem Anschließen alle Geräte des Computers auf und prüfen, welches Gerät neu ist.

Führen Sie den folgenden Befehl aus, bevor Sie das Gerät über USB anschließen:

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

Daraufhin wird eine Liste der angeschlossenen Geräte ausgegeben, die in etwa so aussieht:

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

Schließe jetzt den Programmierer an den USB-Anschluss des Computers an. Geben Sie den folgenden Befehl noch einmal ein:

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

In der Ausgabe sollte wie im Beispiel unten ein zusätzliches Element angezeigt werden. Dein neuer Artikel hat möglicherweise einen anderen Namen. Das neue Element ist der Name des Geräts.

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

Hinweis:Einige Nutzer haben gemeldet, dass zwei Geräte in der Liste angezeigt werden. Wenn du zwei Geräte siehst, beginnt das richtige Gerät mit den Buchstaben „wch“, z. B. „/dev/wchusbserial-1450“.

Zuerst erstellen wir eine Umgebungsvariable, um den Gerätenamen zu identifizieren:

export DEVICENAME=put your device name here

Hinweis: In diesem Beispiel lautet der Befehl: export DEVICENAME=/dev/cu.wchusbserial-1450

Als Nächstes erstellen wir eine Umgebungsvariable, um die Baudrate anzugeben, also die Geschwindigkeit, mit der Daten an das Gerät gesendet werden:

export BAUD_RATE=921600

Hinweis:Wenn Sie Ihr SparkFun Edge-Board auf der TensorFlow Dev Summit-Konferenz erhalten haben, verfügen Sie über eine frühe Version der Hardware, die über eine andere Baudrate kommuniziert. Verwenden Sie stattdessen den folgenden Befehl:

export BAUD_RATE=115200

6. Binärprogramm flashen

Skript ausführen, um das Board zu flashen

Um das Board zu flashen, müssen wir es in einen speziellen Bootloader laden. , der ihn auf den Empfang der neuen Binärdatei vorbereitet. Wir führen dann ein Skript aus, um die Binärdatei an das Board zu senden.

Machen wir uns mit den folgenden Schaltflächen auf dem Board vertraut:

Führen Sie die folgenden Schritte aus, um die Karte zurückzusetzen und zu blinken:

1. Achten Sie darauf, dass die Karte mit der Programmiereinheit und das gesamte Setup über USB mit Ihrem Computer verbunden ist.
2. Starten: Halten Sie die Taste 14 auf dem Board gedrückt. Halten Sie sie bis zu Schritt 6 gedrückt.
3. Halten Sie die Taste 14 weiterhin gedrückt. Um das Board in seinen Bootloader-Status zurückzusetzen, klicken Sie auf die Schaltfläche RST, um das Board zurückzusetzen.
4. Halten Sie die Taste 14 gedrückt, fügen Sie den folgenden Befehl in Ihr Terminal ein und drücken Sie die Eingabetaste, um ihn auszuführen. Sie können diesen Befehl in Ihr Terminal einfügen, bevor Sie die Taste gedrückt halten, aber die Eingabetaste erst drücken, wenn Sie diesen Schritt erreicht haben.

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. Wenn Sie die Schaltfläche 14 weiterhin gedrückt halten, sollten Sie jetzt auf dem Bildschirm Folgendes sehen:

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. Stoppen Sie das Halten der Taste 14 auf dem Board, nachdem Sie Sending Data Packet of length 8180 gesehen haben. Es ist aber in Ordnung, wenn Sie die Taste weiterhin gedrückt halten. Das Programm druckt weiterhin Zeilen am Terminal aus. Das Ergebnis sieht dann in etwa so aus:

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

Wenn Done angezeigt wird, bedeutet das, dass das Blinken erfolgreich war. Wenn die Programmausgabe mit einem Fehler endet, prüfen Sie, ob Sending Reset Command gedruckt wurde. Falls ja, war das Blinken trotz des Fehlers wahrscheinlich erfolgreich.

Hinweis:Der folgende Inhalt richtet sich nur an Nutzer, die einen Linux-Computer haben und das Gerät nicht flashen konnten. Fahren Sie andernfalls mit dem nächsten Abschnitt fort.

Auf einem Linux-Computer wird möglicherweise ein NoResponse Error angezeigt. Das liegt daran, dass der serielle ch34x-Treiber zusammen mit dem vorhandenen seriellen Treiber installiert wurde, der wie folgt aufgelöst werden kann:

Schritt 1: Installieren Sie die korrekte Version der ch34x-Bibliothek neu. Das Gerät muss während der Installation vom Computer getrennt sein.

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

Schritt 2: Schließen Sie den USB-Anschluss des Boards an und führen Sie Folgendes aus:

dmesg | grep "ch34x"

Eine Meldung wie diese sollte angezeigt werden:

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

Wenn der verwendete Treiber nicht „ch34x“ ist (z. B. ch341), versuchen Sie, den anderen Treiber zu deaktivieren, indem Sie Folgendes ausführen:

rmmod <non-ch34x driver name>

Trennen Sie das Gerät vom Stromnetz und schließen Sie es wieder an. Achten Sie darauf, dass der verwendete Treiber „ch34x“ ist.

7. Demo

Programm ausprobieren

Sobald Ihr Board erfolgreich geflasht wurde, klicken Sie auf die Schaltfläche

RST, um das Board neu zu starten und das Programm zu starten. Wenn die blaue LED zu blinken beginnt, ist sie erfolgreich. Falls nicht, scrollen Sie nach unten zum Abschnitt Was ist, wenn es nicht funktioniert hat? unten.

Das Modell für maschinelles Lernen auf dem Board ist darauf trainiert, die Wörter „Ja“ zu erkennen. und „Nein“ und um das Vorhandensein und Fehlen von Sprache zu erkennen. Die Ergebnisse werden durch das Anleuchten farbiger LEDs kommuniziert. In der folgenden Tabelle sehen Sie die Bedeutung der einzelnen LED-Farben:

Ergebnis der Erkennung	LED-Farbe
"Ja"	Gelb
"Nein"	Rot
Unbekannte Sprachausgabe	Grün
Keinen gesprochenen Text erkannt	Keine LEDs leuchten

Probieren Sie es aus!

Halte das Spielbrett vor den Mund und sag „Ja“ mehrere Male. Die gelbe LED blinkt. Wenn nichts passiert, wenn Sie „Ja“ sagen, probieren Sie Folgendes:

• Halte das Spiel ungefähr 10" aus deinem Mund
• Übermäßige Hintergrundgeräusche vermeiden
• „Ja“ wiederholen mehrmals hintereinander (versuchen Sie, „Ja, ja, ja“ zu sagen).

Was, wenn es nicht funktioniert hat?

Im Folgenden finden Sie einige mögliche Probleme und die entsprechende Fehlerbehebung:

Problem: Nach dem Blinken leuchtet keine der LEDs auf.

Lösung:Drücke die Taste RST oder trenne die Verbindung zum Programmiergerät und schließe sie dann wieder an. Wenn das Problem weiterhin besteht, blinken Sie das Board noch einmal.

Problem: Die blaue LED leuchtet auf, aber sie ist sehr dunkel.

Lösung:Tausch die Batterie aus, wenn sie schwach ist. Alternativ kann die Leiterplatte über den Programmierer und das Kabel vom Computer mit Strom versorgt werden.

8. Debug-Ausgabe lesen (optional)

Lesen Sie diesen Abschnitt, falls Probleme auftreten und Sie Ihren Code im Detail debuggen müssen. Um zu verstehen, was in einem Mikrocontroller vor sich geht, wenn Ihr Code ausgeführt wird, können Sie Debugging-Informationen über die serielle Verbindung der Leiterplatte ausdrucken. Sie stellen über Ihren Computer eine Verbindung zum Board her und zeigen die vom Board gesendeten Daten an.

Serielle Verbindung öffnen

Standardmäßig protokolliert unser SparkFun Edge-Beispielcode alle gesprochenen Befehle zusammen mit ihrer Konfidenz. Mit dem folgenden Befehl können Sie sich die Ausgabe des Boards anzeigen lassen:

screen ${DEVICENAME} 115200

Anfänglich sehen Sie möglicherweise eine Ausgabe, die in etwa so aussieht: (Erscheint nur, wenn das Board zurückgesetzt wird, nachdem die Verbindung hergestellt wurde. Andernfalls werden möglicherweise Informationen zur Fehlerbehebung angezeigt.)

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Versuche, einige Befehle zu geben, indem du „Ja“ sagst oder „Nein“. Sie sollten für jeden Befehl die Debug-Informationen des Boarddrucks sehen:

 Heard yes (202) @65536ms

Im obigen Log bezieht sich yes auf den Befehl. Die Zahl 202 gibt an, wie sicher der Befehl war (mindestens 200). 65536ms bezieht sich schließlich auf die Zeit, die seit dem letzten Zurücksetzen des Mikrocontrollers vergangen ist.

Wenn Sie die Debug-Ausgabe nicht mehr ansehen möchten, drücken Sie Ctrl+A, direkt gefolgt vom Schlüssel K und drücken Sie dann die Taste Y.

Fehlerbehebungsprotokolle schreiben

Sie können den Code, der diese Informationen protokolliert, in der Datei „command_responder.cc“ sehen, mit der Sie gerade gearbeitet haben:

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

Zum Protokollieren von Daten können Sie die Methode error_reporter->Report() aufrufen. Es unterstützt die Standardtokens vom Typ printf für die Stringinterpolation, mit denen Sie wichtige Informationen in Ihre Logs aufnehmen können:

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

Diese Methode sollte sich als nützlich erweisen, wenn Sie im nächsten Abschnitt eigene Änderungen am Code vornehmen.

9. Code erweitern (optional)

Nachdem Sie nun wissen, wie Sie Ihren SparkFun Edge erstellen und flashen, können Sie mit dem Code experimentieren und ihn auf Ihrem Gerät bereitstellen, um die Ergebnisse zu sehen.

Code lesen

Ein guter Ausgangspunkt, um den Code zu lesen, ist die folgende Datei command_responder.cc..

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

Sie können die Datei auf GitHub ansehen.

Die Methode in dieser Datei (RespondToCommand) wird aufgerufen, wenn ein Sprachbefehl erkannt wird. Durch den vorhandenen Code wird eine andere LED eingeschaltet, je nachdem, ob „Ja“, „Nein“ oder ein unbekannter Befehl gehört wurde. Das folgende Snippet zeigt, wie das funktioniert:

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

Das Argument found_command enthält den Namen des erkannten Befehls. Durch Prüfen des ersten Zeichens wird anhand dieser if-Anweisungen bestimmt, welche LED leuchtet.

Die Methode ReplyToCommand wird mit mehreren Argumenten aufgerufen:

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

• Mit error_reporter werden Informationen zur Fehlerbehebung protokolliert (mehr dazu später).
• current_time steht für den Zeitpunkt, zu dem der Befehl erkannt wurde.
• found_command teilt uns mit, welcher Befehl erkannt wurde.
• score gibt an, wie wahrscheinlich es ist, dass ein Befehl erkannt wurde.
• is_new_command teilt uns mit, ob der Befehl zum ersten Mal gehört.

score ist eine Ganzzahl von 0 bis 255, die die Wahrscheinlichkeit darstellt, dass ein Befehl erkannt wurde. Im Beispielcode wird ein Befehl nur dann als gültig betrachtet, wenn der Wert größer als 200 ist. Basierend auf unseren Tests liegen die meisten gültigen Befehle im Bereich von 200 bis 210.

Code ändern

Das SparkFun Edge-Board hat vier LEDs. Aktuell blinkt die blaue LED, um anzuzeigen, dass die Erkennung erfolgt. Sie können dies in der Datei command_responder.cc sehen:

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

Da wir eine Gruppe mit vier LEDs haben, ändern wir das Programm so, dass sie als visuelle Indikator für die score eines bestimmten Befehls verwendet werden. Ein niedriger Wert weist eine einzelne leuchtende LED, ein hoher Wert auf mehrere Leuchten hin.

Um sicherzustellen, dass das Programm läuft, blinkt statt der blauen die rote LED kontinuierlich. Die blauen, grünen und gelben LEDs werden verwendet, um die Stärke des letzten score anzuzeigen. Der Einfachheit halber leuchten diese LEDs nur auf, wenn das Wort „Ja“ gesprochen wird. Wenn ein anderes Wort erkannt wird, erlöschen die LEDs.

Um diese Änderung vorzunehmen, ersetze den gesamten Code in deiner command_responder.cc-Datei durch das folgende Snippet:

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

Wenn ein neuer Befehl erkannt wird, gibt is_new_command den Wert „true“ zurück. Wir löschen die blauen, grünen und gelben LEDs und leuchten dann abhängig von den Werten von found_command und score wieder auf.

Neu erstellen und flashen

Nachdem Sie Änderungen am Code vorgenommen haben, testen Sie ihn. Führen Sie dazu alle Schritte unter Binärdatei erstellen und vorbereiten aus.

10. Nächste Schritte

Herzlichen Glückwunsch, Sie haben Ihren ersten Sprachdetektor erfolgreich auf einem Mikrocontroller gebaut!

Wir hoffen, dass Ihnen diese kurze Einführung in die Entwicklung mit TensorFlow Lite für Mikrocontroller gefallen hat. Die Idee von Deep Learning auf Mikrocontrollern ist neu und spannend und wir ermutigen Sie, zu experimentieren.

Referenzdokumente

• Nachdem Sie nun Erfahrung mit dem Basisprogramm haben, trainieren Sie Ihr eigenes Modell, das verschiedene Befehle versteht. Hinweis: Das Training dauert einige Stunden.
• Weitere Informationen zu TensorFlow Lite für Mikrocontroller ( Website, GitHub)
• Probieren Sie andere Beispiele aus und führen Sie sie auf dem SparkFun Edge aus, wenn dieses unterstützt wird.
• Lesen Sie dazu das Buch TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers von O'Reilly, in dem maschinelles Lernen auf winzigen Geräten vorgestellt wird und verschiedene unterhaltsame Projekte erläutert werden. Dieses Codelab basiert auf Kapitel 7 und 8 des Buchs.

Vielen Dank und viel Spaß beim Entwickeln!