Cette page a été traduite par l'API Cloud Translation.

Reconnaissance vocale par IA avec TensorFlow Lite for Microcontrollers et SparkFun Edge

1. Introduction

Objectifs de l'atelier

Dans cet atelier de programmation, nous allons apprendre à utiliser TensorFlow Lite pour les microcontrôleurs afin d'exécuter un modèle de deep learning sur la carte de développement SparkFun Edge. Nous allons travailler avec le modèle de détection vocale intégré au tableau, qui utilise un réseau de neurones convolutif pour détecter les mots "oui". et "non" à l'aide des deux micros du tableau.

Machine learning sur des microcontrôleurs

Le machine learning peut servir à créer des outils intelligents qui améliorent l'expérience comme l'Assistant Google. Mais souvent, ces expériences nécessitent beaucoup de calculs ou de ressources, comme un serveur cloud puissant ou un ordinateur de bureau. Toutefois, il est désormais possible d'exécuter des inférences de machine learning sur du matériel minuscule et peu puissant, comme des microcontrôleurs.

Les microcontrôleurs sont extrêmement courants, bon marché, nécessitent très peu d'énergie et sont très fiables. Ils font partie de toutes sortes d'appareils ménagers: appareils électroménagers, voitures, jouets, etc. Dans les faits, on produit environ 30 milliards d'appareils équipés de microcontrôleurs chaque année.

En appliquant le machine learning à de minuscules microcontrôleurs, nous pouvons renforcer l'intelligence des milliards d'appareils que nous utilisons dans notre vie, sans dépendre de matériel coûteux ni de connexions Internet fiables. Imaginez des appareils électroménagers intelligents capables de s'adapter à votre quotidien, des capteurs industriels intelligents qui comprennent la différence entre les problèmes et un fonctionnement normal, et des jouets magiques qui aident les enfants à apprendre de manière amusante et agréable.

TensorFlow Lite pour microcontrôleurs (logiciel)

TensorFlow est le framework de machine learning Open Source de Google qui permet d'entraîner et d'exécuter des modèles. TensorFlow Lite est un framework logiciel, une version optimisée de TensorFlow, conçue pour exécuter des modèles TensorFlow sur de petits appareils relativement peu puissants, tels que les téléphones mobiles.

TensorFlow Lite For Microcontrollers est un framework logiciel, une version optimisée de TensorFlow, conçue pour exécuter des modèles TensorFlow sur du matériel minuscule et de faible puissance, tel que des microcontrôleurs. Il respecte les contraintes requises dans ces environnements intégrés : sa taille binaire est petite, il ne nécessite aucune compatibilité avec le système d'exploitation, aucune bibliothèque C ou C++ standard, aucune allocation de mémoire dynamique, etc.

SparkFun Edge (matériel)

SparkFun Edge est une plate-forme basée sur un microcontrôleur: un petit ordinateur sur un seul circuit imprimé. Il est doté d'un processeur, d'une mémoire et d'un matériel d'E/S qui lui permet d'envoyer et de recevoir des signaux numériques vers d'autres appareils. Il est doté de quatre LED contrôlables par logiciel, dans vos couleurs Google préférées.

Contrairement à un ordinateur, un microcontrôleur n’exécute pas un système d’exploitation. Au lieu de cela, les programmes que vous écrivez s'exécutent directement sur le matériel. Vous écrivez votre code sur un ordinateur et le téléchargez sur le microcontrôleur via un appareil appelé programmeur.

Les microcontrôleurs ne sont pas des ordinateurs puissants. Ils ont de petits processeurs et peu de mémoire. Mais comme ils sont conçus pour être aussi simples que possible, un microcontrôleur peut utiliser très peu d'énergie. Selon le fonctionnement de votre programme, SparkFun Edge peut fonctionner pendant des semaines sur une seule pile bouton !

Points abordés

Compiler l'exemple de programme pour SparkFun Edge sur votre ordinateur
Déployer le programme sur votre appareil
Modifier le programme et le déployer à nouveau

Prérequis

Vous aurez besoin du matériel suivant:

Ordinateur Linux ou macOS
Tableau SparkFun Edge
Programmateur SparkFun USB-C Serial Basic
Câble USB-C vers USB-A (si vous utilisez un ordinateur USB-C, utilisez plutôt un câble USB-C vers USB-C)
(Facultatif) Pile au lithium de 3 V de 20 mm (CR2032) pour exécuter l'inférence sans programmateur ni câble

Vous aurez besoin des logiciels suivants:

Git (vérifiez s'il est installé en exécutant git sur la ligne de commande)
Python 3 (vérifiez s'il est installé en exécutant python3 ou python --version sur la ligne de commande)
Pip pour Python 3 ( réponse utile de StackOverflow)
Installez la version 4.2.1 ou une version ultérieure (pour vérifier si elle est installée, exécutez make --version sur la ligne de commande).
Pilotes SparkFun Serial Basic

2. Configurer votre matériel

Le microcontrôleur SparkFun Edge est fourni avec un binaire préinstallé capable d'exécuter le modèle de reconnaissance vocale. Avant de remplacer cette version par notre propre version, exécutons d'abord ce modèle.

Alimentez votre tableau en:

Insertion d'une pile bouton dans le connecteur de batterie à l'arrière du tableau (le côté "+" de la pile orienté vers le haut) Si une batterie est déjà insérée dans votre tableau, retirez la languette en plastique et poussez-la pour vous assurer qu'elle est bien insérée.)

Si vous n'avez pas de pile bouton, vous pouvez utiliser le programmateur SparkFun USB-C Serial Basic pour alimenter la carte. Pour connecter cet appareil à votre tableau, procédez comme suit:

Repérez l'en-tête à six broches sur le côté de SparkFun Edge.
Branchez le SparkFun USB-C Serial Basic sur ces broches, en vous assurant qu'elles portent la mention "BLK". et "GRN" sur chaque appareil sont alignés correctement.
Connectez un câble USB-C entre l'appareil SparkFun USB-C Serial Basic et votre ordinateur.

Une fois que vous avez mis votre tableau sous tension en insérant la batterie ou en connectant le programmateur USB, la carte s'active et commence à écouter avec ses micros. Le voyant bleu doit se mettre à clignoter.

Le modèle de machine learning présent sur le tableau est entraîné à reconnaître les mots "oui" et "no", et pour détecter la présence et l'absence de parole. Il communique ses résultats par l'éclairage de LED colorées. Le tableau suivant indique la signification de chaque couleur de voyant:

Résultat de la détection	Couleur de la LED
"Oui"	Jaune
"Non"	Rouge
Voix inconnue	Vert
Aucune voix détectée.	Voyants éteints

essayez de le passer

Tenez le tableau devant votre bouche et dites "oui" plusieurs fois. Le voyant LED jaune clignote. Si rien ne se passe lorsque vous répondez "Oui", voici quelques conseils:

Maintenir le tableau à environ 10 po de votre bouche
Éviter les bruits de fond excessifs
Répéter "yes" (oui) plusieurs fois de suite (essayez de dire "oui, oui, oui")

3. Configurer votre logiciel

Nous allons maintenant télécharger, installer et exécuter le modèle de reconnaissance vocale sur le microcontrôleur. Pour cela, nous commençons par télécharger le code source de ce programme et les dépendances dont nous avons besoin pour le compiler. Le programme est écrit en C++, qui doit être compilé dans un binaire avant d'être téléchargé sur le tableau. Un binaire est un fichier qui contient le programme dans un format pouvant être exécuté directement par le matériel SparkFun Edge.

Les instructions suivantes sont rédigées pour Linux ou macOS.

Télécharger le dépôt TensorFlow

Le code est disponible dans le dépôt TensorFlow sur GitHub, à l'emplacement suivant:

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

Ouvrez un terminal sur votre ordinateur, accédez au répertoire dans lequel vous stockez généralement les projets de codage, téléchargez le dépôt TensorFlow et accédez au répertoire créé, comme indiqué ci-dessous:

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

Télécharger les dépendances Python

Nous allons utiliser Python 3 pour préparer notre binaire et le flasher sur l'appareil. Les scripts Python dépendent de la disponibilité de certaines bibliothèques. Exécutez la commande suivante pour installer ces dépendances:

pip3 install pycrypto pyserial --user

4. Créer et préparer le binaire

Nous allons créer le binaire et exécuter des commandes qui le préparent pour le téléchargement sur l'appareil.

Créer le binaire

Pour télécharger toutes les dépendances requises et créer le binaire, exécutez la commande suivante:

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

Si la compilation fonctionne correctement, la dernière ligne du résultat doit apparaître comme suit:

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

Pour vérifier que le binaire a bien été créé, exécutez la commande suivante:

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 devrait s'afficher sur la console. Si Binary is missing s'affiche, cela signifie qu'un problème est survenu au niveau du processus de compilation. Celui-ci nécessitera un débogage.

Préparer le binaire

Le binaire doit être signé avec des clés cryptographiques pour être déployé sur l'appareil. Nous allons maintenant exécuter des commandes qui signeront notre binaire afin qu'il puisse être téléchargé dans SparkFun Edge.

Saisissez la commande suivante pour configurer des clés cryptographiques factices que nous pouvons utiliser pour le développement:

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

À présent, exécutez la commande suivante pour créer un binaire signé:

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

Le fichier main_nonsecure_ota.bin est créé. Nous allons maintenant exécuter une autre commande pour créer une version finale du fichier, qui pourra être utilisée pour flasher notre appareil avec le script bootloader que nous utiliserons à l'étape suivante:

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

Le répertoire où vous avez exécuté les commandes devrait maintenant contenir un fichier nommé main_nonsecure_wire.bin. Il s'agit du fichier que nous allons flasher sur l'appareil.

5. Préparez-vous à flasher le binaire

Qu'est-ce qui clignote ?

SparkFun Edge stocke le programme qu'il exécute actuellement dans ses 512 kilo-octets de mémoire flash. Si nous voulons que le tableau exécute un nouveau programme, nous devons l'envoyer au tableau, qui le stockera dans la mémoire flash, en écrasant tout programme déjà enregistré.

Ce processus est appelé "flashage" et nous l'utiliserons pour envoyer notre programme au tableau.

Fixer le programmateur à la carte

Pour télécharger de nouveaux programmes sur le tableau, nous allons utiliser le programmeur série SparkFun USB-C Serial Basic. Ce dispositif permet à votre ordinateur de communiquer avec le microcontrôleur via USB.

Pour connecter cet appareil à votre tableau, procédez comme suit:

Repérez l'en-tête à six broches sur le côté de SparkFun Edge.
Branchez le SparkFun USB-C Serial Basic sur ces broches, en vous assurant qu'elles portent la mention "BLK". et "GRN" sur chaque appareil sont alignés correctement.

Brancher le programmeur à votre ordinateur

Nous allons connecter le tableau à votre ordinateur via USB. Pour programmer le tableau, nous avons besoin de connaître le nom que votre ordinateur donne à l'appareil. La meilleure façon de le faire est de lister tous les périphériques de l'ordinateur avant et après l'avoir connecté, et de vérifier quel appareil est neuf.

Avant de connecter l'appareil à l'aide d'un câble USB, exécutez la commande suivante:

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

La liste des périphériques connectés devrait ressembler à ceci:

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

Connectez maintenant le programmeur au port USB de votre ordinateur. Saisissez à nouveau la commande suivante:

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

Vous devriez voir un élément supplémentaire dans la sortie, comme dans l'exemple ci-dessous. Le nouvel élément peut avoir un nom différent. Ce nouvel élément correspond au nom de l'appareil.

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

Tout d'abord, nous allons créer une variable d'environnement permettant d'identifier le nom de l'appareil:

export DEVICENAME=put your device name here

Nous allons maintenant créer une variable d'environnement pour spécifier le débit en bauds, c'est-à-dire la vitesse à laquelle les données seront envoyées à l'appareil:

export BAUD_RATE=921600

6. Flasher le binaire

Exécuter le script pour flasher votre tableau

Pour flasher la carte, nous devons la placer dans un "bootloader" spécial qui le prépare à recevoir le nouveau binaire. Nous allons ensuite exécuter un script pour envoyer le binaire au tableau.

Familiarisez-vous avec les boutons suivants du tableau:

Pour réinitialiser et flasher le tableau, procédez comme suit:

Assurez-vous que la carte est connectée au programmeur et que l'ensemble de la configuration est connecté à votre ordinateur via un câble USB.
Commencez à maintenir le bouton 14 affiché sur le tableau. Maintenez-le enfoncé jusqu'à l'étape 6.
Maintenez toujours le bouton 14 enfoncé, puis cliquez sur le bouton RST pour réinitialiser le tableau dans son état de bootloader.
Toujours maintenir le bouton 14 enfoncé, collez la commande suivante dans votre terminal, puis appuyez sur Entrée pour l'exécuter (pour plus de commodité, vous pouvez coller cette commande dans votre terminal avant de commencer à maintenir le bouton enfoncé, mais n'appuyez pas sur Entrée tant que vous n'avez pas atteint cette étape).

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

Si vous maintenez le bouton 14 enfoncé, un message semblable au suivant doit s'afficher à l'écran:

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

Arrêtez d'appuyer sur le bouton 14 sur le tableau après avoir vu Sending Data Packet of length 8180 (mais ce n'est pas grave si vous continuez de le maintenir enfoncé). Le programme continue d'imprimer des lignes sur le terminal. Le résultat ressemblera à ceci:

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

Si Done s'affiche, cela signifie que le clignotement a réussi. Si la sortie du programme se termine par une erreur, vérifiez si Sending Reset Command s'est affiché. Si c'est le cas, le flash a probablement réussi malgré l'erreur.

Sur une machine Linux, vous pouvez rencontrer une erreur NoResponse Error. En effet, le pilote série ch34x a été installé en même temps que le pilote série existant. Le problème peut être résolu comme suit:

Étape 1: réinstallez la version appropriée de la bibliothèque ch34x. Assurez-vous que l'appareil est débranché de l'ordinateur pendant l'installation.

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

Étape 2: Branchez la carte USB sur la carte et exécutez la commande suivante:

dmesg | grep "ch34x"

Un message de ce type s'affiche :

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

Si le pilote utilisé n'est pas "ch34x" (par exemple, ch341), essayez de désactiver l'autre pilote en exécutant la commande suivante :

rmmod <non-ch34x driver name>

Débranchez, puis rebranchez l'appareil, puis vérifiez que le pilote utilisé est "ch34x".

7. Démo

Essayer le programme

Une fois votre tableau flashé, appuyez sur le bouton

RST pour redémarrer le tableau et démarrer le programme. Si le voyant LED bleu se met à clignoter, cela signifie que le clignotement est correct. Si ce n'est pas le cas, faites défiler la page jusqu'à la section Que faire si l'opération a échoué ? ci-dessous.

Le modèle de machine learning présent sur le tableau est entraîné à reconnaître les mots "oui" et "no", et pour détecter la présence et l'absence de parole. Il communique ses résultats grâce à des LED colorées. Le tableau suivant indique la signification de chaque couleur de voyant:

Résultat de la détection	Couleur de la LED
"Oui"	Jaune
"Non"	Rouge
Voix inconnue	Vert
Aucune voix détectée.	Voyants éteints

essayez de le passer

Tenez le tableau devant votre bouche et dites "oui" plusieurs fois. Le voyant LED jaune clignote. Si rien ne se passe lorsque vous répondez "Oui", voici quelques conseils:

Maintenir le tableau à environ 10 po de votre bouche
Éviter les bruits de fond excessifs
Répéter "yes" (oui) plusieurs fois de suite (essayez de dire "oui, oui, oui")

Que faire si le problème persiste ?

Voici quelques problèmes possibles et la procédure à suivre pour les déboguer:

Problème: après le flash, aucun voyant ne s'allume.

Solution:essayez d'appuyer sur le bouton RST ou de débrancher et de reconnecter la carte du programmateur. Si le problème persiste, essayez à nouveau de flasher le tableau.

Problème: La LED bleue s'allume, mais la luminosité est très faible.

Solution:remplacez les piles lorsque le niveau de charge est faible. La carte peut également être alimentée par un ordinateur à l’aide du programmeur et du câble.

8. Lire la sortie de débogage (facultatif)

Consultez cette section si vous rencontrez des problèmes et devez déboguer votre code en détail. Pour comprendre ce qui se passe dans un microcontrôleur lors de l'exécution de votre code, vous pouvez imprimer les informations de débogage via la connexion série de la carte. Vous utilisez votre ordinateur pour vous connecter au tableau et afficher les données qu'il envoie.

Ouvrir une connexion série

Par défaut, notre exemple de code SparkFun Edge enregistre toutes les commandes vocales, ainsi que leur niveau de confiance. Pour voir la sortie du tableau, vous pouvez exécuter la commande suivante:

screen ${DEVICENAME} 115200

Au départ, un résultat semblable aux lignes suivantes peut s'afficher: (il ne s'affiche que si le tableau est réinitialisé une fois connecté, il se peut que vous commenciez à voir des informations de débogage).

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Essayez d'émettre des commandes en disant "oui" ou "non". Le tableau doit afficher les informations de débogage pour chaque commande:

 Heard yes (202) @65536ms

Dans le journal ci-dessus, yes fait référence à la commande. Le chiffre 202 correspond au niveau de confiance quant au fait que la commande a été entendue (200 étant le minimum). Enfin, 65536ms fait référence au temps écoulé depuis la dernière réinitialisation du microcontrôleur.

Pour arrêter d'afficher le résultat du débogage, appuyez sur Ctrl+A, puis immédiatement sur la touche K, puis sur la touche Y.

Écrire des journaux de débogage

Vous pouvez voir le code qui enregistre ces informations dans le fichier command_responder.cc avec lequel vous venez de travailler:

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

Pour enregistrer des données, vous pouvez appeler la méthode error_reporter->Report(). Il est compatible avec les jetons printf standards pour l'interpolation de chaîne, que vous pouvez utiliser pour inclure des informations importantes dans vos journaux:

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

Cette méthode peut s'avérer utile lorsque vous apportez vos propres modifications au code dans la section suivante.

9. Étendre le code (facultatif)

Maintenant que vous savez comment compiler et flasher votre SparkFun Edge, vous pouvez commencer à jouer avec le code et à le déployer sur votre appareil pour voir les résultats.

Lire le code

Le fichier suivant, command_responder.cc., constitue un bon point de départ pour lire le code.

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

Cliquez ici pour consulter le fichier sur GitHub.

La méthode de ce fichier, RespondToCommand, est appelée lorsqu'une commande vocale est détectée. Le code existant allume une LED différente selon que vous avez entendu "oui", "non" ou une commande inconnue. L'extrait de code suivant montre comment cela fonctionne:

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

L'argument found_command contient le nom de la commande détectée. En cochant le premier caractère, cet ensemble d'instructions if détermine quelle LED allumer.

La méthode RépondreToCommand est appelée avec plusieurs arguments:

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

error_reporter permet de consigner les informations de débogage (nous y reviendrons plus tard).
current_time représente l'heure à laquelle la commande a été détectée.
found_command nous indique quelle commande a été détectée.
score nous indique le degré de confiance de la détection d'une commande.
is_new_command nous indique si vous entendez la commande pour la première fois.

score est un nombre entier compris entre 0 et 255 qui représente la probabilité qu'une commande ait été détectée. L'exemple de code ne considère une commande comme valide que si le score est supérieur à 200. D'après nos tests, la plupart des commandes valides sont comprises entre 200 et 210.

Modifier le code

La carte SparkFun Edge est dotée de quatre LED. Actuellement, le voyant bleu clignote pour indiquer que la reconnaissance est en cours. Vous pouvez voir ceci dans le fichier 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);
}

Étant donné que nous avons une banque de quatre LED, modifions le programme pour les utiliser comme indicateur visuel du score d'une commande donnée. Un score faible mérite une seule LED allumée, tandis qu'un score élevé génère plusieurs lumières.

Pour nous assurer que nous avons un moyen de savoir que le programme est en cours d'exécution, nous allons faire clignoter le voyant rouge en continu au lieu du bleu. Les voyants bleus, verts et jaunes adjacents permettent d'afficher l'intensité du score le plus récent. Et pour plus de simplicité, nous n'allumerons ces LED que si le mot « oui » est énoncée. Si un autre mot est détecté, les voyants LED s'effacent.

Pour apporter cette modification, remplacez tout le code de votre fichier command_responder.cc par l'extrait de code suivant:

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

Si une nouvelle commande est détectée, is_new_command a la valeur "true". Nous allons effacer les voyants bleu, vert et jaune, puis les rallumer en fonction des valeurs de found_command et score.

Recompiler et flasher

Une fois que vous avez apporté des modifications au code, testez-les en exécutant toutes les étapes de la section Compiler et préparer le binaire.

10. Étapes suivantes

Félicitations ! Vous venez de construire votre premier détecteur de parole sur un microcontrôleur.

Nous espérons que cette brève introduction au développement avec TensorFlow Lite for Microcontrollers vous a plu. L'idée du deep learning sur les microcontrôleurs est nouvelle et passionnante, et nous vous encourageons à l'expérimenter.

Documents de référence

Maintenant que vous savez utiliser le programme de base, entraînez votre propre modèle à comprendre les différentes commandes. Remarque: L'entraînement prendra quelques heures.
Pour en savoir plus sur TensorFlow Lite for Microcontrollers, consultez le site Web, GitHub.
Essayez d'autres exemples et exécutez-les sur SparkFun Edge, s'il est compatible.
Reportez-vous à l'ouvrage TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers publié par O'Reilly, qui présente le machine learning sur de petits appareils et présente plusieurs projets amusants. Cet atelier de programmation est basé sur les chapitres 7 et 8 du livre.

Merci et amusez-vous bien !