L'IA de demain Glossaire
FR

← Retour au carnet

Approfondissement · Folio V

Un petit modèle qui progresse seul, sur un ordinateur ordinaire ?

Dans la page précédente, un géant servait de maître au petit modèle. Ici, on l'enlève. Il reste un modèle de 8 milliards de paramètres, un ordinateur de joueur et des nuits libres. Notre réponse tient en une phrase : le maître n'a pas besoin d'être plus intelligent que l'élève, il suffit qu'il sache dire juste ou faux. Voici le raisonnement, les calculs, et le plafond qu'on ne franchit pas si facilement.

Prometteur mise à jour du

I

L'idée, simplement

Pensez à un élève seul avec un cahier d'exercices et le corrigé. Personne ne lui explique rien. Il essaie, compare avec le corrigé, garde en mémoire ce qui a marché, et recommence. Au bout de quelques semaines, il réussit du premier coup des exercices qu'il ne réussissait qu'une fois sur cinq.

Un modèle de langage peut faire exactement la même chose. Il tente plusieurs fois le même problème, un juge trie les essais justes, et le modèle s'entraîne sur ses propres réussites. C'est l'auto-entraînement. La méthode STaR l'a montré dès 2022, et ReST-EM, chez Google, a fait mieux en apprenant de ses propres essais triés qu'en apprenant des solutions écrites par des humains.

Le point clé : le juge n'est pas un grand modèle. C'est le corrigé, un test, une règle du jeu. Vérifier est bien plus facile que trouver. Vérifier qu'une addition est juste est immédiat ; trouver la démonstration d'un théorème peut prendre des années. Cette asymétrie permet à un maître « bête » d'enseigner à un élève plus intelligent que lui.

Source : Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning (2022), Singh et al., Beyond Human Data: Scaling Self-Training for Problem-Solving (2023)

II

Pourquoi ça peut marcher : la marge cachée

Un modèle a deux notes. La première, c'est sa réussite au premier essai. La seconde, c'est sa réussite en beaucoup d'essais : la chance qu'au moins une de ses tentatives soit juste. Les chercheurs écrivent pass@1 et pass@k. L'écart entre les deux peut être énorme : chez Brown et ses coauteurs, la part de problèmes résolus grimpe régulièrement à chaque doublement du nombre d'essais.

Cet écart, c'est de la compétence cachée : le modèle « sait » trouver la réponse, mais pas de façon fiable. L'auto-entraînement transforme cette compétence cachée en compétence fiable. Il ne crée presque rien de nouveau ; il rend sûr ce qui était hasardeux.

C'est aussi sa limite, et nous y reviendrons : Yue et ses coauteurs observent que le renforcement fait monter pass@1, mais qu'avec beaucoup d'essais, le modèle de départ résout autant de problèmes, voire plus. Retenez l'image : l'entraînement remplit le verre, il ne l'agrandit pas. Bonne nouvelle pour un vieux modèle comme Llama 3 8B : moins fiable qu'un modèle récent, il a souvent un verre plus vide, donc plus de marge à remplir.

Source : Brown et al., Large Language Monkeys (2024), Yue et al., Does RL Really Incentivize Reasoning Capacity Beyond the Base Model? (NeurIPS 2025)

III

Qui dit « juste » quand il n'y a pas de maître ?

Tout repose sur le juge. Voici les juges qu'un ordinateur ordinaire peut faire tourner seul, du plus sûr au plus fragile.

Établi

Le corrigé : des exercices dont on connaît la réponse

Des milliers de problèmes de mathématiques existent avec leur réponse finale. Le juge compare simplement deux nombres. C'est le juge de ReST-EM, sur le test MATH : générer, garder les essais justes, réentraîner, recommencer. Simple et solide, mais le stock d'exercices est fini.

Source : Singh et al., Beyond Human Data: Scaling Self-Training for Problem-Solving (2023)

Prometteur

Le test : exécuter le code et regarder

Pour du code, le juge est l'ordinateur lui-même : on lance le programme, on regarde s'il passe les tests. Absolute Zero va plus loin : le modèle invente ses propres exercices de code, un interpréteur Python vérifie, et il apprend sans aucune donnée extérieure. Ses auteurs annoncent mieux que des modèles entraînés sur des dizaines de milliers d'exemples choisis par des humains.

Source : Zhao et al., Absolute Zero: Reinforced Self-play Reasoning with Zero Data (2025)

Prometteur

La règle du jeu : un problème qui se vérifie tout seul

Le jeu Countdown : atteindre un nombre cible avec quelques nombres et les quatre opérations. Vérifier une solution prend une ligne de calcul. TinyZero, à Berkeley, a appris ce jeu à un modèle de 3 milliards par renforcement, et le modèle a développé seul l'habitude de vérifier ses calculs et de chercher autrement quand il se trompe. Le tout pour moins de 30 dollars de calcul.

Source : Pan et al., TinyZero (2025)

Spéculatif

Vous : l'utilisateur qui corrige

Sur votre ordinateur, vous êtes un juge gratuit. Le code proposé a planté ? La réponse a été corrigée à la main ? Chaque correction est un exemple étiqueté. C'est notre propre idée, non testée ici : un modèle local qui apprend la nuit des corrections de la journée. Le risque : un juge humain se fatigue et se trompe.

Prometteur

Le vote : faire confiance à la majorité de ses propres réponses

Sans corrigé, on peut répondre 64 fois et prendre la réponse la plus fréquente comme « vérité ». TTRL fait exactement cela sur des problèmes sans réponse connue et annonce une hausse d'environ 211 % au concours AIME 2024 pour un modèle de 7 milliards. Fragile par nature : quand la majorité se trompe, le modèle apprend son erreur.

Source : Zuo et al., TTRL: Test-Time Reinforcement Learning (2025)

IV

Ce qui a déjà été montré

Deux résultats donnent la mesure de ce qu'on peut attendre, l'un ancien et solide, l'autre récent et spectaculaire.

Établi

STaR : apprendre de ses propres raisonnements (2022)

Le modèle écrit un raisonnement, on garde ceux qui mènent à la bonne réponse. Quand il échoue, on lui souffle la réponse et il réécrit un raisonnement qui y mène : c'est la « rationalisation ». Sur CommonsenseQA, le résultat rivalise avec un modèle 30 fois plus gros entraîné de façon classique.

Source : Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning (2022)

Prometteur

Un seul exemple suffit à beaucoup (2025)

Avec un seul problème et un renforcement vérifié, un modèle de 1,5 milliard passe de 36,0 % à 73,6 % au test MATH500. Prudence : une grande partie du saut vient de ce que le modèle apprend à présenter sa réponse au bon format ; les auteurs mesurent 8,6 points au-delà de cet effet. C'est la preuve que la compétence était déjà là, cachée.

Source : Wang et al., Reinforcement Learning for Reasoning with One Training Example (2025)

V

L'ordinateur ordinaire : est-ce que ça tient ?

Faisons les comptes pour Llama 3.1 8B, soit 8,03 milliards de paramètres. Stockés en 16 bits, ils pèsent 16 Go : trop pour la plupart des cartes graphiques. Deux astuces changent tout.

Première astuce : arrondir les poids à 4 bits, comme dans QLoRA. 8,03 milliards × 0,5 octet = 4,0 Go. QLoRA a montré qu'on peut ainsi affiner un modèle de 65 milliards sur une seule carte de 48 Go sans perdre en qualité.

Seconde astuce : ne pas toucher aux poids, mais ajouter un adaptateur (LoRA). On gèle les 8 milliards de poids et l'on entraîne seulement de petites matrices greffées à côté. Avec un rang de 16 sur toutes les couches de Llama 3 8B, le compte donne 41,9 millions de paramètres, soit 0,5 % du modèle et 84 Mo. L'entraînement garde pour chacun quatre nombres de 4 octets (le paramètre, sa correction et deux moyennes de l'optimiseur) : 41,9 M × 16 octets = 0,67 Go.

Ajoutons la mémoire de travail. Pour écrire, le modèle garde en mémoire 128 Ko par mot déjà écrit ; 16 essais de 1 000 mots en parallèle demandent 2,1 Go. Comptons encore quelques gigaoctets pour l'entraînement lui-même. Total : 9 à 10 Go. Cela tient sur une carte de joueur de 12 Go, et confortablement sur 16 ou 24 Go.

Un bonus inattendu : l'adaptateur oublie moins. Biderman et ses coauteurs montrent que LoRA apprend moins qu'un réentraînement complet en code et en maths, mais préserve mieux ce que le modèle savait déjà faire ailleurs. Pour un modèle qui s'entraîne seul pendant des semaines, oublier peu compte plus qu'apprendre vite.

Source : Dettmers et al., QLoRA: Efficient Finetuning of Quantized LLMs (2023), Biderman et al., LoRA Learns Less and Forgets Less (2024), Meta, Llama 3.1 8B Instruct model card (2024)

VI

Une nuit de travail, heure par heure

Prenons une nuit de 8 heures et découpons-la en trois temps : 6 h d'essais, 1 h d'apprentissage, 1 h de contrôle.

Les essais (6 h). Une carte de joueur haut de gamme lit sa mémoire à environ 1 000 Go par seconde ; une carte plus modeste, deux à trois fois moins vite, et la nuit donne alors deux à trois fois moins d'essais. Pour écrire un mot, le modèle relit ses 4 Go de poids : seul, il plafonnerait vers 250 mots par seconde. En menant 16 essais de front, la même lecture sert à 16 mots. Nous prenons une hypothèse prudente de 1 000 mots par seconde. En 6 h : 6 × 3 600 × 1 000 = 21,6 millions de mots, soit environ 21 600 essais de 1 000 mots. De quoi tenter 2 500 exercices 8 fois chacun (20 000 essais), avec de la marge.

L'apprentissage (1 h). On garde au plus deux essais justes par exercice, donc au plus 5 000 exemples d'environ 500 mots : 2,5 millions de mots. Apprendre coûte, en comptant large, 6 opérations par paramètre et par mot : 6 × 8 milliards × 2,5 millions = 1,2 × 10¹⁷ opérations. À un rendement effectif de 40 000 milliards d'opérations par seconde (une hypothèse, bien en dessous du maximum de ces cartes), cela prend 50 minutes.

Le contrôle (1 h). On fait passer au modèle un petit examen qu'il n'a jamais vu, et une série de questions générales, pour vérifier qu'il a progressé sans rien oublier. Si la note générale baisse, on jette l'adaptateur de la nuit. C'est la ceinture de sécurité de toute la méthode.

L'électricité. Un PC de joueur en pleine charge consomme environ 450 W (notre hypothèse). 450 W × 8 h = 3,6 kWh. Au tarif réglementé français d'octobre 2026, environ 0,20 € le kWh : 0,72 € la nuit, environ 5 € la semaine.

VII

Le calcul : nuit après nuit, jusqu'où ?

Construisons un modèle-jouet. Les exercices n'ont pas tous la même difficulté pour notre modèle : disons qu'un quart ne sont jamais réussis, 15 % le sont une fois sur dix, 25 % six fois sur dix et 35 % neuf fois sur dix. Sa note au premier essai : 0,15 × 10 % + 0,25 × 60 % + 0,35 × 90 % = 48 %.

Chaque nuit, il tente chaque exercice 8 fois. Un exercice réussi une fois sur dix donne au moins un essai juste avec une chance de 1 − 0,9⁸ = 57 % : une nuit sur deux, environ, il fournit un exemple à apprendre. Un exercice jamais réussi ne fournit rien, jamais.

Supposons que chaque exemple appris rapproche l'exercice de la réussite de 30 % du chemin restant. La note passe de 48 % à 60 % en deux nuits, 73 % en une semaine, puis ralentit. Avec un apprentissage trois fois plus lent (10 %), on n'atteint que 61 % en une semaine. Mais dans les deux cas, la courbe se rapproche de la même ligne : 75 %, exactement la part d'exercices que le modèle de départ réussissait au moins une fois en 64 essais.

Voilà la loi du plafond, en une phrase : l'auto-entraînement rapproche la note du premier essai de la note en beaucoup d'essais, pas au-delà. C'est notre traduction en chiffres de l'observation de Yue et de ses coauteurs. Le modèle-jouet est optimiste sur un point : Llama 3.1 8B a déjà été affiné après coup sur des exercices de ce genre, une partie de sa marge est donc déjà consommée.

Source : Yue et al., Does RL Really Incentivize Reasoning Capacity Beyond the Base Model? (NeurIPS 2025)

Fig. N — Nuit après nuit, la note monte vers un plafond

Apprentissage rapide : 73 % après 7 nuitsApprentissage lent : 61 % après 7 nuits

Schéma illustratif : il montre l'idée, pas des mesures.

Un modèle-jouet, pas une mesure. Un quart des exercices ne sont jamais réussis au départ, 15 % le sont une fois sur dix, 25 % six fois sur dix, 35 % neuf fois sur dix : 48 % au premier essai. Chaque nuit, 8 essais par exercice ; quand au moins un est juste, l'apprentissage rapproche cet exercice de la réussite (de 30 % ou de 10 % du chemin restant). La vitesse dépend de l'apprentissage ; le plafond, lui, ne bouge pas : un exercice jamais réussi ne donne jamais rien à apprendre.
VIII

Relever le plafond sans grand modèle

Si le plafond est ce que le modèle trouve en beaucoup d'essais, il y a trois façons de le relever, et aucune n'exige un géant.

Souffler la réponse. C'est la rationalisation de STaR : pour un exercice jamais réussi, on donne la réponse finale et l'on demande un raisonnement qui y mène. L'exercice à p = 0 donne enfin un signal. Le risque : un raisonnement qui « tombe juste » par une mauvaise route. Il faut donc un juge pour le raisonnement aussi, pas seulement pour la réponse.

Graduer les exercices. Un exercice impossible aujourd'hui devient faisable si l'on passe d'abord par des versions plus simples. Le modèle peut inventer ces marches lui-même, comme dans Absolute Zero, où il propose des exercices juste à la limite de ce qu'il sait faire. C'est l'idée de progression du carnet, appliquée à l'élève seul.

Donner des outils. Une calculatrice, un interpréteur Python, un moteur de recherche dans une bibliothèque locale. Avec un outil, des exercices hors de portée deviennent faisables parfois, et ce « parfois » suffit pour que la boucle démarre.

D'où notre hypothèse H9 : le monde peut servir de maître. Des corrigés, des tests, des règles, des outils, et le temps d'une nuit.

Source : Zelikman et al., STaR: Bootstrapping Reasoning With Reasoning (2022), Zhao et al., Absolute Zero: Reinforced Self-play Reasoning with Zero Data (2025)

IX

Mille ordinateurs ordinaires

Et si mille volontaires prêtaient leur PC la nuit ? Le calcul surprend. Mille machines × 21 600 essais = 21,6 millions d'essais par nuit. Sur nos 2 500 exercices, cela fait plus de 8 000 essais par exercice et par nuit. Le calcul cesse d'être le problème : le goulot devient le stock d'exercices vérifiables.

Que faut-il s'échanger ? Deux options. On peut s'échanger les adaptateurs (84 Mo chacun) et les fusionner. On sait entraîner un modèle à plusieurs sur internet : DiLoCo égale un entraînement classique en communiquant 500 fois moins, et INTELLECT-1, un modèle de 10 milliards, a été entraîné sur trois continents par une trentaine de fournisseurs de calcul. Mais il faut faire confiance aux poids reçus, et l'on ne peut pas les relire.

Nous préférons la seconde : s'échanger les exemples vérifiés. Une solution juste pèse environ 2 Ko ; les 5 000 exemples d'une nuit, 10 Mo. Surtout, chacun peut relancer le juge sur un exemple reçu en une fraction de seconde. Un tricheur qui envoie de faux exemples est démasqué aussitôt. On s'échange des preuves, pas des poids. C'est notre proposition, pas un résultat publié.

Source : Douillard et al., DiLoCo: Distributed Low-Communication Training (2023), Jaghouar et al., INTELLECT-1 Technical Report (2024)

X

Ce qui résiste

Le plafond. On l'a calculé : sans nouveaux exercices, sans réponse soufflée et sans outils, la note s'arrête à ce que le modèle trouvait déjà en beaucoup d'essais.

L'effondrement. Un modèle qui n'apprend que de ses propres textes peut s'appauvrir, génération après génération : Shumailov et ses coauteurs l'ont montré. Le juge extérieur limite ce risque, car il filtre sur la justesse et pas sur le style, mais il ne l'annule pas : les solutions gardées se ressemblent de plus en plus. Garder les données d'origine dans le mélange aide.

Tricher avec le juge. Un modèle apprend ce qui est récompensé, pas ce qu'on voulait. Si les tests sont faibles, il apprendra à les contourner. Un juge laxiste fabrique un élève tricheur.

Le vote qui s'emballe. Quand le juge est la majorité de ses propres réponses, une erreur fréquente devient une « vérité » qu'on renforce. Sur une nuit, c'est un risque ; sur des mois sans ancre extérieure, c'est notre principale inquiétude.

Les tâches sans juge. Écrire une lettre, donner un conseil : aucun programme ne dit quel essai est le meilleur. Ici, l'ordinateur ordinaire ne remplace pas un maître, humain ou modèle.

Source : Shumailov et al., AI models collapse… (Nature, 2024), Yue et al., Does RL Really Incentivize Reasoning Capacity Beyond the Base Model? (NeurIPS 2025), Zuo et al., TTRL: Test-Time Reinforcement Learning (2025)

XI

Nos paris, chiffrés

Ce qui suit est notre propre raisonnement, pas un résultat publié. Chaque pari porte un degré de confiance, comme les hypothèses du carnet.

Spéculatif

Une semaine de nuits suffit pour un gain net · 65 %

Llama 3.1 8B, entraîné 7 nuits sur ses propres essais triés par un corrigé, gagne au moins 5 points de réussite au premier essai au test MATH-500, sur une seule carte de joueur. Ce pari tomberait si le gain restait sous 2 points.

Spéculatif

Le plafond tient · 70 %

Sa réussite en 64 essais bouge de moins de 3 points. Ce que la boucle ajoute, c'est de la fiabilité, pas de la portée. Si ce pari tombe, c'est une excellente nouvelle : l'élève seul découvrirait vraiment du neuf.

Spéculatif

À plusieurs, le goulot est l'exercice, pas le calcul · 70 %

Un réseau de volontaires échangeant des exemples vérifiés progresse plus vite que chacun seul, mais il épuise vite les exercices disponibles. La valeur passe de la puissance de calcul aux juges et aux exercices.

Spéculatif

Sans aucune ancre extérieure, ça dérive · 60 %

Un modèle qui n'apprend que par le vote de ses propres réponses progresse d'abord, puis, sur des mois, renforce ses erreurs fréquentes et perd en diversité. Il faut toujours un morceau de monde pour dire juste ou faux.

XII

L'expérience à faire, et nos prédictions

Prendre Llama 3.1 8B, ou Llama 3 8B pour corser l'épreuve, une carte de 24 Go, et un adaptateur de rang 16. Tirer 2 500 problèmes du jeu d'entraînement de MATH, avec leurs réponses. Chaque nuit : 8 essais par problème, garder au plus deux essais justes, apprendre, puis contrôler. Sept nuits.

Mesurer avant et après : la réussite au premier essai et en 64 essais sur MATH-500, et une série de questions générales (MMLU) pour l'oubli.

Nos prédictions, écrites avant toute expérience pour qu'on puisse nous donner tort. Au premier essai : de +5 à +12 points. En 64 essais : moins de 3 points de mieux. Questions générales : moins d'un point de perte. Coût : environ 5 € d'électricité. Si le gain au premier essai reste sous 2 points, nous baisserons H9. S'il dépasse 15 points, ou si la note en 64 essais bondit, notre loi du plafond est fausse, et nous réviserons le carnet avec plaisir.

Haut de page