Ce microcontrôleur à 8 $ exécute un modèle linguistique en local !

Transcript

00:00:00Voici un modèle linguistique de 28,9 millions de paramètres qui génère du texte en ce moment même, mot par mot,
00:00:08sur une puce qui coûte environ huit dollars. Pas de wi-fi, rien n'est envoyé à un serveur,
00:00:14tout se passe dans un ESP32S3, un microcontrôleur avec moins de RAM qu'un ordinateur
00:00:22des années 90. C'est de la folie. Comment est-ce possible ? Quel est le secret et comment pouvons-nous
00:00:29construire quelque chose de similaire ? Ce sont d'excellentes questions auxquelles nous allons répondre dans cette
00:00:34vidéo. Ça va être très amusant, alors c'est parti. L'ESP32S3 est donc une puce qui vous offre
00:00:46512 kilo-octets de SRAM, ce qui correspond à la quantité de mémoire rapide utilisable par la puce. En temps normal,
00:00:54si vous essayiez d'y faire tourner un LLM, le modèle entier devrait y tenir intégralement.
00:01:00Le dernier modèle linguistique qu'on ait réussi à faire tourner sur une telle puce plafonnait à 260 000 paramètres. Celui-ci
00:01:08en contient environ 110 fois plus, et l'auteur de cet exploit est un développeur ukrainien, Slava S.
00:01:16Alors, quelle est l'astuce ? Comment a-t-il fait ? Comment faire tenir un modèle de 28,9 millions de paramètres sur une puce à 8 $ ?
00:01:24La solution repose sur une idée utilisée par Google dans Gemma : les plongements par couche (per-layer embeddings). La plupart
00:01:31des paramètres d'un modèle ne font aucun calcul. Ils restent dans une table d'embeddings qui est simplement lue.
00:01:37Si la majorité des paramètres ne sert qu'à de la consultation, ils n'ont pas besoin de mémoire rapide. On peut donc
00:01:44laisser cette table dans une mémoire flash lente et économique, et ne charger que les lignes requises par le jeton actuel.
00:01:52Et la petite partie qui calcule et réfléchit au jeton suivant, la tête d'attention et le réseau feed-forward, reste dans la SRAM.
00:01:59Voilà pour le calcul. Mais la question demeure : comment faire entrer un si gros modèle dans une si petite puce ?
00:02:05La table de 25 millions de lignes réside dans la mémoire flash. C'est le plus gros morceau des
00:02:1228,9 millions de paramètres du modèle. Et la flash est très bon marché et vaste sur cette puce, qui en embarque 16 méga-octets.
00:02:20Au lieu de tenter de faire rentrer cette table dans les 512 kilo-octets de SRAM,
00:02:26elle reste stockée dans la flash. On n'en extrait qu'environ six lignes, une pour chacune des six couches du modèle.
00:02:33Cela représente environ 450 octets au total. Mais avant de trop vous enthousiasmer, il faut préciser
00:02:40qu'il s'agit d'un modèle très basique et rudimentaire. Ce n'est pas un LLM classique de type GPT. Il ne générera pas
00:02:47de code et ne répondra pas à des questions complexes. En entraînant un modèle classique de cette taille
00:02:53sur un jeu de données standard, 28 millions de paramètres ne produiraient que du charabia. Mais ce modèle a été entraîné sur
00:03:01Tiny Stories, un dataset conçu par des chercheurs de Microsoft, rédigé de façon très simple pour que
00:03:08même un tout petit modèle de quelques millions de paramètres puisse apprendre à écrire des histoires cohérentes. L'exécuter en C pur,
00:03:15sur une puce sans système d'exploitation ni interpréteur Python, provient du célèbre projet
00:03:22Llama2.c d'Andrei Karpathy. Il a montré qu'on pouvait entraîner un petit modèle et exécuter
00:03:28l'inférence uniquement avec quelques centaines de lignes de code C portable. C'est la fondation sur laquelle
00:03:35repose tout ce projet. Sans Karpathy, ce ne serait probablement pas possible. Voilà pour le fonctionnement global.
00:03:40Passons maintenant à la pratique pour le construire nous-mêmes et le tester sur la puce afin de voir ses performances.
00:03:47Pour le fabriquer vous-même, il vous faut d'abord le bon matériel, plus précisément un ESP32S3
00:03:54équipé de 16 méga-octets de flash et de 8 méga-octets de PSRAM. C'est la variante N16R8. C'est un point
00:04:03très important : vous vous souvenez de cette table de 25 millions de lignes stockée en flash ? À elle seule,
00:04:10une fois entraînée et exportée, elle pèse environ 15 méga-octets. Les cartes dotées de 4 ou 8 méga-octets de flash
00:04:17ne pourront tout simplement pas la contenir. Si vous achetez une carte pour suivre ce tutoriel, vérifiez bien
00:04:22cette caractéristique en premier. En consultant les instructions d'origine du projet, la configuration était répartie
00:04:28dans plusieurs fichiers et nécessitait des prérequis que je n'avais pas au départ. Donc,
00:04:34plutôt que de suivre la procédure à la lettre, j'ai préparé un script unique qui automatise
00:04:40l'ensemble du processus. Il vérifie la carte, installe la chaîne d'outils, prépare les données, entraîne le modèle, l'exporte, vérifie,
00:04:47compile et flashe le composant d'un seul coup. Lançons donc ce script. Un petit avertissement au passage :
00:04:55si vous réalisez l'expérience en même temps, le script prend environ 25 minutes. C'est à peu près
00:05:00le temps nécessaire pour le faire étape par étape, car il y a de nombreuses
00:05:05commandes distinctes à surveiller. La majeure partie du temps est consacrée à l'entraînement du modèle Tiny Stories.
00:05:11Cela prend environ 13 minutes sur mon MacBook. Une fois l'entraînement terminé, les LED du panneau
00:05:18se mettent à clignoter. C'est le signal que le chargement du modèle va commencer. Et une fois chargé,
00:05:24on voit apparaître le premier exemple : l'histoire d'une petite fille. Et en effet,
00:05:29on atteint bien ces neuf jetons par seconde. Mais vous remarquerez qu'à un certain moment,
00:05:33l'histoire recommence depuis le début. Le modèle tourne en boucle. Si vous souhaitez
00:05:39lui donner une invite personnalisée, j'ai inclus un exemple de script pour exécuter vos propres
00:05:44prompts. Pour cet exemple, débutons une histoire à propos d'un robot. Remarquez aussi que si vous
00:05:50modifiez le prompt, il faut reflasher l'ESP32. C'est une limite de cette méthode :
00:05:56elle ne peut exécuter qu'un seul prompt pré-enregistré à la fois. Comme vous le voyez,
00:06:02le robot est bien mentionné dans le récit, et l'histoire est effectivement différente cette fois-ci.
00:06:08Mais observez ce qui se passe après la fin du paragraphe : nous revenons à l'histoire de la petite
00:06:13fille. Je n'ai aucune idée de la raison, mais le modèle tend visiblement à revenir à cette
00:06:19histoire précise. Faisons un autre essai, cette fois avec la
00:06:24fameuse phrase d'introduction des films Star Wars, pour voir ce que cela
00:06:30donne. Le résultat est intéressant : le modèle dérive immédiatement à nouveau vers le
00:06:36récit de la petite fille. J'imagine qu'un modèle de cette taille ne comprend même pas
00:06:42ce qu'est une galaxie, ce qui explique pourquoi il ignore notre consigne. Et
00:06:47une fois de plus, le paragraphe suivant reprend la même histoire. Bien que cette expérience soit
00:06:53impressionnante et qu'un modèle générant neuf jetons par seconde sur une si petite puce soit bluffant,
00:06:59cela reste une preuve de concept très limitée. Peu importe la question posée, le modèle
00:07:06reviendra toujours à la narration d'histoires, car c'est ce pour quoi il a été entraîné. Si ce test vous a
00:07:11intéressé, j'ai réalisé une autre vidéo similaire dans laquelle j'ai testé si un Raspberry
00:07:18Pi de première génération pouvait faire tourner un vrai LLM en local. N'hésitez pas à la regarder. Voilà
00:07:24tout pour aujourd'hui. C'est ainsi qu'on fait tourner un modèle linguistique de 28,9 millions de paramètres sur une puce ESP32. Nous l'avons
00:07:32testé, cela fonctionne. Bravo à Slava pour ce projet. Que pensez-vous de cette expérience ?
00:07:38Voyez-vous des cas d'usage concrets où une telle implémentation serait utile ? Partagez vos
00:07:43impressions dans la section commentaires ci-dessous. Si vous aimez ce genre d'analyses techniques,
00:07:48faites-le-moi savoir en cliquant sur le bouton J'aime sous la vidéo. N'oubliez pas non plus de
00:07:53vous abonner à notre chaîne. C'était Andres de Betterstack, et je vous dis à bientôt pour de prochaines vidéos.

Description

A developer got a 28.9-million-parameter language model running entirely offline on an $8 ESP32-S3 microcontroller, a chip with just 512KB of RAM, using a memory trick borrowed from Google's Gemma architecture called Per-Layer Embeddings. In this video we break down how the trick actually works, reproduce the entire training and flashing process ourselves from a bare board, and put the model through some prompt tests of our own, including one it stubbornly refuses to follow. If you're curious how far you can push AI onto hardware that was never meant to run it, this one's for you. 🔗 Relevant Links Esp32-ai: https://github.com/slvDev/esp32-ai build_and_flash.sh: https://gist.github.com/andrisgauracs/ce459630660f82cf4ca7e43aa81604c7 run_prompt.sh: https://gist.github.com/andrisgauracs/e84b842d0f5e301485ecbf6654b0838e ❤️ More about us Radically better observability stack: https://betterstack.com/ Written tutorials: https://betterstack.com/community/ Example projects: https://github.com/BetterStackHQ 📱 Socials Twitter: https://twitter.com/betterstackhq Instagram: https://www.instagram.com/betterstackhq/ TikTok: https://www.tiktok.com/@betterstack LinkedIn: https://www.linkedin.com/company/betterstack 📌 Chapters: 00:00 Running an LLM on an $8 Chip 00:43 The ESP32’s Memory Problem 01:12 How Did They Make It Work? 01:30 The Per-Layer Embedding Trick 02:04 Fitting 28.9 Million Parameters 02:36 What This Tiny LLM Can Actually Do 02:58 TinyStories and Karpathy’s llama2.c 03:41 Building It Ourselves 03:47 Choosing the Right ESP32 04:23 The One-Shot Installation Script 04:52 Training and Flashing the Model 05:24 Testing the LLM at 9 Tokens per Second 05:38 Trying Custom Prompts 06:21 The Star Wars Prompt Test 06:51 Is an ESP32 LLM Actually Useful? 07:23 Final Thoughts

Community Posts

No posts yet. Be the first to write about this video!

Write about this video