💻 computer science

Try Again, Don't Look Back: Blind Resampling Outperforms Self-Repair in Small Code Models

Dit artikel toont aan dat voor kleine codemodellen blind herbemonsteren (opnieuw proberen zonder feedback) standaard zelfherstelmethoden evenaart of overtreft terwijl er aanzienlijk minder tokens worden gebruikt, omdat conditionering op de eigen mislukte poging van een model ervoor zorgt dat het zich aan de oorspronkelijke fout "ankert" in plaats van uitvoeringfeedback effectief te benutten.

Oorspronkelijke auteurs: Yuvraj Verma

Gepubliceerd 2026-07-30

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Yuvraj Verma

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een robot leert om computercode te schrijven. Je geeft de robot een taak, zoals "schrijf een programma dat twee getallen bij elkaar optelt," en de robot probeert het te doen. Soms maakt de robot een fout, en werkt de code niet. In de wereld van kunstmatige intelligentie is er een populair idee van "zelfherstel" (self-repair). Dit is alsof je tegen de robot zegt: "Hé, je hebt een fout gemaakt. Hier is je kapotte code en de foutmelding. Kijk er nu naar, denk na over wat er misging, en probeer het te repareren." Het klinkt als een slimme manier om van fouten te leren, toch? Maar er is een addertje onder het gras. Wanneer we testen of dit "repareren" werkt, vergelijken we het vaak met een robot die het gewoon opgeeft na één poging. Dat is een beetje oneerlijk, omdat de robot die een tweede kans krijgt een grotere kans op succes heeft simpelweg omdat hij het nog een keer probeert, en niet noodzakelijkerwijs omdat hij heeft geleerd van zijn fout. Om echt te weten of "repareren" het magische ingrediënt is, moeten we het vergelijken met een robot die een tweede kans krijgt maar de eerdere fout niet ziet. Dit artikel duikt in precies die vraag: Is het beter om terug te kijken naar een mislukking en te proberen het te repareren, of is het beter om de mislukking te vergeten en een volledig nieuwe aanpak te proberen vanaf nul?

De onderzoekers in dit artikel besloten een spelletje "Probeer het opnieuw, kijk niet terug" te spelen met enkele kleine AI-modellen. Ze zetten een slim experiment op met een "placebo"-test, wat meestal iets is wat je doet in de geneeskunde om te zien of een pil werkt of dat het slechts de hoop van het nemen van een pil is die hels. Hier vergeleken ze vier verschillende manieren waarop een robot zijn code zou kunnen proberen te repareren:

Blind Resampling: De robot krijgt een tweede kans maar krijgt niets te horen over de eerste poging. Het is alsof je een leerling vraagt om opnieuw een wiskundetoets te maken zonder de eerste te laten zien.
De Placebo: De robot ziet zijn kapotte code en een simpele opmerking: "Dit is fout," maar zonder details over waarom.
Echte Feedback: De robot ziet de kapotte code en de specifieke foutmelding (zoals "je bent een puntkomma vergeten").
Reflectie: De robot ziet de fout en krijgt de opdracht om een paragraaf te schrijven waarin hij uitlegt wat er misging voordat hij probeert het te repareren.
Ze voerden deze test uit op drie verschillende groottes van AI-modellen (klein, medium en iets groter) en hielden bij hoe vaak ze de code correct kregen.

Hier is de verrassende wending: Terugkijken naar de fout maakte de kleine robots juist slechter.

Voor de kleinere modellen (1,5 miljard en 3 miljard parameters) was de "Blind Resampling"-strategie de duidelijke winnaar. Deze was niet alleen het meest nauwkeurig, maar ook het goedkoopst qua computer tijd en energie. Wanneer de onderzoekers de robots dwongen om naar hun eigen kapotte code te kijken (de "Placebo"- of "Feedback"-groepen), liepen de robots vast. Ze hadden de neiging om minuscule, bijna onzichtbare wijzigingen aan te brengen in de kapotte code in plaats van na te denken over een compleet nieuwe oplossing. De paper noemt dit "anchoring" (verankering). Het is alsof je een kat probeert te tekenen, het verpest, en dan probeert de fout te herstellen door slechts een paar lijnen van de slechte tekening weg te gummen. Je eindigt met een vreemde, half-gefixte kat. Maar als je gewoon een nieuw vel papier pakt en opnieuw begint, kun je misschien een totaal andere, betere kat tekenen.

De onderzoekers ontdekten dat wanneer de robots naar hun eigen mislukte pogingen keken, ze een bijna identiek programma reproduceerden in 33% tot 68% van de gevallen. In tegen geval, wanneer ze blind probeerden (zonder te kijken), herhaalden ze zichzelf slechts 2% tot 14% van de tijd. De "informatie" in de foutmeldingen hielp helemaal niet; een simpele opmerking als "dit is fout" was net zo slecht als het volledige foutrapport. Zelfs de robot vragen om "hardop na te denken" over de fout (Reflectie) redde de dag niet; het maakte het proces alleen maar duurder zonder de resultaten genoeg te verbeteren om het waard te zijn.

Er is echter een sprankje hoop voor grotere breinen. Toen ze het grootste model (7 miljard parameters) testten, verdween de straf voor het terugkijken bijna volledig. De "Blind Resampling"- en de "Self-Repair"-methoden eindigden in een statistische gelijkstand. Dit suggereert dat naarmate AI slimmer wordt, het beter wordt in het niet vastlopen op de eigen fouten. Maar voor de kleinere, goedkopere modellen die veel mensen daadwerkelijk gebruiken, is het advies duidelijk: Kijk niet terug.

De paper weerlegde ook een aantal andere ideeën. Ze controleerden of het probleem simpelweg kwam doordat de prompts te lang werden en de robots in de war brachten, maar het toevoegen van code van andere succesvolle taken schaadde de prestaties niet. Dit bewees dat het probleem niet over de lengte ging, maar specif

Technisch Overzicht: Blind Resampling Presteert Beter dan Self-Repair bij Kleine Code-modellen

Probleemstelling

Het artikel behandelt een fundamenteel gebrek in de evaluatie van self-repair (zelfherstel) mechanismen in code-genererende agenten. Standaard evaluaties vergelijken self-repair (opnieuw proberen met uitvoering-feedback) met een single-shot baseline. De auteurs stellen dat deze vergelijking een verwarring bevat: het vervuilt de waarde van de feedbackinformatie met de waarde van de extra poging zelf. Onder stochastische decodering verhoogt het simpelweg opnieuw proberen van een taak meerdere keren de kans op succes, ongeacht of de retry geïnformeerd is. Het artikel stelt dat zonder een "placebo" controle die rekening houdt met de kosten van een extra poging, de schijnbare voordelen van self-repair illusoir kunnen zijn.

Methodologie

De studie hanteert een placebo-gecontroleerd experimenteel ontwerp op de MBPP+-benchmark (378 taken) over drie modelmaten (1,5B, 3B en 7B) met behulp van Qwen2.5-Coder modellen.

Experimentele Condities

Wanneer een programma een test niet doorstaat, voegt het systeem een van vier suffixen toe aan de oorspronkelijke instructie om een repair-poging te triggeren. Alle condities delen dezelfde token-budgetbeperkingen en decoderingsparameters (temperatuur 0,8 voor retries, greedy voor de initiële poging):

Resample (Blind Control): De oorspronkelijke prompt wordt opnieuw gesampled zonder referentie naar de mislukte poging. Dit isoleert de waarde van een extra extractie.
Placebo: Het mislukte programma wordt aangevuld met een inhoudsloos bericht dat het onjuist was. Dit isoleert de waarde van het opnieuw lezen van de eigen poging.
Feedback: Het mislukte programma wordt aangevuld met de werkelijke uitvoer (foutieve input, verwachte vs. geobserveerde waarden). Dit isoleert de waarde van diagnostische informatie.
Reflect: Het mislukte programma en de uitvoer worden voorafgegaan door een instructie om de fout in tekstuele vorm te diagnosticeren voordat er opnieuw wordt geschreven. Dit test de waarde van expliciete verbale redenering.

Evaluatiemetrieken

Prestaties: pass@1 bij $k=8$ iteraties, gemeten via differentiële testen tegen referentie-implementaties op EvalPlus.
Kosten: Output tokenconsumptie.
Mechanisme-analyse: Tekstuele gelijkenis (ratio van de langst passende subreeks) tussen opeenvolgende pogingen om "anchoring" (verankering) te meten.
Statistische Rigor: McNemar's exacte test voor gepaarde contrasten, bootstrap betrouwbaarheidsintervallen en Holm-correctie voor meervoudige vergelijkingen. Experimenten werden vooraf geregistreerd en uitgevoerd op een enkele consumenten-GPU.

Belangrijkste Resultaten

1. Blind Resampling Domineert Kleine Modellen

Bij de 1,5B en 3B schaal bereikt blind resampling (opnieuw proberen zonder de fout te zien) de hoogste pass rates en is dit de meest token-efficiënte strategie.

1,5B: Self-repair condities (placebo, feedback, reflect) worden strikt Pareto-gedomineerd door blind resampling, wat slechter presteert in nauwkeurigheid en aanzienlijk meer tokens kost. Specifiek vermindert het conditioneren op de eigen mislukte poging (placebo) de nauwkeurigheid met 6,1 punten ( $p=0,006$ ) vergeleken met blind resampling.
3B: Vergelijkbare trends zijn zichtbaar; de straf voor zelf-conditionering is 6,9 punten ( $p<0,001$ ).
7B: De straf wordt kleiner, en blind resampling is statistisch gelijk aan de beste self-repair condities. Echter, de "Reflect" conditie levert slechts een niet-significante winst op van +0,8 punten boven blind resampling, terwijl deze 2,5× zoveel tokens verbruikt.

2. Execution Feedback Voegt Geen Meetbare Waarde Toe

De informatieve inhoud van execution feedback is niet te onderscheiden van een inhoudsloze placebo.

Het contrast tussen Feedback en Placebo is statistisch nul over alle schalen (verschillen van +0,000, +0,026 en +0,008).
De aanname van praktijkgebruikers dat execution feedback het "actieve ingrediënt" is in self-repair, wordt weerlegd; het louter tonen van de eigen mislukte code is de primaire drijfveer achter de veranderingen in prestaties.

3. Het Mechanisme: Anchoring

Het artikel identificeert anchoring (verankering) als het mechanisme dat de daling in prestaties veroorzaakt.

Wanneer het model wordt getoond aan de eigen mislukte code, reproduceert het in 33–68% van de retries bijna identieke programma's, vergeleken met slechts 2–14% onder blind resampling.
Het model neigt de generatie te sturen naar lokale wijzigingen van het mislukte programma in plaats van nieuwe gebieden in de oplossingsruimte te verkennen.
Verbale Reflectie mitigeert anchoring gedeeltelijk (vermindert gelijkenis met 0,04–0,12), maar blijft minder kosteneffectief dan blind resampling.

4. Specificiteit bij Zelf-Conditionering

Cross-Task Ervaring: Het vooraf toevoegen van opgehaalde oplossingen uit andere taken (succesvolle exemplaren) heeft geen effect (beperkt tot ±3,5 punten). Dit bevestigt dat de schade specifiek is aan zelf-conditionering (het zien van de eigen fout), en niet een algemeen gevolg van langere contextvensters.
Replicatie: Het effect blijft bestaan over verschillende modelfamilies (DeepSeek-Coder) en precisies (FP16 vs. Q4 kwantisatie), wat uitsluit dat kwantisatie-artefacten of specifieke pre-training distributies de oorzaak zijn.

5. De Rol van Baseline Capaciteit

De omvang van de anchoring-straf wordt sterk voorspeld door de baseline kwaliteit van het model ( $r=0,96$ ), en niet alleen door model schaal of familie.

De straf is de "kost van het vastleggen aan een slechte eerste poging."
Naarmate de baseline capaciteit verbetert (bijv. bij 7B), is de eerste poging minder waarschijnlijk "slecht", waardoor de kosten van anchoring verwaarloosbaar worden. De schijnbare schaaltrend is dus een capaciteitseffect.

Betekenis en Claims

Het artikel claimt het begrip van iteratieve zelfcorrectie in code-agenten fundamenteel te veranderen:

Methodologische Correctie: Het stelt dat de capaciteiten die aan agent-prompts worden toegevoegd, moeten worden geëvalueerd tegen even dure, oninformatieve controles (zoals blind resampling) in plaats van single-shot baselines. Zonder dit is de "voordelen" van feedback vaak slechts het voordeel van persistentie.
Praktisch Advies voor Kleine Modellen: Voor modellen onder de 7B is de optimale strategie om blind te proberen in plaats van self-repair te pogen. Agenten zouden hun iteratie-budgetten rond $k \approx 2$ moeten beperken en execution feedback moeten behandelen als een kostbare bron in plaats van een standaardmechanisme.
Economische Impact: Het adopteren van blind resampling boven self-repair voor kleine modellen levert gelijke of betere nauwkeurigheid op met aanzienlijk minder tokenconsumptie (2,5–5,5× minder tokens), wat leidt tot directe reducties in compute en energieverbruik.
Theoretisch Inzicht: De studie toont aan dat de "schade" van self-repair in kleine modellen niet een gebrek aan redeneervermogen is, maar een cognitieve bias (anchoring) die het model verhindert om een mislukt traject te verlaten. Deze bias neemt af naarmate de initiële generatiekwaliteit van het model verbetert.

De auteurs concluderen dat voor kleine code-modellen de strategie "Probeer het opnieuw, kijk niet terug" de superieure strategie is, en dat het overgangspunt waar self-repair levensvatbaar wordt, samenvalt met het punt waar de eerste poging voldoende kwalitatief hoogwaardig is zodat anchoring geen straf meer oplevert.