Technische Samenvatting: LatentRevise: Leren van Zero-Hit Redeneren

1. Probleemstelling: Het Zero-Hit Regime in RLVR

Reinforcement Learning met Verifieerbare Beloningen (RLVR) is een standaardaanpak geworden voor het verbeteren van redeneren in taalmodellen. Het wordt echter geconfronteerd met een fundamentele bottleneck die bekend staat als het zero-hit regime. In dit scenario wordt een prompt gepresenteerd waarbij de huidige policy er niet in slaagt om binnen een praktische steleffect-budget zelfs maar één enkel correct traject te genereren (i.e., $pass@N = 0$).

Standaard RLVR-algoritmen, zoals Group Relative Policy Optimization (GRPO), vertrouwen op groep-genormaliseerde voordelen (advantages) om de policy bij te werken. Wanneer alle gesamplede trajecten in een groep falen, ontvangen ze identieke beloningen (meestal nul of negatief). Bijgevolg is het groepsgemiddelde gelijk aan de individuele beloningen, waardoor het genormaliseerde voordeel naar nul convergeert. Dit resulteert in een gebrek aan constructieve gradiëntsignalen, waardoor deze "moeilijke" prompts effectief worden weggegooid als onleerbare ruis.

Bestaande oplossingen proberen dit aan te pakken door:

1. Het sampling-budget te vergroten: Het verhogen van $N$ of de decoding temperature, wat computationeel duur is en nog steeds alleen op uitkomstniveau werkt (zonder tussenliggende sturing).
2. On-policy distillatie: Het gebruik van een docent-model (teacher model) of geprivilegieerde informatie om token-niveau targets te bieden. Deze methoden vertrouwen echter op externe begeleiding die zwak, mismatchend of niet beschikbaar kan zijn wanneer het student-model al moeite heeft.

Het kernprobleem is dat deze zero-hit prompts zich vaak bevinden op de "sampling frontier" waar nieuwe redeneergedragingen het meest nodig zijn, maar standaard pipelines niet van kunnen leren omdat ze geen positief signaal missen.

2. Methodologie: LatentRevise

De auteurs stellen LatentRevise voor, een first-order latent revisiemethode die ontworpen is om trainingssignalen te herstellen uit mislukte rollouts zonder externe docent-modellen of referentietracers te vereisen. In plaats van een mislukt traject te verwerpen, behandelt LatentRevise het als een informatieve trace en optimaliseert het de input-embeddings van de redeneerprefix in een continue latente ruimte.

Kernpipeline

1. Input: Een mislukte rollout $y_{fail} = [r; c]$, waarbij $r$ de redeneerprefix is en $c$ de mislukte voortzetting, samen met het gouden antwoord $y_{GT}$.
2. Freeze & Optimize: De modelparameters $\theta$ worden bevroren. De input-embeddings van de redeneerprefix, $E_r$, worden geoptimaliseerd om het traject weg te bewegen van de fout en richting de oplossing.
3. Composiet Objectief: De optimalisatie minimaliseert een totale loss $L_{total}$ bestaande uit drie termen:
   • Latent Exploration Loss ($L_{explore}$): Een afstotend signaal dat de waarschijnlijkheid van het reproduceren van de oorspronkelijke mislukte voortzetting $c$ minimaliseert. Dit moedigt de latente staat aan om alternatieve paden te verkennen.
   • Latent Guidance Loss ($L_{guide}$): Een sturend signaal dat de waarschijnlijkheid van het genereren van het gouden antwoord $y_{GT}$ maximaliseert (geconditioneerd op een vaste antwoordtemplate). Dit verankert de revisie richting de juiste oplossing.
   • Language Fluency Prior ($L_{NLL}$): Een regularisatieterm die de negative log-likelihood van de oorspronkelijke redeneertokens $r$ behoudt. Dit zorgt ervoor dat de geoptimaliseerde latente staat semantisch coherent blijft en niet afdwaalt naar adversariële ruis.
4. Manifold Constraint (Frank-Wolfe): Om te voorkomen dat de continue embeddings afdwalen naar een oninterpreteerbare feature space (waar het model zou kunnen "valsspelen" door antwoorden in willekeurige vectoren te coderen), wordt de optimalisatie beperkt tot de convexe hull van de vocabulaire-embeddings van het model. Dit wordt bereikt met het Frank-Wolfe (Conditional Gradient) algoritme. Bij elke stap is de update een convexe combinatie van de huidige embedding en de optimale vertex (vocabulaire token) die de lineaire benadering van de loss minimaliseert.
5. Discrete Recovery: De geoptimaliseerde zachte prefix $E^*_r$ wordt teruggeprojecteerd naar discrete tokens via een nearest-neighbor zoekopdracht tegen de vocabulaire-matrix. Een nieuwe voortzetting wordt autoregressief gedecodeerd. Als het resulterende traject de verifieerder passeert, wordt het behouden als supervised data of geïnjecteerd in RL-groepen.

3. Belangrijkste Bijdragen

Het artikel schetst drie primaire bijdragen:

1. Herformulering van de Zero-Hit Frontier: De auteurs identificeren zero-hit prompts niet als onleerbare uitschieters, maar als een herstelbare frontier. Ze tonen aan dat geldige trainingssignalen algoritmisch kunnen worden hersteld uit deze mislukkingen met behulp van de eigen latente ruimte van het model.
2. LatentRevise Algoritme: Een nieuw first-order latent revisiekader dat mislukte rollouts omzet in succesvolle rollouts. Cruciaal is dat het werkt zonder externe docent-distributies of geprivilegieerde traces, door in plaats daarvan te vertrouwen op het goude antwoord en de eigen mislukte voortzetting van het model om dichte, positionele correctiesignalen te genereren.
3. Empirische Validatie: De herstelde trajecten blijken hoogwaardige trainingsdata te zijn. Ze verbeteren zowel $pass@1$ als $pass@k$ op wiskundige redeneerbenchmarks, met name in scenario's waar standaard RL en grotere sampling-budgetten geen verbeteringen opleveren.

4. Experimentele Resultaten

De methode werd geëvalueerd op DAPO-Math-14K met behulp van Qwen2.5-1.5B-Instruct en Qwen3-8B-Base modellen over benchmarks inclusief MATH500, AIME 24/25, AMC 23, OlympiadBench en Minerva Math.

• Zero-Hit Regime (DAPO-Hard): Op de subset van queries waar het basismodel een $pass@32 = 0$ bereikte (ongeveer 46% van de dataset voor het kleinere model), bood standaard GRPO verwaarloosbare verbetering vanwege gecompileerde voordelen. LatentRevise, wanneer gebruikt om SFT-data te genereren of geïnjecteerd in RL-groepen, presteerde significant beter dan de baselines.
  • Voor Qwen2.5-1.5B bereikte GRPO+Ours een gemiddelde $pass@32$ van 53,51%, vergeleken met 44,84% voor standaard GRPO en 50,69% voor GRPO met een verdubbelde rollout groep ($N=16$).
  • Opvallend genoeg presteerde de methode beter dan OPSD (On-Policy Self-Distillation), die vertrouwt op een docent geconditioneerd op het goude antwoord, wat suggereert dat de interne latente optimalisatie van LatentRevise effectiever is dan hindsight docent-conditionering in dit regime.
• Volledige Dataset (DAPO-Full): Wanneer toegepast op de volledige trainingsdistributie (mix van makkelijke en moeilijke prompts), bleef LatentRevise GRPO, DAPO en baselines met grotere rollouts overtreffen, met de meest significante winsten bij hogere $k$-waarden ($pass@32$).
• Efficiëntie: LatentRevise veroorzaakte een lagere computationele overhead dan simpelweg het vergroten van de rollout groep grootte ($N=16$). Het voegde ~24% trainingstijd en ~3% geheugen toe aan standaard GRPO ($N=8$), terwijl het verdubbelen van de groep grootte de tijd met ~66% en het geheugen met ~14% verhoogde.
• Kwalitatieve Analyse: De gereviseerde trajecten vertoonden een toename in lengte en expliciete zelfreflectie-markers (bijv. "Wacht, laat me even heroverwegen"), wat aangeeft dat de methode foutcorrectie-gedragingen naar boven brengt die discrete sampling zelden bereikt.

5. Betekenis en Claims

Het artikel beweert dat LatentRevise een complementair assenstelsel biedt voor reasoning RL. Wanneer token-level sampling zijn eindige budget-frontier bereikt, kan first-order revisie in de eigen latente ruimte van het model mislukte rollouts transformeren in geverifieerde supervisie.

De auteurs stellen dat:

• Zero-hit prompts waardevol zijn: Ze zijn niet louter ruis, maar vertegenwoordigen een hoogwaardige trainingsfrontier. Eenmaal gereviseerd, bieden ze signalen die de oplossing-dekking van het model uitbreiden.
• Interne recovery levensvatbaar is: Een model kan leren van zijn eigen fouten zonder een sterkere docent of externe referentietraces nodig te hebben, mits de optimalisatie wordt beperkt tot de vocabulaire-manifold.
• Efficiëntie: Het herstellen van signalen uit mislukte rollouts is computationeel efficiënter dan brute-force sampling expansie, vooral naarmate modelschalen en redeneerketens langer worden.

Het werk suggereert dat naarmate redeneertaken moeilijker worden, de grens van sampling-gebaseerde training niet alleen kan worden verlegd door meer te samplen, maar door te reviseren wat er al is gesampled, waardoor de "doodlopende wegen" van de huidige policy worden omgezet in een bron van curriculum en trainingssignaal.