ARC-TGI: Human-Validated Task Generators with Reasoning Chain Templates for ARC-AGI

Dit paper introduceert ARC-TGI, een open-source framework voor door mensen gevalideerde generatoren die diverse ARC-AGI-taken met consistente redeneringsketens produceren om overfitting te voorkomen en schaalbare, gecontroleerde benchmarking mogelijk te maken.

De kern

Stel je voor dat je een meesterkok bent die probeert een nieuw gerecht te leren. De huidige manier om AI's te testen is alsof je ze één keer een recept geeft (een puzzel) en vraagt of ze het kunnen nabakken. Het probleem? Als je ze dat recept honderd keer geeft, leren ze het niet echt, maar onthouden ze het gewoon. Ze "pappen" het uit. Als je ze dan een heel ander recept geeft, zakken ze door de vloer.

Deze paper introduceert ARC-TGI, en dat is als het bouwen van een recepten-generator in plaats van een statisch receptenboek.

Hier is hoe het werkt, vertaald naar alledaags taal:

1. Het Probleem: De "Pauzeer-knop" van de AI

Huidige AI-tests (zoals ARC-AGI) zijn als een doos met vaste legpuzzels. Als een AI deze puzzels te vaak ziet, leert hij niet hoe hij moet redeneren, maar onthoudt hij gewoon de oplossing. Het is alsof je een kind leert wiskunde door alleen maar één som te laten zien: "2 + 2 = 4". Als je dan vraagt "3 + 3", kan het kind niet meer.

2. De Oplossing: ARC-TGI (De "Recepten-generator")

De auteurs hebben een systeem gemaakt dat niet één puzzel maakt, maar een generator die oneindig veel variaties van dezelfde puzzel kan maken.

• De Metafoor: Stel je voor dat je een AI leert hoe je een taart maakt.
  • Oude manier: Je geeft de AI één foto van een aardbeienaardbeietaart.
  • ARC-TGI manier: Je geeft de AI een recept (een Python-programma) dat zegt: "Neem een bodem, voeg fruit toe, bak het."
  • Nu kan de generator elke keer een andere taart maken: een appel-taart, een blauwe bessen-taart, een taart in een vierkante vorm of een ronde vorm.
  • De kern: De regel (bakken) blijft hetzelfde, maar de details (kleur, grootte, vorm) veranderen.

3. Hoe werkt het precies? (De drie stappen)

Elke generator in dit systeem doet drie dingen, net als een goede leraar:

1. Het Maken van de Ingrediënten (Input): De generator kiest willekeurig welke kleuren, vormen of groottes er in de puzzel zitten. Dit zorgt voor variatie.
2. Het Toepassen van de Regel (Transformatie): Dit is de "magie". De AI moet de regel ontdekken. Bijvoorbeeld: "Draai alles 90 graden" of "Verander alle rode blokken in blauwe". De generator past deze regel strikt toe.
3. Het Controleren van de Les (Constraints): Dit is het slimste deel. De generator zorgt ervoor dat de voorbeelden die de AI krijgt, voldoende informatie bevatten om de regel te raden.
   • Voorbeeld: Als de regel is "verander rode blokken in blauwe", maar de AI krijgt alleen voorbeelden met groene blokken, dan kan hij de regel niet leren. ARC-TGI zorgt ervoor dat er altijd genoeg variatie is in de voorbeelden, zodat de AI de regel echt moet begrijpen en niet kan gissen.

4. De "Vertaler" (Redeneerketens)

Wat dit systeem uniek maakt, is dat het niet alleen de puzzel maakt, maar ook uitleg schrijft.

• Het systeem schrijft in mensentaal: "Kijk, hier is een rood blokje. De regel zegt dat rood blauw wordt. Dus hier wordt het blauw."
• Dit helpt de AI (en de mensen die de AI testen) om te zien waarom een oplossing klopt. Het is alsof de leraar niet alleen het antwoord geeft, maar ook uitlegt hoe hij erbij kwam.

5. Wat hebben ze gevonden? (De Testresultaten)

De auteurs hebben dit systeem gebruikt om 461 verschillende "recepten" (generatoren) te maken en ze getest op verschillende AI-modellen.

• De uitkomst: De meeste AI's doen het nog steeds niet geweldig. Ze kunnen de regels vaak niet snappen als de kleuren of vormen veranderen.
• De les: Als je een AI traint op deze variabele puzzels, wordt hij beter in het begrijpen van regels, maar hij is nog steeds niet perfect. Het laat zien dat AI's vaak nog steeds "kletsen" (patronen herkennen) in plaats van echt te "denken" (abstracte regels toepassen).

Samenvattend

ARC-TGI is als het vervangen van een statisch examenboek door een slimme, oneindige oefenmachine.

• In plaats van 100 vaste vragen, krijg je 100 variaties van 100 soorten vragen.
• Het zorgt ervoor dat de vragen niet te makkelijk zijn (geen "trucs") en dat er altijd genoeg voorbeelden zijn om de regel te leren.
• Het helpt ons te zien of AI's echt slim zijn, of dat ze gewoon het antwoordboekje hebben gelezen.

Het is een stap in de richting van AI's die niet alleen dingen kunnen onthouden, maar echt kunnen leren en aanpassen aan nieuwe situaties, net zoals een mens dat doet.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "ARC-TGI: Human-Validated Task Generators with Reasoning Chain Templates for ARC-AGI" in het Nederlands.

Probleemstelling

De Abstraction and Reasoning Corpus (ARC-AGI) is ontworpen om het vermogen van AI-systemen te testen om nieuwe vaardigheden uit weinig voorbeelden af te leiden (few-shot learning) en regels te induceren op kleine visuele roosters. Een groot probleem bij het evalueren van voortgang op dit gebied is dat de huidige benchmarks statisch zijn en bestaan uit handgeschreven puzzels. Dit leidt tot drie kritieke uitdagingen:

1. Overfitting en dataset-lek: Modellen kunnen specifieke puzzels memoriseren in plaats van de onderliggende regels te leren.
2. Moeilijkheid om generalisatie te onderscheiden van memorisatie: Het is lastig te bepalen of een model echt abstracte redenering toepast of alleen bekende patronen herkent.
3. Gebrek aan gecontroleerde studies: Het is moeilijk om één variabele (zoals roostergrootte of kleuren) te variëren terwijl de onderliggende regel constant blijft, wat nodig is voor robuustheidstests.

Bestaande oplossingen zoals data-augmentatie of LLM-gegenereerde datasets missen vaak de garantie dat de verzameling trainingsvoorbeelden de bedoelde regel eenduidig maakt, of ze leveren geen stap-voor-stap redenering die gekoppeld is aan de gegenereerde instanties.

Methodologie: ARC-TGI Framework

Het paper introduceert ARC-TGI (ARC Task Generators Inventory), een open-source framework voor het maken van "task-family generators". In plaats van statische puzzels, definieert ARC-TGI elke taak als een distributie van taken die dezelfde latente regel delen, maar variëren in "nuisance details" (zoals kleuren, objectpositie, roostergrootte).

Het framework bestaat uit de volgende kerncomponenten:

1. Generator Interface (Python-modules):
   Elke generator is een compact Python-module dat drie fasen doorloopt:

   • create_input: Sample invoerroosters door nuisance-factoren te randomiseren.
   • transform_input: Past de deterministische, latente regel toe om de uitvoer te genereren.
   • create_grids: Bouwt het volledige episode op (train/test-paren). Dit is de cruciale stap waar taakniveau-beperkingen worden afgedwongen.

2. Taakniveau-beperkingen (Episode Constraints):
   Een uniek kenmerk van ARC-TGI is dat het garandeert dat de verzameling trainingsvoorbeelden samen de regel eenduidig maakt. Het framework dwingt af:

   • Geen "test-only" kenmerken (alles wat in de test voorkomt, moet ook in de training zijn gezien).
   • Geen degeneratieve shortcuts (bijv. identiteitsfuncties of constante uitvoer, tenzij dat de regel is).
   • Eenduidige dekking: De trainingsparen moeten samen de variaties bevatten die nodig zijn om de regel te infereren.

3. Redeneringsketens (Reasoning Chains):
   Elke gegenereerde taak wordt gekoppeld aan twee natuurlijke taal-redeneringsketens:

   • Input reasoning: Beschrijft wat er in het invoerrooster staat.
   • Transformation reasoning: Beschrijft de stappen van de oplossing.
     Deze zijn sjablonen met variabelen die worden ingevuld op basis van de gesamplede parameters, waardoor ze consistent blijven bij variatie.

4. Human-in-the-Loop Validatie:
   Generators worden iteratief ontwikkeld en gevalideerd door mensen. Hoewel LLMs kunnen helpen bij het schrijven van code, wordt elke generator handmatig gecontroleerd en verfijnd via herhaald sampling en visualisatie om te zorgen dat de roosters en redeneringen natuurlijk en correct blijven onder variatie.

5. Zelfverificerende Export:
   Het framework exporteert "executable witnesses": gedeeltelijk geëvalueerde Python-programma's die de gegenereerde data en logica bevatten. Dit maakt goedkope, automatische verificatie mogelijk (bijv. controleren of de uitvoer exact overeenkomt met de opgeslagen output).

Belangrijkste Bijdragen

• Dataset Release: De auteurs hebben 461 task-family generators vrijgegeven die 180 ARC-Mini, 215 ARC-AGI-1 en 66 ARC-AGI-2 taken dekken.
• Schaalbaarheid: Het framework maakt het mogelijk om duizenden nieuwe, willekeurige varianten van bestaande taken te genereren voor training of evaluatie.
• Solver-facing Representatie: Het biedt niet alleen roosters, maar ook gestructureerde natuurlijke taal-uitleg en uitvoerbare code, wat essentieel is voor code-gebaseerde solvers en interpretatie.
• Validatie van Generalisatie: Door het gebruik van taakfamilies kan men generalisatie testen binnen dezelfde distributie (in-distribution) en daarbuiten (out-of-distribution).

Resultaten

De auteurs hebben twee studies uitgevoerd om de kwaliteit en bruikbaarheid te testen:

1. Pre-trained LLM Performance (Few-shot):

   • Er werden 11 open-source decoder LLMs (van 4B tot 32B parameters) getest op een dataset van 10.000 gegenereerde episodes.
   • Resultaat: De prestaties zijn over het algemeen laag. De beste open-source model (Qwen3-30B) bereikte slechts 21% exact-match nauwkeurigheid.
   • Er is een duidelijke hiërarchie: grotere modellen presteren beter, maar zelfs de beste modellen kunnen slechts een klein aantal taken per generator oplossen.
   • De moeilijkheidsgraad van een generator is consistent: wat voor het ene model moeilijk is, is dat ook voor andere modellen.

2. Fine-tuning Impact:

   • Drie modellen (Qwen3-8B, Llama-3.1-8B, Phi-4) werden gefine-tuned op de ARC-TGI dataset.
   • In-Distribution (ID): Fine-tuning leidde tot aanzienlijke verbeteringen. Phi-4 verdubbelde zijn nauwkeurigheid (8% -> 16%) en Llama-3.1-8B steeg met 183% (6% -> 17%). Qwen3-8B presteerde echter slechter na fine-tuning, wat suggereert dat architectuurverschillen belangrijk zijn.
   • Out-of-Distribution (OOD): De modellen die op ARC-TGI waren getraind, presteerden beter op de publieke ARC-AGI-1 evaluatiedataset dan modellen die direct op de originele trainingsdata waren getraind. Dit toont aan dat ARC-TGI helpt bij het leren van robuuste, abstracte regels in plaats van het memoriseren van specifieke puzzels.

Betekenis en Conclusie

ARC-TGI vormt een paradigmaverschuiving in de evaluatie van redeneringsvermogen bij AI. Door statische puzzels te vervangen door resampleable task families, biedt het een platform voor:

• Diagnostische evaluatie: Het meten van robuustheid tegen variaties in roostergrootte, kleuren en afleidingen.
• Gecontroleerde studies: Het isoleren van specifieke factoren die de prestaties beïnvloeden.
• Betrouwbare benchmarks: Het minimaliseren van dataset-lek en memorisatie door het gebruik van oneindig veel variaties van dezelfde regel.

De studie benadrukt dat hoewel huidige LLMs vooruitgang boeken, er nog een aanzienlijke kloof bestaat tussen leren en echte generalisatie. ARC-TGI biedt de gemeenschap de nodige infrastructuur om deze grenzen systematisch te onderzoeken en te verplaatsen, met een sterke focus op menselijk valideerde, cognitief onderbouwde taken.