Technische Samenvatting: Recursieve Zelf-trainingsinstorting in Code LLM's

1. Probleemstelling

Het artikel onderzoekt het risico op recursieve zelf-trainingsinstorting in Code Large Language Models (LLM's). Naarmate AI-coderingsinstrumenten (bijv. GitHub Copilot, Cursor) steeds meer code genereren die wordt samengevoegd in publieke repositories, kan de toekomstige trainingscorpus grotendeels uit door AI gegenereerde code bestaan. Als een model wordt gefinetuned op data die het zelf eerder heeft gegenereerd, en die data vervolgens wordt gebruikt om de volgende iteratie te trainen zonder externe kwaliteitscontrole, komt het systeem in een "zelf-consumptieve" lus terecht.

Het kernprobleem is dat zonder verse menselijke data of exogene kwaliteitsignalen, deze lus kan leiden tot modelinstorting (model collapse):

• Distributionele Drift: Het model leert de eigen eerdere outputs te imiteren in plaats van de oorspronkelijke datadistributie.
• Foutversterking: Bugs, incomplete logica en stilistische nauwzettingsheid in gegenereerde code worden gekopieerd en versterkt in opeenvolgende generaties.
• Verlies van Diversiteit: Het model convergeert naar outputs met een lage variantie en lage kwaliteit, waardoor het niet langer effectief programmeertaken kan oplossen.

Het artikel contrasteert specifiek drie regimes van recursieve training:

1. Geen Review (Ongestructureerd): Alle gegenereerde code wordt hergebruikt.
2. Human-Gate Review: Code wordt gefilterd door model-onafhankelijke signalen (bijv. compilatie, statische analyse, executietests).
3. AI-Self-Gate Review: De code LLM evalueert en filtert zijn eigen outputs met behulp van interne signalen (bijv. perplexiteit, binaire zelf-scoring).

2. Methodologie

Theoretisch Kader

De auteurs formaliseren recursieve training als gegateerde distributionele herweging.

• Ongestructureerde Recursie: De trainingsdistributie bij iteratie $t$ is simpelweg de outputdistributie van het model $p_{\theta_t}(c|x)$. Het volgende model minimaliseert de KL-divergentie ten opzichte van deze distributie, wat enkel zelf-consistentie afdwingt.
• Gated Recursie: Een sample wordt geaccepteerd met waarschijnlijkheid $r(x, c)$. De trainingsdistributie wordt $q_{\theta_t}(c|x) \propto p_{\theta_t}(c|x)r(x, c)$.
• Theoretische Analyse:
  • Spectrale Concentratie: De auteurs bewijzen (Propositie 2.1) dat recursieve hertraining dominante representatierichtingen versterkt terwijl andere worden onderdrukt, wat leidt tot een instorting in de covariantie-matrix van de representatieruimte (verminderde rang/diversiteit).
  • Degeneratie van AI Self-Gating: Het artikel bewijst (Theorem 2.3) dat als een AI-reviewer gekoppeld is aan de generator (het deelt parameters of distributie), en de reviewer "zelf-bevestigend" wordt (hoge scores toekent aan de waarschijnlijke outputs van de generator ongeacht de kwaliteit), het gating-mechanisme wiskundig degradeert naar ongestructureerde zelf-training. In dit "rubber-stamp" regime verliest de filter het vermogen om gedegradeerde outputs af te wijzen.
  • Stabiliteitsconditie: AI-gegateerde training vermijdt instorting alleen als de AI-reviewer gekalibreerd blijft ten opzichte van een exogene menselijke standaard (Theorem - 2.6).

Experimentele Opzet

• Modellen: Vier code LLM-families werden getest: SantaCoder (1.1B), StarCoder2-3B, Qwen2.5-Coder-1.5B, en Code Llama-7B.
• Benchmarks: HumanEval, MBPP, LiveCodeBench, en hun uitgebreide versies (HumanEval+, MBPP+).
• Protocol: Recursieve fine-tuning over 5 rondes. In elke ronde genereert het model code, selecteert een filteringstrategie 5.000 samples, en wordt het model op deze set gefinetuned voor 3.000 stappen.
• Filteringstrategieën:
  • Vanilla: Geen filter.
  • Human Gates: Compile (syntaxcheck), Quality (statische metrieken zoals herhaling/lengte), Compile+Quality.
  • AI Self-Gates: Perplexity (laagste 25% door model-waarschijnlijkheid), Binary Classifier (hoogste 25% door logit-verschil score).

3. Belangrijkste Resultaten

Universele Degradatie

Over alle modelfamilies en filteringstrategieën heen leidt recursieve zelf-training tot prestatiedegradatie vergeleken met de pre-training baseline.

• Geen Review: Instort het snelst en het meest ernstig. Bijvoorbeeld, Qwen2.5-Coder daalde van een HumanEval+ baseline van 0.372 naar 0.043 (−88.4%) in Ronde 5.
• Human Gates: Vertragen het tempo van de instorting maar stoppen het niet. Hoewel Compile en Quality filters de uitvoerbare validiteit behouden en semantische drift vertragen, kunnen ze langdurige degradatie niet voorkomen.
• AI Self-Gates: Vertonen een "rubber-stamp" faalmodus. Aanvankelijk selecteren ze mogelijk hoogpresterende samples (bijv. de Binary Classifier behaalde de hoogste Ronde 5 HumanEval+ voor drie modellen), maar hun effectiviteit van filtering degradeert in de loop van de tijd.
  • Divergentie van Metrieken: Een cruciale bevinding is de divergentie tussen het interne signaal van de filter en de werkelijke correctheid. Voor de Binary Classifier stegen de acceptatiescores (het vertrouwen van het model in zijn eigen code) terwijl de benchmark-correctheid daalde. Dit bevestigt de theoretische voorspelling dat de self-gate zelf-bevestigend wordt.

Cross-Model Consistentie

Het fenomeen van de instorting is niet specifiek voor één architectuur.

• LiveCodeBench: Alle modellen naderden bijna nul pass@1 op deze out-of-distribution benchmark tegen Ronde 5 onder vanilla training, wat aangeeft dat recursieve zelf-training de complexe redeneercapaciteiten onevenredig veel degradeert.
• Omvang van de Instorting: Modellen met sterkere initiële distributies (bijv. Qwen2.5-Coder) vertoonden scherpere distributionele verschuivingen wanneer zij besmet werden met zelf-gegenereerde outputs, hoewel alle modellen uiteindelijk convergeren naar een laag-presterende "instortings-attractor".

Filter Pass Rates

• Human Gates: Behielden stabiele pass rates (bijv. Compile bleef hoog omdat het steunt op externe executie).
• AI Self-Gates: Toonden toenemende pass rates over de rondes (bijv. de Perplexity pass rate steeg van ~0.17 naar ~0.24), wat duidt op een verlies van onderscheidend vermogen naarmate de interne scoringsdistributie van het model meedrijft met de gedegradeerde generatie-distributie.

4. Bijdragen

1. Empirische Studie van Code LLM-instorting: Bood een systematische evaluatie van recursieve zelf-training over vijf filteringregimes en vier verschillende code LLM-families, waarmee werd aangetoond dat instorting een cross-model fenomeen is.
2. Formulering van Review als Gated Reweighting: Formuleerde code review theoretisch als een sampling reweighting mechanisme, wat verklaart waarom exogene gates de instorting vertragen terwijl endogene gates falen.
3. Identificatie van Exogeniteit als Sleutelfactor: Stelde vast dat het cruciale verschil tussen succesvolle en falende recursieve training is of de acceptatieregel exogeen (vast, model-onafhankelijk) of endogeen (gekoppeld aan de generator) is.
4. Theoretisch Bewijs van Degeneratie: Bewees dat AI self-gating degradeert naar ongestructureerde zelf-training onder zelf-bevestigende condities en leverde een spectrale analyse die laat zien hoe recursieve hertraining de representatie-variantie concentreert in een laag-dimensionale subspace.

5. Betekenis en Claims

Het artikel betoogt dat stabiele recursieve code LLM-training exogene verificatie vereist in plaats van model-gekoppelde zelf-review.

• Beperking van AI Review: De studie suggereert dat het vertrouwen op AI-systemen om hun eigen code te beoordelen voor toekomstige training inherent onstabiel is. Naarmate de generator degradeert, drijft de criteria van de zelf-reviewer mee, waardoor gedegradeerde outputs uiteindelijk als hoogwaardig worden geaccepteerd (het "rubber-stamp" regime).
• Rol van Human Gates: Hoewel Human gates (compilatie, statische analyse) robuuster zijn en de uitvoerbare validiteit behouden, zijn ze onvoldoende om langdurige semantische drift volledig te stoppen. Ze fungeren als een rem, niet als een genezing.
• Implicatie voor Toekomstige Systemen: De bevindingen waarschuwen tegen de "zelf-consumptieve" lus waarbij door AI gegenereerde code in repositories terechtkomt en onmiddellijk wordt gebruikt om de volgende generatie modellen te trainen zonder verse menselijke data of sterke externe signalen. Het artikel concludeert dat om instorting te voorkomen, het verificatiesignaal buiten de eigen voorkeursdistributie van het model moet blijven.

De auteurs blijven bescheiden en merken op dat hun experimenten zich richtten op Python en modellen tot 7B parameters, en dat langere horizonten, grotere modellen en sterkere executie-gebaseerde gates openstaande gebieden blijven voor toekomstig onderzoek.