💬 NLP

How Language Models Fail: Token-Level Signatures of Committed and Persistent Reasoning Failures

Dit artikel identificeert en karakteriseert twee onderscheidende token-niveau redeneerfoutmodi in taalmodellen—committed failure, gekenmerkt door vroege padvergrendeling, en persistent onzekerheid, gekenmerkt door accumulerende twijfel—en demonstreert dat deze signaturen reproduceerbaar zijn over diverse configuraties en de optimalisatie van detectiestrategieën voor fouten, zoals self-consistency, kunnen sturen.

Oorspronkelijke auteurs: Tanvi Thoria, Kiana Jafari, Marc R. Schlichting, Mykel J. Kochenderfer

Gepubliceerd 2026-06-08

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Tanvi Thoria, Kiana Jafari, Marc R. Schlichting, Mykel J. Kochenderfer

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 detective een mysterie ziet oplossen. Soms maakt de detective vroeg in het proces een fout, zet hij vast op de verkeerde verdachte, en brengt hij de rest van de film door met vol vertrouwen te beargumenteren waarom die verdachte schuldig is, ook al is hij onschuldig. Andere keren is de detective de hele tijd echt in de war, bladert hij door aanwijzingen en is hij onzeker over het antwoord tot het allerlaatste moment.

Dit artikel gaat over het uitzoeken welk soort fout een Large Language Model (LLM) maakt door simpelweg te kijken naar hoe het "denkt" (de chain of thought) terwijl het zijn antwoord schrijft. De onderzoekers ontdekten dat modellen niet op slechts één manier falen; ze falen in twee verschillende patronen, en het herkennen van het patroon bepaalt hoe we de fout moeten proberen te vangen.

Hier is een uitsplitsing van hun bevindingen met behulp van eenvoudige analogieën:

1. De twee soorten fouten

De onderzoekers ontdekten dat wanneer een model een fout maakt, dit meestal op twee manieren gebeurt:

Type A: De "Vroege Toezegging" (De Koppige Detective)

Wat er gebeurt: Het model kiest heel vroeg in zijn redenering een foutief pad. Zodra het dat pad heeft gekozen, zit het "vast". Het stopt met het verkennen van andere mogelijkheden en blijft simpelweg meer zinnen schrijven om dat foute idee te ondersteunen.
Het kenmerk: Als je kijkt naar de "onzekerheid" (hoe onzeker het model zich voelt) terwijl het schrijft, zie je een piek in het begin, waarna deze daalt. Het model wordt te snel te zelfverzekerd.
De les: Je hoeft niet te wachten tot het hele verhaal af is om te weten dat het fout is. Sterker nog, het lezen van het einde van het verhaal kan je zelfs in de war brengen, omdat het model zo zelfverzekerd is over zijn foute antwoord dat het er goed uitziet. Het beste moment om deze fout op te merken, is direct nadat het model zijn eerste grote fout maakt.

Type B: "Aanhoudende Onzekerheid" (De Verwarde Detective)

Wat er gebeurt: Het model kiest nooit echt een kant. Het dwaalt door de redenering en is de hele tijd onzeker over het antwoord. Het blijft van gedachten veranderen of twijfelen tot het allerlaatste woord.
Het kenmerk: De onzekerheid van het model blijft hoog of bouwt langzaam op van begin tot eind. Het legt zich nooit vast op één enkel pad.
De les: Je moet het hele verhaal lezen om te weten of het is misgegaan. Als je halverwege stopt, denk je misschien dat het gewoon voorzichtig is. De fout wordt pas duidelijk wanneer je het hele rommelige spoor van gedachten ziet.

2. Hoe ze dit ontdekten (De "Onzekerheidsmeter")

De onderzoekers hadden geen toegang nodig tot de binnenkant van het brein van het model (wat voor veel populaire AI-modellen onmogelijk is). In plaats daarvan keken ze naar de log probabilities — een technische manier om te zeggen: "hoe zeker het model was over elk woord dat het typde."

Ze beschouwden de redenering van het model als een film. Ze volgden de "onzekerheidsmeter" terwijl de meter omhoog en omlaag tikte terwijl het model woord voor woord typte.

Voor Type A toonde de meter een duidelijke piek in het begin, waarna deze afvlakte.
Voor Type B bleef de meter stijgen of bleef deze hoog tot het einde.

Ze testten dit op 23 verschillende combinaties van AI-modellen en taken (zoals wiskunde, programmeren en wetenschap). In 20 van de 23 gevallen hield hun theorie perfect stand. Ze konden het verschil zien tussen een "koppige" fout en een "verwarde" fout, enkel door naar deze patronen te kijken.

3. Waarom dit ertoe doet: De "Tweede Mening"-strategie

Het paper onderzocht ook een veelgebruikte truc genaamd Self-Consistency. Dit houdt in dat je dezelfde vraag 10 keer aan de AI stelt en het antwoord neemt dat het vaakst voorkomt.

Voor het "Koppige" Model (Type A): Het 10 keer stellen van dezelfde vraag is nutteloos. Als het model koppig is, zal het 10 keer achter elkaar hetzelfde foute antwoord geven. De "meerderheidsstem" zal het foute antwoord alleen maar bevestigen. In dit geval is het kijken naar de onzekerheid van een enkel antwoord eigenlijk beter dan het meerdere malen vragen.
Voor het "Verwarde" Model (Type B): Het 10 keer stellen van de vraag is zeer nuttig. Omdat het model echt onzeker is, zal het elke keer andere antwoorden geven. Het feit dat het het niet met zichzelf eens kan worden, is een enorme rode vlag.

De Kernboodschap

Het paper betoogt dat we geen "one-size-fits-all" benadering moeten gebruiken om AI-fouten te vangen.

Als de AI vroeg in een fout idee vastloopt, moeten we het snel onderscheppen door naar de betrouwbaarheidsniveaus in een vroeg stadium te kijken, en moeten we niet de moeite nemen om om een tweede mening te vragen (omdat het de fout gewoon zal herhalen).
Als de AI echt in de war is, moeten we het zijn denkproces laten voltooien en dan om meerdere meningen vragen om te zien of het met zichzelf tot overeenstemming kan komen.

Door te begrijpen hoe de AI faalt, kunnen we de juiste tool kiezen om de fout te vangen, wat tijd bespaart en de betrouwbaarheid verbetert.

Technische Samenvatting: Hoe taalmodellen falen: Token-niveau signaturen van gecommitteerde en persistente redeneerfouten

Probleemstelling

Het detecteren wanneer Large Language Models (LLMs) zullen falen bij complexe redeneertaken blijft een kritieke uitdaging voor de betrouwbaarheid van implementaties. Bestaande methoden voor foutdetectie, zoals zelfconsistentie (het samplen van meerdere ketens van gedachten) en onzekerheidskwantificatie, behandelen falen doorgaans als een binaire voorspellingsopgave. Deze benaderingen gaan uit van een enkelvoudig proces van falen-emergentie, wat de mogelijkheid tot het aanpassen van detectiestrategieën beperkt. Specifiek faalt zelfconsistentie wanneer een model zich vroegtijdig "committeert" aan een onjuist redeneepad, waarbij het dezelfde foutieve antwoorden consistent reproduceert over verschillende samples heen. Daarentegen, voor modellen die gedurende een trace werkelijke onzekerheid vertonen, zijn onzekerheidssignalen op basis van een enkele sample onvoldoende. Het artikel betoogt dat redeneerfouten zich ontwikkelen via onderscheidende processen die verschillende detectiestrategieën vereisen, terwijl huidige methoden een uniforme aanpak hanteren ongeacht de onderliggende foutmodus.

Methodologie

De auteurs stellen een framework voor dat redeneerfouten karakteriseert met behulp van token-niveau onzekerheidssignalen afgeleid van chain-of-thought (CoT) traces. Het framework vereist alleen log-waarschijnlijkheden van een enkele model-voltooiing, waardoor het toepasbaar is op closed-API frontier modellen (bijv. GPT-4o, Gemini) waarbij interne gewichten niet toegankelijk zijn.

Kernconcepten

Foutmodi: Het framework identificeert twee kwalitatief onderscheidende foutmodi:
- Gecommitteerde Fout (Committed Failure): Het model legt zich vroeg in de trace vast op een onjuist redeneepad. Onzekerheidssignalen zijn het meest voorspellend over een vroeg prefix van de trace; het toevoegen van daaropvolgende tokens verzwakt het signaal.
- Persistente Onzekerheid (Persistent Uncertainty): Het model legt zich nooit vast op een enkel pad. Onzekerheid accumuleert monotoon gedurende de hele trace, en de volledige trace is vereist om falende van succesvolle voltooiingen te onderscheiden.
Commitment Punt ( $T^*$ ): Gedefinieerd als de tokenpositie in een redeneetrace waar onzekerheidssignalen maximaal voorspellend zijn voor falen. Voorbij dit punt vertegenwoordigen de daaropvolgende tokens eerder downstream-ruis dan een signaal met betrekking tot de uiteindelijke uitkomst.
Onzekerheidsfeatures: De auteurs berekenen vijf token-niveau signalen over prefix-vensters ( $W_T$ ) van de redeneetrace:
- Entropie: Spreiding van de top- $K$ distributie.
- Margin: Verschil tussen de top twee waarschijnlijkheden.
- NLL (Negative Log-Likelihood): Vertrouwen in de top-token.
- Nucleus: Tokens die nodig zijn om een 0,9 waarschijnlijkheidsdrempel te bereiken.
- Near-Tie: Fractie van top- $K$ tokens binnen 90% van de top-waarschijnlijkheid.
- Aggregatie: Zowel gemiddelde als maximale features worden voor elk signaal berekend over het venster.
Diagnostische Metriek (PR-AUC): Het framework gebruikt Precision-Recall Area Under the Curve (PR-AUC) om foutdetectie te kwantificeren bij variërende prefix-venstergroottes.
- Gecommitteerde Signature: Een omgekeerde U-vorm in de PR-AUC-curve. Het voorspellend vermogen piekt bij $T^*$ en neemt af naarmato de window groter wordt.
- Persistente Signature: Een monotoon stijgende PR-AUC-curve waarbij de volledige trace altijd beter presteert dan elk vroeg venster.
Pre-final Analyse: Om de confounder van trace-lengte (waarbij falende modellen vaak langere traces schrijven) te controleren, verwijdert het framework alle tokens die voorkomen na de finale antwoordmarker voordat de onzekerheidssignalen worden berekend.

Experimentele Opzet

Het framework werd geëvalueerd over 23 model-dataset configuraties bestaande uit:

Modellen: Vijf families (Qwen, Llama, GPT-OSS, Gemma, GPT-4o/Gemini) variërend van 2B tot 122B parameters, inclusief open-source en frontier modellen.
Datasets: Vier redeneerdomeinen (GSM8K, MATH-500, GPQA Diamond, LiveCodeBench).
Restricties: Experimenten werden beperkt tot configuraties met foutpercentages tussen de 15% en 60% en voldoende fout-aantallen voor statistische betrouwbaarheid. Frontier modellen werden beperkt tot de top-20 log-waarschijnlijkheden.

Belangrijkste Resultaten

Reproduceerbaarheid van Foutmodi: De falsifieerbare voorspellingen van het framework hielden stand in 20 van de 23 gevallen, wat significant boven de kans is.
- Gecommitteerde Fout: Geobserveerd in 14 configuraties (bijv. Gemma4-31B op LiveCodeBench, GPT-OSS-20B op MATH-500). Deze vertoonden de voorspelde omgekeerde U-vormige PR-AUC-curve met een duidelijk commitment punt.
- Persistente Onzekerheid: Geobserveerd in 9 configuraties (bijv. Llama3.1-8B op MATH-500, Qwen3.5-122B op GPQA). Deze vertoonden monotoon stijgende PR-AUC-curves waarbij de volledige trace strikt informatiever was dan enig prefix.
Statistische Validatie: Meta-analytische pooling bevestigde de bidirectionele voorspellingen:
- Sign-test op gecommitteerde configuraties: 14/14 consistent ( $p = 6,1 \times 10^{-5}$ ).
- Joint sign-test over alle configuraties: 20/23 consistent ( $p = 2,4 \times 10^{-4}$ ).
- Gepoolde effectgrootte ( $\hat{\Delta}$ ) voor gecommitteerde gevallen was $+0,013$ (95% CI $[+0,005, +0,020]$ ).
Implicaties voor Zelfconsistentie:
- Gecommitteerd Regime: Zelfconsistentie is ineffectief omdat het model hetzelfde foutieve antwoord reproduceert. Hier bieden onzekerheidssignalen van een enkele voltooiing (specifiek vroege-window features) superieure detectie. De auteurs demonstreren dat voor gecommitteerde modellen zelfconsistentie kan worden overgeslagen voor de top 30% van de zelfverzekerde inputs zonder verlies van fout-recall.
- Persistent Regime: Zelfconsistentie blijft effectief omdat falen zich manifesteert als discrepantie tussen voltooiingen.
- Complementariteit: Het combineren van single-completion onzekerheid met zelfconsistentie-overeenstemming verbeterde de PR-AUC consistent over alle geteste regimes, waarbij de kwaliteit van het redeneren binnen de voltooiing wordt gevangen die overeenstemmingspercentages alleen missen.

Betekenis en Claims

Het artikel claimt een fundamenteel framework te bieden voor het begrijpen van wanneer en hoe redeneerfouten van LLM's detecteerbaar worden. Door falen te karakteriseren als ofwel "gecommitteerd" of "persistent", betogen de auteurs dat detectiestrategieën moeten worden aangepast aan de specifieke foutmodus in plaats van uniform te worden toegepast.

Belangrijke bijdragen zijn onder meer:

Token-niveau Signaturen: Het aantonen dat token-niveau onzekerheidssignalen tussen twee onderscheidende redeneerprocessen kunnen onderscheiden met behulp van enkel externe log-waarschijnlijkheden.
Identificatie van het Commitment Punt: Het definiëren en empirisch valideren van een specifiek punt in een redeneetrace waar het model zich vastlegt op een pad, wat de overgang van signaal naar ruis markeert.
Praktische Implementatie-richtlijnen: Het bieden van een mechanisme om te triageren wanneer zelfconsistentie noodzakelijk is versus wanneer het selectief kan worden overgeslagen, en het aantonen hoe onzekerheidsfeatures bestaande verificatiemethoden aanvullen.

De auteurs blijven bescheiden over hun claims en merken op dat het framework opereert op zichtbare CoT-traces (zonder te beweren dat deze traces de interne berekening perfect reflecteren) en beperkt wordt door API-beperkingen op de toegang tot log-waarschijnlijkheden. Ze benadrukken dat het framework een matig foutpercentage vereist om betrouwbaar te functioneren en dat het commitment punt wordt geïdentificeerd op de granulariteit van window-groottes in plaats van exacte tokenposities.