🤖 machine learning

Primal Generation, Dual Judgment: Self-Training from Test-Time Scaling

Ce papier présente DuST, un cadre d'auto-apprentissage qui exploite l'échantillonnage au moment du test pour créer un « espace de jugement dual » où les modèles apprennent à classer des programmes candidats par apprentissage par renforcement on-policy, améliorant ainsi à la fois leur capacité à évaluer la correction du code et à générer des solutions de haute qualité sans récompenses directes pour une génération correcte.

Auteurs originaux : Yizhu Jiao, Ruixiang Zhang, Richard Bai, Jiawei Han, Ronan Collobert, Yizhe Zhang

Publié 2026-05-13

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Yizhu Jiao, Ruixiang Zhang, Richard Bai, Jiawei Han, Ronan Collobert, Yizhe Zhang

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous enseigniez à un robot à écrire du code informatique. Traditionnellement, vous lui apprenez en disant : « Voici un problème. Écrivez une solution. Exécutez-la. Si cela fonctionne, tant mieux ! Si cela plante, réessayez. » C'est comme donner au robot une seule note de « Réussi » ou « Échoué » pour chaque tentative. Le robot apprend, mais il ne sait que *qu'*il a échoué, pas pourquoi il a échoué par rapport à d'autres choses qu'il aurait pu écrire.

Ce papier introduit une nouvelle méthode d'enseignement appelée DuST (Dual Self-Training, ou Auto-entraînement Dual). Il change la donne en utilisant un concept appelé « Génération Primal » versus « Jugement Dual ».

Voici la décomposition utilisant des analogies simples :

1. L'Ancienne Méthode : Le Quiz « Réussi/Échoué »

Génération Primal :
Imaginez le robot comme un élève passant un examen.

Le Processus : L'élève écrit une seule réponse. L'enseignant la vérifie.
La Rétroaction : L'enseignant donne une seule croix rouge « X » ou une coche verte.
Le Problème : Si l'élève obtient un « X », il sait qu'il a tort, mais il ne sait pas à quel point il était proche de la justesse, ni pourquoi sa réponse spécifique était pire qu'une autre réponse possible qu'il aurait pu imaginer. Il sait simplement « Ne faites pas cela ».

2. La Nouvelle Idée : Le Panel de « Dégustation »

Mise à l'échelle au moment du test (La Configuration) :
Avant la méthode du papier, les chercheurs tentaient d'aider en demandant au robot d'écrire plusieurs réponses (disons 4 ou 5) à la fois et de choisir la meilleure. C'est comme un « Test de Dégustation ».

Le Défaut : Dans l'ancienne méthode, une fois que le robot choisit la meilleure réponse, les 4 autres réponses sont jetées à la poubelle. Le robot n'apprend rien du fait que la Réponse #2 était « presque juste » tandis que la Réponse #4 était « complètement fausse ». Ces données de comparaison précieuses sont gaspillées.

3. La Solution DuST : Apprendre des « Presque-Gagnants »

Espace de Jugement Dual :
Les auteurs soutiennent que le robot devrait apprendre de la comparaison entre ses propres réponses, et non pas seulement du gagnant final.

L'Analogie : Imaginez un concours de cuisine.
- Ancienne Méthode : Le juge goûte un plat et dit : « Brûlé. Échec. » Le chef n'apprend rien sur ce qui rend un plat bon.
- Méthode DuST : Le chef prépare 4 versions différentes du même plat. Le juge goûte les 4.
  - Plat A : Parfait.
  - Plat B : Un peu trop salé.
  - Plat C : Pas assez cuit.
  - Plat D : Brûlé.
- La Leçon : Au lieu de simplement dire au chef « Le Plat A est bon », l'enseignant dit : « Le Plat A est le gagnant car il est équilibré. Le Plat B a échoué à cause du sel. Le Plat C a échoué à cause de la chaleur. » Le chef apprend les différences entre le succès et l'échec.

4. Comment DuST Fonctionne (La Recette)

Le papier décrit une boucle spécifique que le robot parcourt :

Générer : Le robot écrit un lot de solutions de code (le lot de « Test de Dégustation »).
Juger : Le robot les exécute tous dans un bac à sable sécurisé pour voir lesquels fonctionnent réellement (Réussi/Échoué).
Grouper : Le robot examine le lot. Si tous ont échoué ou si tous ont réussi, il jette ce lot. Il ne conserve que les lots où certains ont fonctionné et certains ont échoué. C'est le « Groupe Mixte ».
Classer (L'Entraînement) : On demande au robot de classer ces groupes mixtes du « Meilleur » au « Pire ».
- Point Crucial : Le robot n'est jamais récompensé pour avoir écrit le code lui-même. Il est seulement récompensé pour avoir correctement identifié quel code est meilleur.
- Il gagne des points en disant : « Ce code fonctionnel est meilleur que ce code cassé. »
Le Transfert Magique : Même si le robot n'a été entraîné que pour être un juge, il devient étonnamment meilleur pour être un écrivain. En apprenant à repérer les différences subtiles entre une solution fonctionnelle et une solution cassée, le robot commence à « comprendre » ce qui fait fonctionner le code. Il intègre ces règles et commence à écrire un meilleur code par lui-même.

5. Les Résultats : Pourquoi Cela Compte

Le papier a testé cela sur plusieurs modèles d'IA différents (allant de petits à très grands) en utilisant un test de codage standard appelé LiveCodeBench.

Meilleurs Juges : Les modèles sont devenus beaucoup meilleurs pour repérer le code correct (améliorant leur score de « classement »).
Meilleurs Écrivains : Étonnamment, les modèles sont aussi devenus meilleurs pour écrire du code à partir de zéro, même s'ils n'ont jamais reçu l'ordre direct « Écrivez un programme correct ».
Le Miracle « Un Coup » : Avant cet entraînement, un modèle pouvait avoir besoin d'écrire 4 réponses et de choisir la meilleure pour obtenir un score élevé. Après l'entraînement DuST, le modèle pouvait écrire juste une réponse et obtenir le même score élevé. Il a appris à générer la réponse « meilleure » immédiatement, plutôt que d'avoir besoin de deviner et de vérifier.

6. L'Ingrédient Secret : RL vs Simple Copie

Les auteurs ont réalisé une dernière expérience pour voir pourquoi cela fonctionnait.

SFT (Affinement Supervisé) : Ils ont essayé d'enseigner simplement au robot de copier les classements corrects (comme un élève mémorisant une clé de réponses). Cela a rendu le robot meilleur juge, mais n'a pas fait de lui un meilleur écrivain.
RL (Apprentissage par Renforcement) : Ils ont utilisé une méthode appelée GRPO, où le robot apprend en essayant, en échouant et en ajustant son propre comportement basé sur les récompenses. C'était la clé. L'« apprentissage actif » du classement a permis au robot de changer sa façon de penser, ce qui a amélioré son écriture.

Résumé

DuST est une méthode où une IA apprend à coder en devenant un critique maître de son propre travail. En entraînant l'IA à distinguer entre ses propres tentatives « bonnes » et « mauvaises », elle apprend les règles cachées de la correction. Cette connaissance se transfère ensuite dans sa capacité d'écriture, la rendant meilleure en codage sans jamais avoir reçu l'ordre direct de savoir comment écrire un programme parfait. Elle transforme les données « gaspillées » des tentatives échouées en un puissant enseignant.

Résumé technique : Génération primale, jugement dual : Auto-entraînement à partir de l'extension au moment du test

Énoncé du problème

Les modèles de génération de code sont généralement entraînés dans l'espace primal, où un modèle produit une solution candidate et reçoit un feedback d'exécution binaire et sparse (succès/échec). Bien que l'extension au moment du test (échantillonnage de plusieurs candidats et sélection du meilleur via un juge) améliore la précision à l'inférence, les informations comparatives révélées durant ce processus — spécifiquement les différences structurelles entre les tentatives réussies et échouées — sont jetées après l'inférence. Les systèmes existants « générer puis juger » n'utilisent cette structure comparative que pour le classement au moment de l'inférence, échouant à mettre à jour le générateur lui-même. Par conséquent, le modèle peut continuer à attribuer une probabilité élevée à du code plausible mais incorrect lors des futures exécutions.

L'article soutient que la structure comparative de l'extension au moment du test définit un espace de jugement dual. Cet espace offre un signal d'entraînement plus dense que l'espace primal : au lieu de bits isolés de succès/échec, il fournit des structures de correction relative à travers des tentatives plausibles, révélant ce qui distingue le succès de l'échec.

Méthodologie : DuST (Auto-entraînement Dual)

Les auteurs introduisent DuST, un cadre pour l'auto-entraînement à partir de cet espace de jugement dual. L'hypothèse centrale est qu'un modèle entraîné à discriminer le code correct du code incorrect dans l'espace dual acquiert des caractéristiques sensibles à la correction qui bénéficient à la génération primale, même sans récompenses directes pour la génération de code correct.

1. Construction des données

Échantillonnage : Pour un problème de codage $x$ , le modèle de base échantillonne un grand pool de codes candidats ( $M$ candidats).
Exécution et étiquetage : Les candidats sont exécutés dans un bac à sable pour obtenir des étiquettes de correction binaires ($1$ pour succès, $0$ pour échec).
Regroupement : Les candidats sont partitionnés en groupes de taille $K$ . Seuls les groupes de qualité mixte (contenant au moins un candidat correct et un candidat incorrect) sont conservés. Les groupes composés uniquement de candidats corrects ou uniquement de candidats incorrects sont rejetés car ils manquent de contraste de classement.
Jeu de données : Le jeu de données résultant est composé de problèmes appariés à des ensembles de candidats auto-générés et d'étiquettes ancrées dans l'exécution.

2. Objectif d'entraînement

Le modèle est entraîné à classer les candidats au sein d'un groupe en fonction de la correction d'exécution.

Fonction de récompense : La récompense est purement discriminative. Elle mesure la fréquence à laquelle les candidats corrects d'exécution sont classés au-dessus des candidats incorrects d'exécution.
- $R_{exec}$ calcule la fraction de paires correctes-sur-incorrectes $(i, j)$ où le rang prédit de $i$ est meilleur que celui de $j$ .
- Les réponses malformées reçoivent une pénalité de format négative.
Optimisation : Le cadre utilise l'Optimisation de Politique Relative par Groupe (GRPO).
- Les échantillons de code candidats sont maintenus fixes (hors politique concernant la génération).
- Le modèle échantillonne des réponses de jugement (traces de raisonnement et classements) en politique.
- La politique est mise à jour pour maximiser la récompense de classement, régularisée par rapport à une politique de référence figée.

3. Distinction clé

Contrairement à l'Apprentissage par Renforcement (RL) standard pour la génération de code, DuST ne récompense jamais directement la génération de programmes corrects. La supervision provient entièrement du jugement des contrastes de correction parmi les propres tentatives du modèle. Les paramètres mis à jour sont les mêmes que ceux utilisés pour la génération de code subséquente.

Contributions clés

Cadre d'espace de jugement dual : L'article propose de considérer l'extension au moment du test non seulement comme une stratégie d'inférence, mais comme une source de signaux d'entraînement denses et contrastifs dans un espace dual.
Auto-entraînement discriminatif : DuST démontre qu'entraîner un modèle à classer les candidats par correction d'exécution (une tâche discriminative) améliore ses capacités génératives (une tâche générative) sans récompenses de génération directes.
Isolement du mécanisme : Grâce à des études d'ablation comparant l'Affinement Supervisé (SFT) et le GRPO, l'article identifie le RL en politique comme le mécanisme critique pour transférer l'apprentissage de l'espace dual vers la génération primale. Le SFT améliore le jugement mais échoue à améliorer la génération, tandis que le GRPO améliore les deux.
Densité de la récompense : L'article souligne que le signal contrastif dense du classement (exposant $O(N^2)$ comparaisons par paires) est plus efficace pour le transfert que les récompenses primales sparse ou les récompenses basées sur la sélection.

Résultats expérimentaux

La méthode a été évaluée sur LiveCodeBench (v5 et v6) à travers cinq modèles couvrant deux familles (Qwen, GPT-oss) et trois échelles (4B à 30B).

Précision de l'extension au moment du test : DuST améliore constamment la précision Best-of-4. Pour Qwen3-30B-Thinking sur LiveCodeBench v6, la précision a augmenté de +4,1 % (passant de 68,7 % à 72,6 %).
Qualité du jugement : La capacité du modèle entraîné à classer les candidats s'est considérablement améliorée, avec une augmentation de +6,2 du NDCG pour Qwen3-30B-Thinking.
Génération primale (Pass@1) : De manière remarquable, la qualité de la génération en échantillon unique s'est améliorée sans récompenses directes. Pour Qwen3-30B-Thinking, le pass@1 a augmenté de +3,1 % (passant de 65,4 % à 68,5 %).
Généralisation : Des améliorations ont été observées sur toutes les tailles de modèles (4B–30B) et familles, suggérant que l'approche est indépendante de l'architecture.
Comparaison avec le SFT : Lorsqu'entraîné sur les mêmes données de classement, le SFT a amélioré le jugement (NDCG) mais a laissé la génération (pass@1) inchangée. Seul le GRPO a amélioré les deux, confirmant que la boucle de rétroaction en politique est essentielle pour le transfert.
Sensibilité à la récompense : Les récompenses de classement (Précision par paires/NDCG) ont surpassé les récompenses de sélection (top-1 uniquement) dans le transfert vers la génération, probablement parce que le classement expose toute la structure contrastive du code correct par rapport au code incorrect.

Importance et affirmations

L'article affirme que les espaces primal (génération) et dual (jugement) de la génération de code sont plus étroitement couplés que ne le suppose l'entraînement standard.

Transfert de compréhension : Les auteurs soutiennent qu'en apprenant à distinguer pourquoi une solution échoue ou réussit par rapport à d'autres tentatives plausibles, le modèle internalise des caractéristiques de correction exécutable (par exemple, invariants algorithmiques, cas limites). Ces caractéristiques déplacent ensuite la masse de probabilité du générateur vers des trajectoires correctes.
Efficacité : Le déploiement unique du modèle entraîné correspond aux performances Best-of-4 du modèle de base, intégrant efficacement les bénéfices de l'extension au moment du test dans les poids du modèle.
Limites des paradigmes actuels : Ce travail suggère que rejeter les informations comparatives après l'inférence est une occasion manquée. La structure contrastive révélée au moment du test est un signal d'entraînement riche et largement inexploité.

L'article conclut que l'apprentissage par renforcement en politique dans l'espace de jugement dual est un mécanisme viable et efficace pour améliorer la génération de code, offrant une nouvelle voie d'auto-amélioration qui ne dépend ni des préférences humaines externes ni des récompenses de génération directes.