💬 NLP

Teaching Language Models to Think in Code

Het artikel introduceert ThinC, een raamwerk dat redeneren van taalmodellen verschuift van verweven natuurlijke taal en code naar een code-gecentreerd paradigma waarbij code zelf fungeert als de primaire redenaar, en dat state-of-the-art prestaties bereikt op wiskundebenchmarks van competitieniveau door code-trajecten te distilleren en toezichtgeleide fijne afstemming gevolgd door versterkingsleer toe te passen.

Oorspronkelijke auteurs: Hyeon Hwang, Jiwoo Lee, Jaewoo Kang

Gepubliceerd 2026-05-11

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Hyeon Hwang, Jiwoo Lee, Jaewoo Kang

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 probeert een heel lastig wiskundepuzzel op te lossen. Je hebt twee manieren om dit te doen:

De Oude Manier (Interleaved Reasoning): Je praat met jezelf in het Engels en bedacht de stappen. "Oké, eerst moet ik 500 vermenigvuldigen met 0,12..." Dan word je een beetje onzeker, dus vraag je een rekenmachine (de code-tool) om je werk te controleren. Maar hier zit de adder onder het gras: als je een fout hebt gemaakt in je Engelse gedachten (bijvoorbeeld door te zeggen dat 500 keer 0,12 gelijk is aan 50 in plaats van 60), typ je die verkeerde getal per ongeluk in de rekenmachine. De rekenmachine doet gewoon wat je zegt; hij weet niet dat je een fout hebt gemaakt. Hij rekent op basis van jouw verkeerde getal, en je krijgt een verkeerd antwoord.
De Nieuwe Manier (THINC): Je neemt een klein moment om je strategie in het Engels te plannen ("Ik moet het oppervlak van deze vorm vinden"), en geef je vervolgens direct de hele taak over aan een robotprogrammeur. De robot schrijft code, voert het uit, ziet het resultaat, schrijft meer code op basis van dat resultaat, en gaat zo door totdat het antwoord naar voren komt. Je doet geen wiskunde in je hoofd of in Engelse zinnen; de robot doet alle het zware werk.

Dit artikel introduceert THINC (Thinking in Code), een nieuwe manier om AI-modellen wiskundeproblemen te leren oplossen door de code zelf de denker te laten zijn, in plaats van slechts een hulpmiddel dat de AI gebruikt om zijn werk te controleren.

Het Probleem met de Oude Manier

De auteurs zeggen dat huidige AI-modellen die Engels denken combineren met code (Tool-Integrated Reasoning genoemd) drie hoofdfouten hebben, die ze "structurele beperkingen" noemen:

De "Post-Hoc" Verificatie: De AI schrijft vaak eerst de hele oplossing in het Engels uit, en voert code pas uit om te zeggen: "Ja, dat klopt." De code doet eigenlijk niet het denken; het is slechts een stempel van goedkeuring aan het einde.
De "Stille Fout": Als de AI een rekenfout maakt in zijn Engelse gedachten (bijvoorbeeld 12% van 500 berekenen als 50 in plaats van 60), kopieert hij dat verkeerde getal misschien naar de code. De code rekent dan met het verkeerde getal, en de AI merkt het nooit. De fout is "stil" omdat de code gewoon de bevelen opvolgt.
De "Dubbele Werk": De AI schrijft vaak een lange Engelse uitleg over hoe het probleem opgelost moet worden, en schrijft dan code die exact hetzelfde doet. Het is alsof je een recept in het Engels schrijft en vervolgens precies hetzelfde recept in het Frans schrijft, alleen om te bewijzen dat je weet hoe je moet koken. Het is overbodig en verwarrend.

De THINC Oplossing

THINC verandert de regels van het spel. In plaats dat de AI over de wiskunde praat, praat de AI in de wiskunde (via code).

Het Plan: De AI begint met één korte Engelse zin om de strategie vast te stellen (bijvoorbeeld: "Ik zal door getallen heen lopen om het antwoord te vinden").
Het Werk: Na die ene zin gebeurt alles in code-blokken. De AI schrijft een stukje code, voert het uit, ziet de output, en schrijft dan het volgende stukje code op basis van die output.
Het Resultaat: Het eindantwoord komt rechtstreeks van de rekenmachine van de computer (de interpreter), niet van de AI die in het Engels gokt.

Hoe Ze de AI Leren

De onderzoekers vertelden de AI niet alleen om dit te doen; ze leerden het via een drie-stappenproces:

Distillatie (De Leraar): Ze namen een zeer slim, groot AI-model en vroegen het om wiskundeproblemen op te lossen met deze nieuwe "Code-First" stijl. Ze verzamelden 12.200 voorbeelden van deze perfecte "Code-First" oplossingen.
Supervised Fine-Tuning (De Leerling): Ze leerden twee kleinere AI-modellen (een met 1,7 miljard "hersencellen" en een met 4 miljard) om deze voorbeelden na te bootsen. Dit leerde de modellen de gewoonte om in code te denken.
Versterkend Leren (De Coach): Ze lieten de modellen oefenen op duizenden wiskundeproblemen. Als het model het juiste antwoord kreeg, kreeg het een "beloning". Als het faalde, leerde het om een andere code-strategie te proberen. Dit maakte de modellen veel slimmer en betrouwbaarder.

De Resultaten: Kleine Modellen, Grote Overwinningen

Het artikel testte deze nieuwe modellen op zeer moeilijke, wedstrijdniveau wiskundewedstrijden (zoals AIME en HMMT).

De Reuzen Verslaan: Het kleine 4-miljard-parameter THINC-model scoorde gemiddeld 78,1%. Dit is beter dan het 1,7B-model, beter dan andere "Tool-Integrated" modellen, en zelfs beter dan een enorm 235-miljard-parameter model dat alleen in het Engels denkt!
Betrouwbaarheid: In 99,2% van de gevallen werd het eindantwoord rechtstreeks uit de code-output van de computer gehaald. De AI gokte niet; het rekende.
Terugkomen: Als de code een fout maakte en crashte (een error), was het THINC-model verrassend goed in het oplossen ervan in het volgende code-blok zonder dat het zijn weg eruit hoefde te "praten". Andere modellen die Engels en code mengen, hebben de neiging in elkaar te storten wanneer ze een code-fout tegenkomen.

De Conclusie

Het artikel beweert dat door de AI te dwingen te stoppen met "praten" over de wiskunde en te beginnen met het "doen" van de wiskunde in code, de modellen nauwkeuriger worden, minder domme rekenfouten maken en moeilijke problemen efficiënter oplossen. Het is alsof je overschakelt van een mens die probeert een staartdeling in zijn hoofd te doen naar een mens die weet hoe hij een rekenmachine moet programmeren om het voor hem te doen, stap voor stap, zonder ooit een mentale rekenfout te maken.

Technische Samenvatting: Taalmodellen Leren Denken in Code (THINC)

Probleemstelling

Hoewel Tool-Integrated Reasoning (TIR) een dominant paradigma is geworden voor wiskundige probleemoplossing in Large Language Models (LLMs), lijdt de heersende "interleaved" opzet—waarbij redenering in natuurlijke taal (NL) alterneert met code-uitvoering—onder drie structurele beperkingen:

Post-hoc Verificatie: Modellen voltooien derivaties vaak in NL en gebruiken code slechts om het antwoord te bevestigen, waardoor de interpreter een passieve verificateur wordt in plaats van een actieve redenaar.
Onbetrouwbare NL-berekening: Intermediaire rekenkundige of algebraïsche stappen die in NL worden uitgevoerd, zijn foutgevoelig. Wanneer deze foutieve waarden worden overgenomen in daaropvolgende codeblokken als hard-gecodeerde constanten, kan de interpreter de fout niet detecteren, wat leidt tot stilzwijgende foutpropagatie.
Fout Toegewezen Rollen: NL en code voeren vaak overlappende taken uit. NL beschrijft frequent algoritmes stap-voor-stap die code vervolgens opnieuw implementeert, waardoor de onderscheidende sterktes van elke modaliteit niet worden benut (NL voor hoog-niveau planning, code voor precieze uitvoering).

Methodologie

De auteurs stellen THINC (Thinking in Code) voor, een trainingsframework ontworpen om de primaire last van redenering te verschuiven van natuurlijke taal naar code-uitvoering.

1. Het THINC Trajectformaat

In tegenstelling tot standaard TIR-trajecten ( $q, t_1, c_1, o_1, t_2, c_2, o_2, \dots$ ), dwingt een THINC-traject ( $q, t_1, c_1, o_1, c_2, o_2, \dots$ ) een strikte structurele scheiding af:

Enkele Planningsstap ( $t_1$ ): Het model genereert één kort NL-blok aan het begin om de hoog-niveau strategie of algebraïsche herstructurering van het probleem te definiëren. Cruciaal bevat dit blok geen stap-voor-stap afleiding of numerieke berekening.
Code-gerichte Redenering: Alle daaropvolgende redenering ontvouwt zich via codeblokken ( $c_i$ ) die uitsluitend verbonden zijn door hun uitvoer ( $o_i$ ). Er zijn geen intermediaire NL-denkblokken tussen code-uitvoeringen.
Interpreter als Redenaar: De codeblokken voeren de afleidingen, zelfcorrecties en verificaties uit. Het uiteindelijke antwoord wordt direct afgeleid uit de uitvoer van de interpreter.

2. Trainingspijplijn

Het framework wordt gerealiseerd via drie fasen:

Trajectdistillatie: Een leraar-model (Qwen3.5-27B) wordt met few-shot voorbeelden geprompt om 12.200 code-gerichte trajecten te genereren. Deze worden gefilterd om correctheid, succesvolle uitvoering, een minimum van drie codeblokken, en het feit dat de planningsgedachte minder dan 50% van de totale tokens uitmaakt, te waarborgen.
Supervised Fine-Tuning (SFT): Studentmodellen (Qwen3-1.7B en Qwen3-4B-Thinking-2507) worden fijngetuned op het gedistilleerde THINC-SFT-dataset. Dit vestigt de "code-gerichte gedragsprior", waarbij het model wordt geleerd zich te houden aan het specifieke trajectformaat.
Versterkend Leren (RL): Met behulp van Group Relative Policy Optimization (GRPO) met verifieerbare beloningen (exacte overeenkomst met ground truth) worden de modellen verder verfijnd op het DAPO-Math-17k-dataset. Het RL-proces hanteert een drie-fasen curriculum met toenemende contextlengtes (16K tot 32K) en limieten voor tool-aanroepen om moeilijkere problemen aan te kunnen.

Belangrijkste Bijdragen

THINC Framework: Een nieuw trainingsparadigma dat code behandelt als de primaire redenaar in plaats van een tool die door NL wordt opgeroepen. Het lost de structurele beperkingen van interleaved TIR per definitie op.
THINC-SFT Dataset: Een gecureerd dataset van 12,2k code-gerichte trajecten die het gewenste redeneringsformaat demonstreren.
THINC Modellen: Twee getrainde modellen, THINC-1.7B en THINC-4B, die aantonen dat schaalbare modellen hoog-niveau redeneercapaciteiten kunnen bereiken wanneer getraind met dit specifieke paradigma.

Experimentele Resultaten

De modellen zijn geëvalueerd op vijf wiskundige benchmarks op competitieniveau: AIME 2024–2026, HMMT 2025 en BeyondAIME.

Prestatie:
- THINC-4B behaalde een gemiddelde nauwkeurigheid van 78,1%, en presteerde beter dan alle TIR-baselines (waaronder ASTER-4B, ReTool-32B en rStar2-Agent-14B) en overtrof het veel grotere Qwen3-235B-A22B-Thinking (75,2%) op vier van de vijf benchmarks.
- THINC-1.7B bereikte 42,8% gemiddelde nauwkeurigheid, een verbetering van 10,6 procentpunten ten opzichte van zijn basismodel (Qwen3-1.7B) en presteerde significant beter dan andere schaalbare TIR-baselines.
Efficiëntie: THINC-4B vereiste minder tool-aanroepen per traject (6,1 versus 11,1 voor ASTER-4B) en produceerde kortere antwoorden, wat wijst op hogere efficiëntie.
Robuustheid: In experimenten die herstel meten na initiële code-uitvoeringsfouten (Recovery@k), behield THINC-4B een herstelsnelheid van 64–69% zelfs na drie opeenvolgende code-fouten. Interleaved TIR-baselines degradeerden daarentegen scherp, waarbij sommige daalden tot bijna 0% herstel.
Code Grounding: Analyse toonde aan dat 99,2% van de uiteindelijke antwoorden van THINC-4B was verankerd in interpreter-uitvoer, vergeleken met aanzienlijk lagere percentages voor baselines (bijvoorbeeld 88,4% voor ReTool, 74,3% voor rStar2).

Betekenis

Het artikel stelt dat THINC aantoont dat code-gerichte redenering een superieur paradigma is voor wiskundige probleemoplossing in vergelijking met interleaved TIR. Door natuurlijke taal te beperken tot hoog-niveau planning en alle afleidingen te forceren naar uitvoerbare code, elimineert het framework de propagatie van rekenfouten en zorgt het ervoor dat het uiteindelijke antwoord wordt geverifieerd door de interpreter. De resultaten suggereren dat deze structurele verandering kleinere modellen (4B parameters) in staat stelt om aanzienlijk grotere redenaars die alleen natuurlijke taal gebruiken (235B parameters) en gevestigde tool-geïntegreerde agenten te overtreffen, wat de effectiviteit van "denken in code" boven "denken met code" onderstreept.