From Compression to Deployment: Real-Time and Energy-Efficient FastGRNN on Ultra-Constrained Microcontrollers

Cet article présente une reproduction open-source de bout en en bout du modèle FastGRNN, démontrant son déploiement réussi sur des microcontrôleurs 8 bits et 16 bits ultra-contraints grâce à un nouveau pipeline de compression qui permet une inférence en temps réel et économe en énergie avec une grande précision et un déterminisme équivalent au bit.

L'essentiel

Imaginez que vous possédez un cerveau de robot brillant et super intelligent, conçu pour reconnaître les mouvements humains comme la marche, l'assise ou la montée d'escaliers. Habitéralement, pour faire fonctionner ce cerveau, vous avez besoin d'un ordinateur massif avec une mémoire énorme et des processeurs puissants — comme un supercalculateur dans un centre de données.

Mais et si vous vouliez mettre ce même cerveau à l'intérieur d'une montre minuscule et bon marché ou d'un simple capteur fonctionnant sur une pile bouton ? C'est le défi que relève cet article.

Voici l'histoire de la manière dont les chercheurs ont rétréci un cerveau d'IA géant pour qu'il puisse entrer dans une puce microélectronique minuscule et « idiote », en utilisant des analogies simples pour expliquer comment ils s'y sont pris.

1. Le Problème : L'« Costume trop grand »

Pendant des années, la tendance en Intelligence Artificielle (IA) a été : « plus c'est gros, mieux c'est ». Nous construisons des modèles plus grands sur des ordinateurs plus grands. Mais cet article soutient que cette approche est fragile. Elle consomme trop d'énergie, coûte trop cher et repose sur des chaînes d'approvisionnement actuellement brisées.

Les chercheurs ont posé une question différente : Pourquoi construire un nouvel ordinateur coûteux alors que nous avons déjà des milliards de minuscules et peu coûteuses puces microélectroniques dans nos maisons et nos vêtements ?

Ils ont choisi deux des puces les plus petites et les plus basiques disponibles :

• L'Arduino Uno : Une puce 8 bits (considérez cela comme une calculatrice très simple).
• L'MSP430 : Une puce 16 bits encore plus basique. Elle n'a même pas de « multiplicateur » intégré (un outil pour faire des mathématiques rapidement). Chaque problème mathématique doit être résolu lentement, étape par étape, comme si l'on faisait une division longue sur papier.

2. La Solution : Le Costume « FastGRNN »

Les chercheurs ont utilisé un type spécifique d'IA appelé FastGRNN. Considérez un modèle d'IA standard comme un manteau d'hiver en laine épais. Il est chaud (précis), mais il est trop lourd pour qu'une minuscule puce puisse le porter.

Ils ont pris ce manteau et l'ont taillé pour en faire un gilet minuscule et léger en utilisant trois astuces spécifiques :

• Astuce 1 : La factorisation de rang faible (L'astuce du « Squelette »)
  Imaginez que la mémoire de l'IA est une immense bibliothèque de livres. La plupart des livres ne sont que des copies les uns des autres. Les chercheurs ont réalisé qu'ils pouvaient jeter les doublons et ne garder qu'une version « squelette » de la bibliothèque. Ils ont compressé les énormes tables mathématiques en versions minuscules et fines qui contiennent toujours la même information.

  • Résultat : Le modèle est devenu beaucoup plus petit sans perdre sa puissance cérébrale.

• Astuce 2 : La parcimonie (L'astuce de l'« Élagage »)
  Ils ont examiné les tables mathématiques restantes et ont réalisé que beaucoup de nombres étaient essentiellement nuls (inutiles). Ils les ont entièrement coupés, comme on élague les branches mortes d'un arbre.

  • Résultat : Le modèle est devenu encore plus léger, avec moins de « branches » à traiter.

• Astuce 3 : La quantification (L'astuce de l'« Arrondi »)
  Les ordinateurs utilisent généralement des nombres très précis (comme 3,14159265). Mais les puces minuscules ne peuvent pas gérer une telle précision. Les chercheurs ont arrondi tous les nombres à des valeurs simples, proches de nombres entiers (comme 3,14).

  • Le Piège : Si vous arrondissez aveuglément, l'IA devient confuse et oublie comment reconnaître l'état de « station debout ».
  • La Solution : Ils ont ajouté une étape de Calibrage. Avant le déploiement, ils ont fait passer le modèle par quelques tests pour voir exactement quelle taille prenaient les nombres, puis ils ont ajusté les règles d'arrondi spécifiquement pour ces nombres. Cela a sauvé le modèle de l'effondrement.

3. L'Arme Secrète : La « Fiche de triche » (Table de correspondance)

Le plus grand obstacle était la puce MSP430, qui n'a pas de multiplicateur matériel. Pour calculer des courbes complexes (comme la forme en « S » utilisée en IA), cette puce doit normalement effectuer des milliers d'étapes mathématiques lentes.

Les chercheurs ont résolu cela avec une Table de correspondance (LUT - Look-Up Table).

• Analogie : Imaginez que vous êtes un chef qui doit faire un gâteau. Au lieu de mesurer la farine, le sucre et les œufs à chaque fois (lent), vous avez une « Fiche de triche » pré-établie au mur qui dit : « Si la recette demande 1 tasse de farine, prenez simplement le sac déjà mesuré ».
• Ils ont créé une table de 256 réponses pré-calculées pour les problèmes mathématiques les plus courants. Quand la puce a besoin d'une réponse, elle se contente de pointer vers la table.
• Résultat : Cela a rendu la puce 30 fois plus rapide, transformant un processus qui prenait 54 secondes en un processus qui ne prend que 1,8 seconde. Cela a permis à la puce de suivre le mouvement en temps réel (50 fois par seconde).

4. Les Résultats : Un Petit Cerveau dans un Petit Corps

Le résultat final est un modèle qui tient dans 566 octets de mémoire. Pour donner une idée de l'échelle :

• Une seule photo haute résolution fait des millions d'octets.
• Ce modèle d'IA est plus petit qu'une seule phrase dans un fichier texte.

À quel point est-ce efficace ?

• Précision : Il identifie correctement les activités humaines (marcher, s'asseoir, etc.) environ 92 % du temps.
• Vitesse : Il traite les données en temps réel, avec largement de la marge.
• Énergie : Il consomme presque aucune énergie. Lorsqu'il est simplement en veille, il utilise moins d'énergie qu'une seule goutte d'eau qui tombe. Lorsqu'il travaille, il reste suffisamment efficace pour fonctionner pendant des mois sur une pile bouton.

5. Une Particularité : La Période de « Mise en route »

Les chercheurs ont découvert quelque chose d'intéressant sur la façon dont cette IA réfléchit. Lorsque vous activez le capteur, l'IA ne sait pas immédiatement ce que vous faites. Elle a besoin d'une période de « mise en route ».

• Analogie : C'est comme un nouvel employé à son travail. Pendant les 1,5 première secondes (environ 74 étapes de données), l'IA devine. Elle peut penser que vous marchez alors que vous êtes en fait debout. Mais après environ 2,5 secondes, elle « s'installe » et devient sûre à 100 %.
• C'est une propriété de la mémoire de l'IA, pas de la puce. Cela signifie que si vous voulez détecter une chute soudaine, vous devez attendre environ 1,5 seconde pour que l'IA soit certaine.

Résumé

Cet article prouve que vous n'avez pas besoin d'un superordinateur pour avoir une IA intelligente. En utilisant des astuces de compression ingénieuses (squelettes, élagage et arrondi) et une « fiche de triche » pour les mathématiques, vous pouvez faire tenir un cerveau intelligent et économe en énergie dans les puces les plus petites, les moins chères et les plus gourmandes en énergie disponibles. C'est la démonstration que l'IA intelligente n'a pas besoin d'être grande ; elle doit simplement être efficace.

Résumé technique

Résumé technique : De la compression au déploiement : FastGRNN en temps réel et économe en énergie sur des microcontrôleurs ultra-contraints

Énoncé du problème

La trajectoire dominante de l'apprentissage automatique moderne a consisté à accroître la taille des modèles et les exigences de mémoire, une stratégie de plus en plus remise en question par les contraintes mondiales d'approvisionnement en semi-conducteurs et par les coûts croissants d'énergie et de carbone de l'inférence toujours active. Bien que le « tinyML » ait gagné du terrain, la plupart des déploiements visent des dispositifs ARM Cortex-M relativement puissants dotés d'unités de calcul en virgule flottante et de multiplicateurs matériels. Il subsiste un écart important pour le déploiement de réseaux récurrents (RNN) précis sur l'extrémité « bare-metal » du spectre silicium : les microcontrôleurs (MCU) ultra-contraints dépourvus de multiplicateurs matériels et d'unités de calcul en virgule flottante, tels que l'Arduino Uno R3 (ATmega328P) à 8 bits et l'MSP430G2553 à 16 bits. Ces dispositifs, omniprésents dans les wearables et les capteurs, offrent des coûts unitaires un ordre de grandeur inférieurs aux cibles Cortex-M, mais présentent de sévères contraintes de mémoire (512 octets de SRAM) et de calcul.

Cet article traite du défi consistant à exécuter un réseau récurrent à portes pour la reconnaissance d'activité humaine (HAR) sur ces MCU de classe kilobyte sans multiplicateur, en temps réel et sans accélérateurs spécialisés.

Méthodologie

Les auteurs présentent une reproduction open-source de bout en bout de FastGRNN, une cellule récurrente à portes compacte, adaptée pour un déploiement sur des MCU bare-metal. L'approche combine la compression algorithmique avec une optimisation spécifique au matériel.

1. Architecture du modèle et pipeline de compression

Le modèle central est une cellule FastGRNN avec une taille cachée ($H$) de 16 et une dimension d'entrée ($d$) de 3 (accélération triaxiale). Le pipeline de compression applique trois techniques orthogonales de manière séquentielle :

• Factorisation de bas rang : Les matrices de poids ($W$ et $U$) sont décomposées en produits de matrices minces ($W_1W_2^T$, $U_1U_2^T$). Les auteurs ont sélectionné un rang récurrent ($r_u$) de 8 et un rang d'entrée ($r_w$) de 2, réduisant les paramètres tout en maintenant l'expressivité.
• Sparsité par seuillage dur itératif (IHT) : Pendant l'entraînement, les entrées de magnitude top-$k$ des tenseurs de poids sont conservées tandis que les autres sont mises à zéro. Un calendrier cubique augmente la sparsité vers une cible de $s=0,5$ (50 % de sparsité) sur 50 époques, suivi de 50 époques d'ajustement fin avec un masque fixe.
• Quantification Q15 par tenseur avec étalonnage des activations : Les poids sont quantifiés au format de point fixe Q15. Crucialement, les auteurs ont constaté qu'une quantification Q15 naïve des activations causait une perte de précision catastrophique (le score F1 chutant de 0,918 à 0,16) car les magnitudes de l'état caché ($\sim 62$) dépassaient la plage Q15. Pour résoudre cela, ils ont implémenté un étalonnage des activations par tenseur : un passage préalable sur les données d'entraînement enregistre les maximums empiriques pour les tenseurs intermédiaires, appliquant une marge de sécurité de 10 % pour assigner des échelles uniques. Cela permet aux tenseurs comme l'état caché d'utiliser une plage effective plus large (approchant le Q9.6) tout en préservant la pleine résolution Q15 pour les portes bornées.

2. Optimisation sans multiplicateur (Tables de correspondance - LUT)

Pour remédier à l'absence de multiplicateurs matériels et au coût élevé des fonctions transcendantes calculées par logiciel ($\sigma$ et $\tanh$), les auteurs ont remplacé les appels de fonctions au runtime par une table de correspondance (LUT) de 256 entrées stockée en Flash.

• La LUT couvre le domaine d'entrée $[-8, +8]$. Les valeurs en dehors de ce domaine saturent à $\pm 1$.
• À l'intérieur du domaine, les valeurs sont récupérées via une interpolation linéaire entre les entrées adjacentes.
• Cela remplace les calculs transcendants coûteux par des comparaisons simples, des chargements indexés et un produit-somme, accélérant considérablement l'inférence sur l'MSP430G2553.

3. Détails d'implémentation

• Entraînement : Réalisé sur PyTorch 2.x sur un CPU de bureau utilisant le jeu de données HAPT (30 sujets, 6 activités, échantillonnage à 50 Hz).
• Déploiement : Un fichier source C portable unique (fastgrnn.cpp) se compile sans modification pour les toolchains AVR (Arduino) et MSP430.
• Mémoire : Le modèle déployé occupe finalement 566 octets de Flash (283 paramètres Q15 non nuls + échelles + LUTs) et utilise environ 300 octets de SRAM pour l'ensemble de travail au runtime, s'insérant dans les 512 octets de SRAM de l'MSP430G2553.

Principales contributions

L'article étend le travail original sur FastGRNN avec quatre contributions spécifiques :

1. Inférence déterministe bit-équivalente multiplateforme : Le même code C produit des trajectoires d'état caché identiques et une concordance de prédiction de 100 % sur 3 399 fenêtres de test sur les cibles 8 bits et 16 bits, correspondant à une référence FP32 PyTorch.
2. Recette de LUT déployable pour les cibles sans multiplicateur : Une LUT de 256 entrées pour $\sigma$ et $\tanh$ accélère l'inférence de fenêtre complète sur l'MSP430G2553 de 30,5× (réduisant le temps d'inférence d'environ 54 s à 1,8 s), permettant un streaming en temps réel à 50 Hz.
3. Caractérisation de la latence de préchauffage récurrent : L'étude quantifie que la stabilité de la prédiction nécessite un échantillon médian de 74 échantillons (1,48 s) d'évolution de l'état caché, avec un pire cas de 125 échantillons (2,50 s). Cette latence est une propriété inhérente à la dynamique récurrente, et non au matériel.
4. Caractérisation énergétique du matériel : En utilisant un capteur INA226, les auteurs ont mesuré une puissance d'inférence active de 17,7 mW et une puissance au repos de < 0,09 mW. La LUT a permis une réduction de 96,7 % de l'énergie par fenêtre d'inférence (31,5 mJ contre 954 mJ sans LUT) en réduisant le temps d'activité requis pour respecter l'échéance de 50 Hz.

Résultats

• Précision : Le modèle déployé (Seed 0) a atteint un score F1 macro de 0,918 sur le test HAPT. La moyenne sur cinq graines pour le pipeline Q15/LUT était de 0,853 ± 0,107.
• Performance en temps réel : Les deux plateformes ont maintenu un streaming à 50 Hz avec zéro échantillon hors budget.
  • Arduino Uno R3 : 9,21 ms par échantillon (46 % du budget de 20 ms).
  • MSP430G2553 : 13,0 ms par échantillon (65 % du budget de 20 ms).
• Efficacité : Le modèle est 44× plus petit qu'un modèle de base MLP standard et s'exécute sur un matériel sans unité de calcul en virgule flottante.
• Performance par classe : Les classes statiques (Assis, Debout, Couché) maintiennent un F1 élevé. La classe « Descente d'escaliers » est restée la plus difficile, ce qui est cohérent avec la littérature plus large sur l'HAR, bien qu'elle ait récupéré un F1 d'environ 0,91 après l'étalonnage de la quantification.

Signification et affirmations

L'article affirme fournir une « preuve d'existence » concrète que les architectures récurrentes compactes, combinées à une quantification étalonnée, des activations par table de correspondance et un profilage énergétique mesuré, peuvent offrir une reconnaissance d'activité humaine précise et économe en énergie sur des microcontrôleurs aux ressources extrêmement limitées sans accélérateurs spécialisés.

Les auteurs soulignent que ce travail démontre la viabilité de « réduire l'échelle » de l'IA pour l'adapter au silicium existant et produit en masse (spécifiquement l'MSP430G2553 sans multiplicateur), offrant une voie pour réduire l'empreinte énergétique et les dépendances de la chaîne d'approvisionnement. Le travail met en évidence que la latence de « préchauffage » des modèles récurrents est un facteur critique, souvent négligé, pour les temps de réponse réels face à l'utilisateur. Enfin, l'article établit qu'une inférence bit-équivalente entre différents ISA (8 bits vs 16 bits) est réalisable, ce qui est significatif pour les applications critiques en matière de sécurité où la validation réglementaire exige une reproductibilité stricte.

Tout le code, les modèles et les binaires de déploiement sont disponibles publiquement sous licence Apache 2.0.