Programmation dans l’espace des poids : comment les LLM lisent et modifient les poids des réseaux de neurones

La programmation dans l’espace des poids est une méthode où un grand modèle de langage (LLM) polyvalent lit les poids bruts d’un réseau de neurones et les modifie ou les écrit directement à partir d’un objectif en langage naturel, sans descente de gradient ni boucle d’entraînement. Dans un billet de blog publié le 2 novembre 2026, quatre chercheurs du MIT CSAIL rapportent que GPT-6 Astra sait déjà le faire : il a modifié 0,016 % des poids de Qwen3.5-0.8B et fait passer le score MATH-500 du modèle de 7,9 % à 48,1 %.

Les auteurs sont Rikiya Takehi, Jayden Teoh, Alex Zhang et Omar Khattab, premier auteur de l’article original sur DSPy. Les résultats sont préliminaires et proviennent d’un seul LLM, mais l’équipe a publié l’intégralité des invites, réponses et évaluations.

Dans cet article, je couvre ce qu’est la programmation dans l’espace des poids, ce que montrent les expériences, où la méthode atteint ses limites et ce que cela signifie pour votre travail. Si vous avez besoin d’un rappel sur le modèle qui effectue l’édition, consultez notre guide de GPT-6 Astra.

Qu’est-ce que la programmation dans l’espace des poids ?

La programmation dans l’espace des poids consiste à demander à un LLM de lire, corriger ou écrire directement les poids d’un réseau de neurones à partir d’un cahier des charges en langage naturel, parfois sans aucune boucle de rétroaction de l’environnement. Le LLM détermine ce que calcule chaque partie du réseau, ou devrait calculer, et ajuste les nombres en conséquence.

C’est une approche différente de la façon dont les poids sont généralement produits. Aujourd’hui, ils proviennent de la descente de gradient avec des optimiseurs comme Adam ou Muon, de réseaux entraînés à générer les poids d’autres réseaux, ou de compilateurs qui transforment des programmes formels en réseaux. Dans la configuration du MIT, GPT-6 Astra n’écrit aucune boucle d’entraînement. Il raisonne sur les poids comme un ingénieur raisonne sur du code.

Les LLM optimisent déjà les invites, les programmes et le code d’entraînement. Les auteurs soutiennent que cette optimisation guidée par le raisonnement s’étend désormais aux poids eux-mêmes.

Ce que les chercheurs du MIT ont montré

Les 8 expériences se répartissent en trois groupes : lire les poids, les corriger et écrire des réseaux à partir de zéro. La plupart utilisent de petits réseaux dont les poids tiennent dans la fenêtre de contexte d’Astra sous forme de texte ; pour les plus grands, ils ajoutent un bac à sable Python et, parfois, un budget de passes avant.

Lire les poids d’un réseau

L’équipe a entraîné quatre politiques avec proximal policy optimization (PPO), l’algorithme de référence en apprentissage par renforcement pour les agents de jeu, sur des versions en grille de Breakout, Pong, Pac-Man et Freeway, toutes avec la même architecture de 17 253 poids. Sans recevoir la liste des jeux, Astra a nommé le bon jeu pour les 4 réseaux, en lisant des indices comme les poids de la première couche de l’agent Breakout alignés sur la rangée du bas, là où se trouve la raquette.

Deux versions plus difficiles ont suivi :

• Modèles de diffusion : à partir des poids de 3 petits DDPM, sans autoriser de passe avant, Astra a identifié lequel génère des cercles, des carrés ou des triangles. Il les a dessinés en contours alors que les modèles produisent des formes pleines, signe qu’il a lu la géométrie des poids plutôt que de simuler le réseau.
• Modèles de langage : en ne recevant que les 4 blocs transformeurs du milieu de modèles au niveau caractère de 7,2 millions de paramètres, Astra a nommé la langue d’entraînement (Python, japonais en romaji ou anglais) pour les 3, et ce lors des deux tentatives. Il a aussi trouvé chaque copying head, aussi appelée induction head, sans en confondre d’autres. Notre guide sur l’attention multi-têtes explique le rôle de ces têtes.

Réparer une politique défaillante

Une politique PPO entraînée pendant 1 milliard d’étapes sur un niveau voiture-et-rampe dans l’environnement Kinetix fonçait droit sur la rampe et calait à chaque fois. Avec les 171 664 poids, la scène et un épisode enregistré, Astra a expliqué l’échec et proposé une correction en une seule réponse sans outils. L’édition a modifié 3,5 % des poids et fait passer le taux de réussite de 0 % à 100 % sur 1 024 épisodes.

La correction est lisible : un petit chemin supplémentaire qui fait reculer la voiture, puis se désactive une fois la bande franchie.

Écrire des réseaux à partir de zéro

Pour trois jeux MinAtar, Astra a reçu les règles, le code source et un réseau rempli de zéros, puis a écrit tous les poids sous forme de texte en une seule réponse, sans données, gradients ni outils. Les trois réseaux ont surpassé des agents PPO entraînés pendant 100 millions d’étapes.

Breakout fait figure d’exception car Astra l’a écrit comme un programme : la première couche calcule où la balle va tomber, la seconde déplace la raquette à cet endroit. Un réseau de Go 9x9 avec 1 480 274 poids, écrit dans un bac à sable Python, a battu un réseau PPO de taille équivalente entraîné sur 20 millions de parties une fois qu’Astra a disposé de 50 passes avant pour tester.

Corriger les boucles de raisonnement dans Qwen3.5-0.8B

Le résultat le plus concret cible un défaut connu. La fiche du modèle de Qwen avertit que Qwen3.5-0.8B est sujet à des boucles de réflexion, et dans les tests du MIT, 93,0 % de ses réponses MATH-500 atteignaient la limite de 32 768 tokens. En travaillant dans un noyau Python avec 50 passes avant sur des exercices issus de GSM8K et MATH, Astra a retracé ces boucles jusqu’à une direction écrite par les MLP des couches 15 et 19 et l’a soustraite de 64 colonnes de sortie dans chacune.

La part de réponses atteignant la limite de tokens est tombée à 33,1 %, et comme les boucles ne sont pas spécifiques aux mathématiques, le suivi d’instructions s’est également amélioré. Le budget comptait : avec 10 ou 25 passes avant, les boucles disparaissaient à peine. Ahsen Khaliq de Hugging Face a reconstruit le checkpoint édité à partir des journaux et relancé MATH-500 avec les mêmes paramètres, obtenant 51,0 %.

Où la programmation dans l’espace des poids atteint ses limites

Elle montre ses limites dès que le problème n’est pas un défaut unique et localisé dans les poids. Les auteurs rapportent deux échecs nets, tous deux instructifs.

• La flagornerie était invisible dans les poids. Face à un affinement honnête et un affinement « flagorneur » de Gemma 3 270M, Astra n’a pas su les distinguer à partir des seuls poids lors de ses quatre tentatives. Une fois les schémas d’attention visibles, il a repéré le modèle flagorneur dans les trois paires.
• Gemma 3 270M ne s’est pas amélioré en mathématiques. Gemma boucle rarement, donc il n’y avait pas de faute unique à éliminer, et la meilleure édition d’Astra a fait passer MATH-500 de 6,8 % à 7,7 %. Comme le résument les auteurs, éditer des poids peut lever un obstacle qui masquait une capacité, mais ne peut pas ajouter une capacité absente.

Prudences plus larges : chaque expérience utilise un seul LLM, le plus grand réseau compte 0,8 milliard de poids, et il s’agit d’un billet de blog avec des résultats préliminaires, pas d’un article évalué par les pairs. Les auteurs indiquent qu’ils construisent encore un benchmark pour la tâche.

Ce que cela signifie pour les praticiens des données et de l’IA

Pour les praticiens, la programmation dans l’espace des poids est aujourd’hui un signal de recherche, pas encore un outil. Deux aspects méritent déjà votre attention.

Le premier est l’interprétabilité. Les méthodes d’attribution comme SHAP expliquent un modèle via ses entrées, et l’interprétabilité mécaniste a besoin d’outils dédiés. Astra a retrouvé des induction heads avec une méthode de multiplication matricielle connue que les chercheurs ne lui avaient pas mentionnée. Si cela tient sur des modèles plus grands, « demander à un modèle de pointe ce que fait cette couche » peut devenir un premier passage avant l’outillage lourd.

Le second est la réparation ciblée. Lorsqu’un petit modèle a une défaillance étroite et bien circonscrite, comme les boucles de Qwen, le correctif habituel est de le réentraîner (fine-tuning) sur de nouvelles données. Une édition de 131 072 poids laisse le reste du modèle intact, ce qui, selon les auteurs, évite l’oubli catastrophique que peut entraîner le fine-tuning. Je traiterais cela comme une hypothèse : le résultat sur Gemma montre que l’édition ne fonctionne que lorsqu’il existe un coupable unique à identifier. La liste d’envies des auteurs — de l’audit de portes dérobées sans exécuter les modèles à la désapprentissage de capacités sans données — reste à démontrer.

Comment essayer vous-même la programmation dans l’espace des poids

La manière la plus directe de la tester est de rejouer l’une des expériences : les journaux contiennent les invites exactes reçues par Astra, et GPT-6 Astra est disponible sous gpt-6-astra dans l’API OpenAI, sur Amazon Bedrock et dans les offres payantes de ChatGPT. L’expérience 1, qui consiste à nommer le jeu à partir des poids d’une politique, est l’endroit le plus simple pour commencer :

1. Récupérez les journaux. Clonez le repository lm_understand-logs. Chaque dossier d’expérience contient un README qui relie chaque chiffre du billet au fichier source.

2. Choisissez une expérience sans outils. Les expériences 1, 2, 4 et 5 n’ont donné aucun outil à Astra, donc une seule invite suffit à reproduire chaque exécution. Dans l’expérience 1, chaque dossier de run contient un prompt.txt avec la description du réseau, la question et les 17 253 poids sous forme de texte.

3. Envoyez-la comme les auteurs l’ont fait. Ils ont appelé gpt-6-astra via la CLI Codex (codex exec, invite sur stdin) avec tous les outils intégrés désactivés, et un effort de raisonnement élevé pour l’expérience 1. Le reste de la configuration est dans harness/codex_config.toml, mais ses valeurs par défaut sont gpt-6-luna avec un effort medium ; définissez donc le modèle et l’effort de raisonnement à chaque appel, comme les auteurs.

4. Comparez les réponses. Chaque dossier de run contient aussi la answer.md d’Astra, et eval/ contient la notation et le corrigé.

Une exécution a utilisé environ 73 700 tokens en entrée et moins de 2 000 tokens en sortie ; au tarif API de 10 $ et 50 $ par million de tokens, une relecture coûte moins d’1 $. Les expériences avec bac à sable Python (3, 6, 7 et 8) nécessitent le harness/sandbox.py des auteurs et beaucoup plus d’échanges ; prévoyez le budget en conséquence.

Si vous préférez ne rien exécuter, le Qwen3.5-0.8B édité est sur Hugging Face sous licence Apache-2.0, avec les empreintes des 2 tenseurs modifiés sur sa fiche. Le Space Hugging Face vous permet de saisir un problème et de voir le modèle de base boucler pendant que la version éditée le résout.

Dernières réflexions

La programmation dans l’espace des poids montre qu’un LLM de pointe peut lire et éditer des poids de réseau de neurones par raisonnement, au moins pour de petits réseaux et des défauts uniques et localisés. La correction de Qwen est le résultat qui fera parler, et à juste titre, d’autant que Hugging Face l’a reproduite en moins d’une journée.

Je reste prudent sur les affirmations plus larges. Un seul modèle, de petits réseaux et aucun benchmark constituent une base mince pour l’énoncé des auteurs selon lequel « nos poids de réseaux neuronaux seront bientôt nativement optimisés par des LLM ». Reste que les échecs sont rapportés avec autant de soin que les réussites, ce qui me fait prendre ces dernières plus au sérieux.

Si vous souhaitez approfondir les mécanismes internes des transformeurs visés par ces éditions, je vous recommande notre parcours Developing Large Language Models.