Zelfverzekerd verkeerd: waarom de slimste AI-modellen het slechtst zijn in het corrigeren van zichzelf

Velen in de AI-gemeenschap geloven dat de volgende grote revolutie de era van zelfverbeterende AI zal zijn, waarin AI zichzelf kan verbeteren zonder menselijke tussenkomst. Het argument is: naarmate modellen krachtiger worden, zullen ze uiteindelijk niet alleen leren van data, maar ook van zichzelf. Elke iteratie zou de vorige verfijnen. Fouten zouden worden geïdentificeerd, gecorrigeerd en geëlimineerd. Na verloop van tijd zou deze opeenstapeling van verbeteringen een intelligentie-explosie kunnen veroorzaken waarin AI AI begint te bouwen. Deze visie vormt de basis van de opwinding rondom recursieve AI, autonome agenten en de langverwachte intelligentie-explosie. In het centrum van deze visie ligt de mogelijkheid voor AI-systemen om hun eigen fouten betrouwbaar te corrigeren. Echter, zonder robuuste zelfcorrectie kan zelfverbetering niet worden bereikt. Een systeem dat niet kan herkennen wanneer het fout zit, kan niet zinvol leren van zijn eigen uitvoer, ongeacht hoe krachtig het lijkt.

De heersende aanname was dat zelfcorrectie van nature zou ontstaan naarmate modellen krachtiger werden. Deze overtuiging voelt intuïtief. Immers, sterkere modellen weten meer, redeneren beter en presteren goed in verschillende taken. Echter, recent onderzoek onthult een tegenintuïtieve bevinding dat geavanceerdere modellen vaak worstelen met het corrigeren van hun eigen fouten, terwijl zwakkere modellen beter presteren bij zelfcorrectie. Dit fenomeen, bekend als het Accuratie-Correctie-Paradox, dwingt ons om niet alleen na te denken over hoe AI-systemen redeneren, maar ook over hoe goed we echt zijn voorbereid op zelfverbeterende AI.

Begrip van zelfverbeterende AI

Zelfverbeterende AI verwijst naar een AI-systeem dat zijn eigen fouten kan identificeren, ervan kan leren en zijn gedrag iteratief kan verfijnen. In tegenstelling tot traditionele modellen, die uitsluitend afhankelijk zijn van trainingsdata die door mensen zijn gecureerd, zou zelfverbeterende AI zijn eigen uitvoer actief evalueren en in de loop van de tijd aanpassen. In theorie creëert dit een feedbacklus waarin elke leercurve zich opbouwt op de vorige, wat leidt tot wat vaak wordt beschreven als een intelligentie-explosie.

Maar het bereiken van dit doel is verre van triviaal. Zelfverbetering vereist meer dan alleen brute rekenkracht of grotere datasets. Het vereist betrouwbare zelfbeoordeling, inclusief de mogelijkheid om fouten te detecteren, hun oorsprong te identificeren en gecorrigeerde oplossingen te produceren. Zonder deze mogelijkheden kan een model niet onderscheiden tussen een correcte redenering en een gebrekkige. Het itereren op de verkeerde oplossing, ongeacht hoe snel, versterkt alleen maar fouten in plaats van de prestaties te verbeteren.

Deze onderscheid is kritiek. Bij mensen houdt leren van fouten vaak in dat men reflecteert, hypothesen test en van richting verandert. Voor AI moeten deze processen worden gecodeerd in het systeem zelf. Als een model zijn eigen fouten niet betrouwbaar kan herkennen en corrigeren, kan het niet zinvol deelnemen aan een zelfverbeteringslus, en blijft de belofte van recursieve intelligentie theoretisch in plaats van praktisch.

Het Accuratie-Correctie-Paradox

Zelfcorrectie wordt vaak behandeld als één mogelijkheid, maar in werkelijkheid combineert het verschillende afzonderlijke mogelijkheden die afzonderlijk moeten worden overwogen. Minimaal kunnen we het opsplitsen in drie meetbare submogelijkheden: foutdetectie, foutlocalisatie of bron detectie, en foutcorrectie. Foutdetectie vraagt of een model kan herkennen dat zijn uitvoer onjuist is. Foutlocalisatie richt zich op het identificeren van de locatie van de fout. Foutcorrectie verwijst naar de mogelijkheid om een gecorrigeerde oplossing te produceren.

Door deze mogelijkheden afzonderlijk te meten, onthullen onderzoekers belangrijke inzichten over de beperkingen van huidige systemen. Ze laten zien dat modellen sterk variëren over deze mogelijkheden. Sommige modellen zijn goed in het detecteren van fouten, maar slecht in het corrigeren ervan. Andere herkennen nauwelijks fouten, maar slagen er toch in om ze te corrigeren door herhaalde pogingen. Belangrijker nog, deze inzichten laten zien dat verbetering in het ene gebied niet noodzakelijkerwijs verbetering in de andere gebieden impliceert.

Wanneer onderzoekers geavanceerde modellen testten op complexe wiskundige redeneertaken, maakten deze modellen minder fouten. Dat was verwacht. Wat onverwacht was de bevinding dat: wanneer deze modellen fouten maakten, ze minder geneigd waren om ze zelf te corrigeren. Omgekeerd waren zwakkere modellen, ondanks dat ze meer fouten maakten, aanzienlijk beter in het corrigeren van hun eigen fouten zonder externe feedback. Met andere woorden, onderzoekers vonden dat nauwkeurigheid en zelfcorrectie in tegenovergestelde richting bewogen, een paradox die ze het Accuratie-Correctie-Paradox noemen. Deze bevinding uitdaagt een diepgeworteld geloof in AI-ontwikkeling. We gaan er vaak van uit dat het schalen van modellen elk aspect van intelligentie verbetert. De paradox toont aan dat deze aanname niet altijd geldt, vooral voor introspectieve mogelijkheden.

De Foutdiepte-Hypothese

Deze paradox roept een voor de hand liggende vraag op: waarom presteren zwakkere modellen beter bij zelfcorrectie dan sterkere modellen? Onderzoekers vinden het antwoord door de soort fouten te onderzoeken die modellen maken. Ze vonden dat sterkere modellen minder fouten maken, maar de fouten die ze wel maken zijn “dieper” en moeilijker te corrigeren. Omgekeerd maken zwakkere modellen “ondiepere” fouten die gemakkelijk te corrigeren zijn tijdens een tweede poging.

Onderzoekers noemen deze inzicht de Foutdiepte-Hypothese. Ze categoriseren fouten in opzet-, logica- en berekeningsfouten. Opzetfouten houden in dat het probleem verkeerd wordt geïnterpreteerd. Logicafouten treden op wanneer de redeneerweg structureel gebrekkig is. Berekeningsfouten zijn eenvoudige rekenfouten. Voor GPT-3.5 zijn de meeste fouten (62%) eenvoudige berekeningsfouten. Dit zijn ondiepe fouten. Wanneer het model wordt gevraagd om “zorgvuldig te controleren”, kan het model vaak de rekenfout vinden en corrigeren. Voor DeepSeek zijn 77% van de fouten opzet- of logicafouten. Deze diepe fouten vereisen dat het model zijn aanpak fundamenteel herziet. Sterke modellen hebben moeite met dit omdat ze de neiging hebben om vast te houden aan hun initiële redeneerweg. Naarmate de intelligentie van het model toeneemt, blijven alleen de meest resistente en moeilijke fouten over.

Waarom het detecteren van fouten geen garantie biedt voor het corrigeren ervan

Een van de meest verrassende bevindingen van het onderzoek is dat foutdetectie niet correleert met de mogelijkheid om fouten te corrigeren. Een model kan correct herkennen dat zijn antwoord fout is, maar toch falen in het corrigeren ervan. Een ander model kan nauwelijks fouten detecteren, maar toch verbeteren door herhaalde pogingen. Claude-3-Haiku biedt het meest dramatische voorbeeld. Claude detecteerde slechts 10,1% van zijn eigen fouten, het laagste onder alle geteste modellen. Ondanks deze zwakke detectie, bereikte het het hoogste intrinsieke correctieratio van 29,1%. In vergelijking detecteerde GPT-3.5 81,5% van zijn fouten, maar corrigeerde slechts 26,8%.

Dit suggereert dat sommige modellen mogelijk “per ongeluk” hun eigen fouten corrigeren door simpelweg het probleem opnieuw op te lossen via een andere steekproefweg, zelfs als ze niet herkennen dat de eerste poging fout was. Deze disconnectie is gevaarlijk voor de inzet in de praktijk. Wanneer een model oververzekerd is en zijn eigen logische fouten niet kan detecteren, kan het een plausibele maar volledig onjuiste verklaring als waarheid presenteren. In sommige gevallen kan het model vragen om zijn eigen fouten te identificeren de situatie zelfs verergeren. Wanneer een model onjuist identificeert waar het fout is gegaan, hecht het zich aan een gebrekkige verklaring en versterkt het de fout. In plaats van te helpen, kunnen zelf gegenereerde hints het model vastzetten in de verkeerde redeneerweg. Dit gedrag spiegelt menselijke cognitieve bias. Zodra we denken dat we weten wat er fout is gegaan, stoppen we met zoeken naar diepere oorzaken.

Iteratie helpt, maar niet gelijk

Het onderzoek toont ook aan dat iteratieve reflectie vaak de resultaten verbetert, maar niet alle modellen profiteren op dezelfde manier. Zwakkere modellen profiteren aanzienlijk van meerdere rondes van heroverweging, omdat elke iteratie hen een andere kans geeft om hun oppervlakkige problemen te corrigeren. Sterkere modellen laten veel kleinere verbeteringen zien door iteratie. Hun fouten zijn niet gemakkelijk op te lossen door herhaling. Zonder externe leiding reproduceren extra pogingen vaak dezelfde gebrekkige redenering in andere woorden. Deze inzicht suggereert dat zelfverbeteringstechnieken niet universeel effectief zijn. Hun succes hangt af van de aard van de fouten die worden gemaakt, niet alleen van de intelligentie van het model.

Wat dit betekent voor AI-systeemontwerp

Deze inzichten hebben praktische implicaties. Ten eerste moeten we stoppen met de aanname dat hogere nauwkeurigheid betere zelfcorrectie impliceert. Systemen die afhankelijk zijn van autonome zelfverbetering moeten expliciet getest worden op correctiegedrag, niet alleen op de eindprestaties. Ten tweede kunnen verschillende modellen verschillende interventiestrategieën vereisen. Zwakkere modellen kunnen profiteren van eenvoudige verificatie en iteratie. Sterkere modellen kunnen externe feedback, gestructureerde verificatie of tool-gebaseerde controles nodig hebben om diepe redeneerfouten te overwinnen. Ten derde moeten zelfcorrectiepijpleidingen foutgevoelig zijn. Het begrijpen of een taak vatbaar is voor ondiepe of diepe fouten kan informeren of zelfcorrectie waarschijnlijk zal werken. Ten slotte moeten evaluatiebenchmarks detectie, localisatie en correctie afzonderlijk behandelen. Het behandelen ervan als één maatstaf verhult kritieke zwakheden die ertoe doen in de praktijk.

De bottom line

Zelfverbeterende AI hangt af van de mogelijkheid om niet alleen correcte antwoorden te produceren, maar ook om onjuiste antwoorden te herkennen, te diagnosticeren en te herzien. Het Accuratie-Correctie-Paradox onthult dat sterkere modellen niet automatisch beter zijn in deze taak. Naarmate modellen krachtiger worden, worden hun fouten dieper, moeilijker te detecteren en meer resistent tegen zelfcorrectie. Dit betekent dat vooruitgang in model schaling alleen niet genoeg is. Als we AI-systemen willen die echt van hun eigen fouten kunnen leren, moet zelfcorrectie worden behandeld als een afzonderlijke mogelijkheid, expliciet gemeten, getraind en ondersteund.