🔁 Apprendre à un LLM français de 15M à penser plus profond — et à savoir quand s'arrêter 🇫🇷

---

👤 Contexte — où on en était

Si tu as lu le deuxième article : un LLM français de 15M paramètres, construit from scratch, solo, sur une GTX 1080 Ti. Une semaine entière de mesurer → corriger → mesurer a prouvé que l'architecture est un seuil, pas un levier — les gains venaient des données (document packing) et du décodage (repetition_penalty 1.3), pas du modèle.

Cet article se terminait sur une promesse : passer à 25-30M avec le corpus étendu. Celui-ci, c'est le détour que j'ai pris d'abord — et c'est là que le projet est devenu vraiment intéressant.

La question que je ne pouvais pas lâcher : si optimiser ce que le modèle voit est épuisé, est-ce que je peux changer comment il apprend ? Et quand ça a échoué quatre fois de suite — est-ce que je pouvais changer la forme du calcul lui-même sans ajouter un seul paramètre ?

Le chemin : quatre échecs honnêtes, puis un transformer en boucle (issu de deux papiers) qui bat la baseline sur la perplexité, puis une combinaison que j'ai assemblée — arrêt par entropie par token, 0 paramètre, appris à l'entraînement — qui échange la qualité in-domain contre la robustesse out-of-domain. Voilà le chemin honnête, échecs et impasses inclus.

⚠️ Résultats préliminaires — 1 seed, variance non contrôlée. Chaque nombre ci-dessous est un seul run d'entraînement évalué une fois (50 prompts × 200 tokens, seed d'échantillonnage fixe). Les écarts sont réels mais petits, et je n'ai pas encore fait tourner plusieurs seeds. Traite ça comme un carnet de labo, pas un benchmark. La validation multi-seed est la prochaine étape explicite avant que quoi que ce soit devienne une affirmation.

🧬 Ce n'est pas inventé from scratch — et j'ai fait la revue de littérature pour le prouver. La profondeur adaptative par token, c'est Adaptive Computation Time (ACT, Graves 2016). Boucler un bloc partagé, c'est le Universal Transformer (Dehghani et al. 2018), récemment mis à l'échelle en Recurrent-Depth Transformer (Geiping et al. 2025, Huginn-3.5B — le RDT canonique que mes modèles suivent). L'arrêt sur confiance/entropie, c'est CALM (Schuster et al., Google 2022) entre couches. Et le travail le plus proche : LoopViT (Shu et al., 2026) combine déjà une sortie par entropie prédictive sans paramètre avec une boucle à poids partagés — deux de mes trois ingrédients, dans un seul papier. Donc la combinaison entropie + boucle n'est pas nouvelle ; LoopViT l'a fait. Ce qui reste du mien est étroit : LoopViT est vision (ARC-AGI) avec une sortie appliquée à l'inférence ; moi je fais du langage autorégressif, avec un arrêt par token, appris pendant l'entraînement. C'est une variante, pas une invention. Je montre ce que j'ai mesuré, à toi de juger.

---

🧗 La campagne "comment il apprend" — quatre échecs honnêtes

Le modèle mental en entrant : j'avais franchi le seuil d'architecture, donc les leviers restants concernaient comment les mêmes données se transforment en poids. Même corpus, mêmes paramètres — seule la dynamique d'apprentissage change. Zéro capacité ajoutée, donc impossible de dépasser le plafond des 15M. En théorie, le dernier levier valable à petite échelle.

J'ai testé rigoureusement — même corpus, mêmes epochs, même harness d'éval, seed fixe des deux côtés. Voilà le tableau :

Quatre leviers. Quatre pertes. Et un caveat sur Lion qui mérite d'être dit clairement : mon premier run Lion "a échoué" à lr=1e-4 — mais c'était juste un learning rate trop petit (Lion a besoin d'~5× moins qu'AdamW). Retesté à 2e-4 : toujours perdu, mais là c'est une comparaison honnête. Un échec dû à un mauvais réglage n'est pas le même qu'un échec de la méthode — il faut séparer les deux avant de conclure, sinon on jette de bonnes idées pour les mauvaises raisons.

Le verdict après quatre : à 15M sur un corpus français longue traîne, l'optimiseur et l'init ne sont pas le levier. Signal fort que ce qui plafonne le modèle n'est pas comment il apprend — c'est la capacité. Aucune règle de mise à jour ne crée une capacité compositionnelle que l'architecture n'a structurellement pas.

Ce qui pointait vers la seule chose que je n'avais pas touchée : la forme du calcul lui-même.

---

📚 Deux papiers, une idée — penser plus profond, pas plus large

J'ai lu deux papiers en entier (tous deux s'entraînent from scratch, tous deux à petite échelle — mon régime, pas du territoire LLM frontier) :

• "Loop, Think, & Generalize" (Kohli et al., Ohio State, COLM 2026) · arXiv:2604.07822
• "Thinking Deeper, Not Longer" (Hung-Hsuan Chen, National Central University — moins d'1M paramètres) · arXiv:2603.21676

Les deux s'appuient sur le Recurrent-Depth Transformer (Geiping et al. 2025) — la même idée centrale : le transformer recurrent-depth (ou en boucle). Au lieu d'empiler L couches distinctes, on réutilise le même bloc R fois. La profondeur effective devient L × R — sans ajouter de paramètres.

Pourquoi c'est l'opposé de chaque échec précédent : multi-token, LayerScale, têtes supplémentaires — ils demandent plus au modèle, donc ils saturent le plafond des 15M. La boucle ne demande rien de nouveau. Elle donne aux mêmes poids plus de passes pour composer ce qu'ils savent déjà.

Et ça cible exactement ma maladie. Un transformer vanilla stocke les faits par couche : il récupère "l'interprète de Imagine est Lennon" dans une couche peu profonde, puis "la femme de Lennon est Ono" dans une couche plus profonde. Si le deuxième fait vit dans une couche que le premier ne peut pas atteindre, la chaîne se brise. C'est la composition multi-sauts — et c'est précisément là où les papiers montrent que les transformers vanilla échouent et les transformers en boucle réussissent. La dérive thématique de mon modèle est le même échec déguisé.

Contrairement à Mamba ou à une nouvelle attention (qui "ont des limites" seulement à l'échelle frontier), la boucle garde mon bloc GPT-2 exact intact et le passe juste dans un for. Le premier levier architectural qui rentre vraiment dans mon échelle.

---

🛠️ La construction — trois ingrédients, deux pièges

En lisant les deux papiers complètement (les détails sont dans les annexes, pas dans les abstracts), la recette :

1. La boucle — appliquer les n_layer blocs R fois. R=1 c'est le modèle plain, intact.
2. Depth embedding — un vecteur appris par itération ajouté avant chaque passe, pour que le bloc partagé puisse distinguer "itération 1" de "itération 4".
3. Zero-init les projections résiduelles (c_proj, down_proj) — chaque bloc démarre comme une identité exacte. Les papiers montrent que sans ça, la boucle est instable et dépendante du seed.

Ensuite les deux pièges que j'ai rencontrés — du genre qu'on ne trouve qu'en faisant tourner le code, pas en lisant le papier :

Piège 1 : ne jamais combiner zero-init ET LayerScale. Zero-init rend la sortie du sous-bloc exactement 0. LayerScale calcule x + γ·0 → γ ne reçoit jamais de gradient, gelé à 1e-4 pour toujours. Les deux tricks "identité à l'init" s'annulent. Le papier 1 utilise zero-init seul ; j'ai suivi. (Bonus : c'est pourquoi mon LayerScale standalone précédent avait échoué — le trick n'a de sens que dans la boucle pour laquelle il a été conçu.)

Piège 2 : le gradient checkpointing plantait avec le dropout. R=4 signifie que le backward pass doit tenir les activations pour 32 passes de blocs (8×4) — il saturait 11 Go. Le checkpointing règle la mémoire, mais son mode non-réentrant lançait CheckpointError: 559 vs 32 tensors parce que le dropout rend le recalcul non-déterministe. Correction : preserve_rng_state=True (même masque de dropout au recalcul → numériquement correct) + determinism_check="none" (supprimer le garde trop strict).

Le VRAM de pointe est passé de out-of-memory à ~5 Go en divisant aussi le batch par deux (16→8) et en doublant l'accumulation (4→8) — même batch effectif de 64, maths identiques.

---

📊 Le résultat — la récurrence bouge la perplexité, et peu d'autre chose proprement

Je vais donner des noms aux trois variantes entraînées, parce que "adaptive-absolute-percentile" devient illisible vite :

• Cadence — la boucle plain R=4 (la référence : quatre temps réguliers par token).
• Focal — arrêt appris, seuil d'entropie absolu (concentre le calcul ; fort in-domain).
• Nomade — arrêt appris, seuil percentile (invariant à la taille ; robuste off-domain).

Cadence d'abord. R=4, même protocole 20% × 2 epochs que chaque levier raté précédent, évalué sur le harness robuste — 50 prompts × 200 tokens, seed fixe (auto = vrais prompts de corpus held-out, fixed = prompts génériques écrits à la main) :

Après quatre échecs d'affilée, quelque chose a enfin bougé la métrique dure. val_loss et PPL en baisse (−7%) — aucun autre levier dans tout le projet n'a fait ça, et ça s'aligne avec la loss d'entraînement, donc je lui fais confiance.

Mais soyons honnêtes sur le reste. Sur les prompts in-domain (auto — vrai texte de corpus), la cohérence monte (+12%) et les noms inventés baissent. Sur les prompts out-of-domain (fixed — Paris, TCP, photosynthèse…), la boucle est en fait pire que la baseline (cohérence 32.5 vs 40.7). La récurrence approfondit le raisonnement sur ce que le modèle a vu et overfitte le registre qu'il connaît ; sur des prompts éloignés c'est un défaut, pas un atout. Un seed, donc ne pas sur-lire les magnitudes — mais la direction (in-domain monte, out-of-domain descend) est cohérente entre les métriques.

⚠️ Une note sur les chiffres précédents. Mon premier eval utilisait 8 prompts × 80 tokens et rapportait des écarts dramatiques (cohérence 45.6, proper_noun −62%). C'était du bruit — une moyenne sur 8 prompts, un seed. Les chiffres 50×200 ci-dessus remplacent ceux-là. Si tu avais vu les anciennes valeurs, ignore-les.

---

👁️ Ce que les chiffres ne montrent pas — lire les générations

Les métriques mentent par omission, donc j'ai lu les sorties côte à côte, mêmes prompts, même sampling, seed fixe.

Prompt : "Au Moyen Âge, les chevaliers…"

• Baseline : "chevaliers d'Afrique se trouvaient en Algérie… l'Ovanhah (Kaflø) river, connue sous le nom de Natōnoki, appelée Rukik…" → noms inventés délirants, sauts de continent en milieu de phrase.
• Cadence : "chevaliers d'Oldmann et de Cholm… le château du village se dresse près de la rivière ; c'est le rez-de-chaussée de l'ancienne église." → invente encore des noms, mais reste dans un registre médiéval-européen cohérent (château, église). Le taux réduit de noms inventés, rendu visible.

Prompt : "La capitale de la France est…"

• Baseline : "une ville emblématique… les Pays-Bas septentrionaux… l'identité rurale du Cameroun." Salade.
• Cadence : "une ville emblématique, nichée dans un riche cadre architectural… vestiges médiévaux… ## Géographie." Aucun des deux ne dit Paris (c'est le plafond de capacité — aucun trick n'invente des faits), mais Cadence tient un seul registre au lieu de se téléporter aux quatre coins du globe.

Conclusion honnête : les modèles récurrents ne savent pas plus de faits — ils restent plus cohérents et inventent moins de noms farfelus. Ce qui est exactement la théorie. La récurrence achète de la composition et de la consistance, pas de la connaissance stockée.

---

🔬 L'expérience qui a échoué — et qui a le plus appris

Les papiers promettent un passage à l'échelle à l'inférence : entraîner une fois, puis augmenter R à la volée à la génération pour "penser plus longtemps" sur des prompts difficiles. Du raisonnement extra gratuit, sans ré-entraînement. Je devais tester ça.

J'ai chargé le modèle entraîné R=4 (poids gelés) et changé juste le nombre de boucles à la génération :

Ça a échoué — et exactement comme le papier 1 dit qu'un R fixe échoue : bloqué à sa profondeur d'entraînement, sous-calcule en dessous et sur-réfléchit au-dessus. Les papiers débloquent le scaling R libre seulement avec dynamic-R (en échantillonnant R par batch pendant l'entraînement), jamais avec un R fixe.

Mais dynamic-R ne vaut que quand "penser plus longtemps" a une profondeur cible — un graphe à k sauts = k itérations, les tâches synthétiques des papiers. Le français libre n'a pas de "nombre de sauts" à résoudre, donc je l'ai mis de côté : un run de 5-6h pour un gain qui ne mappe pas à ma tâche. Un résultat négatif qui évite un gaspillage de calcul à l'air positif, c'est quand même une victoire.

---

💡 Combiner des pièces connues — profondeur adaptative par token

C'est là que j'ai arrêté d'appliquer un papier et commencé à en combiner plusieurs.

L'intuition est venue directement de mon corpus. Tous les tokens n'ont pas besoin de la même quantité de réflexion. "le", "de", "et" — trivial, prédit-les en une passe. Mais un nom rare, un hapax — exactement les tokens qui font halluciner mon modèle — ceux-là ont besoin des quatre boucles pour être bien représentés. Alors pourquoi dépenser R=4 sur chaque token ? Laisse chaque token s'arrêter quand il est confiant, continue de boucler quand il ne l'est pas.

C'est ACT — Adaptive Computation Time (Graves 2016) : profondeur variable par token. La nouveauté, si tant est qu'il y en ait une, est dans comment j'arrête. ACT apprend une unité d'arrêt dédiée avec un "ponder cost" à régler (paramètres supplémentaires) ; idem PonderNet, le Sparse Universal Transformer, et le récent Frey et al. (2026) "Adaptive Loops" — tous utilisent un routeur d'arrêt paramétrique. Ce que je fais, c'est utiliser l'entropie de la distribution de sortie comme signal d'arrêt — une valeur que je calcule déjà, donc zéro paramètre ajouté.

Et c'est là que la revue de littérature m'a rattrapé : cette idée entropie-dans-une-boucle est déjà publiée. LoopViT (Shu et al., 2026) combine une sortie par entropie prédictive sans paramètre avec une boucle à poids partagés — exactement deux de mes trois ingrédients. Donc je n'appellerai pas ça une combinaison nouvelle. Ce qui diffère est étroit et je le dis clairement : LoopViT est de la vision (puzzles ARC-AGI) avec la sortie appliquée à l'inférence ; moi c'est du langage autorégressif, arrêt par token, et — la seule chose que mon propre échec expérimental m'a forcé à bien faire — l'arrêt est actif pendant l'entraînement, pour que le modèle apprenne à être bon à la profondeur où il s'arrête. Une variante dans un domaine différent, pas une invention.

Détail intéressant : l'un des deux papiers sources (Chen) a explicitement rejeté l'arrêt par token comme "les probabilités d'arrêt par token complexes de ACT et la régularisation du ponder cost" et est resté sur un R fixe. J'ai fait l'inverse — gardé l'arrêt par token, mais rendu le critère gratuit.

Tentative A — arrêt à l'inférence (volontairement échoué)

D'abord j'ai essayé la version cheap : prendre le modèle R=4 entraîné, et laisser les tokens confiants sortir de la boucle tôt à la génération. Sans ré-entraînement.

Ça a dégradé — monotonement avec le seuil (val PPL 28.9 → 31.1 → 34.9). Et je savais pourquoi avant même de lancer, depuis l'échec du scaling à l'inférence : le modèle n'a été entraîné qu'à être bon à R=4. Un token arrêté à R=2 est sous-calculé, parce que le modèle n'a jamais appris à produire une bonne réponse à R=2. Même maladie.

Mais cet échec m'a dit la correction. Si l'arrêt à l'inférence sous-calcule, le modèle doit apprendre à s'arrêter.

Tentative B — arrêt pendant l'entraînement (ça a marché)

Donc j'ai rendu l'arrêt actif pendant l'entraînement aussi. Maintenant chaque token s'arrête quand il est confiant pendant que le modèle apprend — ce qui force le modèle à devenir bon à la profondeur où chaque token s'arrête. Les tokens faciles apprennent à être justes à R=1-2 ; les hapax continuent de boucler jusqu'à R=4. Le gradient coule à travers l'état gelé ; la loss n'est toujours que sur la sortie finale (pensée silencieuse).

Le résultat — même protocole 20% × 2 epochs, eval robuste (50×200, un seed). Focal utilise un seuil d'entropie absolu ; Nomade utilise un seuil percentile (geler les q=30% tokens actifs les moins incertains à chaque itération — invariant à la taille, transférable à un modèle plus grand plus tard) :

Pas de gagnant unique — et c'est le résultat honnête. L'arrêt appris pousse la qualité in-domain plus loin : Focal donne la meilleure cohérence in-domain (44.1 vs 35.2 baseline) et reste le plus on-topic (prompt_overlap 0.176). Mais ça rend la faiblesse out-of-domain pire, pas meilleure (cohérence 29.1). Nomade fait l'échange inverse : il récupère la cohérence out-of-domain (41.8, meilleur de tous) et coupe les noms inventés le plus (0.094), mais rend l'avantage en perplexité (31.0 ≈ baseline). Tu choisis ton échange ; pas de déjeuner gratuit à un seed.

Tout le résultat 50×200 en un seul coup d'œil — chaque métrique sur sa propre échelle (barres depuis zéro, donc les écarts sont montrés à taille réelle, qui est modeste). Le gagnant étoilé se déplace de panneau en panneau : cette dispersion est le résultat. Cadence prend la perplexité, Focal les panneaux in-domain, Nomade les panneaux out-of-domain et hallucination. Un seed — lis le pattern, pas les décimales.

La surprise que je n'avais pas anticipée : à la génération, l'arrêt se déclenche à peine — le français libre garde l'entropie au-dessus du seuil, donc les tokens s'arrêtent rarement. J'ai instrumenté les deux modèles entraînés sur du vrai texte français pour voir exactement où les tokens arrêtent de boucler :

Focal (seuil absolu) envoie 86% des tokens à pleine profondeur — sur du vrai texte, presque rien n'est assez confiant pour sortir tôt. La règle percentile de Nomade force une cascade fixe (30% sortis après l'itération 1, puis 21%, 15%, 34% complets). L'instrumentation est validée : les logits de la boucle répliquée correspondent exactement au vrai forward pass. (Mesuré en relançant la propre boucle d'arrêt du modèle et en comptant les gels ; logits identiques confirment que le compte est fidèle.)

Donc pour Focal, l'arrêt ne se déclenche presque jamais à l'inférence — ce qui signifie que le gain vient de l'entraînement avec l'arrêt, pas de son utilisation à l'inférence. Forcer "les tokens faciles n'ont pas besoin de quatre passes" pendant l'entraînement agit comme un régulariseur — il remodèle les représentations. Je voulais rendre le modèle plus rapide sur les tokens faciles ; ce que j'ai en réalité obtenu c'est un modèle plus cohérent sur les tokens difficiles. L'intuition pointait dans la bonne direction pour une raison que je n'avais pas prédite — ce qui est exactement pourquoi on mesure plutôt que de théoriser.

Par lecture directe, Focal sur "Au Moyen Âge, les chevaliers…" → "le royaume de Brabant… reconstruit vers 1030 par une église romane…" — un registre médiéval tenu sur plusieurs phrases avec des dates cohérentes, un cran plus riche que Cadence. Toujours pas de faits (la capacité est ce qu'elle est) : ça ne peut pas te dire la capitale de la France. Comme levier de qualité c'est réel, mais modeste et directionnel à un seed — pas un titre.

---

📈 Les courbes

Les chiffres dans un tableau cachent à quel point ces runs sont proches. Voilà la loss d'entraînement pour les quatre, même protocole, mêmes axes :

Les trois variantes récurrentes (Cadence, Focal, Nomade) sont quasi indiscernables à l'entraînement — elles optimisent presque identiquement. La baseline (gris, pointillés) finit un poil plus haut. La falaise au step ~1557 est le début de l'epoch 2. Ce quasi-chevauchement est le point : les différences de qualité entre ces modèles n'apparaissent pas dans la courbe de loss — elles n'apparaissent qu'à la génération, ce qui est exactement pourquoi le harness d'eval compte plus que la loss d'entraînement.

Perplexité de validation, par epoch — là où vit le petit écart réel :

Cadence et Focal (la boucle et l'arrêt à seuil absolu) font descendre la perplexité d'~2 points ; Nomade et la baseline restent ensemble. Note que ce sont les chiffres val-PPL du log d'entraînement (ensemble de validation complet) ; les chiffres du harness d'eval ailleurs dans l'article (échantillon de 200 blocs, ex. Cadence 28.9) diffèrent d'une fraction pour la même raison que n'importe quels deux sous-échantillons.

Et le contrôle d'équité — chaque run partageait un seul schedule de learning rate, donc rien dans la comparaison n'est un artefact de schedule :

Décroissance cosinus, 7% de warmup, pic 5×10⁻⁴ — identique pour les quatre runs. Les courbes se superposent exactement, ce qui est le contrôle de sanité prévu : même optimiseur, même schedule, seule l'architecture change.

---

✅ Ce qui a marché

• 🔁 Cadence (loopé R=4) — la seule victoire nette : val_loss/PPL en baisse −7%, et taux de noms inventés plus bas in-domain. Zéro paramètre ajouté. (Universal Transformer, appliqué au français à 15M.)
• 💡 Focal & Nomade (arrêt entropique 0 paramètre, appris) — l'effet de régularisation est réel : Focal → meilleure cohérence in-domain (44.1) ; Nomade → meilleure cohérence out-of-domain (41.8) et moins de noms inventés (0.094). Zéro paramètre ajouté. Ingrédients d'ACT / CALM / LoopViT ; la variante apprise à l'entraînement est ce que j'ai testé.
• 🧱 Zero-init résiduels — rend le dépliage profond stable ; explique aussi un échec précédent.
• 🧮 Checkpointing + trick de batch — 11 Go OOM → ~5 Go, maths identiques.
• 📊 Le harness de l'article 2, correctement lancé (50×200) — c'est ce qui a tué mes propres chiffres gonflés à 8 prompts. La mesure a attrapé l'overclaim avant publication.

❌ Ce qui n'a pas marché (et c'est bien — c'est de la recherche)

• 📉 β2, Lion, multi-token, LayerScale — quatre leviers "comment il apprend", quatre pertes. La capacité, pas la dynamique d'apprentissage, est le plafond.
• 📉 Scaling R à l'inférence & arrêt inférence uniquement — un modèle à R fixe est bloqué à sa profondeur d'entraînement (sous-pense en dessous, sur-réfléchit au-dessus). L'arrêt n'aide que s'il est appris.
• 📉 Un seul "meilleur modèle" — il n'existe pas. La récurrence aide in-domain et nuit out-of-domain ; l'arrêt percentile inverse l'échange. Des outils différents, pas un classement.
• 🎯 Factualité — toujours plafonnée. La récurrence achète de la cohérence, pas de la connaissance. Aucun trick architectural n'invente des faits.

⚠️ Limites (lis ça avant de citer un chiffre)

• Un seed, pas de contrôle de variance. Chaque chiffre est un seul run évalué une fois. Les écarts sont assez petits pour que des runs multi-seed puissent les réordonner. C'est un carnet de labo, pas un benchmark.
• Les gains sont directionnels et modestes à 50×200 — rien comme les chiffres dramatiques à 8 prompts que j'ai d'abord vus (c'était du bruit).
• R=4 coûte ~4× le calcul par step — la profondeur se paye en temps, pas en paramètres.
• Les papiers sources prouvent la récurrence sur des tâches multi-sauts synthétiques ; le transfert au français libre est partiel.
• Pas nouveau — et j'ai vérifié. ACT (2016), Universal Transformer (2018), CALM (2022) précèdent les pièces, et LoopViT (2026) combine déjà une sortie entropique sans paramètre avec une boucle à poids partagés. La seule chose spécifique ici est la variante apprise à l'entraînement en langage autorégressif. J'ai fait la revue de littérature avant de publier, c'est tout l'intérêt.

---

📋 Référence rapide

---

🏁 Conclusion

L'article 2 se terminait par une règle : l'architecture est un seuil, pas un levier. Celui-ci est l'amendement honnête. Quatre tentatives de changer comment le modèle apprend l'ont confirmé — aucune n'a bougé l'aiguille. Mais changer la forme du calcul — boucler le même bloc plus profond, zéro paramètre ajouté — l'a enfin fait.

La nuance compte : le transformer en boucle n'est pas un levier de capacité (il ne peut toujours pas te dire la capitale de la France). C'est un levier de qualité, et même ça vient avec un hic — ça aide sur les prompts que le modèle connaît et nuit sur ceux qu'il ne connaît pas. La récurrence attaque la composition (chaîner ce que tu sais déjà), qui est un vrai trou dans un transformer vanilla — mais à 15M, un seed, l'effet est directionnel et modeste, pas un titre.

Puis est venue la partie que j'ai assemblée moi-même : laisser le modèle apprendre jusqu'où penser, token par token — l'idée d'ACT, avec un critère entropique à 0 paramètre, dans une boucle partagée, appris à l'entraînement. Ça a échoué la façon cheap d'abord (arrêt à l'inférence), et l'échec pointait directement vers la correction (arrêter pendant l'entraînement). Le gain n'était pas le speedup attendu mais un effet de régularisation, et ça achète un échange — in-domain vs out-of-domain — pas une victoire nette. C'est la forme honnête.

Ce que je garde vraiment de tout ça n'est pas un "meilleur modèle". C'est une méthode : un test cheap, un négatif honnête, une correction mesurée — et un harness assez impitoyable pour tuer mes propres chiffres gonflés à 8 prompts avant que je les publie. Le résultat est préliminaire (un seed) ; la validation multi-seed et une vraie revue de littérature viennent avant que quoi que ce soit soit une affirmation. Prochaine étape : le passage à l'échelle — en emportant la récurrence et l'arrêt percentile invariant à la taille, et cette fois avec des seeds. 🚀

---

🤗 Les modèles

Les trois sont sur le Hugging Face Hub, from scratch, 15M, Apache-2.0 — même tableau 50×200 sur chaque carte pour que l'échange soit visible partout :

• 🔁 Cadence-15M-fr — la référence loopée R=4 (meilleure perplexité, 28.9).
• 🎯 Focal-15M-fr — arrêt à seuil absolu (meilleur in-domain : cohérence 44.1).
• 🧭 Nomade-15M-fr — arrêt percentile, invariant à la taille (meilleur out-of-domain : cohérence 41.8, moins de noms inventés).

---

❓ Q&A

— Une baisse de 0.077 de val_loss (un seed), c'est pas trop petit pour signifier quoi que ce soit ?

Tout seul, oui — traite ça comme un indice, pas une preuve. Ce qui me fait provisoirement lui faire confiance : c'est le seul levier parmi cinq qui a bougé val_loss et PPL ensemble, et ça s'aligne avec la loss d'entraînement. Mais c'est un seed. C'est pourquoi tout l'article est estampillé préliminaire et pourquoi les runs multi-seed sont la prochaine étape, pas un tour de victoire.

— Tu n'avais pas d'abord rapporté des gains bien plus grands ?

Si — et c'est l'histoire avec une morale. Mon premier eval (8 prompts × 80 tokens) montrait une cohérence de 58.5 et une baisse de −62% des noms inventés. Relancé à 50 prompts × 200 tokens, ça devient 44.1 et −31%, avec le résultat out-of-domain qui bascule négatif. La version dramatique était du bruit sur un petit échantillon. Je laisse ça dans l'article ouvertement parce que attraper ton propre chiffre gonflé, c'est le job.

— Ton idée de profondeur adaptative est nouvelle ?

Non — et j'ai fait la revue plutôt que de deviner. La profondeur adaptative par token c'est ACT (Graves 2016) ; la boucle à poids partagés c'est le Universal Transformer (2018) ; la sortie anticipée par confiance/entropie c'est CALM (Google 2022). Et le résultat le plus proche, LoopViT (2026), combine déjà une sortie par entropie prédictive sans paramètre avec une boucle à poids partagés — donc "entropie + boucle" est pris. Ce qui reste du mien est étroit : LoopViT c'est de la vision avec une sortie à l'inférence ; le mien c'est du langage autorégressif avec un arrêt appris pendant l'entraînement, par token. C'est une variante qui vaut d'être rapportée, pas une invention. Trouver le papier qui a grillé les deux tiers de ton idée avant de publier, c'est mieux que de l'apprendre dans les commentaires.

— Si ça ne peut pas dire "Paris", à quoi ça sert ?

La factualité est un problème de capacité — 15M paramètres sur un corpus où chaque fait apparaît une fois. Aucun trick de décodage ou d'architecture n'invente de la connaissance ; je l'ai montré sur trois articles maintenant. La récurrence achète de la cohérence, pas de la connaissance — et même ça avec un échange. Levier différent, périmètre honnête.

— Ton arrêt adaptatif se déclenche à peine à la génération. Donc qu'est-ce qu'il a vraiment fait ?

C'est la partie la plus intéressante. Le gain ne vient pas d'économiser du calcul à l'inférence — sur du français libre, les tokens deviennent rarement assez confiants pour s'arrêter. Il vient de l'entraînement avec l'arrêt : forcer "les tokens faciles n'ont pas besoin de quatre passes" agit comme un régulariseur qui construit des représentations plus robustes. Je voulais rendre le modèle plus rapide sur les tokens faciles ; ce que j'ai obtenu c'est un modèle plus cohérent sur les tokens difficiles. L'idée pointait dans la bonne direction pour une raison que je n'avais pas prédite — ce qui est exactement pourquoi on mesure plutôt que de théoriser.

---

💡 Le saviez-vous ?

Un transformer à profondeur fixe est limité à une classe de complexité appelée TC⁰ — il ne peut littéralement pas exprimer certains calculs séquentiels intrinsèques, quelle que soit sa largeur. La profondeur récurrente contourne ça en rendant la profondeur variable : boucler le même bloc laisse le calcul effectif grandir avec le problème. C'est la motivation théorique pour laquelle "penser plus profond" peut aider là où "penser plus large" plafonne — une raison d'essayer la récurrence, ce qui est tout l'objet de cet article : un essai, mesuré honnêtement.

---

Théo CHARLET

Diplômé TSSR (Technicien Supérieur Systèmes et Réseaux) - Spécialisation IA/ML

Créateur d'AG-BPE (Attention-Guided Byte-Pair Encoding)

🔗 LinkedIn : https://www.linkedin.com/in/théo-charlet

🔎 RDTvlokip Search (mon moteur de recherche) : https://search.rdtvlokip.fr

🚀 En recherche d'alternance

🔗 Site : https://rdtvlokip.fr

🔗 GitHub du projet : https://github.com/RDTvlokip/GPT-2-French-From-Scratch