Self-Distillation Zero: Self-Revision Turns Binary Rewards into Dense Supervision

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

Stel je voor dat je een student hebt die wiskundeproblemen probeert op te lossen. Soms lukt het, maar vaak maakt hij fouten.

In de wereld van kunstmatige intelligentie (AI) zijn er tot nu toe twee manieren om zo'n 'student' (een computermodel) te leren:

De strenge leraar (RL): De computer probeert een antwoord. Als het goed is, krijgt hij een stipje (+1). Als het fout is, krijgt hij een nul (-1). Hij weet niet waar hij precies fout zat, alleen dat het totaal niet goed was. Hij moet duizenden keren proberen om door trial-and-error te ontdekken wat wel werkt. Dit is veel werk en kost veel tijd.
De perfecte tutor (Distillation): De computer kijkt naar een oplossing van een super-intelligente leraar en probeert die na te bootsen. Dit werkt heel goed, maar het kost enorm veel tijd en geld om die 'super-leraar' te vinden of te maken.

SD-ZERO is een nieuwe, slimme methode die zegt: "Waarom zoeken we een externe leraar of laten we de computer blindelings gissen? Laten we de computer zijn eigen leraar maken, zelfs als hij fouten maakt."

Hier is hoe het werkt, vertaald naar een alledaags verhaal:

Het Grote Plan: De 'Reiziger' en de 'Reiziger'

Stel je voor dat het computermodel twee rollen tegelijk speelt:

De Reisgids (Generator): Deze probeert een antwoord te bedenken.
De Herziener (Reviser): Deze kijkt naar het antwoord van de Reisgids en zegt: "Hé, hier zit een foutje in. Laten we het anders doen." of "Dit is goed, maar we kunnen het netter formuleren."

Het magische van SD-ZERO is dat hetzelfde model beide rollen speelt. Het leert van zijn eigen fouten zonder dat er een externe leraar nodig is.

De Twee Fasen van het Avontuur

Het proces verloopt in twee stappen, zoals het leren van een sport:

Fase 1: De 'Fouten-oefening' (Self-Revision Training)

Stel, de computer probeert een wiskundevraag op te lossen en komt op een fout antwoord.

De oude manier: De computer zou dit antwoord weggooien en opnieuw beginnen.
De SD-ZERO manier: De computer krijgt een seintje: "Je antwoord is fout." Vervolgens krijgt hij de opdracht: "Kijk naar je eigen fout, begrijp waarom het misging, en schrijf een nieuw, correct antwoord."

Het model doet dit duizenden keren. Het leert niet alleen om antwoorden te geven, maar vooral om fouten te herkennen en te corrigeren. Het is alsof een student een examen maakt, de antwoorden controleert, en dan de fouten in de marge uitlegt aan zichzelf.

Fase 2: De 'Inwendige Leraar' (Self-Distillation)

Nu is het model goed geworden in het corrigeren van fouten. Maar in het echte leven willen we dat het model het antwoord eerst goed heeft, zonder eerst een fout te maken en die dan te corrigeren (dat kost te veel tijd).

Dus, in deze fase gebruiken we de 'Herziener' (de leraar) om de 'Reisgids' (de student) te trainen.

De Reisgids schrijft een antwoord.
De Herziener kijkt ernaar en zegt: "Je had hier een fout, en hier was het goed. Hier is hoe je het direct zo had moeten doen."
De Reisgids luistert en leert: "Ah, ik moet die stap direct zo doen, zonder eerst de fout te maken."

Op deze manier leert het model de corrigering in zich op te nemen. Het wordt slimmer en sneller, omdat het de 'herstelwerkzaamheden' heeft omgezet in een betere eerste poging.

Waarom is dit zo speciaal? (De Creatieve Analogie)

Stel je voor dat je een spoorlijn bouwt.

RL (Reinforcement Learning) is alsof je een trein laat rijden die constant van spoor springt. Je ziet alleen of hij op het eindstation aankomt of niet. Hij moet duizenden keren crashen om te leren waar de rails liggen.
SD-ZERO is alsof de trein zelf een kaarttekent. Als hij van spoor springt, stopt hij, kijkt hij naar de kaart, en zegt: "Ah, ik was te snel bij bocht X." Vervolgens tekent hij de kaart bij en rijdt hij de volgende keer direct over het juiste spoor.

Het belangrijkste voordeel:
Het model hoeft geen dure 'super-leraar' te hebben. Het maakt zijn eigen fouten, leert ervan, en wordt daardoor zijn eigen beste leraar. Het zet een simpele 'ja/nee' (goed/slecht) om in een gedetailleerde instructie over waar en hoe het beter kan.

Het Resultaat

Door deze methode te gebruiken, worden de modellen (zoals Qwen en Olmo) in tests over wiskunde en programmeren 10% beter dan hun oorspronkelijke versie. Ze maken minder fouten, zijn sneller (ze hoeven niet meer te 'proberen en te hopen') en ze doen dit allemaal zonder dat er dure menselijke experts nodig zijn om de antwoorden te controleren.

Kortom: SD-ZERO leert de computer om slimmer te leren van zijn eigen fouten, zodat hij in de toekomst direct het juiste antwoord geeft.

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

Probleemstelling

Huidige methoden voor het na-trainen (post-training) van taalmodellen in verifieerbare omgevingen (zoals wiskunde en codering) vallen in twee categorieën, die beide beperkingen hebben:

Versterkend Leren (RLVR): Methoden zoals GRPO vertrouwen op binaire beloningen (correct/incorrect). Hoewel dit breed toepasbaar is, biedt het slechts spaarzame supervisie. Het model weet niet welke tussenstappen in het redeneren fout waren, wat het trainingsproces duur en inefficiënt maakt omdat het model veel zelf gegenereerde antwoorden moet vergelijken om patronen te vinden.
Distillatie: Methoden die dichte token-level supervisie bieden, vereisen meestal een externe, sterkere "leraar" of hoogwaardige demonstraties. Het verzamelen van dergelijke data is vaak kostbaar of niet beschikbaar. Bestaande zelf-distillatiemethoden vereisen nog steeds hoogwaardige voorbeelden die beter zijn dan het model zelf, wat de cirkel doorbreekt.

De centrale vraag van dit werk is: Kan een model zijn eigen initiële pogingen (die mogelijk onjuist zijn) en de bijbehorende spaarzame binaire beloning gebruiken om zichzelf rijke, dichte supervisie te bieden?

Methodologie: SD-ZERO

De auteurs stellen Self-Distillation Zero (SD-ZERO) voor, een methode die een enkel model in twee rollen traint: een Generator (die een initiële respons produceert) en een Reviser (die conditioneert op die respons en de beloning om een verbeterde respons te produceren). De methode verloopt in twee fasen:

Fase 1: Self-Revision Training (SRT)

In deze fase wordt het model getraind om fouten te corrigeren.

Data Collectie: Voor een gegeven vraag $x$ wordt een initiële respons $y_{init}$ gegenereerd. Een binaire verifier bepaalt of deze correct is ( $r=1$ ) of niet ( $r=0$ ).
Prompting: Het model wordt gevraagd om de respons te herformuleren als deze correct is, of om te beginnen met een nieuwe poging als deze incorrect is (gebaseerd op een controlemelding).
Doel: Het model leert een Self-Revision respons ( $y_{revised}$ ) te genereren die correct is.
Verliesfunctie: Het model wordt getraind op twee taken tegelijkertijd:
1. Revision Loss: Het genereren van een gecorrigeerde respons gegeven de initiële poging en de beloning.
2. Generation Loss: Het genereren van een correcte respons vanaf nul (om de generatiecapaciteit te behouden).
Resultaat: Het model ontwikkelt expliciete zelf-revisiegedragingen, maar neigt vaak naar zeer lange antwoorden omdat het expliciet zijn fouten analyseert.

Fase 2: On-Policy Self-Distillation

In deze fase wordt de kennis van de reviser "teruggedistilleerd" naar de generator om efficiëntere antwoorden te genereren.

Setup: De SRT-getrainde reviser fungeert als een vaste leraar (Teacher), terwijl het huidige model de student is.
Proces: De student genereert een respons. De reviser (leraar) bekijkt deze respons en de binaire beloning en genereert een token-level verdeling van hoe de respons had moeten zijn.
Doel: De student wordt getraind om de token-distributie van de reviser te imiteren via een KL-divergentie-verlies.
Effect: De binaire beloning wordt omgezet in dichte token-level supervisie. De reviser identificeert specifiek welke tokens fout waren en stuurt de student naar een betere richting, zonder dat het model expliciet hoeft te "terugdenken" tijdens de inferentie.

Belangrijkste Bijdragen

Van Spaarzaam naar Dicht: SD-ZERO is de eerste methode die binaire uitkomstbeloningen succesvol omzet in dichte token-level supervisie zonder externe leraar of hoogwaardige demonstraties.
Token-Level Self-Localization: Het paper toont aan dat de reviser, ondanks slechts een binaire input, de fouten lokaal kan lokaliseren. Bij een onjuiste respons concentreert de "KL-beloning" zich op een klein aantal tokens die de fout bevatten, terwijl correcte responsen een vlakke verdeling krijgen.
Iteratieve Zelf-Evolutie: Omdat de trainingsfase ook de revisievaardigheid verbetert, kan het bijgewerkte model dienen als een sterkere leraar voor volgende rondes van zelf-distillatie, wat leidt tot continue verbetering.
Efficiëntie: De methode vereist slechts één respons per vraag tijdens de distillatiefase, wat het trainingsproces aanzienlijk sample-efficiënter maakt dan RL-methoden die meerdere rollouts per vraag nodig hebben.

Resultaten

De methode is getest op wiskunde- en code-redeneringsbenchmarks met de modellen Qwen3-4B-Instruct en Olmo-3-7B-Instruct.

Prestatieverbetering: SD-ZERO verbetert de prestaties met minimaal 10% ten opzichte van de basismodellen.
- Qwen3-4B: +10.5% verbetering.
- Olmo-3-7B: +10.4% verbetering.
Vergelijking met Baselines: SD-ZERO overtreft sterke baselines zoals Rejection Fine-Tuning (RFT), GRPO en Self-Distillation Fine-Tuning (SDFT) onder dezelfde trainingsbudgetten en vraagsets.
Token-Efficiëntie: Hoewel Fase 1 (SRT) leidt tot langere antwoorden door expliciete zelf-correctie, reduceert Fase 2 (Self-Distillation) de token-lengte met ongeveer 2x ten opzichte van het SRT-model, terwijl de nauwkeurigheid verder stijgt. Het model leert de correcties "inwendig" te maken in plaats van ze expliciet te uiten.
Sample Efficiency: SD-ZERO bereikt betere resultaten met minder gegenereerde tokens dan RL-methoden zoals GRPO, omdat het de binaire feedback direct omzet in gerichte supervisie.

Betekenis en Impact

SD-ZERO biedt een nieuwe paradigma voor het trainen van redenerende modellen:

Onafhankelijkheid: Het elimineert de afhankelijkheid van dure, externe leraars of hoogwaardige datasets, waardoor zelf-distillatie toepasbaar wordt op domeinen waar dergelijke data schaars is.
Schaalbaarheid: Door de noodzaak van externe supervisie weg te nemen, kan deze methode makkelijker worden geschaald naar grotere modellen en bredere domeinen.
Inzicht in Redenering: De bevinding dat een model uit een binaire beloning kan leren waar de fout zit (token-level self-localization), biedt waardevolle inzichten in hoe taalmodellen redeneren en zichzelf kunnen corrigeren.

Kortom, SD-ZERO bewijst dat een model zijn eigen fouten en de bijbehorende simpele feedback kan gebruiken om een krachtig, intern leerproces op te zetten dat zowel nauwkeuriger als efficiënter is dan bestaande methoden.