Découvrir concrètement le fonctionnement des modèles de langage avec GuppyLM, un petit modèle de langage

 (github.com/arman-bd)
46 points par GN⁺ 2026-04-07 | 1 commentaires | Partager sur WhatsApp
  • Un très petit modèle de langage d’environ 9 millions de paramètres, conçu pour être entraîné en moins de 5 minutes dans un seul notebook Colab
  • De la génération des données au tokenizer, à l’entraînement du modèle et à l’inférence, tout le processus s’exécute dans un environnement unique, avec prise en charge du navigateur, de Colab et du local
  • Conçu autour de « Guppy », un personnage imaginant un environnement sous-marin, qui converse avec des phrases courtes et simples, avec un fort accent sur la transparence à visée pédagogique
  • Utilise une architecture Transformer de base afin de montrer clairement la structure essentielle d’un modèle de langage, sans techniques complexes
  • Projet open source utilisant un dataset public HuggingFace et une licence MIT, permettant à tout le monde d’expérimenter et d’apprendre

Aperçu de GuppyLM

  • GuppyLM est un très petit modèle de langage d’environ 9 millions de paramètres, conçu pour dialoguer comme le personnage-poisson « Guppy »
  • Il a été pensé avec pour objectif un LLM que l’on peut entraîner soi-même en moins de 5 minutes dans un seul notebook Colab, en couvrant dans un environnement unique l’ensemble du processus, de la génération des données au tokenizer, à l’architecture du modèle, à la boucle d’entraînement et à l’inférence
  • Il a été créé pour permettre de faire directement l’expérience du fonctionnement interne d’un modèle de langage sans cluster GPU à grande échelle ni expertise spécialisée
  • Il ne génère pas de longs textes comme les grands modèles, mais c’est un modèle pédagogique qui montre de manière transparente tout le processus d’entrée, d’apprentissage des poids et de génération de sortie
  • Il peut s’exécuter dans un navigateur, sur Colab et en local, et le dataset comme le modèle sont publiés via HuggingFace

Caractéristiques du modèle

  • GuppyLM est un personnage qui pense principalement à l’environnement sous-marin, comme l’eau, la température, la lumière, les vibrations et la nourriture
  • Il utilise des phrases courtes en minuscules et ne comprend pas les concepts abstraits humains comme l’argent ou la politique
  • Il a une personnalité amicale, curieuse et simple
  • Les données d’entraînement se composent de 60 thèmes et 60 000 échantillons de dialogues synthétiques, et l’entraînement peut se faire en environ 5 minutes sur un seul GPU
  • Sa petite taille permet aussi une inférence dans le navigateur via WebAssembly

Architecture

  • Nombre de paramètres : 8.7M
  • Nombre de couches : 6
  • Dimension cachée : 384
  • Têtes d’attention : 6
  • Dimension FFN : 768 (ReLU)
  • Taille du vocabulaire : 4 096 (BPE)
  • Longueur maximale de séquence : 128 tokens
  • Normalisation : LayerNorm
  • Embeddings de position : appris
  • Tête LM : partage des poids avec l’embedding
  • Une architecture Transformer de base, sans techniques complexes comme GQA, RoPE, SwiGLU ou early exit

Personnalité et thèmes de conversation

  • Guppy parle avec des phrases courtes, des formulations en minuscules et une pensée centrée sur les sensations
  • Il réagit à divers sujets comme la nourriture, l’eau, la lumière, l’aquarium, les bulles, les reflets, la surface de l’eau et le monde extérieur
  • Les 60 thèmes principaux incluent notamment les salutations, les émotions, la température, la nourriture, la lumière, l’eau, l’aquarium, le bruit, la solitude, les rêves, les saisons, les blagues, l’amour, la santé et la télévision
Publicité

Exécution et utilisation

  • Exécution dans le navigateur

    • Effectue une inférence locale basée sur WebAssembly
    • Permet une exécution sans serveur ni clé d’API en téléchargeant un modèle ONNX quantifié d’environ 10 Mo

  • Discuter dans Colab

    • Télécharge un modèle pré-entraîné depuis HuggingFace pour l’utiliser via une interface conversationnelle
    • Il suffit d’exécuter toutes les cellules pour commencer à discuter

  • Entraînement dans Colab

    • Régler le runtime sur T4 GPU, puis exécuter toutes les cellules
    • Téléchargement du dataset, entraînement du tokenizer, entraînement du modèle et test sont effectués automatiquement
    • Le modèle obtenu peut être téléversé sur HuggingFace ou enregistré en local

  • Discuter en local

    • Installer pip install torch tokenizers, puis exécuter la commande python -m guppylm chat
    • Si la conversation devient longue, la qualité baisse à cause de la limite de 128 tokens
    • Un mode qui prend un seul prompt, renvoie une réponse, puis se termine, est également pris en charge
Publicité

Dataset

  • Utilise le dataset HuggingFace arman-bd/guppylm-60k-generic
  • Nombre d’échantillons : 60 000 (entraînement 57K / test 3K)
  • Format : {"input": "...", "output": "...", "category": "..."}
  • Nombre de catégories : 60
  • Méthode de génération : données synthétiques basées sur des templates
    • Environ 60 templates, 30 objets d’aquarium, 17 types de nourriture et 25 combinaisons d’activités permettent de générer environ 16 000 sorties uniques

Structure du projet

  • guppylm/

    • config.py : hyperparamètres du modèle et de l’entraînement
    • model.py : modèle Transformer de base
    • dataset.py : chargement des données et traitement par lots
    • train.py : boucle d’entraînement (cosine LR, AMP)
    • generate_data.py : génération de données de dialogue sur 60 thèmes
    • eval_cases.py : cas de test
    • prepare_data.py : préparation des données et entraînement du tokenizer
    • inference.py : interface de chat

  • tools/

    • make_colab.py : génération du notebook Colab
    • export_onnx.py : export vers un modèle ONNX (quantification uint8)
    • export_dataset.py : téléversement du dataset sur HuggingFace
    • dataset_card.md : description du dataset pour HuggingFace
    Publicité

  • docs/

    • index.html : démo dans le navigateur (ONNX + WASM)
    • download.sh : téléchargement du modèle et du tokenizer
    • model.onnx : modèle quantifié (~10 Mo)
    • tokenizer.json : tokenizer BPE
    • guppy.png : image du logo

Choix de conception

  • Suppression du prompt système :comme un modèle de 9M suit difficilement des instructions conditionnelles, la personnalité a été directement intégrée dans les poids au lieu d’utiliser le même prompt sur tous les échantillons

    • Cela permet d’économiser environ 60 tokens à l’inférence
    • Conversation en un seul tour : à cause de la limite de 128 tokens, la qualité baisse après 3 à 4 tours
    • Cela correspond bien au concept de « mémoire de poisson rouge » de Guppy, mais le mode un seul tour reste le plus stable
    • Conserver un Transformer de base : GQA, SwiGLU, RoPE, early exit, etc. n’apportent pas d’amélioration de qualité à l’échelle 9M et ne font qu’augmenter la complexité
    • La combinaison attention standard + ReLU FFN + LayerNorm offre des performances suffisantes
    • Utilisation de données synthétiques : afin de préserver une personnalité cohérente du personnage, une approche de génération de données basée sur des templates a été adoptée

Licence

  • Licence MIT

À lire aussi

1 commentaires

 
GN⁺ 2026-04-07
Avis sur Hacker News

  • Je me demande s’il existe une documentation pour ce projet
    Le code lui-même semble être l’une des implémentations les plus simples d’un (Not So) Large Language Model, mais il n’est pas facile à comprendre pour les développeurs qui ne sont pas familiers avec la multi-head attention, le ReLU FFN, le LayerNorm, les positional embeddings, etc.
    Ce projet a une vocation pédagogique proche de Minix. De la même manière que Minix a servi à apprendre la conception des systèmes d’exploitation, laisser les étudiants ajouter des fonctionnalités à GuppyLM pour apprendre la conception des LLM est aussi une bonne approche

    • Entrer le code dans un LLM et discuter avec lui à son sujet pourrait aussi être une bonne méthode

  • Je me demande en quoi ce projet diffère de microgpt ou de minGPT d’Andrej Karpathy

    • Je n’ai pas encore comparé, mais merci pour la suggestion. Je vais examiner ces deux projets
    • La comparaison n’est pas l’essentiel. Ce n’est pas un produit, mais un super projet expérimental

  • Il y a sur bbycroft.net/llm un exemple de visualisation 3D de petites couches de LLM. C’est très utile pour comprendre le fonctionnement interne
    On peut aussi voir la discussion associée ici

    • C’est assez chouette ! Je vais regarder ça plus en profondeur
    • Ce n’est pas directement lié, mais le projet est vraiment excellent. Ce serait bien d’ajouter un peu plus d’UI
    • Visualisation intéressante

  • C’est vraiment excellent pour s’initier aux LLM
    J’avais déjà créé autrefois mon propre modèle à partir de Paradise Lost de Milton
    Référence : wvrk.org/works/milton

  • Cela vient probablement du fait que les données d’entraînement sont entièrement en minuscules

    You> hello
Guppy> hi. did you bring micro pellets.
You> HELLO
Guppy> i don't know what it means but it's mine.
    • Bien vu ! Il semble que les tokens en majuscules n’existent pas du tout dans le tokenizer
      Malgré ça, la réaction du personnage reste bien présente

  • Je me demande s’il serait possible de créer un LLM entraîné uniquement en toki pona
    Voir le wiki Toki Pona

    • Mais il n’y a pas assez de données d’entraînement. Le cœur des LLM, ce sont d’immenses volumes de données et de ressources de calcul

  • Je travaille sur un projet où plusieurs agents LLM partagent un même monde virtuel et interagissent de façon autonome
    Ce qui est surprenant, c’est que l’existence du « monde » influence fortement le comportement du modèle
    Même avec le même modèle et le même prompt, si des éléments de l’environnement comme les contraintes de ressources, les autres agents ou la mémoire persistante changent, le résultat devient complètement différent
    Nous nous concentrons uniquement sur l’optimisation du modèle lui-même, et nous réfléchissons trop peu à son environnement d’exécution

  • J’ai enfin l’impression qu’un LLM honnête à propos du monde est arrivé
    La réponse « le sens de la vie, c’est la nourriture » me semble moins fausse que celles produites par des modèles 10 000 fois plus grands

    • Cela pourrait même être une meilleure interprétation que cette fameuse réponse
    • Le but de la vie, c’est la reproduction. La nourriture n’est qu’un moyen ; toutes les ressources et toutes les caractéristiques existent pour favoriser l’accouplement

  • L’idée est bonne, mais les exemples semblent être copiés tels quels depuis les données d’entraînement
    Je me demande comment il réagit à des requêtes inconnues

    • Presque pas du tout. Avec 9M de paramètres, la capacité est très limitée
      L’objectif de ce projet est de montrer le fonctionnement des LLM

  • Beau travail. Merci de l’avoir partagé
    Mais je me demande si, désormais, les LLM donnent vraiment l’impression d’avoir « perdu leur mystère »
    Il reste étonnant que de simples statistiques et une énorme puissance de calcul puissent produire ce genre de résultats