Why Code, Why Now: Learnability, Computability, and the Real Limits of Machine Learning

Dit paper stelt dat de voorspelbare schaalbaarheid van codegeneratie ten opzichte van versterkingslering wordt veroorzaakt door de specifieke informatie-structuur van code, en introduceert een hiërarchie van leerbaarheid die suggereert dat de toekomstige grenzen van machine learning meer afhangen van de aard van de taak dan van modelgrootte.

De kern

Waarom Code, Waarom Nu: De Verborgen Grenzen van Kunstmatige Intelligentie

Stel je voor dat je probeert een kind te leren hoe je een auto moet bouwen. Je hebt twee methoden:

1. De 'Code'-methode: Je geeft het kind elke dag een stap-voor-stap handleiding. Als het kind een boutje verkeerd zet, hoor je direct een klik en zie je dat het niet past. De fout is lokaal, duidelijk en onmiddellijk. Het kind leert snel omdat elke fout een directe les is.
2. De 'Reinforcement Learning' (RL)-methode: Je laat het kind proberen de auto te bouwen zonder handleiding. Als de auto na uren bouwen niet rijdt, krijg je een simpele melding: "Fout". Maar je krijgt niet te horen waar de fout zit. Was het de motor? De wielen? Of zat er een boutje verkeerd in de achterbumper? Het kind moet maar gissen.

Dit is de kern van het artikel van Zhimin Zhao. Hij legt uit waarom AI (kunstmatige intelligentie) zo goed is in het schrijven van computercode, maar zo worstelt met andere taken, zoals het spelen van complexe spelletjes of het nemen van autonome beslissingen. Het heeft niets te maken met hoe "slim" of groot de computer is, maar met hoe de informatie in de wereld is verpakt.

Hier is de uitleg in eenvoudige taal, met wat creatieve metaforen.

1. Het Grote Misverstand: "Meer Rekenkracht Lost Alles Op"

Veel mensen denken: "Als we maar genoeg geld in supercomputers steken en de modellen groter maken, kunnen ze uiteindelijk alles doen."
Zhao zegt: Nee.

Het is alsof je denkt dat je met een nog grotere verrekijker de maan kunt bereiken. De verrekijker (het model) maakt het beeld scherper, maar als de weg naar de maan er niet is (het probleem is niet "leerbaar"), helpt de verrekijker niet.

2. Waarom Code een "Gouden Kooi" is

Computercode is speciaal. Het heeft drie eigenschappen die het leren voor een AI enorm makkelijk maken:

• Harde regels (De "Stop-licht" regel): In code is er geen "misschien". Als je een puntkomma mist, werkt het programma niet. Het is als een slot dat alleen opengaat als je de sleutel precies goed draait. Er is geen grijs gebied.
• Lokale fouten (De "Wiebelende Steen"): Als je een muur bouwt en een steen is scheef, zie je dat direct bij die ene steen. Je hoeft niet de hele muur af te breken om te weten wat er mis is. In code wijst een compiler (de controleur) precies aan: "Hier, regel 42, staat een fout."
• Opbouwbaarheid (De "LEGO" regel): Een stukje code dat werkt, werkt altijd. Een functie die getallen optelt, doet dat altijd, of je het nu in een spelletje of in een bankrekening gebruikt.

Omdat elke regel code direct vertelt wat goed en fout is, kan een AI (via Supervised Learning) razendsnel leren door naar miljoenen voorbeelden te kijken. Het is als een kind dat elke dag een puzzelstukje krijgt met de tekst "Dit hoort hier" erop.

3. Het Reinforcement Learning-probleem: Het Spel van het Gokken

Bij Reinforcement Learning (RL) probeert de AI iets te leren door te proberen en te fouten, vaak zonder duidelijke feedback.
Stel je voor dat je een blindeman bent die een doolhof moet doorlopen.

• Bij Code krijg je een kaart en een kompas. Als je een muur raakt, hoor je een piep.
• Bij RL loop je blind. Pas als je de uitgang bereikt (of als je doodgaat), krijg je een puntje. Maar als je 1000 keer doodgaat, weet je niet of het was omdat je linksaf ging, rechtsaf, of omdat je te hard liep.

Dit is het probleem: de feedback is te vaag. De AI moet gissen. En als de omgeving verandert (bijvoorbeeld als de regels van het spel veranderen omdat de AI beter wordt), raakt de AI in de war. Dit noemen de auteurs een "Level 1" probleem: de wereld beweegt mee met de leerling, waardoor het onmogelijk wordt om een vaste regel te vinden.

4. De Vijf Trappen van Leren (De Helling van de Waarde)

De auteur bedacht een ladder met vijf niveaus om te zien of iets überhaupt te leren is:

• Niveau 0 (Het Zwarte Gat): Je ziet niets. Het is alsof je probeert te raden wat er in een gesloten doos zit, maar de doos is volledig ondoorzichtig en verandert elke seconde. Voorbeeld: Het Halting-probleem (kun je ooit weten of een programma oneindig blijft draaien? Nee, dat is wiskundig onmogelijk te leren).
• Niveau 1 (De Vliegende Schijf): Je ziet iets, maar het doel beweegt weg als je er naar grijpt. Voorbeeld: Spellen tegen een slimme tegenstander of algoritmen die gemanipuleerd worden door mensen die weten hoe ze te "spelen".
• Niveau 2 (De Ruis): Je ziet het doel, maar er is veel ruis. Je moet veel proberen om het patroon te zien. Voorbeeld: Het herkennen van een hond op een foto. Soms lijkt het op een wolf, soms op een kat. Maar met genoeg foto's lukt het wel.
• Niveau 3 (De Eenzijdige Weg): Je krijgt alleen te horen wat niet werkt, maar nooit wat wel werkt. Je kunt fouten uitsluiten, maar je weet nooit zeker dat je de juiste oplossing hebt gevonden. Voorbeeld: Het leren van een taal alleen door naar zinnen te luisteren die correct zijn, zonder ooit te horen wat er fout is.
• Niveau 4 (De Perfecte Check): Elke stap is direct en onmiddellijk te controleren. Voorbeeld: Computercode compileren. Het werkt of het werkt niet. Geen twijfel, geen ruis.

De conclusie: Code-generatie werkt zo goed omdat het een Niveau 4 probleem is, maar dan verpakt in een Niveau 3 leerproces. De AI leert van voorbeelden (Niveau 3), maar elke fout die het maakt, wordt direct en hard gecorrigeerd door de computer (Niveau 4).

5. Waarom "Meer Rekenkracht" Niet Altijd Helpt

Als je een probleem hebt dat op Niveau 0 of Niveau 1 zit (zoals het voorspellen van de beurs of het volledig begrijpen van menselijke emoties zonder context), dan helpt het niet om je computer groter te maken.

• Het is alsof je een grotere emmer gebruikt om water uit een put te halen die droog is.
• Als de informatie-structuur van het probleem "slecht" is (te veel ruis, te veel beweging), dan zal een groter model alleen maar sneller leren hoe het de fouten moet herhalen, of het zal vastlopen in een cirkel.

6. Wat moeten we nu doen?

In plaats van blindelings grotere modellen te bouwen, moeten we kijken naar de structuur van het probleem:

1. Breek het op: Maak een groot, onmogelijk probleem op in kleine, beheersbare stukjes die wel te leren zijn. (Zoals code: in plaats van "schrijf een heel bedrijfssysteem", leer de AI eerst "schrijf deze ene functie").
2. Maak de feedback duidelijker: Zorg dat de AI niet alleen weet "fout", maar ook "waar" en "waarom".
3. Zoek de juiste vertaling: Soms moet je een probleem vertalen naar iets anders dat wel te leren is. Bijvoorbeeld: in plaats van "schrijf een gedicht" (wat vaag is), train de AI op "voorspel het volgende woord" (wat heel concreet is).

Samenvattend

De boodschap van dit artikel is hoopvol maar nuchter:
AI is niet magisch. Het is een gereedschap dat werkt als de wereld rondom het gereedschap gestructureerd is. Code is perfect gestructureerd, daarom is AI daar zo goed in. Andere dingen zijn chaotisch, en daar zal AI altijd moeite mee hebben, ongeacht hoe groot de computer is.

De toekomst van AI ligt niet in het bouwen van "goddelijke" modellen, maar in het slimme ontwerpen van problemen die voor deze modellen leerbaar zijn. We moeten stoppen met vragen: "Is dit model sterk genoeg?" en beginnen met vragen: "Is dit probleem überhaupt te leren?"

Technische samenvatting

Titel: Waarom Code, Waarom Nu: Leerbaarheid, Berekenbaarheid en de Echte Grenzen van Machine Learning

1. Het Probleem

Er bestaat een opvallende discrepantie in de prestaties van Machine Learning (ML) tussen verschillende domeinen:

• Codegeneratie: ML-modellen maken hierin aanzienlijke en voorspelbare vooruitgang, waarbij ze complexe programma's schrijven, bestaande codebases refactoren en algoritmische problemen oplossen.
• Versterkende Leer (Reinforcement Learning - RL): Ondanks dat RL interactief, gesloten-lus en adaptief is, faalt het vaak onder distributieveranderingen en slaagt het er niet in om algemene competentie op te bouwen, zelfs niet met enorme interactiebudgetten.

De gebruikelijke verklaringen voor dit verschil (zoals "RL heeft meer rekenkracht nodig" of "het beloningssignaal is te schaars") worden door de auteur verworpen. Deze factoren verklaren niet waarom het patroon zich over schaalordes heen voordoet. De kern van het probleem ligt niet in de architectuur van het model of de hoeveelheid data, maar in de informatiestructuur van de taken zelf. De huidige aanname dat schaling (meer data, grotere modellen) alle ML-uitdagingen zal oplossen, wordt betwist.

2. Methodologie en Theoretisch Kader

De auteur analyseert taken op basis van hun informatiestructuur: de manier waarop de wereld onderscheidende informatie blootlegt aan een leerder. Hiervoor wordt een formeel kader ontwikkeld dat drie fundamentele eigenschappen van computationele problemen onderscheidt:

1. Expressibility (Uitdrukkingskracht): Kan een correcte classifier bestaan binnen een bepaalde functieklasse?
2. Computability (Berekenbaarheid): Bestaat er een halterend algoritme (Turing-machine) dat het probleem oplost?
3. Learnability (Leerbaarheid): Kan een algoritme het probleem leren onder realistische data- en interactievoorwaarden met een gladde convergentie?

De paper introduceert een vijfniveau hiërarchie van leerbaarheid, gebaseerd op de kwaliteit van het feedbacksignaal dat de leerder ontvangt. Deze hiërarchie loopt van volledig onwaarneembaar tot deterministisch verifieerbaar.

De Vijf Niveaus van Leerbaarheid:

• Niveau 0 (Geen Feedback): Informatietheoretische ononderscheidbaarheid. Verschillende hypotheses produceren identieke observaties (bijv. het halting-probleem, volledig "Goodharted" metrics). Schaling helpt hier niet.
• Niveau 1 (Adversariële Feedback): Er bestaat onderscheidende informatie, maar de omgeving is reflexief of vijandig. De doelstelling verschuift als de leerder leert (bijv. het gemanipuleerd worden van ranking-algoritmes). Convergentie is onstabiel.
• Niveau 2 (Ruige/Noisy Feedback): Hypotheses zijn statistisch onderscheidbaar, maar observaties zijn ruisig. Dit komt overeen met PAC-learnability (Probably Approximately Correct). Schaling werkt, maar vereist veel data.
• Niveau 3 (Indirecte Feedback): Eenzijdig bewijs. Foutieve hypotheses worden uiteindelijk weerlegd, maar correctie wordt nooit direct bevestigd. Dit komt overeen met generatie in de limiet (generation in the limit). Correctheid kan nooit definitief worden vastgesteld, maar de leerder convergeert monotoon.
• Niveau 4 (Directe Feedback): Elke output kan direct en deterministisch worden geverifieerd (bijv. type-checking, compilatie, formele bewijsvoering). Dit is het niveau waarop codegeneratie succesvol is.

3. Belangrijkste Bijdragen

1. Hiërarchie van Leerbaarheid: Een nieuw raamwerk dat taken classificeert op basis van feedbackkwaliteit. Het stelt dat de "plafond" van ML-progressie afhangt van het niveau van de taak, niet van de modelgrootte.
2. Formele Distinctie en Relaties: De auteur stelt de formele relaties vast tussen expressibility, computability en learnability.
   • Expressibility impliceert niet Computability.
   • Computability impliceert niet Learnability (bijv. cryptografische functies zijn berekenbaar maar niet efficiënt leerbaar).
   • Learnability impliceert Computability van de evaluatie van hypotheses.
   • Er wordt een unificerend template gepresenteerd dat deze eigenschappen beschrijft via kwantificatie-diepte (de hoeveelheid "voor alle" en "er bestaat" in de definitie).
3. Analyse van Code vs. RL: Een verklaring waarom supervised learning op code schaalt terwijl RL faalt. Code biedt dichte, lokale en verifieerbare feedback op elk token (Niveau 4), terwijl RL vaak werkt met schaarse, globale beloningen (vaak Niveau 1 of 2) die geen causale koppeling hebben met specifieke acties (credit assignment probleem).

4. Resultaten en Analyse

• Code als Speciale Geval: Code is uniek omdat het drie eigenschappen combineert:

  1. Harde syntactische beperkingen: Een enkele fout maakt het programma ongeldig (binair, deterministisch).
  2. Lokaal identificeerbare fouten: Typefouten of scope-fouten kunnen lokaal worden gelokaliseerd, wat dichte feedback geeft.
  3. Sterke compositie: Betekenis is lokaal en herbruikbaar.
     Dit zorgt ervoor dat codegeneratie een Niveau 3-probleem is (leren van positieve voorbeelden) dat wordt gescaffold door Niveau 4-verificatie (compilers/testen). Dit maakt het leerbaar.

• De Valkuil van Expressibility: Een grotere expressiviteit (zoals in diepe neurale netwerken) betekent niet automatisch betere leerbaarheid. Integendeel, een te rijke hypothese-ruimte (oneindige VC-dimensie) kan leiden tot het onvermogen om te leren, tenzij de data een specifieke, gestructureerde submanifold bezet.

  • Conclusie: Uncomputability impliceert niet per se onleerbaarheid voor een computatief beperkte waarnemer op een gestructureerde manifold (bijv. menselijke code), maar het theoretische worst-case scenario blijft onoplosbaar.

• Waarom RL Faalt: RL-strategieën lijden onder:

  • Informatie-misalignement: Beloningen zijn vaak vertraagd en niet gekoppeld aan specifieke acties.
  • Niet-stationariteit: De verdeling van de data verandert naarmate het beleid (policy) verandert.
  • Reflexieve beloningssamenval: Het doel verschuift doordat de leerder het nastreeft (Goodhart's law), wat de feedback onbruikbaar maakt.

5. Betekenis en Implicaties

De paper biedt een fundamentele verschuiving in hoe we AI-progressie moeten bekijken:

• Van "Is het model krachtig genoeg?" naar "Is de taak leerbaar?": De beperking ligt vaak in de structuur van het probleem, niet in de rekenkracht. Schalen van modellen op onleerbare taken (zoals Niveau 0 of 1) leidt tot overfitting en instabiliteit, niet tot doorbraken.
• Strategieën voor de Toekomst: Om vooruitgang te boeken, moeten onderzoekers:
  1. Taken decomponeren in sub-taken met stabiele feedback.
  2. Feedbackstructuren engineeringen (intermediate states, diagnostische fouten).
  3. Zwakkere, lokaal verifieerbare doelen stellen in plaats van globale optimalisatie.
  4. Problemen herschrijven (re-encoding) naar proxies die statistisch optimaliseerbaar zijn (zoals next-token prediction in plaats van logisch bewijzen).

Conclusie: Codegeneratie is succesvol omdat de structuur van code toevallig perfect aansluit bij wat gradient descent en patroonherkenning kunnen exploiteren (dichte, lokale, verifieerbare signalen). De toekomst van AI ligt niet in het bouwen van grotere modellen voor onleerbare taken, maar in het identificeren van welke problemen een leerbare structuur hebben en hoe we complexe taken kunnen transformeren naar die leerbare vormen.