Chain of Thought, RLVR en test-time compute, gemeten

De verleiding is om te zeggen dat de tweede versie erover "nadacht". Weersta die verleiding, want het mechanisme is zowel eenvoudiger als nuttiger om te kennen.

Een transformer doet een vaste hoeveelheid berekening per gegenereerde token. Eén forward pass: dezelfde lagen, dezelfde matrices, hetzelfde aantal operaties, ongeacht of de vraag wat is 2+2 is of bewijs deze stelling. Er zit geen knop in het model voor "doe extra je best op deze".

Dus wanneer een model direct om een antwoord wordt gevraagd, is de volledige berekening die het beschikbaar heeft één forward pass. Elke tussenliggende grootheid moet passen in de activaties van die ene pass, en alles wat het daar niet kan berekenen, kan het niet berekenen.

Tokens uitstoten verandert dat, en het verandert dat op twee verschillende manieren die je uit elkaar moet houden:

• Meer berekening. Elke gegenereerde token is weer een volledige forward pass. Honderdvijfenveertig tokens aan uitwerking is honderdvijfenveertig keer de rekenkundige inspanning van meteen antwoorden.
• Geëxternaliseerd geheugen. De tokens worden in de context geschreven, zodat de volgende pass ze kan lezen. 5 × 13 = 65 wordt een feit in de input, geen waarde die het model in een activatie moet vasthouden en meenemen. Het model gebruikt zijn eigen output als kladblok.

Dat tweede punt missen mensen vaak, en het verklaart waarom de uitwerking opgeschreven moet worden om te helpen. Een model dat wordt gevraagd om "er stil over na te denken en dan te antwoorden" heeft nergens plek om die gedachte neer te zetten.

Hiervoor is niets mystieks nodig, en het doet een stevige voorspelling: chain of thought zou het meest moeten helpen bij problemen met een seriële structuur — waarbij stap twee het resultaat van stap één nodig heeft — en het minst bij problemen die één enkele lookup zijn. Dat is precies wat de literatuur vindt, en daarom doet "denk stap voor stap" niets voor wat is de hoofdstad van Frankrijk.

De techniek kwam in 2022 in twee delen. Wei et al. lieten zien dat uitgewerkte voorbeelden in de prompt — demonstraties waarbij het antwoord wordt voorafgegaan door redenering — grote winst opleverden op rekenkundige en commonsense-benchmarks.¹ Kojima et al. lieten daarna iets vreemders zien: je hebt de voorbeelden niet nodig. "Let's think step by step" toevoegen aan een zero-shot prompt pakt veel van dezelfde winst.²

Het tweede resultaat vertelt je wat er aan de hand is. Als een magische zin het gedrag ontgrendelt, zat het gedrag al in het model — pretraining zit vol uitgewerkte oplossingen, en de zin is een aanwijzer naar dat gebied van de distributie. Chain of thought leerde het model niets. Het selecteerde iets dat het model al had.

Die framing voorspelt ook de uiteindelijke veroudering van de techniek, waar we aan het einde van het hoofdstuk op terugkomen.

De voor de hand liggende volgende stap: als één redeneerketen fout kan zijn, sample er dan meerdere en neem het meerderheidsantwoord. Dat is self-consistency.³ Het is een strikt grotere uitgave — $n$ volledige generaties in plaats van één — en de intuïtie is dat foute antwoorden uitwaaieren terwijl juiste antwoorden overeenkomen.

Gemeten op 16 van dezelfde opgaven, sampling bij temperature 0,8, meerderheidsstem over $n$ ketens:

Zestien opgaven is een kleine noemer, en de regel uit Hoofdstuk 4 geldt net zo goed voor deze tabel als voor elke andere. 13 van 16 is 81 % met een 95%-Wilson-interval van [57, 93]; 16 van 16 is 100 % met [81, 100]. Die overlappen. Lees de vorm van de curve, want dat is de bevinding; lees niet de exacte trede waarop hij afvlakt, want zestien opgaven kunnen die niet lokaliseren.

Twee dingen in die tabel, en het tweede was niet wat ik verwachtte.

De curve vlakt af bij $n = 3$. Bij de derde sample zit de accuracy aan het plafond en kopen de resterende twee samples niets, terwijl ze elk 172 tokens kosten, samen 345. Dat is de vorm van elke self-consistency-curve die in de literatuur wordt gerapporteerd, en het gebeurt veel eerder dan de framing "meer samples is beterder" suggereert.

En greedy decoding zat al op 100 %. Kijk terug naar het begin van het hoofdstuk: één keten, geen sampling, 145 tokens, 24/24. Sampling bij temperature 0,8 verlaagde de accuracy naar 81 %, en self-consistency had drie generaties nodig om terug te klimmen naar waar één greedy pass al was — met 3,6 keer zoveel tokens, of zes keer als je de sweep tot vijf draait zonder te weten waar hij afvlakt.

Dat is geen argument tegen self-consistency. Het is een precieze uitspraak over wat het doet: temperature koopt diversiteit door fouten te injecteren, en stemmen verwijdert de fouten die net zijn geïnjecteerd. Bij problemen waarop greedy decoding faalt — waar de meest waarschijnlijke keten ergens verkeerd uitkomt en een minder waarschijnlijke keten juist is — betaalt die trade-off zich uit, en daarom bestaat de techniek. Bij problemen waarop greedy al slaagt, is het een manier om zes keer zoveel budget uit te geven om quitte te spelen.

Niemand publiceert het tweede geval, en daarom is het de moeite waard om het op je eigen taak te meten voordat je de techniek adopteert. Dit zijn makkelijke tweestapsopgaven voor een klein model; dat is het regime waarin het antwoord er zo uitziet.

Alles tot nu toe gebeurt op prompt-tijd op een model dat er nooit specifiek voor is getraind. De verschuiving die de huidige generatie reasoning-modellen opleverde, was om het naar training te verplaatsen — en de sleutel die dat mogelijk maakte is nauwer dan hij klinkt.

De post-training uit Hoofdstuk 11 had menselijke voorkeuren nodig, omdat "was dit een goed antwoord?" geen programmatisch antwoord heeft. Maar voor sommige vragen heeft het dat wel. Een wiskundig antwoord is gelijk aan de juiste waarde of niet. Code slaagt voor de tests of niet. Een bewijs checkt of niet.

Voor die domeinen kun je het reward model vervangen door een verifier, en alles downstream wordt in één keer beter: geen annotators, geen Bradley–Terry-fitting, geen reward hacking van het soort dat in Hoofdstuk 11 werd gemeten — want je kunt een unit test niet vleien. Dit is reinforcement learning from verifiable rewards, en het is de setting waarvoor GRPO is gebouwd: sample een groep oplossingspogingen voor hetzelfde probleem, check elke poging, en gebruik de gemiddelde score van de groep als baseline. Geen critic, geen annotator, geen reward model. Alleen een programma dat zegt goed of fout.

Het resultaat dat het veld opnieuw kaderde kwam begin 2025 van DeepSeek.⁶ Ze namen een basismodel en pasten reinforcement learning with verifiable rewards direct toe, zonder eerst een supervised fine-tuning-fase — de fase die Hoofdstuk 11 presenteert als het fundament van alles. Lange redeneerketens ontstonden toch. Net als gedrag waarvoor niemand had getraind: het model begon zijn eigen stappen opnieuw te controleren en, in de meest geciteerde passage van de paper, spontaan halverwege de oplossing een aanpak te heroverwegen.

De eerlijke lezing is niet dat redeneren magisch is. Het is dat wanneer het enige dat wordt beloond juist zijn is, en juist zijn op een moeilijk probleem vereist dat je het doorwerkt, doorwerken is wat de optimiser vindt — inclusief de delen van doorwerken die mensen ook doen, omdat ze zijn wat het probleem vereist in plaats van wat iemand heeft aangeleerd.

Het praktische gevolg van dit alles is dat een reasoning-model tokens produceert waar je om vroeg en tokens waar je niet om vroeg, en je betaalt voor beide.

Providers gaan hier verschillend mee om, en dat verschil doet ertoe:

• De meeste API’s tellen reasoning-tokens binnen de output-token-count. Je factuur en je max_tokens-limiet bevatten allebei het denken dat je nooit ziet.
• Google's Gemini rapporteert thinking-tokens als een apart veld, buiten de standaard output-count.

Dat is een echte incompatibiliteit tussen twee manieren om hetzelfde te tellen, en elke code die kosten berekent of een budget afdwingt over providers heen moet dat normaliseren. Hoofdstuk 16 is waar dat geld wordt, en Hoofdstuk 23 waar het een budget wordt dat je kunt afdwingen.

Het andere gevolg is er een van latency dat mensen de eerste keer verrast. De tijd tot de eerste zichtbare token van een reasoning-model omvat al zijn denken, dus een request dat acht seconden niets streamt en daarna in één seconde antwoordt, is geen vastgelopen verbinding — het model is aan het werk. Elke interface die acht seconden een spinner zonder uitleg toont, heeft een ontwerpprobleem, geen netwerkprobleem.

Een afsluitende waarschuwing, omdat dit de meest voorkomende manier is waarop het materiaal uit dit hoofdstuk verkeerd wordt toegepast.

Alles in de eerste helft is een techniek om een model dat niet is getraind om te redeneren toch redenering te laten produceren. Modellen die met RLVR zijn getraind doen dat al: ze stoten hun eigen uitwerking uit, op hun eigen lengte, voordat ze antwoorden. Zo’n model vertellen dat het stap voor stap moet denken is op zijn best overbodig en op zijn slechtst schadelijk — het kan een korte, prompt-vormige keten produceren in plaats van de langere keten die het model zelf zou hebben gegenereerd, en sommige providers documenteren precies dit.

Hetzelfde geldt voor uitgebreide reasoning-scaffolds die in applicatiecode zijn gebouwd. Een prompt die een model door een beslisboom leidt die het intern al navigeert, besteedt jouw tokens om gedrag te beperken dat erin is getraind. Dit is de eerste verschijning van een thema dat door de rest van de cursus loopt: technieken die in 2022 essentieel waren, waren in 2025 bijgeloof geworden, en de enige manier om te bepalen wat wat is voor jouw model, vandaag, is beide meten.

Hoofdstuk 15 is waar die meting een discipline wordt in plaats van een mening.

Reasoning heeft een ongemakkelijke eigenschap: het is de ene capability waarvan de kosten schalen met hoe moeilijk de vraag is. Een model dat negenhonderd tokens denkt, doet negenhonderd forward passes, houdt voor allemaal een groeiende cache in memory bij, en houdt een GPU bezet voor de duur ervan.

Dat maakt de economie van het serveren van een reasoning-model scherp slechter dan die van een chatmodel, en het verandert een reeks implementatiedetails in het verschil tussen een levensvatbaar product en een onhaalbaar product: hoe de cache van eerdere keys en values wordt opgeslagen en hergebruikt, hoeveel requests een forward pass kunnen delen, en hoeveel precisie de weights werkelijk nodig hebben.

Hoofdstuk 13 is het laatste hoofdstuk waarin het model een object in je memory is in plaats van een service achter een poort, en het gaat over dat object goedkoop genoeg maken om te serveren. Het lost ook een belofte uit dit hoofdstuk in: speculative decoding, dat meerdere tokens produceert voor grofweg de prijs van één door een klein model te laten raden en een groot model te laten controleren — een truc die pas logisch wordt zodra je hebt gezien hoeveel van een forward pass wordt besteed aan wachten op memory in plaats van aan rekenen.

Alle metingen in dit hoofdstuk komen uit Qwen/Qwen2.5-0.5B-Instruct op 24 gegenereerde redactiesommen in twee stappen, met greedy decoding behalve waar sampling wordt vermeld, en met nul afgekapte generaties bij de gebruikte token-limieten. Ze zijn reproduceerbaar, en ze betreffen een klein model op makkelijke problemen: lees het self-consistency-resultaat als een demonstratie van het mechanisme, niet als een benchmark. Hoofdstuk 18 van de CS229-collegenotities en hoofdstuk 12 van de Hugging Face LLM Course behandelen dit materiaal allebei met grotere modellen en echte benchmarks.