Résumé Technique : L'Auto-jeu Ancré pour la Réparation de Code

Formulation du Problème

La réparation de code est une capacité critique pour les modèles de langage (LM) dans les flux de travail de programmation, nécessitant que le modèle génère un programme fixe qui réussit les tests unitaires étant donné un programme erroné et la suite de tests. Bien que les données de réparation réelles de haute qualité soient limitées, des travaux récents ont exploré l'extension de la supervision en utilisant des LM pour générer des tâches de correction de bogues. Les auteurs étudient l'auto-jeu générateur-correcteur (generator–fixer self-play), un cadre où un seul modèle est entraîné par apprentissage par renforcement pour alterner entre la génération de bogues (en modifiant du code correct) et leur réparation.

Le défi central identifié est la dérive de distribution (distribution drift). Bien que les tests unitaires vérifient efficacement la correction fonctionnelle (succès/échec), ils ne vérifient pas le réalisme du bogue. Dans l'auto-jeu standard, le générateur peut dériver vers la production de bogues « difficiles mais irréalistes » — des modifications qui échouent aux tests mais ne ressemblent pas aux erreurs rencontrées en pratique (par exemple, le code écrit par des humains ou le code édité par des LM). Par conséquent, bien que le correcteur s'améliore sur la distribution synthétique du générateur, ses performances se dégradent souvent sur les sources de bogues réalistes.

Méthodologie

1. Auto-jeu Générateur–Correcteur

Les auteurs instaurent une boucle d'auto-jeu où une politique unique $\pi_\theta$ joue deux rôles :

• Générateur ($G$) : Modifie une implémentation de référence correcte $c^\star$ pour produire un programme erroné $b$.
• Correcteur ($F$) : Répare $b$ étant donné la description de la tâche et le retour des tests unitaires $o(x, b)$.

Récompenses :

• Récompense du Correcteur : Récompense binaire basée sur le fait que le programme réparé $y$ réussisse tous les tests unitaires ($v(x, y) = 1$).
• Récompense du Générateur : Conçue pour encourager des bogues qui sont valides (exécutables et échouant aux tests) et d'une difficulté intermédiaire. La difficulté est estimée par le taux de réparation de $K$ tentatives de réparation indépendantes. Les bogues trop faciles (toujours réparés) ou trop difficiles (jamais réparés) sont pénalisés pour maintenir un curriculum adaptatif.

Le système est optimisé à l'aide de GRPO (Group Relative Policy Optimization).

2. Le Mode de Défaillance : Dérive de Distribution

Les expériences montrent que l'auto-jeu standard présente des dynamiques de co-évolution où le générateur produit des bogues de plus en plus difficiles pour un correcteur fixe, et le correcteur s'améliore sur ces bogues spécifiques. Cependant, lorsqu'ils sont évalués sur des sources réalistes (bogues écrits par des humains, édités par des humains ou générés par des LM), les performances régressent. Le correcteur fait du surapprentissage (overfitting) sur les modifications idiosyncrasiques et irréalistes générées par la boucle d'auto-jeu.

3. Solution Proposée : L'Auto-jeu Ancré (Anchored Self-Play - ASP)

Pour atténuer la dérive, les auteurs proposent l'Auto-jeu Ancré (ASP), qui ancre le processus d'auto-jeu à un petit ensemble de référence de bogues ($D_{ref}$) échantillonnés à partir de sources réalistes. L'ASP emploie deux mécanismes complémentaires :

• Mélange de Référence pour l'Entraînement du Correcteur : Pendant l'entraînement, une fraction des bogues d'entrée du correcteur est remplacée par des bogues provenant de l'ensemble de référence ($D_{ref}$). Cela garantit que le correcteur est continuellement exposé à des modèles de bogues réalistes, empêchant le surapprentissage de la distribution synthétique évolutive du générateur. Le générateur n'est pas mis à jour sur ces épisodes mélangés pour éviter les problèmes hors-politique (off-policy).
• Façonnage du Générateur Guidé par la Similitude : Une récompense auxiliaire est ajoutée à l'objectif du générateur pour le pousser à produire des bogues similaires à l'ensemble de référence.
  • Le générateur calcule le diff unifié entre la solution de référence et le bogue généré.
  • Ce diff est vectorisé (embedded) à l'aide d'un modèle d'embedding de code (voyage-code-3).
  • La récompense est basée sur la similitude cosinus entre l'embedding du bogue généré et les $k$-plus proches voisins dans le pool de référence.
  • Une récompense de similitude centrée est utilisée : $\delta_t(b) = \text{sim}_{01}(b) - B_t$, où $B_t$ est une ligne de base mobile. Cela façonne le générateur vers des éditions de type référence sans écraser la récompense principale du test unitaire.

Principales Contributions

1. Formulation du Problème : Les auteurs formalisent l'auto-jeu générateur-correcteur pour la réparation de code et identifient la dérive de distribution comme un mode de défaillance primaire lorsqu'on repose uniquement sur les récompenses de tests unitaires.
2. Benchmark (BUGSOURCEBENCH) : Ils introduisent et publient BUGSOURCEBENCH, un benchmark contrôlé pour évaluer la généralisation de la réparation entre différentes sources. Il couvre quatre sources de bogues tout en maintenant constantes les tâches sous-jacentes, les spécifications et les tests unitaires :
   • HUMAN : Bogues introduits par des annotateurs dans des solutions de référence écrites par des humains.
   • HUMAN-EDITED LM : Bogues dans du code généré par LM qui ont été ultérieurement édités par des humains.
   • LM ERRORS (QWEN-7B) : Erreurs provenant d'un modèle de code plus faible.
   • LM ERRORS (GPT-OSS-20B) : Erreurs provenant d'un modèle de code plus fort.
3. Méthode (ASP) : Ils proposent l'Auto-jeu Ancré, qui combine le guidage par similitude d'embedding pour la génération de bogues avec un entraînement de correcteur par mélange de référence pour stabiliser l'auto-jeu et améliorer la généralisation.

Résultats Expérimentaux

Les auteurs évaluent l'ASP par rapport à un Modèle de Base, une ligne de base Correcteur-Seul (générateur gelé, correcteur entraîné) et l'Auto-jeu standard sur BUGSOURCEBENCH.

• Performance Globale : L'ASP atteint le taux de réparation moyen le plus élevé sur toutes les sources de bogues. Il améliore le taux de réparation moyen de +7,0 points de pourcentage (absolu) et de 24 % (relatif) par rapport à l'auto-jeu standard.
• Généralisation Inter-Sources :
  • Bogues Générés par LM : L'ASP montre des gains massifs, améliorant les taux de réparation de +11 pp (100 % relatif) en moyenne pour les bogues générés par LM.
  • Bogues d'Origine Humaine : L'ASP améliore les taux de réparation de +3,4 pp (7,1 % relatif) sur les bogues écrits par des humains, alors que l'auto-jeu standard dégrade souvent les performances sur ces sources.
• Études d'Ablation :
  • Le mélange de référence et le façonnage par similitude contribuent tous deux à la performance, mais leur combinaison produit les gains les plus importants, suggérant qu'ils traitent des modes de défaillance complémentaires.
  • La méthode est efficace en termes d'échantillonnage, montrant des améliorations avec seulement 50 exemples de référence.
  • L'utilisation d'un pool de référence mixte (couvrant toutes les sources de bogues) produit la meilleure performance globale par rapport aux pools restreints à une seule source.
• Robustesse : Les gains de l'ASP sont robustes à travers différents modèles d'embedding (voyage-code-3 vs CodeBERT), modèles de base (Qwen-7B vs DeepSeek-6.7B) et distributions de tâches (transfert vers DebugBench).

Signification et Revendications

L'article affirme que l'auto-jeu basé uniquement sur les tests unitaires est insuffisant pour l'extension de la réparation de code car il manque d'un signal explicite de réalisme, ce qui entraîne une dérive de distribution. En introduisant l'Auto-jeu Ancré, les auteurs démontrent qu'un petit ensemble de référence peut effectivement ancrer le processus de génération, permettant au modèle de bénéficier du curriculum adaptatif de l'auto-jeu tout en maintenant une robustesse aux sources de bogues réalistes.

Le travail souligne que les capacités de réparation sont distinctes de la génération de code ; les modèles qui résolvent des tâches à partir de zéro peuvent échouer à réparer des solutions existantes, et vice versa. La méthode proposée offre une voie pour construire des outils de programmation automatisés plus fiables qui généralisent à travers les sources hétérogènes d'erreurs trouvées dans la programmation assistée par LM du monde réel.

Limites : Les auteurs notent que leurs expériences se concentrent sur la réparation de fonctions Python au niveau de la fonction avec un retour de test unitaire. Le cadre ne capture pas les défis au niveau du dépôt (fautes multi-fichiers, gestion des dépendances) ou l'utilisation d'outils sur un long horizon. De plus, le signal de réalisme repose sur un modèle d'embedding gelé et un pool de référence fini, suggérant que des travaux futurs pourraient explorer des critiques appris ou des récompenses basées sur les préférences.