How Many Tries Does It Take? Iterative Self-Repair in LLM Code Generation Across Model Scales and Benchmarks
Dit onderzoek toont aan dat iteratieve zelfherstelstrategieën, waarbij uitvoeringsfouten teruggekoppeld worden naar moderne taalmodellen, de codeerprestaties op benchmarks zoals HumanEval en MBPP aanzienlijk verbeteren, zelfs bij kleinere modellen en zonder fijnafstemming.
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 zeer slimme, maar soms wat ongeduldige assistent hebt die code voor je schrijft. Als je hem vraagt een programma te maken, doet hij zijn best, maar vaak maakt hij op de eerste poging een foutje. In het verleden dachten onderzoekers: "Oké, als de assistent faalt, probeer je het gewoon opnieuw met een ander voorbeeld." Maar dit nieuwe onderzoek kijkt naar iets anders: Wat gebeurt er als we de assistent de foutmelding laten zien en vragen om het zelf te repareren?
De titel van het paper is: "Hoeveel pogingen kost het?" (Iterative Self-Repair). Hier is de uitleg in simpele taal, met een paar leuke vergelijkingen.
1. Het Grote Experiment: De "Zelf-Reparatie" Test
De onderzoekers hebben zeven verschillende AI-modellen getest (van kleine, snelle modellen tot enorme, dure "superhersenen"). Ze gaven ze allemaal programmeeropdrachten.
- De oude manier: De AI probeert het één keer. Als het fout is, is het fout.
- De nieuwe manier (Self-Repair): De AI probeert het. Als het fout is, krijgt hij een briefje met de foutmelding (bijv. "Je bent vergeten een puntkomma te zetten" of "Je hebt de verkeerde berekening gemaakt"). De AI leest dit, denkt na en probeert het opnieuw. Dit kan tot 5 keer herhaald worden.
Het resultaat? Het werkt voor iedereen. Zelfs de kleinste modellen (die maar zo groot zijn als een gewone laptop-app) worden beter als ze hun fouten mogen oplossen. Vroeger dachten we dat alleen de "grote jongens" dit konden, maar nu blijkt dat zelfs de kleintjes het kunnen, zolang ze maar een goede instructie krijgen.
2. De Vergelijking: De "Snelle Sportwagen" vs. De "Zware Tank"
De onderzoekers keken naar verschillende soorten modellen:
- Dense modellen: Dit zijn als een zware tank. Alles zit in één groot blok. Ze zijn sterk, maar zwaar.
- MoE-modellen (Mixture of Experts): Dit zijn als een team van specialisten. Als er een vraag is over wiskunde, schakelen ze de "wiskundeleraar" in. Als het over taal gaat, de "taalexpert". Ze zijn slimmer en sneller omdat ze niet alles tegelijk hoeven te doen.
Wat bleek?
- De Gemini 2.5 Flash (een snelle, moderne AI van Google) was de absolute winnaar. Hij begon al goed, maar werd na het repareren van fouten nog beter. Hij haalde bijna 96% perfectie.
- De MoE-modellen (zoals Llama 4 Scout) waren verrassend goed in het repareren van hun eigen fouten. Het lijkt erop dat het hebben van "experts" hen helpt om sneller te zien waar ze de fout hebben gemaakt.
3. Het "Twee-Pogingen"-Principe
Een van de belangrijkste ontdekkingen is dat je niet eindeloos hoeft te blijven proberen.
- Poging 1: De AI maakt een fout.
- Poging 2 (Reparatie 1): De AI kijkt naar de fout en maakt het vaak goed. Dit is waar de meeste winst wordt behaald.
- Poging 3 (Reparatie 2): Nog een beetje winst.
- Poging 4 en 5: Hier gebeurt er bijna niets meer. Het is als het proberen van een sleutel in een deur: als hij na twee keer niet opent, helpt het niet om 10 keer harder te duwen.
Advies voor de praktijk: Als je een AI gebruikt om code te schrijven, geef hem twee keer de kans om het zelf te repareren. Dat haalt 80-95% van de mogelijke verbetering op, zonder dat je tijd en geld verspilt aan extra pogingen.
4. Welke Fouten zijn het Moeilijkst?
Niet alle fouten zijn even makkelijk te fixen. De onderzoekers keken naar de "autopsie" van de fouten:
- Naamfouten (Name Errors): "Ik heb geen idee wie 'x' is." Dit is makkelijk. De AI ziet direct wat er mist en voegt het toe. (77% succes).
- Syntaxisfouten: "Je hebt een haakje vergeten." Ook makkelijk. (66% succes).
- Logische fouten (Assertion Errors): Dit is het lastigste. De code draait wel, maar het antwoord is verkeerd. Bijvoorbeeld: "Ik heb 2 appels geteld, maar ik moet 3 hebben." De AI moet nu echt nadenken over de logica, niet alleen de tekst corrigeren. Dit lukt maar in ongeveer 45% van de gevallen.
Vergelijking: Het is alsof je een auto repareert. Als een wiel loshangt (syntaxis), is dat makkelijk te zien en te fixen. Maar als de motor goed draait maar de auto toch naar links trekt (logica), moet je echt diep in de techniek duiken om de oorzaak te vinden.
5. De "Gedachtegang" (Chain-of-Thought)
De onderzoekers probeerden ook of het helpt om de AI te vragen: "Leg eerst uit waarom het fout ging, en schrijf dan de code."
- Voor de grote, slimme modellen werkte dit wonderbaarlijk goed. Het was alsof je de AI een moment gaf om rustig na te denken voordat hij weer begon. Dit leverde extra punten op.
- Voor de kleine modellen was het verschil minder groot. Ze zijn al snel genoeg dat het "nadenken" ze soms alleen maar vertraagt.
6. Repareren vs. Herhalen
Een andere vraag was: "Is het beter om de AI 5 keer iets te laten proberen (zonder foutmelding), of 1 keer proberen en dan 4 keer repareren?"
- Bij de slimme modellen wint het repareren. Ze begrijpen de foutmelding goed en maken het snel goed. Het is efficiënter (goedkoper en sneller).
- Bij de kleine modellen werkt het herhalen soms nog net iets beter, omdat ze de foutmelding niet altijd goed begrijpen.
Conclusie: Wat betekent dit voor jou?
Dit onderzoek zegt ons dat we niet hoeven te wachten tot AI's perfect zijn. We kunnen nu al gebruikmaken van hun vermogen om zichzelf te verbeteren.
- Gebruik "Self-Repair": Laat de AI zijn fouten zien en vraag hem het op te lossen.
- Stop na 2 keer: Meer proberen is vaak een verspilling van tijd.
- Kies de juiste AI: Voor de beste resultaten is een snelle, moderne AI (zoals Gemini Flash) vaak beter dan een enorme, oude AI.
- Wees realistisch: Als de AI een logische fout maakt (de code werkt maar het antwoord is verkeerd), is het lastig om dat te fixen. Soms moet je gewoon een mens ingrijpen.
Kortom: AI's zijn niet meer alleen maar "een-en-één" machines. Ze kunnen leren van hun fouten, net als wij mensen. En met een beetje geduld (twee pogingen) worden ze er enorm beter in.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.