Technische Samenvatting: De Verifieerder is het Curriculum

Probleemstelling

Post-training code-generatoren die gebruikmaken van geleerde judges (bijv. LLM's of multimodale modellen die outputs scoren via prompts) introduceren een structurele kwetsbaarheid: deze judges vertrouwen vaak op oppervlakkige kenmerken die gemanipuleerd kunnen worden zonder de onderliggende artefact te verbeteren. Dit leidt tot "reward hacking", waarbij modellen optimaliseren voor de blinde vlekken van de judge in plaats van voor functionele correctheid. In de context van game-generatie zou een geleerde judge bijvoorbeeld visuele assets kunnen belonen, zelfs als de game-code defect of bevroren is.

Het paper adresseert de vraag wat er gebeurt wanneer het trainingssignaal in plaats daarvan een deterministische, judge-vrije en niet-te manipuleren filter is. Specifiek wordt onderzocht of een strikte executiecheck — het verifiëren of een gegenereerd project foutloos opstart onder een headless engine — effectieve zelf-distillatie en cross-family generalisatie kan aansturen.

Methodologie

De studie maakt gebruik van GameCraft-Bench, een benchmark die modellen vereist om volledige, uitvoerbare Godot 4-projecten te genereren op basis van natuurlijke taal briefings. De taak is inherent moeilijk omdat correctheid conjunctief is; één parse-fout, een ontbrekende resource of een runtime crash maakt het gehele project niet-functioneel.

De Verificatie Ladder

De auteurs definiëren een hiërarchie van verificatiesignalen (Figuur 1):

1. BUILD (Licht): Controleert of het project opent en afsluit zonder directe parse-fouten. Dit is "bijna triviaal" aangezien het veel defecte projecten accepteert (99,9% pass rate).
2. Strict-Launch (Training Gate): Een deterministische check die vereist dat het project schoon opstart onder een headless engine (exit code 0, geen parse/load/runtime errors). Dit is niet te manipuleren en precies.
3. Execution Grounding (Dynamische Audit): Een secundair signaal dat de SceneTree aanstuurt en de runtime-toestand veranderingen meet om functionele substantie te bevestigen.
4. Visual Judge (Te manipuleren): De officiële metriek van de benchmark, die wordt aangetoond manipuleerbaar te zijn (bijv. door assets te wisselen terwijl de code bevroren blijft).

Iteratieve Zelf-Distillatie

De kernmethode is rejection-sampling zelf-distillatie gefilterd door de strict-launch gate:

1. Initialisatie: Start met een supervised model ($M_0$) getraind op 111 gouden projecten uit 10 game-families.
2. Generatie: Genereer voor elke training-familie briefing $K=8$ kandidaat-projecten.
3. Filtering: Materialiseer kandidaten en voer de strict-launch check uit. Alleen kandidaten die schoon opstarten (en $\ge$3 bestanden hebben) worden behouden.
4. Brandstofcreatie: De behouden kandidaten vormen de "brandstof" ($F_t$) voor de volgende ronde.
5. Retraining: Een nieuwe LoRA-adapter wordt getraind op het basismodel met de unie van de originele gouden pool en de nieuwe brandstof ($D_{t+1} = D_t \cup F_t$).
6. Iteratie: Dit proces herhaalt zich voor drie rondes ($RFT-r1, r2, r3$).

Controles

Om de oorzaak van de prestatiewinst te isoleren, gebruiken de auteurs drie gematchte controles:

• Gold-Duplicatie (CTRL): Voegt exacte duplicaten van gouden trainingsprojecten toe in plaats van zelf-gegenereerde brandstof.
• Count-Matched: Vervangt de generator (gebruikt $M_1$ in plaats van $M_0$) om het effect van brandstofkwaliteit versus kwantiteit te isoleren.
• BUILD-Gated: Vervangt de strict-launch filter door de lichte BUILD check, terwijl de generator en het budget identiek blijven.

Belangrijkste Resultaten

De studie richt zich op cross-family generalisatie, waarbij de prestaties worden geëvalueerd op vier ongeziene game-families (horror, rhythm, puzzle, shooter) bestaande uit 25 gehouden-teruggevallen taken.

• Cumulatieve Winsten: Onder de strict-launch gate cumuleert zelf-distillatie de prestaties aanzienlijk:

  • Per-kandidaat clean-launch rate: Stijgt van 8,8% (SFT) naar 13,6% (r1), 30,9% (r2) en 42,2% (r3).
  • Best-of-K Dekking: Stijgt van 18/25 (SFT) naar 25/25 (r3), waarmee het "gouden plafond" wordt bereikt waar elke gehouden-teruggevallen taak ten minste één schone kandidaat heeft.
  • Alle verbeteringen zijn statistisch significant ($p < 10^{-4}$ voor latere rondes).

• Attributie van Winsten:

  • Geen Dataduplicatie: De Gold-Duplicatie controle (CTRL) leidde zelfs tot een regressie in prestaties naar 5,6%, wat bewijst dat louter datavolume of herhaling onvoldoend is en zelfs schadelijk kan zijn.
  • Filterprecisie is Causaal: De BUILD-gated controle (met de lichte filter) wist alle winsten uit, waardoor de prestaties terugkeerden naar de baseline (8,6%). Dit isoleert verificatieprecisie als de causale factor, niet de optimizer of het datavolume.
  • Kwaliteit vs. Kwantiteit: De decompositie van de sprong van ronde 1 naar 2 onthult zowel een kwaliteitskanaal (+8,8 procentpunt) als een kwantiteitskanaal (+8,5 procentpunt), waarbij kwaliteit de dominante drijfveer is.

• Functionele Geldigheid:

  • Statische Audit: Schone projecten uit latere rondes zijn rijker (mediaan 473 regels GDScript versus 331 voor SFT) en bevatten meer bestanden.
  • Dynamische Gronding: Een onafhankelijk execution-grounding signaal bevestigt dat de winsten functioneel zijn. Het aantal taken met "gegronde" (functioneel actieve) kandidaten stijgt monotoon (10 $\to$ 15/25), en zelf-distillatie produceert veel meer gegronde kandidaten dan gouden duplicatie (16 vs. 5 bij een gematcht budget).

Betekenis en Claims

De centrale stelling van het paper is dat "De verifieerder het curriculum is."

1. Deterministische Filters Maken Cumulatie Mogelijk: In tegen tegenover geleerde judges, die gemanipuleerd kunnen worden en leiden tot oppervlakkige optimalisatie, definieert een deterministische, niet-te manipuleren executiecheck een trainingsdistributie die het model dwingt tot functionele correctheid.
2. Precisie Drijft Transfer Aan: Het vermogen van zelf-distillatie om capaciteiten over ongeziene families heen te cumuleren, is direct gekoppeld aan de precisie van de acceptatiefilter. Een filter met een hoog aantal vals-positieven (zoals BUILD) zorgt ervoor dat de loop defecte projecten cumuleert, terwijl een precieze filter werkende projecten cumuleert.
3. Functionele Substantie: De verbeteringen zijn niet "stub-geïnflateerd" (projecten die wel opstarten maar niets doen); ze vertegenwoordigen een echte toename in functionele complexiteit en runtime-gedrag.

De auteurs concluderen dat in zelf-verbeteringsloops het plafond van capaciteit wordt bepaald door de integriteit van de verifieerder, niet enkel door datavolume. Hoewel deze studie specifiek is voor game-generatie als een verifieerbare testomgeving, suggereert het principe dat voor elk domein waar een deterministische, niet-te manipuleren check bestaat, iteratieve zelf-distillatie een robuuste, cross-domein generalisatie kan aansturen.