J'ai lancé un LLM local sur un Raspberry Pi de 12 ans (et ça a marché !)

FrançaisالعربيةDeutschEnglishEspañolहिन्दीBahasa Indonesia日本語한국어PortuguêsРусский中文
BBetter Stack
Computing/SoftwareConsumer Electronics

Transcript

00:00:00Voici le Raspberry Pi de première génération, sorti en 2014.
00:00:05Il dispose d'un processeur monocœur à 700 MHz et de 512 Mo de RAM.
00:00:12Pour les normes actuelles, c'est fondamentalement une calculatrice.
00:00:16Mais aujourd'hui, nous allons voir si nous pouvons pousser ce matériel de 12 ans
00:00:21jusqu'à ses limites absolues en y faisant tourner un grand modèle de langage en local.
00:00:26Dans cette vidéo, je vous montrerai quel est le tout petit modèle que vous pouvez exécuter sur un Raspberry Pi,
00:00:30nous verrons ses performances, et je vous expliquerai comment installer toutes les dépendances nécessaires
00:00:35pour que vous puissiez essayer par vous-mêmes.
00:00:37Ça va être très amusant, alors plongeons dedans.
00:00:40Honnêtement, je ne pensais pas qu'il était possible de trouver un modèle
00:00:47assez léger pour cette architecture.
00:00:49Mais après quelques recherches, j'ai fini par trouver un candidat.
00:00:52Découvrez le Falcon H1 Tiny.
00:00:54C'est un modèle incroyablement compact de seulement 90 millions de paramètres.
00:00:59Il a été développé par le Technology Innovation Institute d'Abou Dabi
00:01:03spécifiquement pour explorer les limites inférieures extrêmes de la modélisation du langage.
00:01:08Mais comment ont-ils pu concevoir un modèle aussi petit ?
00:01:10Y a-t-il une sorte de recette magique technique derrière tout ça ?
00:01:13Eh bien, pas vraiment.
00:01:14Ils utilisent essentiellement la même architecture hybride Transformer + Mamba
00:01:19que des entreprises comme IBM ont utilisée pour leurs minuscules modèles Granite 4.
00:01:24Sur lesquels j'ai également fait une vidéo, si vous voulez aller la voir.
00:01:27Mais voici le truc.
00:01:28Pour réussir à faire tenir ce modèle en mémoire, nous devons parler de quantification.
00:01:33Les modèles Falcon sont disponibles en versions 2 bits, 4 bits et 8 bits.
00:01:38Vous pourriez être tenté d'essayer la quantification IQ ou par importance, qui est ultra-légère.
00:01:43Mais il y a un piège.
00:01:45Ces nouvelles méthodes reposent sur une manipulation complexe des bits
00:01:49qui nécessite des instructions CPU modernes pour être efficace.
00:01:52Sur notre puce ARMv6 vintage de notre Raspberry Pi, ça ne passera pas.
00:01:57À la place, nous devons nous tourner vers les anciens modèles Q4,
00:02:01qui représentent la solution idéale pour notre cas.
00:02:04Cela utilise une méthode de quantification héritée de taille moyenne
00:02:07que le processeur du Pi peut réellement gérer sans s'étouffer.
00:02:11Cela nous donne le meilleur rapport intelligence par mégaoctet tout en préservant la logique.
00:02:17Mais faire fonctionner ce modèle sur ce Raspberry Pi de première génération n'est pas une mince affaire.
00:02:22Étant donné que le Pi utilise l'architecture ARMv6,
00:02:26il lui manque les instructions NEON modernes dont dépendent presque toutes les bibliothèques d'IA.
00:02:31Heureusement, il y a llama.cpp que nous pouvons utiliser pour exécuter notre inférence.
00:02:36Mais pour ce faire, nous devons compiler son binaire spécifiquement pour notre ARMv6.
00:02:42Et si vous essayiez de le compiler directement sur le Pi,
00:02:45il faudrait probablement 18 heures pour que le compilateur se termine.
00:02:49Et ce, s'il ne plante pas d'abord à cause d'un manque de mémoire.
00:02:53Alors pour contourner cela, nous devons être un peu créatifs.
00:02:56Nous devons cross-compiler ces binaires sur notre ordinateur portable au préalable en utilisant dockcross,
00:03:02en ciblant spécifiquement le jeu d'instructions ARMv6 avec l'unité mathématique VFP activée,
00:03:08puis les copier via SSH pour passer directement à l'inférence.
00:03:13C'est exactement ce que nous allons faire maintenant.
00:03:15D'abord, nous devons flasher l'OS le plus léger possible sur notre Pi en utilisant le Raspberry Pi Imager.
00:03:22Et pour une carte avec seulement 512 mégaoctets de RAM, chaque mégaoctet compte.
00:03:28Je vais donc choisir Raspberry Pi OS Lite, la version 32 bits,
00:03:32car elle n'a pas d'interface graphique et consomme au repos une infime fraction de la mémoire
00:03:38par rapport à l'OS standard, laissant presque toute notre RAM disponible pour exécuter le modèle.
00:03:44Autre note importante, assurez-vous d'utiliser les paramètres avancés
00:03:47pour préconfigurer votre Wi-Fi et activer le SSH.
00:03:51Car sur ces anciennes cartes, il est beaucoup plus facile de tout gérer à distance,
00:03:55pour ne pas avoir à vous battre avec un terminal local très lent.
00:03:58Maintenant, une fois que le Pi a démarré et que nous nous y sommes connectés en SSH, il faut régler le problème de l'ARMv6.
00:04:05Si nous essayions de compiler llama.cpp directement ici,
00:04:08le Pi passerait littéralement la prochaine journée et demie juste à traiter les fichiers d'en-tête.
00:04:13Nous allons donc le faire sur un ordinateur portable classique pour accélérer le calcul et gagner du temps.
00:04:18Clonons le code source de llama.cpp et créons un dossier de build
00:04:23dédié où nous stockerons la version compilée que nous utiliserons sur notre Raspberry Pi.
00:04:28Mais voici un autre problème.
00:04:29Mon Mac utilise l'architecture ARMv8, qui est la version 64 bits, et non l'ARMv6 32 bits.
00:04:37Et ils ont des jeux d'instructions différents.
00:04:40Pour compiler un binaire spécifiquement pour le Pi, nous devons utiliser dockcross,
00:04:45qui est une chaîne d'outils de cross-compilation qui s'exécute sur mi Mac,
00:04:48mais génère des binaires spécifiquement pour l'ancienne architecture du Pi.
00:04:53Ensuite, nous devons configurer le build.
00:04:55Et c'est là que nous devons être extrêmement précis.
00:04:58Nous devons passer des drapeaux de compilation très spécifiques.
00:05:00Tout d'abord, désactivons les bibliothèques partagées pour créer un seul binaire portable.
00:05:05Ensuite, nous devons désactiver NEON car notre Pi n'a pas ces instructions mathématiques modernes.
00:05:10Et nous devons désactiver OpenMP pour que notre empreinte mémoire reste aussi légère que possible.
00:05:15Nous supprimons essentiellement tout le confort moderne
00:05:18pour garantir que le binaire soit compatible avec notre ancienne carte Pi.
00:05:22Et maintenant, si l'on lance la compilation, en environ deux minutes, nous devrions avoir
00:05:26un binaire de complétion llama entièrement optimisé et prêt à être copié sur notre carte Pi.
00:05:31Je vais maintenant utiliser SSH pour me connecter directement à mon Pi via le réseau,
00:05:35créer un nouveau dossier sur le Pi, puis utiliser SCP pour y copier notre binaire personnalisé.
00:05:42Et une dernière chose à faire ici.
00:05:44Téléchargeons les modèles Falcon quantifiés de manière classique en 2 bits, 4 bits et 8 bits,
00:05:50car nous allons les tester les uns après les autres.
00:05:53Puis copions-les sur notre Pi un par un via le réseau dans le dossier models.
00:05:58C'est maintenant que la partie amusante commence.
00:05:59Passons sur notre Pi et exécutons notre premier test d'inférence.
00:06:03Nous allons commencer par la compression la plus agressive, le modèle quantifié en 2 bits.
00:06:07Et ici, nous devons lancer cette longue commande.
00:06:10Ce que je fais en gros ici, c'est lui envoyer une invite simple :
00:06:13“Bonjour, comment allez-vous ?” et limiter la sortie à 32 tokens.
00:06:18Et nous spécifions exactement un thread parce que, eh bien, c'est tout ce que nous avons.
00:06:22Nous gardons aussi une taille de contexte minuscule à 128 tokens pour économiser le moindre octet de RAM possible.
00:06:29Mais l'option la plus importante ici est “no-mmap”.
00:06:32Généralement, llama.cpp utilise le mapping mémoire pour charger les modèles, ce qui est idéal pour les GPU haut de gamme,
00:06:38mais c'est un cauchemar pour notre carte Pi.
00:06:41Sur un système 32 bits avec seulement 512 mégaoctets de RAM,
00:06:45mmap peut échouer s'il ne trouve pas un bloc contigu d'espace d'adressage.
00:06:50En le désactivant, nous forçons le modèle à se charger directement dans le tas (heap),
00:06:55ce qui nous donne un contrôle beaucoup plus stable sur notre mémoire limitée.
00:06:58Et cela étant dit, lançons la commande.
00:07:00Et les voilà, nos premiers tokens.
00:07:03Comme on peut le voir ici, la version 2 bits est à la peine.
00:07:08Tout d'abord, on voit qu'elle traite un seul token environ toutes les trois secondes,
00:07:14ce qui est tout à fait prévisible sur une vieille carte Raspberry Pi.
00:07:18Mais surtout, la réponse n'a aucun sens.
00:07:21Sur un modèle de 90 millions de paramètres, les poids sont tellement compressés
00:07:25que la logique linguistique s'est effondrée.
00:07:28C'est à peine cohérent, mais techniquement, ça fonctionne.
00:07:32Voyons maintenant ce qui se passe si on le remplace par le modèle 4 bits.
00:07:35Et regardez ça, on obtient maintenant une salutation cohérente en retour.
00:07:40C'est donc un succès.
00:07:42Nous avons désormais un véritable modèle d'IA qui tourne localement sur le Pi
00:07:47et répond de manière logique à nos invites.
00:07:49Alors, super !
00:07:50Poussons l'expérience encore plus loin.
00:07:53Voyons si le Pi peut gérer un modèle 8 bits.
00:07:56Et cette fois, je vais lui demander quelque chose de plus intelligent,
00:07:59comme “Quelle est la capitale de l'Albanie ?”
00:08:02Et bien, c'est faux, car la capitale de l'Albanie est Tirana,
00:08:08et ce n'est manifestement pas correct sur le plan factuel.
00:08:10Mais si je lui demande quelle est la capitale de la Belgique, il répond correctement.
00:08:15Cela nous montre quelque chose de très intéressant.
00:08:17Il semble que la réduction à 90 millions de paramètres vienne avec un coût.
00:08:22Le modèle possède peut-être des connaissances précises sur les grands pays plus populaires,
00:08:26but manque de connaissances sur les pays moins connus et probablement sur des sujets moins vulgarisés.
00:08:31Et c'est tout simplement la nature même du savoir.
00:08:33Il y a une quantité finie de connaissances que l'on peut faire tenir dans 90 millions de paramètres.
00:08:38Mais malgré tout, le résultat est super cool.
00:08:41Et c'est la confirmation que oui, il existe bel et bien des modèles d'IA assez petits
00:08:46et légers pour tourner sur un Raspberry Pi vieux de 12 ans.
00:08:50Est-ce que c'est rapide ?
00:08:51Absolument pas.
00:08:52Est-ce que c'est précis ?
00:08:53Pas forcément.
00:08:54Devriez-vous l'utiliser en production ?
00:08:55Probablement pas.
00:08:57À moins que vous ne vouliez construire un robot très, très, très, très lent.
00:09:02Mais le plus important, c'est que nous savons maintenant que c'est théoriquement possible.
00:09:06C'est en gros tout ce que je voulais prouver dans cette vidéo.
00:09:09Et pour être honnête, cette expérience était vraiment très amusante.
00:09:13Voilà donc pour vous, les amis.
00:09:14Ce sont les modèles Falcon H1 Tiny.
00:09:17Probablement les plus petits modèles d'IA qui existent actuellement.
00:09:20Et nous savons maintenant qu'ils sont effectivement assez petits pour tourner sur un Raspberry Pi de 1ère génération,
00:09:25ce qui est super cool.
00:09:27Je ne peux pas m'empêcher de me réjouir de voir à quel point ce fait est génial.
00:09:30Même si l'application pratique est inutile, ça reste super cool.
00:09:35Dites-moi dans les commentaires, les amis, si vous avez des pensées amusantes,
00:09:37des commentaires ou des remarques sur ce que vous venez de voir.
00:09:40Publiez-les dans la section des commentaires ci-dessous.
00:09:42Et si vous aimez ce genre d'analyses techniques,
00:09:45faites-le-moi savoir en explosant le bouton “j'aime” sous la vidéo.
00:09:49Et n'oubliez pas non plus de vous abonner à notre chaîne.
00:09:51C'était Andris de Better Stack, et je vous dis à bientôt dans les prochaines vidéos.

Key Takeaway

L'exécution locale d'un grand modèle de langage sur un Raspberry Pi de première génération nécessite la cross-compilation de llama.cpp pour l'architecture ARMv6 sans instructions NEON, l'utilisation d'une quantification classique Q4 en 4 bits et la désactivation du mapping mémoire via l'option “no-mmap” pour s'insérer dans les 512 Mo de RAM disponibles.

Highlights

  • Le Raspberry Pi de première génération fonctionne avec un processeur monocœur cadencé à 700 MHz et dispose de seulement 512 Mo de RAM.

  • Le modèle Falcon H1 Tiny ne compte que 90 millions de paramètres et utilise une architecture hybride Transformer + Mamba.

  • La quantification classique Q4 en 4 bits maintient la cohérence logique du modèle, contrairement à la quantification 2 bits qui détruit la logique linguistique.

  • La cross-compilation de la bibliothèque llama.cpp s'effectue en environ deux minutes sur un ordinateur portable via dockcross pour cibler le jeu d'instructions ARMv6.

  • L'utilisation de l'option “no-mmap” force le chargement du grand modèle de langage directement dans le tas (heap) pour éviter les échecs d'allocation de mémoire sur le système 32 bits.

  • Le modèle Falcon H1 Tiny exécuté sur cette configuration matérielle traite un seul token environ toutes les trois secondes.

Timeline

Limites matérielles du Raspberry Pi et caractéristiques du modèle Falcon H1 Tiny

  • Le Raspberry Pi de première génération sorti en 2014 possède un processeur monocœur à 700 MHz et 512 Mo de RAM.
  • Le modèle Falcon H1 Tiny comporte 90 millions de paramètres pour explorer les limites inférieures de la modélisation du langage.
  • L'architecture de Falcon H1 Tiny repose sur une combinaison hybride de Transformer et de Mamba.

Le matériel vieux de 12 ans présente des contraintes techniques similaires à une calculatrice par rapport aux normes actuelles. La recherche d'un modèle adapté mène au choix du Falcon H1 Tiny, développé par le Technology Innovation Institute d'Abou Dabi. Ce modèle ultra-compact partage la même structure technique sous-jacente que les modèles Granite 4 d'IBM.

Contraintes de quantification et choix du format Q4 pour l'architecture ARMv6

  • Les méthodes de quantification IQ par importance nécessitent des instructions CPU modernes absentes de la puce ARMv6.
  • La quantification classique Q4 de taille moyenne constitue la solution technique adaptée pour le processeur du Raspberry Pi.

Les versions 2 bits, 4 bits et 8 bits du modèle Falcon sont disponibles, mais les techniques de quantification les plus légères reposent sur des manipulations de bits complexes et incompatibles avec l'architecture vintage. Le format Q4 permet de préserver la logique du modèle sans provoquer l'étouffement du processeur. Ce choix technique assure le meilleur rapport entre l'intelligence préservée et l'espace mémoire occupé en mégaoctets.

Stratégie de cross-compilation avec dockcross pour contourner les lenteurs du processeur

  • L'absence d'instructions mathématiques modernes NEON impose l'utilisation de llama.cpp pour l'inférence.
  • La compilation directe sur le Raspberry Pi requiert environ 18 heures de traitement avec un risque élevé de plantage.
  • L'installation du système d'exploitation Raspberry Pi OS Lite version 32 bits maximise la RAM disponible en supprimant l'interface graphique.

La puce ARMv6 ne gère pas les bibliothèques d'IA standards. Pour éviter une attente prolongée ou un manque de mémoire, la cross-compilation s'effectue sur un ordinateur portable via l'outil dockcross en ciblant l'unité mathématique VFP. Le flashage de la carte mémoire avec la version Lite de l'OS permet d'économiser chaque mégaoctet de RAM disponible, et l'activation préalable du SSH facilite la gestion à distance sans ralentissement lié à un terminal local.

Configuration précise des drapeaux de compilation et transfert des fichiers

  • La génération du binaire sur une architecture ARMv8 nécessite une chaîne d'outils spécifique pour produire du code ARMv6 32 bits.
  • La désactivation des bibliothèques partagées, de NEON et d'OpenMP garantit la compatibilité et la légèreté du binaire.
  • Le transfert du binaire optimisé et des modèles s'effectue via les protocoles SSH et SCP.

Le code source de llama.cpp est cloné dans un dossier de build dédié sur un ordinateur portable. L'exclusion d'OpenMP limite l'empreinte mémoire au strict minimum lors de l'exécution sur la carte cible. La compilation dure environ deux minutes, après quoi le binaire personnalisé ainsi que les versions quantifiées en 2, 4 et 8 bits du modèle Falcon sont copiés dans le répertoire du Raspberry Pi.

Tests d'inférence, gestion du tas de mémoire et analyse des performances linguistiques

  • L'activation de l'option “no-mmap” force le chargement du modèle dans le tas pour stabiliser l'allocation de mémoire.
  • Le modèle quantifié en 2 bits génère des réponses incohérentes à une vitesse d'un token toutes les trois secondes.
  • Le modèle quantifié en 4 bits produit des salutations cohérentes, tandis que la version 8 bits affiche des limites factuelles sur les sujets moins documentés.

Le mapping mémoire classique échoue sur un système 32 bits doté de 512 Mo de RAM en l'absence de blocs d'adressage contigus, ce qui justifie l'usage obligatoire de “no-mmap”. Les tests avec un seul thread et un contexte réduit à 128 tokens confirment la faisabilité technique de l'inférence locale. La forte compression à 90 millions de paramètres restreint la base de connaissances du modèle aux données les plus populaires, rendant l'application impropre à la production mais valide sur le plan théorique.

Community Posts

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

Write about this video