Logit Arithmetic Elicits Long Reasoning Capabilities Without Training

Probleemstelling

Grote redeneringsmodellen (Large Reasoning Models of LRMs), zoals OpenAI o1 en DeepSeek-R1, tonen indrukwekkende vaardigheden in langdurig "Chain-of-Thought" (CoT) redeneren, inclusief complexe strategieën zoals terugkeren (backtracking), zelfverificatie en planning. Deze vaardigheden worden echter doorgaans bereikt via kostbare post-trainingstechnieken, zoals versterkingsleer (RL) of gesuperviseerde distillatie. Voor zeer grote modellen is deze training vaak onbetaalbaar of technisch onuitvoerbaar.

Bestaande methoden om lang CoT-redeneren op te wekken zonder training (training-free) zijn beperkt; ze verlengen vaak de output zonder daadwerkelijk complexe redeneerstrategieën te genereren, of vereisen witte-boks-toegang en domeinspecifieke supervisie. De centrale onderzoeksvraag is: Kan een klein redeneringsmodel langdurig CoT-gedrag opwekken in een groot, niet-getraind model tijdens de inferentie, zonder dat het grote model zelf getraind hoeft te worden?

Methodologie: THINKLOGIT en THINKLOGIT-DPO

De auteurs stellen twee methoden voor die redeneringscapaciteiten overdragen van een klein "gids-model" (guider) naar een groot "doelmodel" (target) via logit-aritmetiek tijdens het decoderingsproces.

1. THINKLOGIT (Decoding-time Logit Arithmetic)

Deze methode vereist geen gradient-updates voor het doelmodel.

• Setup: Er worden drie modellen gebruikt:
  • $L$: Het grote, bevroren doelmodel (zonder lang CoT).
  • $S_0$: Een klein basismodel (zonder lang CoT training).
  • $S$: Een klein "gids"-model dat is getraind voor lang CoT (afgeleid van $S_0$).
• Mechanisme: Bij elke decoderingsstap $t+1$ worden de logits van het doelmodel ($\ell(L)$) aangepast door het verschil in logits tussen het getrainde gidsmodel en het basisgidsmodel toe te voegen:
  $$\tilde{\ell}_{t+1} = \ell(L)_{t+1} + \alpha \cdot (\ell(S)_{t+1} - \ell(S_0)_{t+1})$$
  Hierbij is $\alpha$ een parameter die de sterkte van de begeleiding bepaalt. Het term $(\ell(S) - \ell(S_0))$ encodeert de waarschijnlijkheidsverschuiving die nodig is om van kort naar lang redeneren te gaan. Dit "delta" wordt toegepast op het doelmodel, waardoor het de redeneerpatronen van het kleine model overneemt zonder zelf getraind te worden.

2. THINKLOGIT-DPO (Direct Preference Optimization)

Om distributiemismatches tussen het gids- en doelmodel te minimaliseren, wordt het kleine gidsmodel verder geoptimaliseerd.

• Doel: Het gidsmodel leren om fouten van het doelmodel te corrigeren, terwijl het de sterke punten van het doelmodel behoudt.
• Data: Er worden twee soorten preferentieparen gegenereerd uit de output van beide modellen:
  • Type-1: Het korte, correcte antwoord van het doelmodel is beter dan het lange, foutieve antwoord van het gidsmodel (behoud van doelmodel-kwaliteit).
  • Type-2: Het lange, correcte antwoord van het gidsmodel is beter dan het korte, foutieve antwoord van het doelmodel (leren om fouten te corrigeren).
• Training: Het gidsmodel wordt getraind met DPO op deze gemengde dataset. Vervolgens wordt dit geoptimaliseerde gidsmodel gebruikt in de THINKLOGIT-formule.

Kernbijdragen

1. THINKLOGIT: Een trainingsvrije decoderingsmethode die lang CoT-redeneren overbrengt van een klein model naar een groot model via logit-aritmetiek.
2. THINKLOGIT-DPO: Een verbeterde variant die de prestaties verhoogt door het gidsmodel te aligneren met het doelmodel via preferentie-optimalisatie.
3. Generalisatie: De methode werkt effectief over verschillende model-families heen (bijv. Qwen als gids voor Llama, OLMo, EXAONE), zelfs zonder gedeelde tokenizer (via vocabulaire-afstemming).
4. Efficiëntie: De methode vereist nul training voor het grote model en introduceert minimale inferentie-overhead, vooral als logits parallel worden berekend.

Resultaten

De methoden zijn geëvalueerd op zes benchmarks (wiskunde, wetenschap, codering) met een Qwen2.5-32B als doelmodel en een R1-Distill-Qwen-1.5B (21x kleiner) als gids.

• Prestatieverbetering:
  • THINKLOGIT bereikte een relatieve verbetering van 21,5% ten opzichte van het bevroren doelmodel.
  • THINKLOGIT-DPO bereikte een relatieve verbetering van 24,2%.
  • De methoden presteerden beter dan zowel het doelmodel als het gidsmodel op zichzelf.
• Vergelijking met Full Fine-tuning: De methode recupereert een aanzienlijk deel van de prestaties van volledige parameter-fine-tuning (bijv. 45% van de kloof naar een data-efficiënt getraind 32B-model), zonder enige training van het grote model.
• Cross-Family Generalisatie: De methode bleek robuust bij het toepassen van een Qwen-gids op Llama, OLMo en EXAONE doelmodellen, met absolute nauwkeurigheidsverbeteringen tot 25,9%.
• Redeneringsgedrag: Analyse toont aan dat de methode echte cognitieve patronen activeert (zoals backtracking, zelfverificatie en het verkennen van alternatieven) in plaats van alleen de outputlengte kunstmatig te verhogen (wat bij andere "training-free" methoden vaak het geval is).

Significantie en Toekomstperspectief

Dit onderzoek biedt een praktische oplossing voor het activeren van geavanceerde redeneringsvaardigheden in grote modellen wanneer training onmogelijk is (bijv. bij extreme schaal, zwarte-boks API's, of privacy-gevoelige scenario's).

• Kostenbesparing: Het elimineert de enorme rekentijd en kosten van het fine-tunen van grote modellen.
• Modulariteit: Het stelt systemen in staat om gespecialiseerde, lichte redeneringsmodellen te hergebruiken om grote foundation-modellen te "sturen".
• Inferentie-overhead: Hoewel er een lichte vertraging is door het berekenen van extra logits, is dit verwaarloosbaar vergeleken met de kosten van training, en kan het worden geminimaliseerd door parallelle inferentie.

Samenvattend bewijst dit werk dat complexe redeneercapaciteiten niet per se in de parameters van een groot model moeten worden "gebrand" via training, maar dynamisch kunnen worden opgewekt door slimme interactie met kleinere, gespecialiseerde modellen tijdens de inferentie.