Exécuter un modèle d'apprentissage automatique « Hello World » sur des microcontrôleurs STM32

L'apprentissage automatique (Machine Learning, ML) fait fureur depuis des années dans les applications de serveurs et mobiles, mais il s'est désormais étendu aux dispositifs en périphérie où il est devenu essentiel. Comme les dispositifs en périphérie doivent être écoénergétiques, les développeurs doivent apprendre et comprendre comment déployer des modèles ML sur des systèmes basés sur des microcontrôleurs. Les modèles ML fonctionnant sur un microcontrôleur sont souvent appelés tinyML. Malheureusement, le déploiement d'un modèle sur un microcontrôleur n'est pas une tâche aisée. Néanmoins, cela devient de plus en plus facile et les développeurs sans formation spécifique constateront qu'ils peuvent le faire en peu de temps.

Cet article explique comment les développeurs de systèmes embarqués peuvent se lancer dans l'apprentissage automatique avec les microcontrôleurs STM32 de STMicroelectronics. À cette fin, il montre comment créer une application « Hello World » en convertissant un modèle TensorFlow Lite for Microcontrollers à utiliser dans STM32CubeIDE avec X-CUBE-AI.

Présentation de cas d'utilisation tinyML

TinyML est un domaine en pleine expansion qui apporte la puissance de l'apprentissage automatique à des dispositifs aux ressources et à la puissance limitées comme les microcontrôleurs, en utilisant généralement des réseaux neuronaux profonds. Ces microcontrôleurs peuvent ensuite exécuter le modèle ML et effectuer des tâches de valeur en périphérie. Il y a plusieurs cas d'utilisation où tinyML se révèle très intéressant.

Le premier cas d'utilisation, que l'on retrouve dans de nombreux appareils mobiles et équipements domotiques, est la reconnaissance de mots-clés. La reconnaissance de mots-clés permet au dispositif embarqué d'utiliser un microphone pour capturer la parole et détecter des mots-clés préalablement entraînés. Le modèle tinyML utilise une entrée chronologique représentant la parole et la convertit en fonctionnalités de parole, généralement un spectrogramme. Le spectrogramme contient des informations de fréquence dans le temps. Le spectrogramme est ensuite injecté dans un réseau neuronal entraîné à détecter des mots spécifiques. Le résultat est une probabilité de reconnaissance d'un mot donné. La Figure 1 montre un exemple du déroulement de ce processus.

Figure 1 : La reconnaissance des mots-clés est un cas d'utilisation intéressant pour tinyML. La parole en entrée est convertie en un spectrogramme, qui est injecté dans un réseau neuronal entraîné pour déterminer si un mot préalablement entraîné est présent. (Source de l'image : Arm®)

Le prochain cas d'utilisation de tinyML qui intéresse de nombreux développeurs de systèmes embarqués est la reconnaissance d'images. Le microcontrôleur capture les images d'une caméra, qui sont ensuite injectées dans un modèle pré-entraîné. Le modèle peut discerner ce qui est visible sur l'image. On pourrait par exemple déterminer s'il y a un chat, un chien, un poisson, etc. Les sonnettes vidéo constituent un excellent exemple de l'utilisation de la reconnaissance d'images à la périphérie. La sonnette vidéo peut souvent détecter si une personne est présente à la porte ou si un colis a été déposé.

Un dernier cas d'application très populaire est l'utilisation de tinyML pour la maintenance prédictive. La maintenance prédictive utilise l'apprentissage automatique pour prédire l'état des équipements sur la base de la détection d'anomalies, d'algorithmes de classification et de modèles prédictifs. Là encore, de nombreuses applications sont disponibles, s'étendant des systèmes CVC aux équipements d'usine.

Si les trois cas d'utilisation ci-dessus sont actuellement parmi les plus populaires pour tinyML, il ne fait aucun doute qu'il existe de nombreux cas d'utilisation potentiels que les développeurs peuvent identifier. En voici une liste rapide :

• Classification des gestes
• Détection des anomalies
• Relevé de compteur analogique
• Guidage et contrôle (GNC)
• Détection des colis

Quel que soit le cas d'utilisation, la meilleure façon de commencer à se familiariser avec tinyML est de réaliser une application Hello World, qui aide les développeurs à apprendre et à comprendre le processus de base qu'ils devront suivre pour mettre en place et faire fonctionner un système minimal. Cinq étapes sont nécessaires pour exécuter un modèle tinyML sur un microcontrôleur STM32 :

1. Capturer les données
2. Étiqueter les données
3. Entraîner le réseau neuronal
4. Convertir le modèle
5. Exécuter le modèle sur le microcontrôleur

Capture, étiquetage et entraînement d'un modèle Hello World

Les développeurs disposent généralement de nombreuses options pour capturer et étiqueter les données nécessaires à l'entraînement de leur modèle. Tout d'abord, il existe de nombreuses bases de données d'entraînement en ligne. Les développeurs peuvent rechercher des données que quelqu'un a collectées et étiquetées. Par exemple, pour la détection d'images de base, il y a CIFAR-10 ou ImageNet. Pour entraîner un modèle à détecter des sourires sur des photos, il existe également une collection d'images. Les référentiels de données en ligne sont clairement un bon point de départ.

Si les données requises ne sont pas encore disponibles en accès public sur Internet, une autre option est que les développeurs génèrent leurs propres données. Matlab ou un autre outil peut être utilisé pour générer les ensembles de données. Si la génération automatique de données n'est pas envisageable, elle peut être effectuée manuellement. Enfin, si tout cela vous semble trop fastidieux, il existe des ensembles de données disponibles à l'achat, également sur Internet. La collecte des données est souvent l'option la plus stimulante et la plus intéressante, mais c'est aussi celle qui demande le plus de travail.

L'exemple Hello World étudié ici montre comment entraîner un modèle pour générer une onde sinusoïdale et le déployer sur un STM32. Cet exemple a été élaboré par Pete Warden et Daniel Situnayake dans le cadre de leur travail chez Google sur TensorFlow Lite for Microcontrollers. Cela facilite le travail car ils ont mis au point un tutoriel public simple sur la capture, l'étiquetage et l'entraînement du modèle. Il est disponible sur Github ici. Puis les développeurs doivent cliquer sur le bouton "Run in Google Colab". Google Colab, abréviation de Google Collaboratory, permet aux développeurs d'écrire et d'exécuter Python dans leur navigateur sans aucune configuration et offre un accès gratuit aux GPU de Google.

La sortie de l'exemple d'entraînement contiendra deux fichiers de modèle différents : un modèle TensorFlow model.tflite quantifié pour les microcontrôleurs et un modèle model_no_quant.tflite non quantifié. La quantification indique comment les activations et les biais du modèle sont stockés numériquement. La version quantifiée produit un modèle plus petit qui convient mieux à un microcontrôleur. Les résultats du modèle entraîné par rapport aux résultats réels de l'onde sinusoïdale sont présentés à la Figure 2. La sortie du modèle est en rouge. La sortie de l'onde sinusoïdale n'est pas parfaite, mais elle fonctionne suffisamment bien pour un programme Hello World.

Figure 2 : Comparaison entre les prédictions du modèle TensorFlow pour une onde sinusoïdale et les valeurs réelles. (Source de l'image : Beningo Embedded Group)

Sélection d'une carte de développement

Avant de voir comment convertir le modèle TensorFlow pour l'exécution sur un microcontrôleur, il faut sélectionner un microcontrôleur pour le déploiement dans le modèle. Cet article se concentrera sur les microcontrôleurs STM32 car STMicroelectronics dispose de nombreux outils tinyML/ML qui fonctionnent bien pour la conversion et l'exécution des modèles. De plus, STMicroelectronics propose une grande variété de composants compatibles avec ses outils ML (Figure 3).

Figure 3 : Présentation des microcontrôleurs et du microprocesseur (MPU) actuellement pris en charge par l'écosystème IA de STMicroelectronics. (Source de l'image : STMicroelectronics)

Ces cartes sont idéales pour exécuter l'application Hello World. Toutefois, pour ceux qui souhaitent aller au-delà de cet exemple et se lancer dans le contrôle des gestes ou la reconnaissance de mots-clés, optez pour le kit Discovery STM32 B-L4S5I-IOT01A pour nœud IoT (Figure 4).

Cette carte est équipée d'un processeur Arm Cortex®-M4 basé sur la série STM32L4+. Le processeur offre 2 méga-octets (Mo) de mémoire Flash et 640 kilo-octets (Ko) de RAM, ce qui offre beaucoup d'espace pour les modèles tinyML. Le module est adaptable aux expériences du cas d'utilisation tinyML car il est également doté du microphone MEMS MP34DT01 de STMicroelectronics qui peut être utilisé pour le développement d'applications de reconnaissance de mots-clés. En outre, l'accéléromètre à trois axes LIS3MDLTR embarqué, également de STMicroelectronics, peut être utilisé pour la détection des gestes basée sur la technologie tinyML.

Figure 4 : Le kit Discovery STM32 B-L4S5I-IOT01A pour nœud IoT est une plateforme d'expérimentation adaptable pour tinyML grâce à son processeur Arm Cortex-M4, son microphone MEMS et son accéléromètre à trois axes. (Source de l'image : STMicroelectronics)

Conversion et exécution du modèle TensorFlow Lite avec STM32Cube.AI

Équipés d'une carte de développement pouvant être utilisée pour exécuter le modèle tinyML, les développeurs peuvent maintenant commencer à convertir le modèle TensorFlow Lite en quelque chose qui peut fonctionner sur le microcontrôleur. Le modèle TensorFlow Lite peut s'exécuter directement sur le microcontrôleur, mais il a besoin d'un environnement d'exécution pour le traiter.

Lorsque le modèle est exécuté, plusieurs fonctions doivent être effectuées. Ces fonctions commencent par la collecte des données des capteurs, puis leur filtrage, l'extraction des caractéristiques nécessaires et la transmission au modèle. Le modèle renvoie un résultat qui peut ensuite être filtré, puis — généralement — une action est entreprise. La Figure 5 donne un aperçu de ce processus.

Figure 5 : Flux des données des capteurs vers l'environnement d'exécution puis vers la sortie dans une application tinyML. (Source de l'image : Beningo Embedded Group)

Le plug-in X-CUBE-AI pour le STM32CubeMx fournit l'environnement d'exécution pour interpréter le modèle TensorFlow Lite et offre des exécutions alternatives et des outils de conversion que les développeurs peuvent exploiter. Le plug-in X-CUBE-AI n'est pas activé par défaut dans un projet. Cependant, après avoir créé un nouveau projet et initialisé la carte, il y a une option pour activer AI runtime sous Software Packs-> Select Components. Plusieurs options sont disponibles ici ; assurez-vous que le modèle Application est utilisé pour cet exemple, comme illustré à la Figure 6.

Figure 6 : Le plug-in X-CUBE-AI doit être activé en utilisant le modèle Application pour cet exemple. (Source de l'image : Beningo Embedded Group)

Une fois X-CUBE-AI activé, une catégorie STMicroelectronics X-CUBE-AI apparaît dans la chaîne d'outils. En cliquant sur la catégorie, le développeur aura la possibilité de sélectionner le fichier de modèle qu'il a créé et de définir les paramètres du modèle, comme illustré à la Figure 7. Un bouton d'analyse permet également d'analyser le modèle et de fournir aux développeurs des informations sur la RAM, la ROM et le cycle d'exécution. Il est fortement recommandé aux développeurs de comparer les options des modèles Keras et TFLite. Sur l'exemple du modèle d'onde sinusoïdale, qui est petit, la différence n'est pas considérable, mais elle est perceptible. Le projet peut alors être généré en cliquant sur "Generate code".

Figure 7 : Le bouton d'analyse fournit aux développeurs des informations sur la RAM, la ROM et le cycle d'exécution. (Source de l'image : Beningo Embedded Group)

Le générateur de code initialise le projet et construit l'environnement d'exécution pour le modèle tinyML. Cependant, par défaut, le modèle n'est pas alimenté. Les développeurs doivent ajouter du code pour fournir les valeurs d'entrée du modèle — les valeurs x — que le modèle interprétera ensuite et utilisera pour générer les valeurs sinusoïdales y. Quelques morceaux de code doivent être ajoutés aux fonctions acquire_and_process_data et post_process, comme illustré à la Figure 8.

Figure 8 : Le code présenté connectera des valeurs de capteurs d'entrée fausses au modèle d'onde sinusoïdale. (Source de l'image : Beningo Embedded Group)

À ce stade, l'exemple est maintenant prêt à être exécuté. Remarque : ajoutez quelques instructions printf pour obtenir la sortie du modèle pour une vérification rapide. Une compilation et un déploiement rapides permettent de faire fonctionner le modèle tinyML Hello World. En extrayant la sortie du modèle pendant un cycle complet, on obtient l'onde sinusoïdale illustrée à la Figure 9. Le résultat n'est pas parfait, mais il est excellent pour une première application tinyML. À partir de là, les développeurs peuvent relier la sortie à un modulateur de largeur d'impulsion (PWM) et générer l'onde sinusoïdale.

Figure 9 : La sortie du modèle d'onde sinusoïdale Hello World lorsqu'il est exécuté sur le STM32. (Source de l'image : Beningo Embedded Group)

Conseils et astuces pour l'apprentissage automatique sur les systèmes embarqués

Les développeurs qui souhaitent se lancer dans l'apprentissage automatique sur des systèmes basés sur des microcontrôleurs ont beaucoup à faire pour que leur première application tinyML soit opérationnelle. Il existe cependant plusieurs conseils et astuces qui peuvent simplifier et accélérer le développement :

• Passez en revue l'exemple TensorFlow Lite for Microcontrollers « Hello World », y compris le fichier Google Colab. Prenez le temps d'ajuster les paramètres et de comprendre leur impact sur le modèle entraîné.
• Utilisez des modèles quantifiés pour les applications de microcontrôleurs. Le modèle quantifié est compressé pour fonctionner avec uint8_t plutôt qu'avec des nombres à virgule flottante de 32 bits. Par conséquent, le modèle sera plus petit et s'exécutera plus rapidement.
• Explorez les exemples supplémentaires fournis dans le référentiel TensorFlow Lite for Microcontrollers. Les autres exemples incluent la détection de gestes et la reconnaissance des mots-clés.
• Prenez l'exemple Hello World en connectant la sortie du modèle à un modulateur PWM et à un filtre passe-bas pour voir l'onde sinusoïdale résultante. Expérimentez avec l'environnement d'exécution pour augmenter et diminuer la fréquence de l'onde sinusoïdale.
• Sélectionnez une carte de développement incluant des capteurs supplémentaires qui permettront de tester un large éventail d'applications ML.
• Même si la collecte de données peut se révéler être une tâche passionnante, il est généralement plus facile d'acheter ou d'utiliser une base de données open-source pour entraîner le modèle.

Les développeurs qui suivent ces conseils et astuces constateront qu'ils économisent beaucoup de temps et d'efforts lors de la sécurisation de leur application.

Conclusion

L'apprentissage automatique est arrivé en périphérie du réseau, et les systèmes basés sur des microcontrôleurs aux ressources limitées constituent une cible de choix. Les outils les plus récents permettent de convertir et d'optimiser les modèles ML pour les exécuter sur des systèmes en temps réel. Comme illustré, il est relativement facile d'exécuter un modèle sur une carte de développement STM32, malgré la complexité de la tâche. Si la discussion a porté sur un modèle simple générant une onde sinusoïdale, des modèles beaucoup plus complexes tels que la détection des gestes et la reconnaissance des mots-clés sont possibles.