Programmation des poids d’IA : le rôle de la PL
Découvrez comment un programme linéaire a corrigé les boucles d’un petit modèle de langage, avec huit fois moins de poids modifiés et un calcul plus direct.

Corriger un modèle d'IA sans le réentraîner : la piste du programme linéaire
Un petit modèle de langage qui répète les mêmes phrases jusqu'à épuiser son budget de tokens n'a pas forcément besoin d'un nouvel entraînement. Parfois, il suffit de comprendre ce que ses poids font déjà - puis de modifier précisément la partie qui entretient le problème. C'est exactement l'idée explorée dans une expérience publiée par le MIT CSAIL.
Dans un cas rapporté, une édition réalisée par un agent d'IA a fait passer la précision de Qwen3.5-0.8B sur MATH-500 de 7,9 % à 48,1 %, en modifiant une fraction minuscule de ses paramètres. En analysant cette intervention, Nathan Barry a remarqué qu'une grande partie du travail pouvait se formuler comme un programme linéaire. Résultat : des performances comparables, avec environ huit fois moins de poids modifiés.
L'intérêt, au-delà de la prouesse, est de savoir quand une intervention ciblée peut remplacer des heures d'essais, ce qu'elle change pour le reste du modèle, et dans quelles conditions on peut vraiment l'exploiter. Dans ce qui suit : le mécanisme, les résultats observés, puis les limites à garder en tête avant d'en tirer des conclusions plus générales.
Pourquoi programmer directement les poids d'un modèle ?
En temps normal, entraîner un réseau neuronal consiste à ajuster ses poids à partir de données et d'une fonction de perte. La programmation dans l'espace des poids propose une autre voie : on regarde les paramètres déjà en place, on comprend le calcul qu'ils produisent, puis on les modifie directement pour obtenir un comportement précis.
Dans l'expérience décrite par le MIT CSAIL, l'agent Astra a d'abord montré qu'à partir des poids d'un petit réseau, il pouvait identifier le jeu sur lequel ce réseau avait été entraîné. Il a aussi généré des poids à partir des règles d'un jeu, sans recourir à une boucle d'entraînement classique, et a obtenu de meilleures performances que des réseaux entraînés par apprentissage par renforcement.
Le cas étudié ensuite ressemble davantage à un problème « production » : Qwen3.5-0.8B avait tendance à tourner en boucle dans ses raisonnements. Selon la configuration évaluée, 93 % de ses réponses sur MATH-500 atteignaient la limite de 32 768 tokens sans produire de réponse finale. L'agent a modifié 0,016 % des poids, et la précision est passée de 7,9 % à 48,1 %.
Un obstacle de comportement, pas une capacité absente
Il faut distinguer les deux choses. L'édition n'a pas « appris » au modèle les mathématiques depuis zéro. Elle a surtout réduit un comportement qui l'empêchait, parfois, d'aller jusqu'au bout. Une fois ce frein levé, des capacités déjà présentes pouvaient mieux s'exprimer.
On voit le même schéma sur d'autres tests : la précision passe de 13,8 % à 67,1 % sur GSM8K, et de 21 % à 62,3 % sur IFEval (un test de respect des consignes). Dans le même temps, la part des réponses interrompues par la limite de tokens chute de 93 % à 33,1 %.
À l'inverse, l'édition n'améliore pas significativement les capacités mathématiques de Gemma 3 270M, un modèle qui boucle rarement. Le diagnostic est donc plus étroit : lever un obstacle peut révéler une compétence, mais ne crée pas une compétence que le modèle n'avait pas.
Pour une équipe produit, c'est une hypothèse à tester, pas une recette universelle. Avant de toucher aux poids, il faut vérifier que l'échec observé vient bien d'un comportement répétitif ou d'un blocage identifiable - pas d'un manque de connaissances, d'un contexte mal préparé ou d'une évaluation inadaptée.
Comment l'édition des poids réduit-elle les boucles ?
Un transformeur utilise des connexions résiduelles : chaque couche ajoute sa sortie à la représentation reçue, au lieu de la remplacer. On peut suivre cette représentation, appelée flux résiduel, comme un vecteur qui traverse le réseau et évolue à chaque couche. Dans le modèle étudié, ce vecteur a 1 024 dimensions.
En comparant des traces de raisonnement qui bouclent et des traces qui restent productives, Astra repère une direction dans laquelle le flux résiduel se déplace quand le modèle boucle. Appelons-la u. L'idée de l'édition est simple : si certaines sorties de couche poussent la représentation dans cette direction, alors modifier ces sorties pour réduire (ou inverser) cette composante devrait limiter la boucle.
Modifier une matrice plutôt que réentraîner le modèle
À la fin de chaque bloc MLP, une matrice nommée down_proj transforme une activation interne h (3 584 dimensions) en une sortie (1 024 dimensions). Cette sortie est ajoutée au flux résiduel. Les colonnes de la matrice correspondent à des directions possibles de cette contribution ; l'activation décide combien on ajoute à chaque direction.
Pour une colonne wj, la composante dans la direction de boucle vaut uTwj. L'édition applique alors :
wj → wj − α(uTwj)u
Avec α = 1, la composante de la colonne le long de u est supprimée. Avec α = 6, elle est inversée et amplifiée : une contribution de +a devient −5a. Autrement dit, l'intervention ne change pas toutes les directions du réseau - elle cible surtout une direction particulière, dans deux couches : les couches 15 et 19.
Les changements se résument à une mise à jour de rang 1 :
ΔW = uvT
Le vecteur u fixe la direction de la modification ; v indique quelles colonnes changent et dans quelles proportions. À chaque étape, la mise à jour ajoute une quantité de u au flux résiduel, quantité contrôlée par les activations des colonnes concernées.
Trouver la direction et choisir les colonnes
Astra estime u à partir de quatre paires de courts textes : un raisonnement productif et sa version qui boucle. Il enregistre les activations internes, puis calcule la différence entre les moyennes des deux groupes. Cette méthode dépend donc d'exemples sélectionnés, construits avec l'aide d'un agent.
Pour déterminer v, Astra teste progressivement. Modifier toutes les colonnes avec α = 1 fait passer le score sur des problèmes d'entraînement de 9 % à 33 %. Avec α = 3, il atteint 48 %. La meilleure variante rapportée retient 64 colonnes par couche qui contribuent le plus à la direction de boucle, avec α = 6, et obtient 55 %.
Un contrôle important : appliquer la même logique à une direction aléatoire change presque rien. Le gain ne vient donc pas juste du fait de « perturber » le réseau.
Pourquoi un programme linéaire peut-il remplacer la recherche ?
La recherche d'Astra pour choisir les colonnes et régler l'intensité prend environ huit heures. L'agent dispose aussi d'un budget de 50 passages avant de figer l'édition. En relisant ces choix, Nathan Barry formalise la sélection de v comme un problème d'optimisation sous contraintes.
Pour chaque token, l'effet de l'édition dans la direction u dépend du produit scalaire v · ht. Cette quantité est linéaire en v. On peut donc écrire des objectifs sous forme de contraintes : pousser les tokens déjà engagés dans une boucle dans la direction opposée, tout en limitant l'impact sur les tokens associés à un raisonnement productif.
Une formulation simplifiée consiste à minimiser la somme des valeurs absolues de v :
minv ∑j |vj|
Sous les contraintes suivantes :
- pour les tokens de boucle t ∈ R, imposer v · ht ≤ −δ ;
- pour les tokens productifs t ∈ P, imposer |v · ht| ≤ ε.
En pratique, il n'y a pas toujours de solution qui satisfait toutes les contraintes à la lettre. Le problème ajoute alors des variables d'écart pénalisées pour trouver le meilleur compromis plutôt que d'abandonner.
Pourquoi minimiser la norme L1 ?
La norme L1 favorise des solutions « parcimonieuses » : beaucoup de coefficients de v deviennent nuls. Sur le plan géométrique, l'ensemble des contraintes forme un losange ; quand il touche la région admissible, il arrive souvent que le contact se fasse sur un sommet, avec plusieurs coordonnées à zéro.
Ici, ça sert directement : les coefficients nuls correspondent aux colonnes laissées intactes. Le solveur choisit donc à la fois quels poids modifier et l'intensité de chaque modification. Pour obtenir exactement huit colonnes par couche, l'auteur garde ensuite les huit coefficients les plus influents, fixe les autres à zéro, puis résout à nouveau.
Les activations utilisées dans les contraintes viennent des traces du modèle. Les tokens sont classés comme répétitifs ou productifs à l'aide d'un détecteur de répétition. C'est actionnable, mais ça dépend de la définition de « boucle » et de la qualité des traces sélectionnées : le programme linéaire optimise ce qu'on lui donne, il ne garantit pas que ce cadrage décrive correctement le problème.
Un solveur rapide, mais pas magique
HiGHS, un solveur généraliste, met plus de 20 minutes par résolution. L'auteur utilise ensuite un solveur sur GPU basé sur PDHG (fondé sur des produits matrice-vecteur) : il obtient une solution à moins de 0,2 % de l'optimum en environ une minute.
La comparaison est parlante : une recherche guidée par agent, avec des essais pendant des heures, peut être remplacée ici par quelques optimisations explicites. Mais tout le travail ne disparaît pas : il reste à définir les tokens pertinents, choisir les couches, et construire la direction à corriger.
Que montrent les résultats et le vecteur de pilotage ?
Sur les évaluations présentées dans l'article, l'édition calculée par programme linéaire (à partir de la direction d'Astra) obtient des résultats proches de l'édition originale, tout en touchant environ huit fois moins de poids.
| Méthode | Poids modifiés | GSM8K test | MATH-500 | IFEval |
|---|---|---|---|---|
| Modèle de base | 0 | 14,1 | 7,0 | 22,9 |
| Édition d'Astra | 130 188 | 68,2 | 50,9 | 61,9 |
| Programme linéaire, direction d'Astra | 16 291 | 69,6 | 51,7 | 59,7 |
| Programme linéaire, direction heuristique | 16 271 | 65,4 | 47,8 | 60,4 |
Ces scores correspondent à une autre série d'évaluations que celles qui annonçaient les premiers chiffres de l'édition d'Astra. Il vaut donc mieux éviter de mixer des tableaux comme s'ils venaient forcément du même protocole. La comparaison utile, c'est celle à l'intérieur d'un même tableau : avec la direction d'Astra, le programme linéaire reste comparable sur les trois jeux, malgré une édition plus parcimonieuse.
Une direction heuristique, construite sans traces rédigées par un agent, récupère aussi une grande partie du gain. Elle identifie les tokens répétitifs, puis compare les flux résiduels des tokens répétitifs et des tokens productifs. Sur les données de développement, réutiliser directement la sélection de colonnes et l'intensité d'Astra donne 44,5 %, contre 54,7 % après optimisation par programme linéaire. En clair : remplacer l'agent ne revient pas à recopier ses réglages.
Un comportement corrigé peut parfois tenir à une correction « simple »
L'analyse met aussi en évidence une limite intéressante. Dans la couche 15, les colonnes retenues par le programme linéaire s'activent sur 89 % des tokens, et la quantité de correction varie peu. L'édition ressemble alors moins à une correction « au bon moment pour les bons tokens » qu'à une impulsion quasi constante dans la direction u.
Dans ce cas, on peut ajouter directement cette impulsion au flux résiduel pendant l'inférence, sans modifier les poids du modèle, sous la forme d'un vecteur de pilotage. À une intensité correspondant à la correction moyenne de l'édition, cette méthode récupère une grande partie du gain : 57,8 % sur le développement et 50,8 % sur MATH-500, contre 62,5 % et 53,2 % pour l'édition par programme linéaire (selon les essais cités).
La fenêtre de réglage, elle, est étroite : à moitié d'intensité, les boucles reviennent ; au double, le raisonnement se dégrade. L'édition des poids a donc l'avantage de produire un checkpoint standard. Le vecteur de pilotage nécessite, lui, du code supplémentaire pendant l'inférence.
Quelles sont les limites pour un usage concret ?
Les résultats sont encourageants, mais la portée reste limitée. L'étude porte sur un modèle, et sur un comportement précis. Le programme linéaire s'appuie sur les couches identifiées par Astra, et ses meilleurs scores dépendent de la direction construite par Astra. L'heuristique réduit cette dépendance, sans l'effacer totalement.
Autre point : dans ce cas, les contraintes « token par token » ne semblent pas indispensables. Le vecteur de pilotage quasi constant récupère déjà l'essentiel de l'effet. Pour vraiment justifier l'intérêt de l'optimisation sous contraintes, il faudrait tester un comportement qui ne peut pas être corrigé sans distinguer certains tokens à modifier et d'autres à préserver.
Ce que les équipes devraient mesurer avant de déployer
Dans un produit, améliorer un benchmark ne suffit pas. Une correction des boucles peut aussi modifier le ton, la capacité à suivre des consignes, ou la qualité des réponses longues. Ici, IFEval progresse, mais ça ne garantit pas que le modèle se comportera mieux dans tous les scénarios métier.
Avant un déploiement, il faut notamment :
- définir le comportement ciblé et les cas où il ne doit pas changer ;
- séparer les données pour construire l'édition, régler l'approche, puis évaluer ;
- comparer l'édition des poids à une méthode de pilotage à l'inférence ;
- vérifier les régressions sur les tâches et les langues réellement utilisées ;
- mesurer la stabilité du résultat quand les prompts ou les données changent.
Cette discipline compte particulièrement pour les usages réglementés ou sensibles en Europe. Modifier des poids peut être difficile à interpréter a posteriori et compliquer la comparaison entre versions. Il faut donc garder une trace de l'édition, des critères, et des évaluations - surtout quand le modèle intervient dans un processus où une réponse incorrecte peut nuire à l'utilisateur.
La méthode n'offre pas non plus une garantie de correction « éthique ». Elle peut réduire une manifestation indésirable, mais ne prouve pas que le système est sûr, juste ou robuste dans d'autres contextes. Des comportements comme le refus inapproprié ou la flatterie excessive pourraient, en théorie, être liés à une direction similaire dans le flux résiduel. Le traitement par optimisation linéaire reste à vérifier.
Conclusion
Cette expérience suggère qu'une partie de la programmation des poids peut être ramenée à un problème d'optimisation explicite. Pour corriger les boucles de Qwen3.5-0.8B, un programme linéaire sélectionne une petite fraction des paramètres à modifier et obtient des scores proches de ceux d'une recherche menée par un agent, avec environ huit fois moins de poids touchés.
La leçon pratique n'est pas que les programmes linéaires remplacent toujours l'entraînement ou les agents. Elle est plus précise : quand un comportement correspond à une direction identifiable dans les activations, une optimisation bien formulée peut réduire le coût de recherche et rendre les choix plus lisibles. Reste à vérifier que ce diagnostic tient sur d'autres modèles, d'autres comportements, et avec des données représentatives de l'usage réel.