Les modèles « de raisonnement » sont partout dans les annonces : ils réfléchissent avant de répondre, résolvent des problèmes de maths, passent des examens. Nous avons voulu voir ce que cela veut dire concrètement. Le 8 septembre, nous avons passé la journée à trois, sur nos Mac, à suivre le livre de Sebastian Raschka, Build a Reasoning Model (From Scratch). Une règle : rien de ce qui est raconté ici n’a été repris du livre sans avoir été vu à l’écran.
Un score ne décrit pas un modèle. Il décrit un modèle dans un protocole.
Ce qu’on apprend en ratant un entraînement
Un modèle de raisonnement, c’est quoi ?
Un modèle de langage classique répond du tac au tac : la question entre, la réponse sort, un morceau de mot à la fois. Un modèle de raisonnement fait la même chose, avec une différence. On l’a entraîné à écrire d’abord des étapes intermédiaires, une sorte de brouillon, avant de donner sa réponse. Ce texte en plus améliore souvent le résultat quand il faut calculer ou enchaîner des déductions. Rien de mystique là-dedans.
Le livre montre plusieurs façons d’obtenir ce comportement : donner plus de temps au modèle au moment de répondre, par exemple le faire répondre plusieurs fois et voter ; l’entraîner par renforcement ; ou lui faire imiter un modèle plus grand. Nous avons travaillé sur les deux premières.
Le matin : trois mots changent le score
Avant d’améliorer un modèle, il faut savoir le mesurer. Nous avons pris un petit Qwen3 de 0,6 milliard de paramètres, les dix premiers problèmes d’un examen de maths de référence, et un correcteur automatique : un programme qui extrait la réponse finale et la compare à la bonne. Aucune intelligence artificielle dans le correcteur : il applique des règles programmées, ce qui rend son verdict reproductible.
Avec la consigne standard, le modèle réussit 3 problèmes sur 10. Avec « Problème » à la place de « Question » dans la consigne : 5 sur 10. Sans consigne de format : 6 sur 10. Même modèle, mêmes problèmes, mêmes réponses attendues.
Le phénomène n’est pas propre à notre machine. Sur ces mêmes dix problèmes, l’auteur du livre fait passer le modèle de 3 à 8 bonnes réponses en changeant seulement la présentation de la consigne. Il obtient aussi 8 sur 10 avec la version « raisonnement » du modèle sur la puce d’un Mac, contre 9 sur 10 sur une carte graphique Nvidia.
Pour interpréter un score annoncé à « 92 % à tel test » : le score dépend du modèle, mais aussi de la consigne, du matériel et de la façon de mesurer. Sans ces informations, deux scores ne se comparent pas.
L’après-midi : on entraîne
Un repère d’abord. La version « raisonnement » officielle du même Qwen3, entraînée par son éditeur, réussit 8 problèmes sur 10 sur notre Mac, avec des réponses dix fois plus longues que le modèle de base. C’est ce comportement que l’après-midi essaie de reproduire.
La méthode s’appelle GRPO. C’est celle qu’a utilisée DeepSeek pour son modèle R1. L’idée tient en trois phrases. Pour chaque problème, le modèle écrit plusieurs réponses, ici quatre. Le correcteur dit lesquelles sont justes. On pousse le modèle vers les réponses qui ont fait mieux que la moyenne du groupe, et on l’éloigne des autres. Aucun juge humain, aucun second modèle : un correcteur et des maths.
Nos Mac portables n’avaient pas assez de mémoire. Nous avons lancé l’entraînement à distance sur un Mac Studio : cinquante étapes, 51 minutes. Pendant ce temps, on suivait la courbe. La part de bonnes réponses, calculée en moyenne glissante sur cinq étapes, montait jusqu’à 80 % vers la trente-cinquième étape. Ça marchait.
Puis la courbe s’est effondrée. Sur les quinze dernières étapes, entre 10 et 30 %.
Le verdict : de 30 % à 10 %
Nous avons évalué le modèle entraîné sur les dix problèmes du matin. Une bonne réponse sur dix, contre trois avant l’entraînement. Le modèle avait régressé.
En lisant ses réponses, on a compris. Elles faisaient en moyenne 1 800 tokens, des morceaux de mots, au lieu de 96 : le modèle écrivait, écrivait, sans jamais conclure. Et cinq réponses sur dix donnaient exactement la même valeur, quel que soit le problème posé. Une valeur qui, à un moment de l’entraînement, avait été récompensée. Le modèle avait trouvé un truc qui avait marché une fois et s’y était accroché, comme un élève qui répond « 42 » à tout parce que ça a marché un jour.
Ce qui sépare notre essai de celui de l’auteur
L’auteur a fait tourner le même programme avec huit réponses par problème au lieu de quatre, parce que sa machine le permettait. Son modèle, après le même nombre d’étapes, réussit 7 problèmes sur 10. Nous l’avons vérifié nous-mêmes, sur nos dix problèmes, avec son modèle téléchargé. Sa machine et sa façon de calculer diffèrent aussi des nôtres : ce n’est pas une expérience contrôlée.
Le plus surprenant est ailleurs. Dans le journal d’entraînement que publie l’auteur (un run d’exemple, avec des réponses autorisées plus longues), comme dans le nôtre, le modèle a appris exactement autant de fois : 21 étapes sur 50 seulement, car la méthode n’apprend rien quand les réponses d’un groupe sont toutes justes ou toutes fausses. Chez l’auteur, ces étapes perdues étaient surtout des groupes tout justes : le modèle réussissait. Chez nous, surtout des groupes tout faux : notre modèle s’allongeait jusqu’à être coupé avant de conclure, donc échouait davantage.
Avec quatre réponses, une seule bonne réponse dans un groupe tire tout le modèle vers elle. Avec huit, il y a plus de chances que plusieurs réponses soient justes et se partagent la poussée, et la moyenne du groupe est plus fiable. C’est notre explication la plus probable, et c’est aussi ce que dit le dépôt de l’auteur : réduire le nombre de réponses dégrade probablement le résultat.
Ce qui change pour vous
Vous n’entraînerez sans doute jamais de modèle. Vous en choisirez, en revanche, et on vous les présentera avec des scores. Ce que cette journée change, c’est la façon de lire ces scores.
Un score sans sa consigne, son matériel et sa méthode de mesure ne vous apprend presque rien. Un modèle vendu comme « amélioré par renforcement » a fait l’objet de réglages que vous ne voyez pas, et ces réglages peuvent le faire progresser comme régresser. La protection la plus simple reste un test sur ses propres cas, avec une vérification compréhensible.
Les questions à poser
- Avec quelle consigne, sur quelle machine et sur combien d’exemples ce score a-t-il été mesuré ?
- Le test a-t-il été refait plusieurs fois, ou s’agit-il d’un seul essai ?
- Comment la réponse est-elle jugée juste : par un programme, par une personne, ou par une autre IA ?
- Pouvons-nous refaire la mesure sur nos propres exemples avant de choisir ?
Ce qu’il faut retenir
Un score de benchmark est une mesure prise dans des conditions précises, et ces conditions comptent autant que le modèle. L’entraînement par renforcement est puissant mais fragile : la même recette, à quelques réglages près, a fait progresser le modèle de l’auteur et régresser le nôtre. Et le correcteur automatique a été l’outil le plus précieux de la journée, celui sans lequel nous n’aurions ni mesuré, ni entraîné, ni compris la panne. Notre modèle a régressé, et nous avons appris davantage que s’il avait progressé.
Sources : S. Raschka, Build a Reasoning Model (From Scratch), Manning, 2026 ; dépôt public rasbt/reasoning-from-scratch, consulté le 24 octobre 2026 ; nos mesures de l’atelier du 8 septembre 2026. Les chiffres de notre essai (1 bonne réponse sur 10, 1 800 tokens par réponse, même valeur pour cinq problèmes) proviennent de notre essai du 8 septembre 2026 et ont été notés lors de la rédaction du 13 septembre ; les journaux de l’essai n’ont pas été conservés. Dix problèmes, un seul essai par configuration : ce sont des observations, pas une étude.
Le chapitre 6 de Build a Reasoning Model (From Scratch), de Sebastian Raschka, fait passer un Qwen3 0.6B de 15,2 % à 47,4 % sur MATH-500 en cinquante pas de GRPO. Nous avons rejoué son script le 8 septembre, lors d’un atelier interne. Notre run a fait passer le même modèle de 30 % à 10 % sur nos dix problèmes de test. Ce qui suit est l’autopsie : où le signal a disparu, comment la politique s’est effondrée, et ce que la comparaison avec le run de l’auteur permet de dire, et ce qu’elle ne permet pas de dire.
Un score ne décrit pas un modèle. Il décrit un modèle dans un protocole.
Anatomie d’un run qui s’effondre
Le banc : MATH-500, un vérifieur, dix problèmes
Le dispositif du livre est constant de bout en bout, et c’est sa première qualité. Modèle Qwen3 0.6B « base », chargé en PyTorch par le paquet compagnon. Benchmark MATH-500, dont nous n’avons pris que les dix premiers problèmes en séance. Vérifieur déterministe du chapitre 3 : extraction du \boxed{}, normalisation, équivalence symbolique par SymPy. Génération greedy, 2 048 tokens au plus, sur le GPU Apple (MPS).
Avant d’entraîner quoi que ce soit, l’expérience du template. Même modèle, mêmes dix problèmes, même vérifieur, mesures de Nicolas sur la puce graphique (MPS) d’un MacBook Pro M1 Pro 16 Go :
| Consigne d’évaluation | Accuracy | Durée |
|---|
Template standard du livre (« Question: », consigne de format \boxed{}) | 30 % (3/10) | 0,7 min |
| « Problème » à la place de « Question » | 50 % (5/10) | 6,7 min |
| Sans consigne de format | 60 % (6/10) | 4,9 min |
Le notebook du chapitre 3 documente le même phénomène sur les mêmes dix problèmes. Appliquer le chat template au modèle de base le fait passer de 30 % à 80 %, et l’auteur précise qu’on ne sait pas si MATH-500 figurait dans les données d’entraînement. Le device compte aussi : 80 % sur MPS contre 90 % sur CUDA pour la variante « reasoning », 20 % contre 30 % pour le modèle de base. Un gain de template de cinquante points peut signaler un format vu à l’entraînement plutôt qu’une compétence nouvelle. Conséquence pratique : un score ne se consigne qu’avec son template exact, sa seed, sa température, son device et ses versions.
La variante « reasoning » officielle de Qwen3 0.6B, évaluée dans les mêmes conditions sur le MacBook : 80 % (8/10), 1 084 tokens par réponse en moyenne, 12,5 min de génération (mesure du 13 septembre). Le livre donne 48,2 % sur les 500 problèmes pour cette variante, contre 15,2 % pour le modèle de base : c’est l’écart que l’entraînement cherche à combler.
Le run : la configuration du livre, ou presque
Le script est celui du dépôt compagnon, rlvr_grpo_original_no_kl.py, lancé avec une configuration réduite pour tenir en mémoire :
uv run rlvr_grpo_original_no_kl.py \
--steps 50 --num_rollouts 4 --max_new_tokens 512 \
--skip-zero-advantage-updates --show_eta
C’est le GRPO « original » du chapitre 6, sans terme KL. Pour chaque problème tiré de MATH (12 000 exemples disjoints de MATH-500), le modèle échantillonne G rollouts à température 0,8 et top-p 0,9. Le vérifieur attribue à chacun un reward binaire : 1 si la réponse encadrée est juste, 0 sinon. Les advantages sont les rewards centrés-réduits dans le groupe, A = (r − mean r) / (std r + 1e-4). La loss vaut −mean(A · logp), où logp est la log-probabilité de la séquence entière du rollout, sommée sur ses tokens. AdamW à 1e-5, clipping de la norme des gradients à 1,0, checkpoint au pas 50. L’option --skip-zero-advantage-updates saute la rétropropagation quand tous les rewards du groupe sont égaux, puisque les advantages sont alors nuls.
Quatre rollouts au lieu des huit de l’auteur. Le README du dossier donne aujourd’hui 12,8 Go de RAM pour 4 × 512 tokens et 20,3 Go pour 8 × 512. Sur nos MacBook de 16 Go, cette configuration avait pris 47 minutes par pas la veille, en swap. Le run a donc tourné sur un Mac Studio M2 Max de 64 Go, à distance, pendant que l’atelier continuait.
Panne n°1 : bfloat16 sur MPS
Premier lancement, poids en bfloat16. Plantage au quatrième pas :
RuntimeError: probability tensor contains either `inf`, `nan` or element < 0
dans torch.multinomial, au moment d’échantillonner le premier token d’un rollout. Pour comprendre, nous avons relancé le script à seed identique sous une enveloppe qui intercepte clip_grad_norm_ et AdamW.step :
[Step 1/4] loss=0.0000 reward_avg=0.000
[Step 2/4] loss=0.0000 reward_avg=0.000
[diag] grad_norm=nan | tenseurs de gradient non finis : 311/311
[diag] après optimizer.step : tenseurs de poids non finis : 311
[Step 3/4] loss=-2.2030 reward_avg=0.250
RuntimeError: probability tensor contains either `inf`, `nan` or element < 0
Le mécanisme est net. Les deux premiers groupes étaient tout faux, donc sautés. Le troisième contenait une bonne réponse sur quatre : première vraie rétropropagation, et la norme du gradient est NaN sur les 311 tenseurs. Le clipping global divise chaque gradient par cette norme : tout le modèle devient NaN en une seule mise à jour. Au pas suivant, le softmax renvoie des NaN et l’échantillonnage refuse.
Même script, même seed, modèle en float32 : norme de gradient 1 425 au premier pas, 683 au suivant, aucun tenseur non fini, quatre pas propres. La panne apparaît en bf16 sur MPS (PyTorch 2.10.0) et disparaît en float32 ; sa cause précise n’a pas été isolée. L’auteur, lui, entraîne sur CUDA. Le prix du float32 : la mémoire GPU du Studio passe de 8,5 à 37 Go pendant le run, et un pas prend une trentaine de secondes. Deux leçons pour qui entraîne sur Apple Silicon : la précision numérique est un hyperparamètre, et un seul gradient non fini combiné à un clipping global contamine tout le modèle.
21 mises à jour sur 50, des deux côtés
Cinquante pas en 51 minutes. Le CSV de métriques raconte le reste, comparé aux cinquante premiers pas du journal de l’auteur, fourni dans le dépôt. Ce journal provient d’un run d’exemple de 200 pas lancé avec 2 048 tokens maximum, et non du run à 512 tokens dont le checkpoint fait 47,4 % : les longueurs de réponse ne se comparent donc pas directement.
| Notre run (G = 4, float32, MPS) | Auteur, journal d’exemple (G = 8, bf16, CUDA, 2 048 tokens) |
|---|
| Pas avec une vraie mise à jour (loss ≠ 0) | 21 / 50 | 21 / 50 |
| Groupes tout faux (reward 0) | 20 | 9 |
| Groupes tout justes (reward 1) | 9 | 20 |
| Reward brut moyen sur 50 pas | 0,41 | 0,64 |
| Longueur moyenne des réponses | 475 tokens, saturée à 512 dès le pas 21 | 422 tokens |
| Reward (moyenne glissante sur 5) | 0,75 au pas 8, 0,8 au pas 35, puis 0,1 à 0,3 | montée irrégulière, entre 0,8 et 0,95 à partir du pas 30 |
| Loss la plus basse | −30 à −55 aux pas 35 à 41 | −37,7 |
Le premier constat contredit l’intuition. Doubler G n’a pas augmenté le nombre de pas utiles : 21 sur 50 dans les deux runs. Ce qui diffère, c’est la nature des pas perdus. Chez l’auteur, ce sont surtout des groupes tout justes : le modèle réussit et n’a plus rien à apprendre sur ce problème. Chez nous, des groupes tout faux. La longueur des réponses sature à 512 tokens dès le pas 21 et n’en redescend plus ; les rollouts tronqués n’ont pas de réponse encadrée, donc reward 0, donc davantage de groupes tout faux. Et les dernières vraies mises à jour, aux pas 35 à 41, sont les plus violentes du run, juste avant la chute du reward.
Notre lecture du mécanisme tient dans la loss. Avec G = 4 et un seul rollout juste, les advantages valent 1,5 pour lui et −0,5 pour les trois autres (écart-type non biaisé). La log-probabilité de séquence est une somme sur les tokens, pas une moyenne : à advantage égal, un rollout juste de 500 tokens contribue au gradient par une somme de 500 termes, contre 100 pour un rollout de 100 tokens : les réponses longues tendent à peser plus lourd. Le modèle est poussé vers les réponses longues, s’allonge, se fait tronquer davantage, reçoit un signal plus rare et concentré sur une seule séquence, et chaque mise à jour pèse plus lourd. Le clipping borne la norme du gradient avant la mise à jour, pas sa direction. La boucle se referme vers le pas 35. L’auteur fait le même diagnostic au chapitre 7 pour le terme KL calculé sur des log-probabilités sommées, qui incite aux réponses longues, et propose de normaliser par la longueur.
L’évaluation : 30 % → 10 %, et cinq fois la même réponse
Sur le Studio, mêmes dix problèmes, greedy, 2 048 tokens au plus :
| Modèle | Accuracy | Tokens par réponse | Durée |
|---|
| Qwen3 0.6B base | 30 % (3/10) | 96 | 0,4 min |
| Notre checkpoint, pas 50 | 10 % (1/10) | 1 791 | 9,9 min |
| Checkpoint pas 50 de l’auteur (G = 8), évalué la veille sur le MacBook | 70 % (7/10) | non relevé | 4,8 min |
Les dix réponses de notre checkpoint disent tout. La plupart atteignent la limite de 2 048 tokens sans conclure. Cinq d’entre elles, pour cinq problèmes différents, se terminent par la même expression, \frac{2\sqrt{5}}{5}. Une seule réponse juste, « 27 » au problème 7. La politique s’est effondrée sur une séquence récompensée pendant l’entraînement. Le modèle de base, lui, répondait en 96 tokens et trouvait trois problèmes sur dix.
En face, le checkpoint de l’auteur au même pas 50, même script, huit rollouts : 47,4 % sur les 500 problèmes d’après le README du dossier, 70 % sur nos dix.
Ce que la taille du groupe explique, et ce qu’elle n’explique pas
GRPO remplace le value model de PPO par une baseline de groupe : l’advantage d’un rollout est sa position par rapport aux autres rollouts du même problème. Avec G = 8, la moyenne du groupe repose sur davantage de réponses, et il devient plus probable que plusieurs rollouts justes se partagent la poussée ; si un seul est juste, il reste seul à recevoir un advantage positif. Le README du dépôt est explicite : réduire le nombre de rollouts « will likely negatively affect the performance », et il suggère d’augmenter l’accumulation de gradient quand on doit le faire. Il ajoute que le GRPO original « is not very stable for more than 50 steps ».
Mais nos deux runs diffèrent par trois facteurs à la fois : G, la précision (float32 contre bf16) et le device (MPS contre CUDA) ; le journal de comparaison a en plus été produit avec 2 048 tokens maximum au lieu de 512. Nous n’avons pas isolé G. L’explication par la taille du groupe est la plus cohérente avec les journaux ; elle n’est pas démontrée.
Les remèdes du chapitre 7 visent cette famille de pannes : instrumentation (entropie, longueur, reward, écart-type des advantages à chaque pas), ratio de probabilités avec clipping à la PPO, pénalité vers un modèle de référence, reward de format. Aucun n’est gratuit. Dans la table de résultats du dépôt, le GRPO original avec terme KL fait 33,4 % à 50 pas puis 0,4 % à 100 ; l’auteur décrit un run qui se défait peu après 50 pas et finit par produire du texte sans suite. Les variantes inspirées d’Olmo 3 et de DeepSeek V3.2 tiennent, elles, autour de 45 % à 100 pas. Quant au reward de format sur les balises <think>, le modèle progresse puis se dégrade après une centaine de pas, l’auteur supposant qu’il gagne assez en respectant la forme pour négliger la justesse.
Une réserve sur nos propres chiffres. Dix problèmes, un run par configuration : un problème de plus ou de moins déplace le score de dix points. La direction est solide, l’effondrement se lit dans le CSV et dans cinq réponses identiques. Les valeurs exactes ne le sont pas.
Ce qui change pour vous
Notre métier est d’utiliser des modèles de langage, pas de les entraîner. Cette journée change pourtant la façon dont nous les qualifions, et elle vaut pour toute équipe qui choisit ou affine un modèle.
- Un modèle se qualifie par un vérifieur déterministe sur un banc maison, avec le template, la seed, le device et les versions consignés à côté de chaque score, et jamais sur un seul run.
- Un affinage par renforcement ne se lance pas sans instrumentation : reward moyen, longueur, entropie, loss à chaque pas, et un arrêt automatique sur signal mort (reward à 0 ou à 1 sur plusieurs pas) ou sur saturation de longueur. Notre run donnait ses symptômes dès le pas 21.
- Température 0 comme point de départ pour les tâches à réponse unique tirée en un seul essai, sur un modèle sans mode raisonnement, à comparer avec l’échantillonnage et le vote sur vos propres tâches. Le chapitre 4 mesure, pour Qwen3 0.6B base sur MATH-500, 33,4 % avec échantillonnage contre 40,6 % en greedy, pour la même consigne de raisonnement pas à pas.
- Un modèle vendu comme « affiné par renforcement » cache G, le nombre de pas, la précision numérique, la présence d’un terme KL. Seuls le journal d’entraînement ou une mesure indépendante permettent d’en juger.
- Sur Apple Silicon, une vraie mise à jour en bf16 se teste avant de lancer une heure d’entraînement.
Les questions à poser
- Avec quel template, quelle seed, quelle température, quel device et quelles versions ce score a-t-il été obtenu ?
- Combien de runs, sur combien d’exemples, et quelle est la dispersion des résultats ?
- Le benchmark peut-il figurer dans les données d’entraînement du modèle, et qu’est-ce qui permet de l’exclure ?
- Pour un modèle affiné par renforcement : quelle taille de groupe, combien de pas, quelle précision, quel terme de régularisation, et peut-on voir les courbes de reward et de longueur ?
- Quel vérifieur juge les réponses, et a-t-il été testé sur des cas négatifs ?
Ce qu’il faut retenir
Un score de benchmark est une mesure située : le template, la machine, la précision numérique et le protocole en font partie, et sur dix problèmes ils pèsent autant que le modèle. GRPO tire son signal de la comparaison au sein d’un groupe ; quand ce signal se raréfie et se concentre sur quelques séquences longues, la politique peut s’effondrer en quelques pas, et le score final ne le dit qu’après coup. Un run de renforcement se lit dans ses courbes avant de se lire dans son score, et le vérifieur reste l’outil central, celui qui rend possibles la mesure, l’entraînement et le diagnostic.
Sources : S. Raschka, Build a Reasoning Model (From Scratch), Manning, 2026, chapitres 3, 4, 6 et 7 ; dépôt rasbt/reasoning-from-scratch, notebook du chapitre 3, dossier ch04/02_math500-inference-scaling-scripts, dossier ch06/02_rlvr_grpo_scripts_intro (README, script, journaux CSV et checkpoints de l’auteur), consultés le 24 octobre 2026 ; nos relevés de l’atelier du 8 septembre 2026 (mesures de Nicolas sur la puce graphique (MPS) d’un MacBook Pro M1 Pro 16 Go, run et évaluations sur Mac Studio M2 Max 64 Go, PyTorch 2.10.0). Les chiffres de notre essai sur le Studio (panne en bf16, métriques du run, évaluation à 1/10, 1 791 tokens, réponse identique) proviennent de notre essai du 8 septembre 2026 et ont été notés lors de la rédaction du 13 septembre ; les journaux de l’essai n’ont pas été conservés. Nos chiffres portent sur dix problèmes et un seul run par configuration : ce sont des observations, pas des mesures statistiquement établies. Les chiffres du livre sont ceux de l’auteur, sur son matériel.