Des chercheurs du MIT montrent que GPT-6 Astra sait lire et modifier directement les poids d'un réseau de neurones

Une équipe du MIT CSAIL a publié des premiers résultats qui suggèrent qu'un modèle de pointe généraliste peut travailler sur les poids d'un réseau de neurones comme un développeur travaille sur du code. Dans un billet intitulé Sparks of Weight-Space Programming, daté du 2 novembre, Rikiya Takehi, Jayden Teoh, Alex Zhang et Omar Khattab rapportent que GPT-6 Astra sait dire à quoi un réseau a été entraîné à partir de ses poids bruts, écrire de petits réseaux de zéro et corriger un défaut connu d'un vrai modèle de langage en modifiant une infime partie de ses paramètres, sans aucune descente de gradient.

Le billet s'est rapidement hissé en tête de Hacker News, avec plus de 2 300 points et plus de 700 commentaires en une journée. Les auteurs appellent cette approche « Weight-Space Programming », la programmation dans l'espace des poids : le modèle lit et écrit des poids à partir d'un objectif formulé en langage naturel, parfois sans aucun retour de l'environnement.

Il s'agit de résultats publiés sur un blog, pas d'un article évalué par des pairs. Les auteurs les qualifient de « très préliminaires » et jugent les capacités « enthousiasmantes mais encore limitées ». Ils ont publié l'intégralité des logs de chaque expérience : les prompts, les réponses du modèle, le code qu'il a exécuté et les évaluations.

Lire des poids : à quoi ce réseau a-t-il été entraîné ?

Les premières expériences testent si le modèle peut déduire un comportement à partir de simples nombres. Selon le billet :

• Jeux. Quatre petits réseaux identiques (17 253 poids chacun) ont été entraînés avec PPO sur des versions en grille de Breakout, Pong, Pac-Man et Freeway. Avec seulement les poids sous forme de texte, et sans connaître la liste des jeux, Astra a trouvé le bon jeu pour les quatre.
• Modèles de diffusion. Trois petits modèles DDPM ont été entraînés à générer des cercles, des triangles et des carrés. Sans exécuter le moindre passage avant (forward pass), Astra a identifié la forme produite par chacun. Les auteurs notent qu'il a dessiné chaque forme en contour alors que les vrais modèles génèrent des formes pleines, ce qu'ils interprètent comme le signe qu'il raisonne sur la structure des poids plutôt qu'il ne simule le réseau.
• Modèles de langage. Trois modèles de 7,2 millions de paramètres, entraînés caractère par caractère sur du code Python, du japonais en romaji et de l'anglais. Sans les couches d'entrée et de sortie, avec Python autorisé pour l'analyse mais pas pour exécuter le réseau, Astra a trouvé la bonne langue lors des deux essais pour les trois modèles, et repéré exactement les têtes de copie (« induction heads ») confirmées ensuite par la mesure.

Un test n'a pas fonctionné aussi nettement. Face à deux copies affinées de Gemma 3 270M, l'une entraînée à répondre correctement, l'autre à flatter l'utilisateur, Astra n'a pas su les distinguer à partir des seuls poids en quatre essais. Il n'a réussi sur les trois paires qu'une fois autorisé à observer les motifs d'attention sur des textes qu'il rédigeait lui-même.

Écrire des poids : corrections et réseaux créés de zéro

La seconde moitié du billet porte sur l'écriture. Dans une tâche de contrôle physique de l'environnement Kinetix, une politique PPO entraînée sur un milliard d'étapes ne parvenait jamais à faire franchir une rampe à une voiture. Avec les poids, une description de la scène et un épisode enregistré, Astra a modifié 3,5 % des poids en une seule réponse, et la voiture a ensuite réussi les 1 024 épisodes de test, selon les auteurs.

Sur trois jeux MinAtar, Astra a écrit des réseaux à partir de poids tous à zéro, en une seule réponse, sans données, sans gradients, sans outils et sans partie d'essai. Ses réseaux ont dépassé PPO entraîné sur 100 millions d'étapes dans les trois jeux. Face à PPO entraîné sur 500 millions d'étapes, le tableau du billet donne 517,4 contre 25,3 sur Breakout, 53,2 contre 55,2 sur Asterix et 53,1 contre 88,9 sur Seaquest. Les auteurs expliquent qu'Astra décide d'abord quel programme chaque couche doit calculer (pour Breakout, où la balle va tomber, puis où déplacer la raquette), puis l'encode sous forme de poids.

À plus grande échelle, Astra a écrit un réseau de 1,48 million de poids pour le Go en 9x9 dans un bac à sable Python, sans entraînement. Sans aucun passage avant, il a gagné plus de la moitié de ses parties contre deux réseaux PPO plus petits ; avec un budget de 50 passages avant, son réseau a battu un réseau PPO de même taille entraîné sur 20 millions de parties.

Le résultat sur Qwen

L'expérience qui a le plus retenu l'attention porte sur Qwen3.5-0.8B, un petit modèle de raisonnement à poids ouverts. Les auteurs rappellent que la fiche du modèle publiée par Qwen prévient qu'il a tendance à tourner en boucle pendant sa réflexion. Dans leur configuration, 85 de ses 96 premières réponses d'entraînement allaient jusqu'à la limite de 32 768 tokens.

Astra travaillait dans une session Python ouverte sur les poids, avec des problèmes d'entraînement tirés de GSM8K et MATH et un budget fixe de passages avant, mais sans aucun entraînement. Il a relié les boucles à une seule direction écrite par les MLP des couches 15 et 19, et a retiré cette direction de 64 colonnes de sortie dans chacune, soit 131 072 poids, 0,016 % du modèle. Avec 50 passages avant, le billet rapporte :

Avec 10 ou 25 passages avant, les gains étaient bien plus faibles et les boucles persistaient en grande partie. Le modèle modifié est publié sur Hugging Face, et Ahsen Khaliq, de Hugging Face, l'a reconstruit à partir des logs, a relancé l'évaluation et mis en ligne une démo, d'après les auteurs.

Les auteurs restent prudents sur la portée du résultat. Supprimer les boucles permet au modèle de terminer des réponses qu'il savait déjà trouver ; cela n'ajoute pas de connaissances. Quand ils ont appliqué la même méthode à Gemma 3 270M, qui boucle rarement, aucune modification n'a fait bouger MATH-500 de plus d'un point environ. Selon eux, modifier les poids « pouvait lever un obstacle qui masquait une capacité, mais pas ajouter une capacité absente du modèle ».

Pourquoi c'est important pour ceux qui construisent avec l'IA

Pour la plupart des développeurs, on change le comportement d'un modèle par le prompt, le fine-tuning ou des adaptateurs, ce qui demande des données et des entraînements. Si ces résultats se confirment, ces travaux ouvrent une autre voie pour des changements ciblés : décrire le problème, laisser un modèle de pointe trouver le composant responsable et le corriger directement. Les auteurs évoquent des usages possibles comme l'audit de comportements cachés ou de portes dérobées sans benchmark, le désapprentissage ou l'ajout de capacités précises sans données, ou la greffe de circuits entre modèles d'architectures différentes. Ce sont des pistes qu'ils proposent, pas des résultats démontrés.

Les limites sont nettes aujourd'hui. La plupart des expériences portent sur des réseaux assez petits pour tenir dans le contexte du modèle ; les cas plus grands reposent sur un environnement sur mesure et un budget de passages avant. Le modèle utilisé est GPT-6 Astra, proposé par OpenAI dans ChatGPT Work et Codex, et le billet ne présente pas de résultats avec d'autres modèles de pointe. Aucune réplication indépendante, au-delà de la reconstruction par Hugging Face, n'a encore été publiée.

L'équipe indique préparer un benchmark et un environnement pour mesurer la programmation dans l'espace des poids de façon standardisée. En attendant, les logs restent le meilleur moyen de vérifier les résultats par soi-même, et le checkpoint Qwen modifié le plus simple à tester.