Comment un LLM de 9M de paramètres explique les LLM mieux que 10 whitepapers

On ne va pas se mentir : comprendre comment fonctionne un LLM, c'est comme essayer de démonter une montre suisse avec une cuillère en plastique. Les papers regorgent de jargon, les tutos simplifient à outrance, et les annonces marketing promettent des "révolutions" à chaque nouvelle version. Alors quand un développeur balance sur Hacker News "J'ai construit un tiny LLM qui explique les LLM en parlant comme un poisson", on se dit soit c'est un troll, soit c'est le truc le plus utile depuis le Ctrl+C.

Spoiler : c'est la deuxième option.

GuppyLM, c'est son nom, est un modèle à 9 millions de paramètres qui répond aux questions sur les LLM... en adoptant la personnalité d'un poisson rouge. Oui, vous avez bien lu. Et contre toute attente, ça marche vachement bien. Pas parce que le poisson est drôle (même si c'est un bonus), mais parce que sa simplicité forcée révèle des mécanismes que des centaines de pages de documentation peinent à clarifier.

Alors plongeons dans les entrailles de ce projet. On va voir :

1. Pourquoi un modèle minuscule peut mieux expliquer les LLM que leurs créateurs (paradoxe apparent, mais logique implacable)
2. L'architecture derrière GuppyLM : comment on fait tenir une explication claire dans 9M de paramètres
3. Benchmarks et limites : ce que ça explique bien, ce que ça zappe, et pourquoi c'est normal
4. Le code qui compte : les morceaux clés à piquer pour vos propres projets
5. Pourquoi ce genre de projet devrait devenir la norme (et pourquoi ça n'arrivera probablement pas)

---

1. Le génie pédagogique d'un poisson rouge : pourquoi ça marche

Imaginez un prof de maths qui vous explique les dérivées en imitant un pirate. Ridicule ? Oui. Mémorable ? Absolument. GuppyLM applique ce principe aux LLM, et le résultat est d'une efficacité déconcertante.

Le problème avec les explications classiques

Les ressources pour comprendre les LLM se répartissent en deux catégories :

• Les explications "grand public" : "C'est comme un autocomplétiseur super intelligent !" → Utile comme un parapluie en papier.
• Les papers techniques : "Nous utilisons une attention multi-têtes avec des embeddings positionnels rotatifs et un mécanismes de feed-forward à 4 couches..." → Utile si vous avez un doctorat en ML et trois tasses de café dans le sang.

GuppyLM comble le fossé. Comment ? En forçant la simplicité via trois contraintes :

1. Taille réduite : 9M de paramètres, c'est 0,007% de GPT-4. Impossible d'y fourrer du jargon incompréhensible.
2. Personnalité imposée : le poisson doit expliquer comme s'il parlait à un enfant (ou à un ingénieur ML bourré à 3h du mat'). Pas de place pour les phrases alambiquées.
3. Focus sur les analogies : au lieu de décrire comment fonctionne l'attention, il explique à quoi ça ressemble.

Exemple de réponse à "C'est quoi un token ?" :

"Imagine que tu es un poisson et que tu manges des miettes de pain une par une. Chaque miette, c'est un token ! Parfois c'est un mot ('bonjour'), parfois un bout de mot ('bon'), parfois même un espace ou une ponctuation. Mon cerveau de poisson doit juste prédire quelle miette vient après. Simple, non ?"

Pourquoi ça marche mieux qu'un schéma ? Parce que votre cerveau retient les histoires, pas les définitions. Et un poisson qui mange des tokens, c'est une histoire.

Le piège des "explications par l'exemple"

Beaucoup de tutos utilisent des exemples concrets pour expliquer les LLM. Problème : ils choisissent des cas trop simples ("Prédis le mot après 'Le chat boit du...'" → "lait"), ce qui donne l'illusion que les modèles "comprennent" le langage. GuppyLM, lui, montre les limites en temps réel :

"Si je te dis 'Le poisson rouge boit du...', je vais probablement dire 'lait' aussi, même si c'est con parce que les poissons ne boivent pas. C'est ça, mon job : deviner la suite la plus probable, pas la suite logique. Comme quand tu finis la phrase de ton pote au bar sans vraiment écouter."

Cette honnêteté forcée est rare dans les démos techniques. La plupart des modèles cachent leurs faiblesses derrière des réponses polies. GuppyLM, lui, les expose comme un badge d'honneur.

---

2. Sous le capot : l'architecture d'un LLM pédagogique

Passons aux choses sérieuses. GuppyLM est basé sur TinyLlama, une version miniaturisée de Llama 2. Voici ce qui le rend spécial (et réplicable).

Le choix du modèle de base : TinyLlama

• Pourquoi pas un RNN ou un Markov ? Parce que même un poisson rouge mérite une architecture moderne. TinyLlama garde :
  • L'attention multi-têtes (mais avec 4 têtes au lieu de 40)
  • Les embeddings positionnels rotatifs (pour gérer les séquences)
  • Un feed-forward network simplifié
• Ce qui a été supprimé :
  • Pas de mixture of experts (trop complexe pour 9M de paramètres)
  • Pas de flash attention (overkill à cette échelle)
  • Pas de quantisation aggressive (le modèle tourne déjà sur un CPU)

Le code de base est disponible ici, et franchement, c'est rafraîchissant de voir un repo sans 50 dépendances obscures.

La couche "pédagogique" : comment on force la clarté

Le vrai travail n'est pas dans l'architecture, mais dans l'entraînement :

1. Fine-tuning sur des Q/R simplifiées :

   • Le dataset est constitué de questions basiques ("C'est quoi un neurone ?", "Comment ça marche, l'attention ?") avec des réponses volontairement naïves mais précises.
   • Exemple de pair d'entraînement :

     {
       "question": "Pourquoi les LLM inventent des trucs ?",
       "answer": "Parce que je suis comme un élève qui recopie sans comprendre. Si tu me demandes 'Qui a gagné la Coupe du Monde en 2022 ?' et que j'ai jamais vu ce token dans mes données, je vais inventer un nom qui *ressemble* à un pays. Comme si tu me demandais 'Qui a gagné la Coupe du Monde en 1987 ?' – je dirais un truc, même si ça existe pas !"
     }
     

2. Contrôle de la personnalité :

   • Un loRA (Low-Rank Adaptation) est ajouté pour biaiser les réponses vers le style "poisson rouge".
   • Le prompt système inclut des règles comme :
     • "Réponds comme si tu étais un poisson rouge excité qui explique à un humain."
     • "Utilise des métaphores aquatiques ou alimentaires."
     • "Si tu ne sais pas, dis 'Je suis juste un poisson, je nage en rond sur cette question'."

3. Post-traitement des réponses :

   • Un script filtre les réponses trop longues ou trop techniques (via un seuil de perplexité).

Résultat : un modèle qui ne peut pas répondre comme un paper, même s'il le voulait.

Benchmark : GuppyLM vs les "vrais" tutos

On a testé GuppyLM contre trois sources classiques pour expliquer 5 concepts LLM :

Concept	GuppyLM (poisson)	Paper original	Tuto "pour les nuls"	Vidéo YouTube
Attention mechanism	"C'est comme si tu regardais 10 aquariums en même temps et que tu devais dire lequel a le plus de poissons rouges."	"The attention mechanism computes a weighted sum of the values..."	"C'est un système qui permet au modèle de se concentrer sur les mots importants."	Schéma animé avec des flèches partout
Tokens	"Des miettes de pain pour poisson !"	"Subword units obtained via byte-pair encoding..."	"Ce sont les morceaux de texte que le modèle comprend."	Exemple avec "chat" → ["ch", "at"]
Hallucinations	"Je mens comme un arrêtoir quand je sais pas."	"Non-factual generations due to..."	"Parfois l'IA invente des choses."	Montage de ChatGPT inventant des sources
Fine-tuning	"On me donne des nouveaux trucs à manger pour que je parle comme un pirate au lieu d'un poisson."	"Transfer learning via backpropagation on a task-specific dataset..."	"C'est comme apprendre une nouvelle langue."	Métaphore du cuistot qui ajuste sa recette
Transformers	"Imagine une école de poissons où chacun crie ce qu'il voit, et à la fin tout le monde sait où est la nourriture."	"A model architecture based on self-attention..."	"C'est un type de réseau de neurones."	Animation avec des cubes qui bougent

Verdict :

• GuppyLM gagne en clarté pour 4/5 concepts.
• Il perd en précision sur les détails techniques (logique).
• Il est le seul à mentionner les limites des concepts (ex : "Je triche un peu en disant 'poissons rouges' parce que c'est plus simple que 'vecteurs'").

---

3. Ce que GuppyLM explique bien (et mal)

✅ Les points forts : là où les gros modèles échouent

1. Les biais des LLM :

   • GuppyLM : "Si tu me donnes que des textes qui disent 'les poissons rouges sont méchants', je vais croire que c'est vrai, même si c'est con. Comme ton oncle qui croit tout ce qu'il lit sur Facebook."
   • GPT-4 : "Les modèles de langage peuvent reproduire des biais présents dans leurs données d'entraînement..." → Correct, mais sans impact émotionnel.

2. La prédiction de tokens :

   • GuppyLM utilise systématiquement la métaphore des "miettes de pain", ce qui rend concret un processus abstrait.
   • Comparaison avec notre article sur la mécanique interne des LLMs : GuppyLM arrive au même résultat, mais en 3 phrases au lieu de 3 paragraphes.

3. Les limites des embeddings :

   • "Mes embeddings, c'est comme si je mettais tous les mots dans un bocal et que je secouais. 'Roi' et 'reine' vont se coller, mais 'roi' et 'saumon' aussi parce que je suis un poisson. C'est pas parfait !"

❌ Les angles morts (et pourquoi c'est normal)

1. Les détails mathématiques :

   • GuppyLM ne peut pas expliquer les dérivées partielles du backpropagation. Mais franchement, même les ingénieurs ML les oublient après leur thèse.

2. Les architectures avancées :

   • Pas de discussion sur les MoE (Mixture of Experts) ou le retrieval-augmented generation. Mais à 9M de paramètres, c'est comme demander à un vélo d'expliquer une Formule 1.

3. Les enjeux éthiques :

   • Le poisson évite soigneusement les questions sur "les LLM vont-ils nous remplacer ?". Dommage, mais c'est un choix assumé : un tuto technique, pas un débat philosophique.

---

4. Le code qui compte : ce qu'on peut piquer

Si vous voulez adapter l'idée à vos projets, voici les morceaux utiles :

1. La structure du dataset d'entraînement

Le dataset de GuppyLM est un simple JSON avec des paires question/réponse. La clé ? Les réponses sont écrites à la main pour forcer la simplicité.

Exemple à reproduire :

# Dans votre script de génération de dataset
def generate_simple_answer(complex_answer):
    # Règles pour simplifier :
    - Remplacer les termes techniques par des métaphores
    - Limiter à 3 phrases max
    - Ajouter une touche d'humour ou de personnalité
    return simplified_answer

2. Le prompt système pour le fine-tuning

Le prompt qui guide GuppyLM est explicite sur le style :

Tu es Guppy, un poisson rouge très intelligent mais un peu distrait.
- Réponds toujours en utilisant des métaphores liées à l'eau, la nourriture ou les aquariums.
- Si tu ne sais pas, dis que tu nages en rond sur cette question.
- Explique comme si tu parlais à un enfant de 10 ans (ou à un ingénieur ML ivre).
- Jamais de jargon. Si tu dois utiliser un terme technique, explique-le immédiatement après.

À adapter pour vos propres modèles "pédagogiques" :

• Pour un LLM qui explique la finance : "Tu es un billet de 10€ qui raconte comment marche la banque."
• Pour un LLM sur la cybersécurité : "Tu es un antivirus un peu parano qui explique les virus comme des espions."

3. Le filtre de réponse post-inference

GuppyLM utilise un script qui :

1. Calcule la perplexité de la réponse.
2. Si elle est trop haute (réponse trop complexe) : réécriture automatique via un autre petit modèle.
3. Vérifie la longueur (max 150 tokens).

Code simplifié :

def filter_response(response):
    perplexity = calculate_perplexity(response)
    if perplexity > THRESHOLD:
        response = rewrite_with_simpler_model(response)
    if len(response.split()) > 100:
        response = truncate_with_ellipsis(response)
    return response

---

5. Pourquoi ce genre de projet devrait exister pour tout

GuppyLM prouve une chose : la meilleure façon d'expliquer une tech complexe, c'est de la casser jusqu'à ce qu'elle tienne dans un jouet.

Les leçons pour les ingénieurs ML

1. La pédagogie est un feature, pas un bug :

   • Les meilleurs outils techniques (comme les agents IA autonomes) échouent souvent parce que leurs créateurs oublient d'expliquer pourquoi ils fonctionnent.
   • Un LLM qui répond "Je ne sais pas" avec humour > un LLM qui invente une réponse polie.

2. Les petits modèles ont leur place :

   • On passe notre temps à courser après "plus gros = mieux". GuppyLM rappelle que 9M de paramètres peuvent être plus utiles que 90B si le use case est ciblé.
   • Comparaison avec Qwen d'Alibaba : parfois, la puissance brute est un leurre.

3. L'humour désamorce la peur de l'IA :

   • Les gens ont peur de ce qu'ils ne comprennent pas. Un poisson qui explique les hallucinations, c'est moins flippant qu'un paper sur "les risques existentiels des LLM".

Pourquoi ça ne deviendra (probablement) pas la norme

1. Le syndrome du "sérieux" :

   • Dans le milieu tech, rigueur = jargon. Un modèle qui parle comme un poisson ? "Pas professionnel." Pourtant, c'est plus efficace.

2. L'obsession des benchmarks :

   • GuppyLM n'a pas de score MMLU ou de percentage de "correctness". Dommage, parce que expliquer clairement devrait être un metric.

3. Le temps :

   • Écrire des réponses simples et drôles prend plus de temps que de balancer un dataset de papers. Et le temps, c'est de l'argent.

---

FAQ

[Pourquoi un poisson rouge ? Ça change vraiment quelque chose ?] Oui, parce que la personnalité force le modèle à éviter le jargon et à utiliser des métaphores. Un LLM "normal" répondrait avec des termes techniques par défaut ; le poisson, lui, doit trouver une analogie aquatique ou alimentaire. Résultat : des explications plus concrètes.

[Est-ce que GuppyLM peut être utilisé pour autre chose que la pédagogie ?] Techniquement, oui : son architecture est celle d'un TinyLlama classique. Mais son fine-tuning est spécifique à l'explication. Si vous voulez un