🤖 AI

The Knowing-Saying Gap: When Probes See Errors that Confidence Misses

Dit artikel onthult dat hoewel lineaire probes corruptie in de context van taalmodellen accuraat kunnen detecteren, ze er niet in slagen de correctheid van het uiteindelijke antwoord betrouwbaar te voorspellen of effectieve realtime interventies te sturen, wat modelbewuste en fouttypebewuste routeringsstrategieën noodzakelijk maakt in plaats van een eenheidsworst-oplossing voor monitoring.

Oorspronkelijke auteurs: Jyotin Goel, Ipshita Bandyopadhyay, Justin Shenk

Gepubliceerd 2026-08-11

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jyotin Goel, Ipshita Bandyopadhyay, Justin Shenk

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 naar een goochelaar kijkt die een kaarttruc uitvoert. De goochelaar is zo vloeiend, zo zelfverzekerd en zo snel dat je niets vermoedt. Maar wat als er diep in de hersenen van de goochelaar een klein alarm schreeuwt: "Wacht! Ik heb net de verkeerde kaart geruild!"? In de wereld van Kunstmatige Intelligentie, specifiek bij Large Language Models (de superintelligente chatbots die code schrijven, reizen plannen en wiskunde oplossen), is dit precies wat er gebeurt. Deze modellen zijn als de goochelaar: ze kunnen met totale zelfverzekerdheid praten, zelfs wanneer ze een enorme fout maken.

Wetenschappers hopen al lang dat als een model in de war is of een fout maakt, het zou gaan "stotteren" of zou zeggen: "Ik weet het niet zeker over dit onderdeel." Dit idee wordt "verbalized confidence" genoemd. Het is alsof je de goochelaar vraagt: "Weet je zeker dat dat de juiste kaart is?" in de hoop dat hij zijn fout toegeeft. Maar er is een andere manier om te controleren: door naar de interne "hersengolven" van het model te kijken (mathematische signalen binnen de computer) om te zien of het weet dat het de mist in is gegaan, zelfs als het dat niet hardop zegt. Dit paper onderzoekt een angstaanjagende maar fascinerende kloof: het verschil tussen wat een model weet in zijn digitale brein en wat het hardop zegt.

Het Stille Alarm en de Zelfverzekerde Leugen

De onderzoekers richtten een digitale speeltuin in om dit te testen. Ze creëerden 1.400 wiskundige problemen die van een model vereisten om een puzzel stap voor stap op te lossen, zoals een kettingreactie. Bijvoorbeeld: "Als ik 5 appels heb en ik koop er 3 bij, en dan verlies ik de helft..." De truc was dat ze stiekem een fout plantten in de allereerste stap van de keten. Ze wilden twee dingen testen:

Het Alarm: Kon een speciale detector (een "linear probe" genoemd) ontdekken dat de eerste stap fout was door enkel naar de interne hersenactiviteit van het model te kijken?
De Voorspelling: Kon diezelfde detector voorspellen dat het eindantwoord fout zou zijn?

Ze testten vijf verschillende modellen, waaronder enkele van de slimste die vandaag de dag beschikbaar zijn, zoals Llama-3.1-8B en Qwen3-4B.

De Grote Ontdekking: Weten maar Niet Zeggen

De resultaten waren een schok. Het "alarm" werkte perfect. Wanneer het model een fout maakte, kon de detector de fout in de interne hersengolven van het model detecteren met bijna 100% nauwkeurigheid (specifiek een AUROC-score van 0,997 voor één model). Het was alsof het brein van het model schreeuwde: "FOUT! FOUT!"

Maar hier komt de twist: het model luisterde niet naar zijn eigen alarm.

Ondanks dat het interne alarm loeide, was het eindantwoord van het model net zo zelfverzekerd als wanneer het wel goed was geweest. De detector die de fout perfect kon zien, was volkomen nutteloos bij het voorspellen of het eindantwoord fout zou zijn. Het is alsof je een rookmelder hebt die "BRAND!" schreeuwt wanneer je toast verbrandt, maar de brandweer (het eindantwoord van het model) nog steeds arriveert en zegt: "Alles is in orde, er is hier geen brand."

Het paper sluit expliciet een aantal zaken uit waarvan mensen zouden hopen dat ze waar zijn:

Zelfverzekerdheid is geen aanwijzing: Wanneer ze de modellen vroegen hoe zelfverzekerd ze waren, gaven de modellen slechts een binair "Ja" of "Nee" zonder echte nuance. Een model dat voor 99% zeker was, had net zo groot risico op een fout als een model dat voor 50% zeker was.
Harder nadenken helpt niet: Ze probeerden een "denkmodus" waarbij het model werd gedwongen om zijn redenering stap voor stap uit te schrijven (Chain-of-Thought). Je zou denken dat dit het model zou helpen om zijn eigen fouten te ontdekken. In plaats daarvan maakte het het model slechter in het geven van het juiste antwoord (de nauwkeurigheid daalde van 27,9% naar 1,2%) zonder dat dit veranderde aan het feit dat het interne alarm nog steeds afging. Het model wist dat het fout zat, maar erover praten loste het niet op.

Kunnen We Het Oplossen? De "Branch-and-Pick" Strategie

Omdat de modellen niet toegeven dat ze fout zitten, probeerden de onderzoekers als een "veiligheidsnet" voor hen te fungeren. Ze bouwden een systeem dat luistert naar het interne alarm en probeert de fout te herstellen voordat het model zijn antwoord afmaakt. Ze testten drie verschillende manieren om in te grijpen:

Reprompt: Gewoon tegen het model zeggen: "Hey, controleer je werk!" (Dit werkte niet goed).
Replace-Prior: De foutieve stap wissen en het model dwingen om vanaf het begin opnieuw te beginnen. Dit leverde gemengde resultaten op; het redde sommige foute antwoorden, maar maakte per ongeluk ook enkele goede antwoorden kapot.
Branch-and-Pick: Dit was de winnaar. Wanneer het alarm afging, liet het systeem het model niet zomaar gokken, maar vroeg het het model om de volgende stap op vier verschillende manieren te proberen (met verschillende niveaus van willekeur). Vervolgens gebruikte het systeem het interne alarm om het pad te kiezen dat er het "schoonst" uitzag (het minst corrupt).

Deze "Branch-and-Pick"-methode was de enige die consistent foute antwoorden redde zonder de goede antwoorden te breken. Op één specifiek model (Llama-3.1-8B) redde het 4 foute antwoorden en maakte het 0 goede antwoorden kapot. Het paper merkt echter op dat dit geen wondermiddel is voor elke situatie. Het succes hing sterk af van het soort fout dat werd gemaakt. Zo werkte het herstellen van een "verkeerde eenheid"-fout uitstekend, maar het herstellen van een "verkeerd percentage"-fout maakte de situatie juist slechter.

De Conclusie

Het paper concludeert dat we de woorden van een model niet kunnen vertrouwen om te weten of het gelijk heeft. Een model kan intern op de hoogte zijn van een ramp, terwijl het met volledige zelfverzekerdheid een foutief antwoord levert. De "Knowing-Saying Gap" is echt en gevaarlijk.

De oplossing is niet om het model te vragen eerlijker te zijn, maar om een "model-bewust" veiligheidssysteem te bouwen. We moeten luisteren naar de interne alarmen (de probes) en slimme strategieën zoals "Branch-and-Pick" gebruiken om fouten op te vangen. Maar we moeten ook voorzichtig zijn: er is geen enkele oplossing die voor elk type fout of elk model werkt. De toekomst van veilige AI gaat niet over het vertrouwen op de zelfverzekerdheid van de chatbot; het gaat over het bouwen van een vangrail die weet wanneer de chatbot tegen zichzelf liegt.

Technische Samenvatting: De Kennis-Zeg-Kloof in Taalmodellen

Probleemstelling

Het artikel behandelt een kritiek betrouwbaarheidsfalen in breed ingezette Large Language Models (LLM's), met name binnen agentische pipelines waar de outputs van het model terugvloeien in de toekomstige context (bijv. programmeeragenten, multi-step planning). In dergelijke omgevingen veroorzaakt een enkele fout in een vroege stap een "cascaderende contextcorruptie" door de daaropvolgende context. Het kernproblein is een dissociatie tussen de interne staat en de verbale output: modellen blijven vaak vloeiende, zelfverzekerde tekst genereren, zelfs nadat hun interne berekening door een fout is gecorrumpeerd. Deze "vloeiendheid zonder getrouwheid" maakt standaard monitoringtechnieken, zoals het vragen aan het model om verbale betrouwbaarheid of zelfkritiek, ineffectief omdat de interne kennis van het model over de fout niet vertaalt naar zijn oppervlakkige gedrag.

Methodologie

De auteurs onderzoeken dit fenomeen met behulp van een gecontroleerd, contrastief experimenteel ontwerp:

Dataset: Een synthetische dataset van 1.400 multi-hop rekenkundige sporen gegenereerd uit 500 basisproblemen. De dataset bevat "schone" sporen en "gecorrumpeerde" sporen waarbij een specifieke hop (stap) is vervangen door een synthetisch foutieve waarde. Vijf verschillende fouttypen worden gebruikt: off_by_one, wrong_operator, wrong_unit, magnitude_error, en wrong_percentage_base.
Modellen: De evaluatie beslaat vijf modellen uit twee families (Qwen en Llama), inclusief instructie-afgestemde en reasoning (thinking-mode) varianten, variërend van 3B tot 8B parameters.
Probe Training: Een lineaire probe (logistische regressie) wordt getraind op de activaties van de residual stream van de bevroren modellen. De probe wordt getraind om tussen schone en gecorrumpeerde contexten te onderscheiden met behulp van twee aggregatiemodi: last-token en mean-over-tokens.
Kernmetrieken:
- Detectie ( $AUROC_{detect}$ ): Het vermogen van de probe om een gecorrumpeerde context van een schone context te onderscheiden.
- Falen Voorspellen ( $AUROC_{fail}$ ): Het vermogen van de probe om te voorspellen of de corruptie zal resulteren in een foutief eindantwoord, gegeven dat de fout al heeft plaatsgevonden.
- Oppervlakkige Signalen: Zes scalaire onzekerheidssignalen (bijv. entropie, vertrouwen, vocabulairekloof) worden berekend uit token logits om als baselines te dienen.
Interventies: Drie door de probe getriggerde strategieën worden getest om te zien of het detecteren van de fout de uiteindelijke nauwkeurigheid kan verbeteren:
1. Reprompt: Het toevoegen van een controle-instructie.
2. Replace-prior: Het regenereren van de vorige hop vanaf nul.
3. Branch-and-pick: Het samplen van meerdere voortzettingen en het selecteren van de optie met de laagste probe-foutscore.

Kernbijdragen

Contrastieve Dataset: Een deterministische, mensvrije dataset van 1.400 sporen met vijf fouttypen, geëvalueerd over instructie-afgestemde en reasoning modelvarianten.
Ineenstorting van Detectie versus Falen Voorspellen: Een karakterisering die aantoont dat hoewel probes corruptie met bijna perfecte nauwkeurigheid detecteren, ze falen in het voorspellen of die corruptie leidt tot een foutief eindantwoord.
Interventie-analyse: Een gecontroleerde vergelijking van drie interventiebeleid, die laat zien dat geen enkele strategie universeel effectief is; de effectiviteit is sterk afhankelijk van het specifieke model en fouttype.
Weerlegde Hypothese: De auteurs hebben vooraf geregistreerd en vervolgens de hypothese weerlegd dat "persistentie van probe-activatie over hops" falen voorspelt.
Robuustheidscontroles: Bewijs dat het detectiesignaal geen artefact is van datalekken of oppervlakkige token-signatures, aangetoond via gegroepeerde kruisvalidatie en leave-one-error-type-out evaluaties.

Resultaten

1. De Kennis-Zeg Dissociatie

Hoge Detectienauwkeurigheid: Lineaire probes detecteren geïnjecteerde fouten met $AUROC_{detect} > 0,98$ over alle modellen, piekend op 0,997 op Llama-3.1-8B. Het signaal ontstaat primair bij de transitie tussen laag 0 en laag 1.
Falen van Falen Voorspellen: Ondanks de hoge detectienauwkeurigheid zijn dezelfde probes niet informatief over de correctheid van het eindantwoord. $AUROC_{fail}$ stort in naar bijna toevalsniveau (0,47–0,53) over alle modellen. Het model "weet" dat de context gecorrumpeerd is, maar "zegt" (of handelt niet naar) die kennis om een foutief eindresultaat te voorkomen.
Oppervlakkige Signalen: Verbaal geuite betrouwbaarheid en andere oppervlakkige onzekerheidssignalen presteren op of nabij toevalsniveau ( $AUROC \approx 0,5$ ) voor detectie en vertonen geen correlatie met de uiteindelijke correctheid. Vertrouwen stort vaak in tot binaire extremen (0 of 1) met ononderscheidbare foutpercentages tussen de twee groepen.

2. Impact van Reasoning Modus

Het inschakelen van de "thinking mode" (uitgebreide chain-of-thought) op Qwen3-4B heeft de kloof niet gedicht. Hoewel het het aantal tokens verhoogde, degradeerde het de foutconditie-nauwkeurigheid van 27,9% naar 1,2% zonder het vermogen van de probe om de interne fouttoestand te detecteren te veranderen. Dit suggereert dat de interne codering van corruptie persisteert, zelfs wanneer het outputkanaal wordt verstoord.

3. Effectiviteit van Interventies

Branch-and-pick: Dit was de enige policy die netto positief was over de modellen en uniek niet-destructief op Llama-3.1-8B (4 gered, 0 gebroken). Het verhoogt echter de inferentiekosten aanzienlijk.
Replace-prior: Deze strategie redde foutieve sporen, maar brak correcte sporen tegen een vergelijkbaar tempo af, wat resulteerde in geen netto winst.
Reprompt: Over het algemeen ineffectief.
Heterogeniteit: Het succes van interventies is sterk afhankelijk van het fouttype. Bijvoorbeeld, replace-prior was zeer effectief voor wrong_unit fouten, maar netto negatief voor wrong_percentage_base fouten.

Betekenis en Claims

Het artikel claimt dat probe-gebaseerde monitoring een noodzakelijke aanvulling is op verbaal geuite betrouwbaarheid, en geen vervanging. De centrale bevinding is dat de aanname dat de interne staat van een model toegankelijk is via zijn verbale outputs, onjuist is in de context van cascaderende fouten.

Decodeerbaarheid, niet Causaliteit: De auteurs benadrukken dat hoewel het foutsignaal lineair decodeerbaar is vanuit de residual stream, dit niet impliceert dat het generatiebeleid dat signaal raadpleegt. Interventies die de gecorrumpeerde waarde verwijderen (replace-prior) verminderen de probe-activatie, maar verbeteren de nauwkeurigheid niet proportioneel, wat suggereert dat de geprobeerde richting niet de proximale oorzaak van het foutieve antwoord is.
Implicaties voor Implementatie: Er is geen "one-size-fits-all" interventie. De inzetbare oplossing is model-bewuste, fouttype-bewuste routing. Omdat geen enkele interventie domineert, moeten systemen routeren naar specifieke correctiestrategieën op basis van het voorspelde model en fouttype.
Beperkingen: De auteurs merken op dat hun interventies niet strikt veilig zijn (ze kunnen correcte sporen breken) en dat branch-and-pick aanzienlijke computationele kosten met zich meebrengt. Het artikel frameert de routingstrategie als een richting voor toekomstig werk in plaats van een volledig inzetbare oplossing, aangezien het momenteel een robuuste fouttype-classifier mist.

Concluderend stelt het artikel vast dat voor agentische systemen vertrouwen op het model om te "vertellen" dat het een fout maakt, onvoldoende is. Interne staat monitoring via lineaire probes biedt een hoogwaardig detectiemechanisme, maar het overbruggen van de kloof tussen detectie en succesvolle correctie vereist genuanceerde, contextspecifieke interventiestrategieën.