Technische Samenvatting: Anchored Self-Play voor Code Repair

Probleemformulering

Code repair is een cruciale capaciteit voor taalmodellen (LM's) in programmeerworkflows, waarbij het model een vast programma moet genereren dat slaagt voor unit tests, gegeven een buggy programma en de testsuite. Hoewel hoogwaardige real-world repair data beperkt is, heeft recent werk onderzocht hoe men supervisie kan opschalen door LM's te gebruiken om bug-fix taken te genereren. De auteurs onderzoeken generator–fixer self-play, een setting waarin een enkel model via reinforcement learning wordt getraind om af te wisselen tussen het genereren van bugs (door correcte code aan te passen) en het repareren ervan.

De kernuitdaging die wordt geïdentificeerd is distributiedrift. Hoewel unit tests effectief de functionele correctheid verifiëren (pass/fail), verifiëren ze niet de realisme van de bug. In standaard self-play kan de generator driften naar het produceren van "moeilijke maar onrealistische" bugs—aanpassingen die falen voor tests maar niet lijken op fouten die in de praktijk voorkomen (bijv. door mensen geschreven code of door mensen bewerkte LM-code). Gevolgelijk, terwijl de fixer verbetert op de synthetische distributie van de generator, verslechtert de prestatie vaak op realistische bugbronnen.

Methodologie

1. Generator–Fixer Self-Play

De auteurs instantiëren een self-play loop waarbij een enkel beleid $\pi_\theta$ twee rollen speelt:

• Generator ($G$): Bewerkt een correcte referentie-implementatie $c^\star$ om een buggy programma $b$ te produceren.
• Fixer ($F$): Repareert $b$ gegeven de taakbeschrijving en unit-test feedback $o(x, b)$.

Beloningen:

• Fixer Beloning: Binaire beloning gebaseerd op of het gerepareerde programma $y$ alle unit tests slaagt ($v(x, y) = 1$).
• Generator Beloning: Ontworpen om bugs aan te moedigen die valide zijn (uitvoerbaar en falende tests) en van gemiddelde moeilijkheid. De moeilijkheid wordt geschat door de fix rate van $K$ onafhankelijke reparatiepogingen. Bugs die te makkelijk zijn (altijd gefixed) of te moeilijk (nooit gefixed) worden bestraft om een adaptief curriculum te behouden.

Het systeem wordt geoptimaliseerd met behulp van GRPO (Group Relative Policy Optimization).

2. De Foutmodus: Distributiedrift

Experimenten tonen aan dat standaard self-play co-evolutionaire dynamiek vertoont waarbij de generator steeds moeilijkere bugs produceert voor een vaste fixer, en de fixer verbetert op die specifieke bugs. Echter, wanneer geëvalueerd op realistische bronnen (door mensen geschreven, door mensen bewerkte LM, en LM-gegenereerde bugs), verslechtert de prestatie. De fixer overfit op de idiosyncratische, onrealistische aanpassingen gegenereerd door de self-play loop.

3. Voorgestelde Oplossing: Anchored Self-Play (ASP)

Om drift te mitigeren, stellen de auteurs Anchored Self-Play (ASP) voor, die het self-play proces verankert aan een kleine referentieset van bugs ($D_{ref}$) gesampled uit realistische bronnen. ASP maakt gebruik van twee complementaire mechanismen:

• Reference Mixing voor Fixer Training: Tijdens de training wordt een fractie van de input-bugs van de fixer vervangen door bugs uit de referentieset ($D_{ref}$). Dit zorgt ervoor dat de fixer continu wordt blootgesteld aan realistische bugpatronen, wat overfitting op de evoluerende synthetische distributie van de generator voorkomt. De generator wordt niet bijgewerkt op deze gemengde episodes om off-policy problemen te vermijden.
• Similarity-Guided Generator Shaping: Er wordt een hulpbeloning toegevoegd aan de generator-objective om de generator richting het produceren van bugs te duwen die lijken op de referentieset.
  • De generator berekent de unified diff tussen de referentie-oplossing en de gegenereerde bug.
  • Deze diff wordt geëmbed gebruikt met een code-embedding model (voyage-code-3).
  • De beloning is gebaseerd op de cosine similarity tussen de embedding van de gegenereerde bug en de $k$-nearest neighbors in de referentiepool.
  • Een centered similarity reward wordt gebruikt: $\delta_t(b) = \text{sim}_{01}(b) - B_t$, waarbij $B_t$ een lopende baseline is. Dit vormt de generator richting referentie-achtige edities zonder de primaire unit-test beloning te overstemmen.

Belangrijkste Bijdragen

1. Probleemformulering: De auteurs formaliseren generator–fixer self-play voor code repair en identificeren distributiedrift als een primaire faalmodus bij het uitsluitend vertrouwen op unit-test beloningen.
2. Benchmark (BUGSOURCEBENCH): Ze introduceren en publiceren BUGSOURCEBENCH, een gecontroleerde benchmark voor het evalueren van cross-source repair generalisatie. Het beslaat vier bugbronnen terwijl de onderliggende taken, specificaties en unit tests constant blijven:
   • HUMAN: Bugs geïntroduceerd door annotatoren in door mensen geschreven referentie-oplossingen.
   • HUMAN-EDITED LM: Bugs in LM-gegenereerde code die vervolgens door mensen zijn bewerkt.
   • LM ERRORS (QWEN-7B): Fouten van een zwakker code-model.
   • LM ERRORS (GPT-OSS-20B): Fouten van een sterker code-model.
3. Methode (ASP): Ze stellen Anchored Self-Play voor, dat embedding-similarity guidance voor buggeneratie combineert met reference-mixed fixer training om self-play te stabiliseren en generalisatie te verbeteren.

Experimentele Resultaten

De auteurs evalueren ASP tegenover een Base Model, een Fixer-Only baseline (bevroren generator, getrainde fixer), en standaard Self-Play op BUGSOURCEBENCH.

• Algemene Prestaties: ASP bereikt de hoogste gemiddelde fix rate over alle bugbronnen. Het verbetert de gemiddelde fix rate met +7,0 procentpunten (absoluut) en 24% (relatief) ten opzichte van standaard self-play.
• Cross-Source Generalisatie:
  • LM-Gegenereerde Bugs: ASP laat enorme winsten zien, met een verbetering van de fix rates met gemiddeld +11 pp (100% relatief) voor LM-gegenereerde bugs.
  • Door Mensen Originele Bugs: ASP verbetert de fix rates met +3,4 pp (7,1% relatief) op mens-geautoriseerde bugs, terwijl standaard self-play op deze bronnen vaak prestaties doet verslechteren.
• Ablatie Studies:
  • Zowel reference mixing als similarity shaping dragen bij aan de prestaties, maar hun combinatie levert de grootste winst op, wat suggereert dat ze complementaire faalmodi aanpakken.
  • De methode is sample-efficiënt en laat verbeteringen zien met slechts 50 referentievoorbeelden.
  • Het gebruik van een gemengde referentiepool (die alle bugbronnen dekt) levert de beste algemene prestaties op vergeleken met pools die beperkt zijn tot één bron.
• Robuustheid: De winst van ASP is robuust over verschillende embedding-modellen (voyage-code-3 vs. CodeBERT), base-modellen (Qwen-7B vs. DeepSeek-6.7B) en taakdistributies (transfer naar DebugBench).

Betekenis en Claims

Het artikel claimt dat unit-test-only self-play onvoldoende is voor het schalen van code repair omdat het een expliciet signaal voor realisme mist, wat leidt tot distributiedrift. Door Anchored Self-Play te introduceren, laten de auteurs zien dat een kleine referentieset het self-play proces effectief kan verankeren, waardoor het model kan profiteren van het adaptieve curriculum van self-play terwijl de robuustheid naar realistische bugbronnen behouden blijft.

Het werk benadrukt dat de capaciteiten voor code repair verschillen van code generatie; modellen die taken vanaf nul kunnen oplossen, kunnen er mogelijk niet in slagen bestaande oplossingen te repareren, en vice versa. De voorgestelde methode biedt een pad naar het bouwen van meer betrouwbare geautomatiseerde programmeertools die generaliseren over de heterogene bronnen van fouten die worden gevonden in real-world LM-ondersteunde programmeren.

Beperkingen: De auteurs merken op dat hun experimenten zich richten op Python functie-niveau repair met unit-test feedback. De setting vangt geen repository-niveau uitdagingen op (multi-file fouten, dependency management) of long-horizon toolgebruik. Daarnaast is het signaal voor realisme afhankelijk van een bevroren embedding-model en een eindige referentiepool, wat suggereert dat toekomstig werk geleerde critics of preference-based rewards zou kunnen verkennen.