Des chercheurs du MIT affirment que GPT-6 Astra a fait progresser les résultats de Qwen en mathématiques en modifiant directement ses poids

Une petite retouche numérique a fait fortement progresser les résultats

Des chercheurs du laboratoire d’informatique et d’intelligence artificielle du MIT affirment que GPT-6 Astra d’OpenAI a fait passer le score d’un petit modèle Qwen en mathématiques de 7,9 % à 48,1 % en ne modifiant que 131 072 de ses quelque 800 millions de paramètres numériques. L’intervention visait un problème précis : le modèle générait du texte à répétition jusqu’à ne plus avoir assez de place pour répondre.

Rikiya Takehi, Jayden Teoh, Alex Zhang et Omar Khattab ont décrit ces expériences dans un billet de recherche publié le 2 novembre et intitulé « Sparks of Weight-Space Programming », suivi d’articles datés du 3 novembre 2026. Leur approche consiste à demander à un modèle de langage d’inspecter, d’interpréter et de réécrire directement les poids d’un autre réseau neuronal, c’est-à-dire les nombres qui déterminent la façon dont il traite l’information.

Le résultat le plus probant concerne Qwen3.5-0.8B. Sa précision sur MATH-500 a progressé de 40,2 points de pourcentage, soit environ six fois son score initial, après qu’Astra a modifié quelque 0,016 % de ses poids. Sa précision sur les questions de mathématiques de GSM8K est passée de 13,8 % à 67,1 %, tandis que son score de suivi des consignes sur IFEval est passé de 21,0 % à 62,3 %, soit près de trois fois le résultat de départ.

Les expériences ne se sont pas limitées aux mathématiques. Astra a identifié le rôle de petits réseaux, réparé un contrôleur de conduite simulée et créé des réseaux capables de jouer à des jeux à partir de règles et de code source. D’autres tests ont révélé ses limites : à partir des seuls poids, le modèle a eu du mal à repérer une tendance excessive à donner raison aux utilisateurs, et ses modifications n’ont guère amélioré les performances mathématiques d’un autre modèle de langage.

Pour les développeurs, la possibilité la plus immédiate est une nouvelle forme de réparation de modèle. Au lieu d’entraîner un réseau au moyen d’une nouvelle phase d’apprentissage classique, un assistant IA pourrait examiner une défaillance et modifier le mécanisme numérique qui en est responsable. Le résultat obtenu sur Qwen montre aussi que la nature du problème compte autant que l’ampleur de la progression.

Que signifie concrètement programmer les poids ?

Un réseau neuronal transforme des entrées en sorties au moyen de couches de calcul. Ses poids déterminent l’intensité avec laquelle les signaux circulent entre ses composants. L’entraînement consiste généralement à ajuster ces nombres à plusieurs reprises, à partir d’exemples et d’une mesure mathématique de l’erreur qui permet de déterminer quelles modifications sont utiles.

La descente de gradient est une méthode courante pour calculer ces ajustements. Elle estime dans quelle direction déplacer les poids afin de réduire les erreurs. Dans ces expériences, Astra a plutôt raisonné sur le réseau cible et apporté elle-même les modifications, sans boucle d’entraînement chargée de les calculer.

Takehi, doctorant au CSAIL du MIT, a décrit le processus envisagé dans une publication sur les réseaux sociaux :

Au lieu de passer par l’entraînement, les modèles pourraient traiter les poids bruts comme du code lisible et modifiable : diagnostiquer les défaillances et les corriger directement.

La comparaison avec la réparation logicielle est parlante. Un programmeur qui enquête sur une application défectueuse peut localiser une fonction fautive et la réécrire. Ici, Astra a recherché dans des structures numériques un motif associé à un comportement indésirable. Les poids d’un réseau neuronal sont plus difficiles à interpréter qu’un logiciel ordinaire, car ils ne portent généralement pas de noms compréhensibles indiquant leur rôle.

Les expériences ont fourni différents niveaux d’assistance à Astra. Certaines ne lui donnaient que les poids et une description de l’architecture. D’autres lui fournissaient un environnement Python, des exemples ou l’autorisation d’exécuter le modèle cible. Dans le cas de Qwen, l’absence d’entraînement classique n’a pas empêché le recours à d’importantes ressources de calcul, à des questions d’exercice et à des tests.

Comment Astra a empêché Qwen de se répéter

Le comportement initial de Qwen a fourni à Astra un problème particulièrement clair à examiner. Lors d’un premier lot de 96 questions, 85 réponses ont atteint la limite maximale de 32 768 jetons. Les jetons sont les unités de texte qu’un modèle de langage lit et produit, souvent des mots ou des fragments de mots. Environ 95 % de ces réponses tronquées se terminaient par des répétitions.

L’évaluation plus large de MATH-500 a révélé le même problème : 93,0 % des réponses de référence atteignaient la limite de jetons. Astra a associé le comportement répétitif à une direction numérique liée aux sorties des composants à propagation avant des couches 15 et 19. Ces composants, souvent appelés perceptrons multicouches ou MLP, transforment l’information au sein de chaque couche.

Une direction numérique est un motif réparti sur de nombreuses valeurs, plutôt qu’un simple interrupteur. Astra a soustrait la direction associée aux répétitions de 64 colonnes de sortie dans chacune des deux couches. Cette modification a touché 131 072 poids et ramené de 93,0 % à 33,1 % la part des réponses à MATH-500 atteignant la limite de jetons.

La répartition des réponses corrigées permet de comprendre cette progression. Sur 1 152 questions mises de côté, 579 réponses sont passées d’incorrectes à correctes, tandis que cinq sont passées de correctes à incorrectes. Parmi les 579 améliorations, 576 réponses avaient initialement été tronquées par la limite de sortie. La plupart des gains sont donc venus de réponses que le modèle modifié a pu terminer, alors que les répétitions avaient interrompu les précédentes.

Après la retouche, environ un tiers des réponses à MATH-500 dépassaient encore la limite de sortie. Le réseau modifié s’est révélé bien plus utile dans les conditions du test, mais les boucles répétitives restaient un problème important.

La recherche de la correction a demandé des heures d’investigation

Lors de sa tentative la plus aboutie sur Qwen, Astra disposait d’un budget de 50 requêtes d’évaluation, chacune pouvant couvrir des centaines d’exemples. L’investigation a comporté 158 échanges, 80 exécutions Python et duré 20,3 heures, dont 4,7 heures d’attente pendant une panne du service.

L’environnement de travail comprenait plus de 14 000 questions d’exercice tirées des jeux de données d’entraînement GSM8K et MATH, un accès aux poids de Qwen et un bac à sable Python fonctionnant sur des processeurs. Ce bac à sable autorisait jusqu’à 300 exécutions de code. D’autres tentatives disposaient de budgets de 10 ou 25 requêtes d’évaluation.

Les chiffres de précision publiés correspondent également à un réglage de génération précis. Les évaluations utilisaient le mode réflexion, une limite de sortie de 32 768 jetons et une température de 0,6. La température détermine le degré d’aléatoire dans le choix du jeton suivant ; la fiche du modèle recommande une température de 1,0 pour les tâches textuelles en mode réflexion. Cette différence compte pour reproduire le comportement initial et comparer les résultats.

Le processus s’est déroulé ainsi :

• Les chercheurs ont fourni à Astra le modèle cible, des problèmes d’exercice et des outils pour inspecter les poids et tester le comportement.
• Astra a étudié les sorties répétitives et conçu une modification ciblant les couches 15 et 19.
• L’évaluation a mesuré les progrès en mathématiques et en suivi des consignes, ainsi que la baisse du nombre de réponses atteignant la limite de sortie.
• L’équipe a présenté ses travaux le 2 novembre et indiqué qu’elle préparait un benchmark et un cadre de test.

La modification finale était limitée, mais sa découverte a nécessité un processus bien plus lourd. La question de savoir si cette approche permet d’économiser du temps ou des ressources de calcul par rapport à un ajustement fin classique reste ouverte.

Lire des jeux, des formes et du langage dans les nombres

Les tests d’inspection d’Astra ont commencé avec quatre réseaux de jeu entraînés par optimisation de politique proximale, ou PPO, une méthode d’apprentissage par renforcement qui améliore le comportement grâce à des récompenses. Les réseaux partageaient la même structure, les mêmes entrées et les mêmes actions possibles. Sans liste de jeux candidats, Astra les a identifiés comme Breakout, Pong, Pac-Man et Freeway.

Selon les chercheurs, Astra a examiné les motifs de la première couche et les différences dans la manière dont la couche de sortie sélectionnait les actions. Dans l’exemple de Breakout, elle a attribué à sa réponse un niveau de confiance de 99 %. Ce chiffre correspondait à sa propre estimation de la justesse de l’identification.

Trois petits modèles de diffusion ont fourni un autre test. Chacun avait appris à générer des cercles, des triangles ou des carrés. Sans les exécuter, Astra a identifié les formes en repérant leurs contours dans les poids de la couche de sortie. Ses dessins étaient creux, alors que les modèles généraient des formes pleines : un détail inhabituel qui reliait son interprétation à la structure numérique examinée.

L’identification du langage a été testée à l’aide de trois modèles de 7,2 millions de paramètres chacun, entraînés à prédire le caractère suivant dans du code Python, du japonais romanisé ou de l’anglais. Astra n’a reçu que les couches intermédiaires et a correctement identifié la langue d’entraînement lors des deux tentatives.

Astra a également repéré les têtes de copie des modèles, des composants d’attention qui aident à répéter du texte déjà rencontré. Le modèle Python en comportait davantage, ce qui correspond au fait que le code réutilise souvent les mêmes noms de variables et de fonctions. Le modèle de japonais romanisé présentait moins de directions émises par son module final, conformément à son répertoire plus restreint de caractères courants.

Réparer une voiture et créer des joueurs de jeu vidéo

Dans l’environnement simulé Kinetix, une voiture avait acquis une habitude peu utile : elle fonçait dans une pente et restait bloquée. Reculer d’abord lui aurait donné assez d’espace pour réussir sa montée. À partir des poids du contrôleur, d’une description de la scène et de l’enregistrement d’un échec, Astra a proposé une correction en une seule réponse et sans outils.

La modification a touché 3,5 % des poids et a réussi les 1 024 tests. Astra a ajouté une petite voie de circulation dans le réseau pour suivre la position et la vitesse, puis a rendu le contrôle au réseau d’origine une fois que la voiture avait dépassé un repère.

Pour les jeux Breakout, Seaquest et Asterix de MinAtar, Astra a été confrontée à une autre tâche : créer des réseaux de politique à partir de zéro. Un réseau de politique transforme l’état d’un jeu en action. Astra a reçu les règles, le code source et l’architecture requise, mais aucun exemple d’entraînement, calcul de gradient, outil ni possibilité de jouer avant l’évaluation.

Ses réseaux ont battu, dans les trois jeux, des modèles de référence PPO entraînés pendant 100 millions d’étapes. L’écart numérique le plus important concerne Breakout : Astra a obtenu un score de 517,4, contre 15,8 pour le modèle de référence entraîné pendant 100 millions d’étapes et 25,3 pour celui entraîné pendant 500 millions d’étapes. Cette dernière comparaison représente un avantage d’environ vingt fois.

L’ampleur de l’avantage variait selon le jeu. Face aux modèles PPO entraînés pendant 500 millions d’étapes, Astra s’est approchée du score de référence dans Asterix et a atteint environ 60 % du score de Seaquest. Sa stratégie pour Breakout traduisait une consigne explicite en poids : estimer l’endroit où la balle va tomber, puis déplacer la raquette vers ce point.

Un réseau de Go plus grand a nécessité une autre méthode

L’expérience sur le jeu de Go utilisait un réseau d’environ 1,5 million de paramètres, trop volumineux pour être placé directement dans la fenêtre de contexte d’Astra, c’est-à-dire la quantité d’informations qu’elle peut traiter à la fois. Les chercheurs lui ont plutôt fourni un bac à sable Python pour inspecter et modifier les poids.

L’architecture comportait 243 entrées, six couches cachées de 512 unités et 82 sorties. Astra l’a organisée comme un programme de Go compact : les premières couches représentaient les pierres et les libertés, c’est-à-dire les intersections vides voisines qui permettent à un groupe de survivre. Les couches intermédiaires faisaient circuler l’information entre les groupes connectés afin de repérer les dangers.

La dernière couche attribuait un score aux coups qui capturaient les pierres adverses, sauvaient les groupes menacés, protégeaient les yeux et évitaient l’atari, situation dans laquelle un groupe ne dispose plus que d’une seule liberté. Cette stratégie était assemblée au moyen de poids numériques plutôt qu’apprise par des parties répétées.

Sans aucune évaluation des performances, le réseau d’Astra a remporté plus de la moitié de ses parties contre deux réseaux PPO plus petits. Avec un budget de 50 évaluations, il a surpassé un réseau de même taille entraîné sur 20 millions de parties. Les retours ont permis à Astra d’examiner ses défaites et de conserver les modifications qui amélioraient son jeu.

Deux tests difficiles révèlent les limites

Gemma 3 270M a fourni un contraste utile avec Qwen. Il se retrouvait rarement piégé dans des boucles répétitives. Astra a plutôt trouvé des erreurs de raisonnement classiques, notamment des erreurs arithmétiques et des étapes algébriques invalides. Les petites modifications, dont le doublement de la force d’un neurone réagissant aux nombres, n’ont amélioré la précision sur MATH-500 que d’un point de pourcentage environ au maximum.

La comparaison met en évidence une distinction pratique. Éliminer un comportement répétitif peut permettre à un modèle de mobiliser des capacités qu’il possède déjà. Corriger des erreurs mathématiques très diverses nécessite une solution plus large que la suppression d’un unique motif numérique partagé.

La flagornerie, c’est-à-dire la tendance à donner raison à un utilisateur même lorsqu’il se trompe, s’est révélée difficile à inspecter directement. Les chercheurs ont ajusté finement des paires de modèles Gemma 3 270M sur les mêmes données de questions et de réponses. L’un était entraîné à répondre correctement ; l’autre, à aller dans le sens des suggestions des utilisateurs.

Astra n’a pas réussi à les distinguer de manière fiable à partir de leurs seuls poids. Lorsqu’elle a été autorisée à examiner les schémas d’attention sur du texte qu’elle avait rédigé, sans voir les réponses des modèles, elle a correctement identifié le modèle flagorneur dans les trois paires. Ces modèles accordaient davantage d’attention, dans leurs couches intermédiaires, aux éléments suggérés par l’utilisateur.

Les mesures d’attention montrent où un modèle dirige une partie de son traitement lorsqu’il analyse du texte. Leur utilité dans ce cas a fait de l’inspection en cours d’exécution un élément important du diagnostic réussi. Repérer une tendance excessive à donner raison était la tâche ; modifier ce comportement constituait une application envisagée distincte.

Les prochains tests envisagés par les chercheurs

L’équipe du MIT voit des applications possibles dans l’inspection de modèles, les réparations ciblées, la modification de capacités sans données d’entraînement classiques et le transfert de composants utiles entre différentes architectures. La modification directe de modèles fait déjà l’objet de travaux de recherche, notamment ROME, présenté à NeurIPS en 2022, et MEMIT, présenté à ICLR en 2023. Cette étude explore la possibilité de laisser un modèle de langage généraliste raisonner lui-même sur les modifications.

L’auto-amélioration récursive est une autre piste envisagée : un système d’IA pourrait aider à améliorer un modèle qui deviendrait ensuite plus apte à procéder à de nouvelles améliorations. Ces expériences s’appuyaient sur des tâches, des outils et des budgets d’évaluation définis par des humains, Astra travaillant sur d’autres réseaux. La mise en place d’un cycle répété fiable nécessiterait d’autres expériences.

L’équipe a publié les journaux d’expérience et les éléments de modification. Le dépôt public contient, selon sa description, des traces de 1 125 appels de modèle. La prochaine étape annoncée est la création d’un benchmark et d’un cadre expérimental permettant des évaluations cohérentes. Aucune date de publication n’a été communiquée.

Pour les personnes qui développent des applications d’IA, le résultat le plus concret est plus limité et facile à comprendre : une petite correction numérique peut améliorer fortement les performances lorsqu’un défaut récurrent empêche un modèle de mener à bien une tâche utile. Les résultats contrastés de Gemma et des tests sur la flagornerie montrent que chaque réparation envisagée devra faire l’objet de son propre diagnostic et de ses propres essais.

Points clés

• Astra a modifié 131 072 poids de Qwen, soit environ 0,016 % du modèle, faisant passer sa précision sur MATH-500 de 7,9 % à 48,1 %.
• La précision sur GSM8K est passée de 13,8 % à 67,1 %, et le score sur IFEval de 21,0 % à 62,3 %.
• La principale réparation a réduit les sorties répétitives : la part des réponses à MATH-500 atteignant la limite de jetons est passée de 93,0 % à 33,1 %.
• La tentative la plus aboutie sur Qwen a utilisé 50 requêtes d’évaluation et duré 20,3 heures, panne comprise.
• Astra a également réparé un contrôleur de voiture simulée et créé des réseaux pour des jeux simplifiés et le Go.
• Les progrès en mathématiques sur Gemma ont été minimes, tandis que l’identification de la flagornerie a nécessité des mesures d’attention.
• Les chercheurs mettent au point un benchmark et un cadre de test pour la programmation dans l’espace des poids.