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 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é à la carte, qui utilise un réseau de neurones convolutif pour détecter les mots "oui" et "non" prononcés via les deux microphones de la carte.

bf256d403a1821af.gif

Machine learning sur les microcontrôleurs

Le machine learning peut être utilisé pour créer des outils intelligents qui simplifient la vie des utilisateurs, comme l'Assistant Google. Mais souvent, ces expériences nécessitent beaucoup de calculs ou de ressources, comme un serveur cloud ou un ordinateur de bureau puissant. Toutefois, il est désormais possible d'exécuter l'inférence de machine learning sur du matériel minuscule et peu puissant, comme des microcontrôleurs.

Les microcontrôleurs sont extrêmement courants, peu coûteux, nécessitent très peu d'énergie et sont très fiables. Ils sont présents dans toutes sortes d'appareils ménagers : pensez aux appareils électroménagers, aux voitures et aux jouets. En effet, environ 30 milliards d'appareils équipés de microcontrôleurs sont produits chaque année.

1360b61fbfa33657.jpeg

En intégrant le machine learning à de minuscules microcontrôleurs, nous pouvons améliorer l'intelligence de milliards d'appareils que nous utilisons au quotidien, sans avoir besoin de matériel coûteux ni de connexions Internet fiables. Imaginez des appareils électroménagers connectés capables de s'adapter à vos habitudes quotidiennes, des capteurs industriels intelligents capables de faire la différence entre un problème et un fonctionnement normal, ou encore des jouets magiques qui aident les enfants à apprendre tout en s'amusant.

TensorFlow Lite for Microcontrollers (logiciel)

358ffdb9eb758b90.png

TensorFlow est le framework de machine learning Open Source de Google pour l'entraînement et l'exécution de modèles. TensorFlow Lite est un framework logiciel, une version optimisée de TensorFlow, conçu pour exécuter des modèles TensorFlow sur des appareils petits et 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 à faible consommation d'énergie, comme les microcontrôleurs. Il respecte les contraintes requises dans ces environnements embarqués, c'est-à-dire qu'il a une petite taille binaire, ne nécessite aucune compatibilité avec le système d'exploitation, aucune bibliothèque C ou C++ standard, ni d'allocation de mémoire dynamique, etc.

SparkFun Edge (matériel)

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

aa4493835a2338c6.png

Contrairement à un ordinateur, un microcontrôleur n'exécute pas de 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 à l'aide d'un appareil appelé programmateur.

Les microcontrôleurs ne sont pas des ordinateurs puissants. Ils sont équipés de petits processeurs et de peu de mémoire. Toutefois, comme ils sont conçus pour être aussi simples que possible, les microcontrôleurs peuvent consommer très peu d'énergie. Selon ce que fait votre programme, la SparkFun Edge peut fonctionner pendant des semaines avec une seule pile bouton.

Points abordés

  • Compilez l'exemple de programme pour la SparkFun Edge sur votre ordinateur.
  • Déployer le programme sur votre appareil
  • Modifier le programme et le redéployer

Prérequis

Vous aurez besoin du matériel suivant :

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 sur Stack Overflow)
  • Make 4.2.1 ou version ultérieure (vérifiez s'il est installé en exécutant 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 fichier binaire préinstallé qui peut exécuter le modèle vocal. Avant de remplacer cette version par la nôtre, exécutons d'abord ce modèle.

Pour alimenter votre tableau :

  1. Insérez une pile bouton dans le connecteur de batterie à l'arrière de la carte (avec le côté "+" de la batterie orienté vers le haut). Si une pile est déjà insérée dans votre carte, retirez la languette en plastique et appuyez sur la pile pour vous assurer qu'elle est bien insérée.

25a6cc6b208e8a4e.png

  1. Si vous n'avez pas de pile bouton, vous pouvez utiliser le programmateur SparkFun USB-C Serial Basic pour alimenter la carte. Pour associer cet appareil à votre tableau, procédez comme suit :
  • Repérez le connecteur à six broches sur le côté de la SparkFun Edge.
  • Branchez le SparkFun USB-C Serial Basic sur ces broches, en veillant à ce que les broches portant les libellés "BLK" et "GRN" sur chaque appareil soient correctement alignées.
  • Connectez un câble USB-C entre le SparkFun USB-C Serial Basic et votre ordinateur.

b140822f0019f92a.png

Une fois que vous avez alimenté votre carte en insérant la batterie ou en connectant le programmateur USB, la carte se réveille et commence à écouter avec ses microphones. Le voyant bleu devrait commencer à clignoter.

Le modèle de machine learning de la carte est entraîné à reconnaître les mots "oui" et "non", et à détecter la présence ou l'absence de parole. Il communique ses résultats en allumant des LED de couleur. Le tableau suivant indique la signification de chaque couleur de LED :

Résultat de la détection

Couleur de la LED

"Oui"

Jaune

"Non"

Rouge

Discours inconnu

Vert

Aucune voix détectée.

Aucun voyant LED n'est allumé

Essayez.

Tenez la planche devant votre bouche et dites "oui" plusieurs fois. Le voyant jaune clignote. Si rien ne se passe lorsque vous dites "oui", voici quelques solutions à essayer :

  • Tenez le tableau à environ 25 cm de votre bouche.
  • Évitez les bruits de fond excessifs
  • Répétez "oui" plusieurs fois de suite (par exemple, dites "oui oui oui").

3. Configurer votre logiciel

Nous allons maintenant télécharger, installer et exécuter nous-mêmes le modèle vocal sur le microcontrôleur. Pour ce faire, nous téléchargeons d'abord 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é en binaire avant d'être téléchargé sur la carte. Un binaire est un fichier contenant le programme sous une forme qui peut être exécutée directement par le matériel SparkFun Edge.

Les instructions suivantes sont écrites 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 à un répertoire dans lequel vous stockez généralement des 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 utiliserons Python 3 pour préparer notre fichier 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. Compiler et préparer le binaire

Nous allons compiler le binaire et exécuter des commandes qui le préparent au 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 se présenter 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 fichier 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 dans la console. Si vous voyez Binary is missing, cela signifie qu'un problème est survenu lors du processus de compilation et que vous devrez le déboguer.

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é sur la SparkFun Edge.

Saisissez la commande suivante pour configurer des clés cryptographiques fictives 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

Exécutez maintenant 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

Cela crée le fichier main_nonsecure_ota.bin. Nous allons maintenant exécuter une autre commande pour créer une version finale du fichier qui peut être utilisée pour flasher notre appareil avec le script du 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 dans lequel vous avez exécuté les commandes doit maintenant contenir un fichier appelé 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 que le clignotement ?

La carte SparkFun Edge stocke le programme qu'elle exécute actuellement dans ses 512 kilo-octets de mémoire flash. Si nous voulons que la carte exécute un nouveau programme, nous devons l'envoyer à la carte, qui le stockera dans la mémoire flash, en écrasant tout programme précédemment enregistré.

Ce processus est appelé "flashing" (ou "flashage"), et nous l'utiliserons pour envoyer notre programme à la carte.

Fixez le programmateur à la carte.

Pour télécharger de nouveaux programmes sur la carte, nous allons utiliser le programmateur série SparkFun USB-C Serial Basic. Cet appareil permet à votre ordinateur de communiquer avec le microcontrôleur via USB.

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

  1. Repérez le connecteur à six broches sur le côté de la SparkFun Edge.
  2. Branchez le SparkFun USB-C Serial Basic sur ces broches, en veillant à ce que les broches portant les libellés "BLK" et "GRN" sur chaque appareil soient correctement alignées.

b140822f0019f92a.png

Connectez le programmateur à votre ordinateur.

Nous allons connecter la carte à votre ordinateur via USB. Pour programmer la carte, nous devons connaître le nom que votre ordinateur donne à l'appareil. Pour ce faire, le mieux est de lister tous les appareils de l'ordinateur avant et après la connexion, et de rechercher l'appareil qui est nouveau.

Avant de connecter l'appareil via USB, exécutez la commande suivante :

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

Vous devriez obtenir une liste des appareils connectés, comme suit :

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

Connectez ensuite le programmateur 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 le résultat, comme dans l'exemple ci-dessous. Le nom de votre nouvel élément peut être 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 pour identifier le nom de l'appareil :

export DEVICENAME=put your device name here

Ensuite, nous allons créer une variable d'environnement pour spécifier le débit en bauds, qui correspond à 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 carte

Pour flasher la carte, nous devons la mettre dans un état spécial de "bootloader" qui la prépare à recevoir le nouveau binaire. Nous exécuterons ensuite un script pour envoyer le binaire à la carte.

Familiarisons-nous avec les boutons suivants du tableau :

64c620570b9d2f83.png

Pour réinitialiser et flasher la carte, procédez comme suit :

  1. Assurez-vous que votre carte est connectée au programmateur et que l'ensemble de la configuration est connecté à votre ordinateur via USB.
  2. Démarrez en maintenant le bouton 14 enfoncé sur la carte. Maintenez-le jusqu'à l'étape 6.
  3. Tout en maintenant le bouton 14 enfoncé, cliquez sur le bouton RST pour réinitialiser la carte et la faire passer en mode bootloader.
  4. Tout en maintenant le bouton 14 enfoncé, collez la commande suivante dans votre terminal et 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 avant d'avoir 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
  1. Tout en maintenant le bouton 14 enfoncé, vous devriez voir un écran semblable à celui-ci s'afficher :
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. Arrêtez d'appuyer sur le bouton 14 de la carte après avoir vu Sending Data Packet of length 8180 (mais vous pouvez continuer à appuyer dessus). Le programme continue d'imprimer des lignes dans le terminal. Le résultat final devrait ressembler à 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 vous voyez Done, cela signifie que le voyant clignote. Si la sortie du programme se termine par une erreur, vérifiez si Sending Reset Command a été imprimé. Si c'est le cas, le flashage a probablement réussi malgré l'erreur.

Sur une machine Linux, vous pouvez rencontrer un NoResponse Error. En effet, le pilote série ch34x a été installé en même temps que le pilote série existant. Pour résoudre ce problème :

Étape 1 : Réinstallez la version correcte 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 le câble USB de 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 et rebranchez l'appareil, et assurez-vous que le pilote utilisé est "ch34x".

7. Démo

Essayer le programme

Une fois votre carte flashée, appuyez sur le bouton marqué

RST pour redémarrer la carte et lancer le programme. Si la LED bleue commence à clignoter, cela signifie que le flashage a réussi. Si ce n'est pas le cas, faites défiler la page jusqu'à la section Que faire si cela n'a pas fonctionné ? ci-dessous.

bf256d403a1821af.gif

Le modèle de machine learning de la carte est entraîné à reconnaître les mots "oui" et "non", et à détecter la présence ou l'absence de parole. Il communique ses résultats en allumant des LED de couleur. Le tableau suivant indique la signification de chaque couleur de LED :

Résultat de la détection

Couleur de la LED

"Oui"

Jaune

"Non"

Rouge

Discours inconnu

Vert

Aucune voix détectée.

Aucun voyant LED n'est allumé

Essayez.

Tenez la planche devant votre bouche et dites "oui" plusieurs fois. Le voyant jaune clignote. Si rien ne se passe lorsque vous dites "oui", voici quelques solutions à essayer :

  • Tenez le tableau à environ 25 cm de votre bouche.
  • Évitez les bruits de fond excessifs
  • Répétez "oui" plusieurs fois de suite (par exemple, dites "oui oui oui").

Que faire si cela ne fonctionne pas ?

Voici quelques problèmes possibles et comment les résoudre :

Problème : Après le flashage, aucune LED ne s'allume.

Solution : Essayez d'appuyer sur le bouton RST, ou de déconnecter la carte du programmateur, puis de la reconnecter. Si aucune de ces solutions ne fonctionne, essayez de flasher à nouveau la carte.

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

Solution : Remplacez la pile, car elle est presque déchargée. Vous pouvez également alimenter la carte à l'aide d'un ordinateur, du programmateur et du câble.

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

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

Ouvrir une connexion série

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

screen ${DEVICENAME} 115200

Au début, vous verrez peut-être un résultat qui ressemble à ce qui suit : (cela ne s'affiche que si la carte est réinitialisée une fois connectée, sinon vous pouvez commencer à 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". Vous devriez voir les informations de débogage de l'impression de la carte pour chaque commande :

 Heard yes (202) @65536ms

Dans le journal ci-dessus, yes fait référence à la commande. Le nombre 202 fait référence au niveau de confiance 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 la sortie de 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 sur lequel vous venez de travailler :

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

Pour consigner 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înes, 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 devrait vous être utile lorsque vous apporterez 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

Un bon point de départ pour lire le code est le fichier suivant : command_responder.cc.

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

Vous pouvez consulter le fichier sur GitHub ici.

La méthode RespondToCommand de ce fichier est appelée lorsqu'une commande vocale est détectée. Le code existant allume une LED différente selon que la réponse entendue est "oui", "non" ou une commande inconnue. L'extrait 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 vérifiant le premier caractère, cet ensemble d'instructions if détermine quelle LED doit s'allumer.

La méthode RespondToCommand 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 est utilisé pour 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 la commande détectée.
  • score indique notre degré de confiance dans la détection d'une commande.
  • is_new_command nous indique si c'est la première fois que l'utilisateur entend la commande.

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 se situent entre 200 et 210.

Modifier le code

La carte SparkFun Edge comporte quatre LED. Actuellement, nous faisons clignoter la LED bleue pour indiquer que la reconnaissance est en cours. Vous pouvez le voir 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);
}

Puisque nous disposons d'une banque de quatre LED, modifions le programme pour les utiliser comme indicateur visuel du score d'une commande donnée. Un score faible correspond à une seule LED allumée, tandis qu'un score élevé correspond à plusieurs LED allumées.

Pour nous assurer de savoir que le programme est en cours d'exécution, nous allons faire clignoter la LED rouge en continu au lieu de la LED bleue. Les voyants bleu, vert et jaune adjacents seront utilisés pour indiquer l'intensité de notre score le plus récent. Pour simplifier, nous n'allumerons ces LED que si le mot "oui" est prononcé. Si un autre mot est détecté, les voyants s'éteignent.

Pour effectuer 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 est défini sur "true". Nous éteignons les LED bleues, vertes et jaunes, puis les rallumons en fonction des valeurs de found_command et score.

Recompiler et flasher

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

10. Étapes suivantes

Félicitations, vous venez de créer votre premier détecteur vocal sur un microcontrôleur !

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

Documents de référence

26699b18f2b199f.png

Merci et bonne création !