R1-Code-Interpreter: LLMs Reason with Code via Supervised and Multi-stage Reinforcement Learning

Each language version is independently generated for its own context, not a direct translation.

Stel je voor dat je een zeer slimme, maar soms wat verwarde assistent hebt. Deze assistent (een Large Language Model of LLM) kan fantastisch praten, verhalen vertellen en redeneren over de wereld. Maar als je hem vraagt om een ingewikkelde wiskundepuzzel op te lossen of een robot te laten bewegen in een virtuele kamer, gaat hij vaak in de war. Hij probeert het allemaal met woorden op te lossen, wat als proberen een auto te repareren met alleen een woordenboek: het helpt bij het begrijpen van de onderdelen, maar niet bij het vastdraaien van de bouten.

Dit artikel introduceert R1-Code-Interpreter, een manier om deze slimme assistent te leren om niet alleen te praten, maar ook te doen door code te schrijven en uit te voeren. Het is alsof we onze assistent een gereedschapskist geven en hem leren wanneer hij een hamer moet gebruiken in plaats van alleen maar te praten.

Hier is hoe ze dat gedaan hebben, vertaald naar alledaagse taal:

1. Het Probleem: Te veel verschillende puzzels

Vroeger trainden wetenschappers deze modellen op één soort taak, zoals wiskunde. Dat werkte goed. Maar in de echte wereld zijn er duizenden verschillende soorten problemen: van het ordenen van blokken op een plank tot het plannen van een reisroute.

De onderzoekers verzamelden 144 verschillende soorten puzzels. Ze probeerden de assistent te trainen op allemaal tegelijk. Het resultaat? De assistent raakte in de war. Het was alsof je iemand probeert te leren zwemmen, skiën, basketballen en piano spelen in één dag. De signalen waren te wazig; de assistent wist niet welke strategie hij moest gebruiken voor welke puzzel.

2. De Oplossing: Een slimme leerplanning (Curriculum Learning)

In plaats van de assistent te laten worstelen met alle puzzels door elkaar, bedachten de onderzoekers een slimme truc: de "potentie-meting".

Stel je voor dat je een leraar bent met een klas van 100 leerlingen. Je wilt ze allemaal leren rekenen.

Als een opgave te makkelijk is, leert de leerling er niets van (hij weet het al).
Als een opgave te moeilijk is, leert de leerling er ook niets van (hij raakt gefrustreerd en geeft het op).
De gouden middenweg? Opgaven die de leerling soms goed en soms fout maakt. Hier zit de grootste leermogelijkheid!

De onderzoekers lieten hun assistent eerst alleen de "gouden middenweg"-puzzels doen. Zodra hij die onder de knie had, gaven ze hem iets moeilijkere. Daarna nog moeilijkere. Ze bouwden een trapsgewijze leerplanning op, van "leuk om te oefenen" naar "echte uitdaging". Hierdoor leerde de assistent veel sneller en effectiever dan wanneer hij alles door elkaar had gedaan.

3. De "Zelfcontrole"-Superkracht

Het mooiste resultaat van deze training is dat de assistent een nieuw, bijna menselijk gedrag ontwikkelde: zelfcontrole.

Vroeger gaf de assistent direct een antwoord. Nu, na de training, ziet hij soms: "Hm, dit antwoord klinkt goed, maar ik ben niet zeker." In plaats van te gokken, schrijft hij een klein stukje code om zijn eigen antwoord te testen.

Voorbeeld: Hij denkt: "Ik denk dat de blokken zo moeten staan." -> Hij schrijft code om de blokken te verplaatsen -> De computer zegt: "Fout, die blokken botsen." -> Hij past zijn plan aan.

Het is alsof de assistent een eigen controlemechanisme heeft ontwikkeld. Hij leert om niet blindelings te vertrouwen op zijn eerste gedachte, maar om zijn werk te verifiëren voordat hij het afgeeft.

4. Het Resultaat: Beter dan de "Grote Broer"

Het eindresultaat, genaamd R1-CI-14B, is een model dat niet alleen praat, maar ook handelt.

Het scoorde 72,4% op de testpuzzels.
Ter vergelijking: De beroemde GPT-4o (zonder code-hulp) scoorde 58,6%, en zelfs GPT-4o met code-hulp (maar zonder deze slimme training) scoorde 70,9%.

Dit betekent dat hun model, dat is getraind op deze specifieke manier, beter presteert dan de grootste modellen van de concurrentie, zelfs als die modellen al een code-hulpmiddel hebben.

Samenvattend: Waarom is dit belangrijk?

Stel je voor dat je een auto bouwt.

Eerdere modellen waren als een auto die alleen maar kon rijden op een rechte weg (alleen tekst).
Deze nieuwe methode heeft de auto uitgerust met een navigatiesysteem, een gereedschapskist en een slimme bestuurder die weet wanneer hij moet remmen, versnellen of een omweg moet nemen.

Ze hebben bewezen dat je een AI niet alleen "slimmer" maakt door meer data te geven, maar door hem de juiste volgorde van uitdagingen te geven en hem te leren niet alleen te denken, maar ook te checken. Dit maakt de AI veel betrouwbaarder voor complexe taken in de echte wereld.

Each language version is independently generated for its own context, not a direct translation.

Hier is een gedetailleerde technische samenvatting van het paper "R1-CODE-INTERPRETER: LLMS REASON WITH CODE VIA SUPERVISED AND MULTI-STAGE REINFORCEMENT LEARNING", geschreven in het Nederlands.

Titel: R1-CODE-INTERPRETER: LLM's Redeneren met Code via Supervised en Multi-Stage Reinforcement Learning

Auteurs: Yongchao Chen et al. (MIT, Harvard, UIUC, etc.)
Publicatie: ICLR 2026

1. Het Probleem

Hoewel Reinforcement Learning (RL) de redeneercapaciteiten van Large Language Models (LLM's) aanzienlijk heeft verbeterd, blijven modellen worstelen met complexe taken die precisievere berekeningen, symbolische manipulatie en optimalisatie vereisen. Tekstuele redenering is uitstekend voor semantiek en gezond verstand, maar faalt vaak bij wiskundige exactheid.

Bestaande oplossingen zoals de Code Interpreter van OpenAI laten modellen code genereren, maar er ontbreekt een gestructureerde methode om modellen te leren wanneer ze tekstuele redenering moeten gebruiken versus wanneer ze code moeten genereren. Eerdere onderzoeken (zoals ToRL en ReTool) zijn beperkt tot specifieke domeinen zoals wiskunde of zoeken, en missen de generaliseerbaarheid voor een breed scala aan real-world taken. De uitdaging ligt in de heterogeniteit van taken en het gebrek aan effectieve trainingsvoorbeelden (samples) die modellen daadwerkelijk kunnen verbeteren.

2. Methodologie

De auteurs introduceren R1-Code-Interpreter, een framework dat LLM's traint om autonoom code te genereren en uit te voeren tijdens stap-voor-stap redenering. De aanpak bestaat uit drie hoofdfasen:

A. Data Curation en Supervised Fine-Tuning (SFT)

Dataset: Er zijn 144 diverse redeneer- en plannings-taken geselecteerd uit benchmarks zoals SymBench, Big-Bench-Hard en Reasoning-Gym. Deze omvatten wiskunde, ruimtelijk redeneren, logica, optimalisatie en zoekproblemen.
Trajecten: Er zijn 6.500 multi-turn trajecten gegenereerd (met GPT-4o) die tekst en code afwisselen. Alleen trajecten met het juiste antwoord werden behouden.
Prompting: Het model leert een natuurlijk formaat te gebruiken: ```python voor code en <<<answer>>> voor het eindantwoord, zonder strikte tags voor tussenstappen, om de natuurlijke leercurve te behouden.

B. Het Uitdaging: Heterogeniteit en Sparsiteit

Directe toepassing van standaard RL (zoals DeepSeek-style GRPO) op deze diverse dataset leverde slechts marginale verbeteringen op (+3,4%). De reden is dat taken te moeilijk of te makkelijk zijn voor het model, wat leidt tot een verwaarloosbaar leer-signaal (variatie in beloning is bijna nul).

C. Multi-Stage Curriculum Learning met "Improvement Potential"

Om dit op te lossen, introduceren de auteurs een nieuw curriculum dat gebaseerd is op de gemeten verbeteringspotentie van elk voorbeeld, in plaats van alleen op moeilijkheidsgraad.

Potentie Schatting: Voor elk trainingsvoorbeeld worden 20 antwoorden gegenereerd met verschillende agent-strategieën (alleen tekst, alleen code, code-agent, etc.).
Potentie Score ( $\Pi_i$ ): De score wordt berekend als $4 \cdot p \cdot (1-p) $, waarbij$ $, w aa r bij$ p$ de correctheidskans is.
- Als een voorbeeld bijna altijd goed of altijd fout is ( $p \approx 0$ of $1$), is de potentie laag (weinig leerwaarde).
- Als een voorbeeld ongeveer 50% van de tijd goed wordt beantwoord ( $p \approx 0.5$ ), is de potentie maximaal (maximale leerwaarde).
Vier Stadia: Het trainingsproces verloopt in vier fasen:
- Fase 1: Trainen op samples met de hoogste verbeteringspotentie.
- Fase 2 t/m 4: Geleidelijk toevoegen van samples met lagere potentie.
- Dit zorgt ervoor dat het model eerst leert op de meest leerzame voorbeelden voordat het wordt blootgesteld aan te moeilijke of te makkelijke taken.

D. Technische Optimalisatie: Code Execution Sandbox

Code-uitvoering is tijdrovend en verlaagt de GPU-gebruiksefficiëntie tijdens training. De auteurs hebben een speciale Code Execution Sandbox ontwikkeld op CPU-nodes die losgekoppeld is van de GPU-berekening van de gradiënten. Dit verlaagt de totale trainingstijd met 39%.

3. Belangrijkste Bijdragen

Eerste General Purpose Code Interpreter: Dit is het eerste gepubliceerde werk dat een algemene Code Interpreter traint over honderden diverse taken en domeinen, in plaats van alleen wiskunde.
Potentie-Gedreven Curriculum Learning: Een nieuwe methode om RL-training te sturen op basis van de verwachte leerwinst van samples, wat de effectiviteit van RL van +3,4% naar +9,3% brengt.
Efficiënte Training: Een architectuur die code-uitvoering ontkoppelt van GPU-gradiëntberekening, wat de trainingstijd aanzienlijk verkort.
Uitgebreide Vergelijking: Een grondige analyse van verschillende trainingsstrategieën (SFT vs. RL, warm-start vs. cold-start) en base-modellen (Qwen-2.5 vs. DeepSeek-distilled).

4. Resultaten

Het beste model, R1-CI-14B (gebaseerd op Qwen-2.5-14B), toont indrukwekkende prestaties:

Testresultaten: De gemiddelde nauwkeurigheid op 37 testtaken steeg van 44,1% (base model) naar 72,4%.
Vergelijking met SOTA: R1-CI-14B presteert beter dan:
- GPT-4o (alleen tekst): 58,6%
- GPT-4o met ingebouwde Code Interpreter: 70,9%
Generalisatie: Het model presteert ook sterk op Out-of-Distribution (OOD) taken zoals GPQA en AIME, wat aantoont dat de vaardigheden generaliseerbaar zijn.
Ablatie Studies:
- Warm-start met SFT is cruciaal; zonder SFT levert RL weinig verbetering op.
- Multi-turn frameworks zijn superieur aan single-turn tekst of code.
- Qwen-2.5 base-modellen werken beter dan DeepSeek-distilled reasoning modellen voor deze taak.

5. Significante Observaties en Emergent Gedrag

Zelfcontrole (Self-Checking): Het model leert tijdens de training emergent gedrag om code te genereren om zijn eigen antwoorden te verifiëren voordat het het eindantwoord geeft. Dit "checken" gebeurt vaak in de laatste redeneerstappen.
Efficiëntie: Hoewel multi-turn redeneren duurder is, lost het model de meeste vragen op met minder dan 4 code-uitvoeringen en binnen twee minuten.
Beperkingen: Het model kan nog steeds worstelen met taken die volledig buiten zijn inherente redeneer- of kennisvermogen liggen, ongeacht de training.

Conclusie

R1-CODE-INTERPRETER demonstreert dat het combineren van tekstuele redenering met code-uitvoering via een zorgvuldig ontworpen, potentie-gestuurde curriculum learning aanpak, leidt tot superieure prestaties in complexe redeneertaken. De methode overwint de beperkingen van traditionele RL-training op heterogene datasets en stelt open-source modellen in staat om zelfs grotere gesloten modellen (zoals GPT-4o) te overtreffen in specifieke domeinen. De code, datasets en modellen zijn open-source beschikbaar gemaakt.