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

Ce papier présente ARC-TGI, un cadre open-source de générateurs de tâches validés par des humains et dotés de chaînes de raisonnement, conçu pour produire de manière évolutive des ensembles de données diversifiés et contrôlés pour l'évaluation des modèles sur ARC-AGI tout en évitant le surapprentissage.

L'essentiel

🧩 Le Problème : L'énigme figée dans le temps

Imaginez que vous essayez d'enseigner à un robot comment résoudre des énigmes logiques (comme des puzzles de couleurs sur une grille). Pour l'instant, les chercheurs utilisent un livre de puzzles statique appelé ARC-AGI.

Le problème ? C'est comme si vous appreniez à conduire en vous entraînant uniquement sur le même circuit de course, à la même heure, avec le même temps.

1. Le robot "mémorise" : Au lieu d'apprendre la logique, il apprend par cœur les réponses de ce livre précis.
2. On ne sait pas s'il est intelligent : Quand il réussit, on ne sait pas s'il a vraiment compris la règle ou s'il a juste deviné la réponse parce qu'il l'a déjà vue.
3. C'est trop petit : Le livre de puzzles est fini. On ne peut pas créer de nouvelles versions pour tester si le robot est vraiment robuste.

💡 La Solution : ARC-TGI (Le "Moule à Gâteaux" Intelligent)

Les auteurs de cet article ont créé ARC-TGI. Au lieu de donner au robot un livre de puzzles fini, ils lui donnent un moule à gâteaux magique (un générateur de tâches).

Voici comment ça marche, avec une analogie culinaire :

1. Le Moule (Le Générateur)

Imaginez un moule à gâteau qui ne produit pas un seul gâteau, mais une infinité de gâteaux différents.

• La règle secrète (La Recette) : Le moule a une règle fixe, par exemple : "Mélanger les ingrédients, puis les cuire à 180°C". C'est la logique que le robot doit apprendre.
• Les variations (Les Ingrédients) : Le moule peut changer la couleur de la pâte, la taille du gâteau, ou la forme du moule à chaque fois.
• Le résultat : À chaque fois que vous appuyez sur le bouton, vous obtenez un nouveau puzzle unique, mais qui suit toujours la même règle logique fondamentale.

2. Le Guide de Cuisine (Les Chaînes de Raisonnement)

C'est la grande innovation de ce papier. Avec chaque nouveau gâteau généré, le système fournit aussi une note explicative écrite en langage naturel.

• Au lieu de juste montrer le gâteau cru et le gâteau cuit, le système dit : "Regarde, j'ai pris les ingrédients rouges et je les ai placés en haut, puis j'ai ajouté le sucre..."
• Cela permet au robot (et aux humains) de comprendre pourquoi le résultat est ce qu'il est, étape par étape. C'est comme avoir un chef qui vous explique sa méthode en direct.

3. Le Contrôleur Qualité (Validation Humaine)

Parfois, les moules automatiques font des erreurs (un gâteau qui ne cuit pas, ou une règle qui devient floue).

• Les chercheurs ont mis en place un processus où des humains vérifient ces "moules". Ils s'assurent que :
  • Le puzzle est toujours soluble.
  • Les indices donnés dans les exemples d'entraînement suffisent vraiment à deviner la règle pour le test final.
  • Le robot ne peut pas tricher en utilisant des astuces faciles.

🚀 Ce que les chercheurs ont découvert

Ils ont créé 461 de ces "moules" (générateurs) couvrant des centaines de puzzles. Ensuite, ils ont testé les meilleurs intelligences artificielles (comme Qwen, Llama, etc.) avec ces nouveaux puzzles.

Voici les résultats clés, simplifiés :

1. Les robots sont encore des débutants : Même les plus grands modèles actuels n'arrivent à résoudre que très peu de ces nouveaux puzzles (environ 20% de réussite pour le meilleur). Ils ont du mal à généraliser la règle quand les couleurs ou la taille changent.
2. La mémoire ne suffit plus : Quand on entraîne un modèle sur ces nouveaux puzzles générés, il s'améliore beaucoup sur ce type de puzzles, mais il a encore du mal à appliquer cette logique à des puzzles totalement nouveaux (ce qu'on appelle la "généralisation").
3. La difficulté est cohérente : Certains types de puzzles sont naturellement plus difficiles pour tous les robots, peu importe leur taille. ARC-TGI permet de cartographier ces difficultés avec précision.

🌍 Pourquoi c'est important pour nous ?

Imaginez que vous vouliez tester si un élève a vraiment compris les mathématiques.

• L'ancienne méthode : Lui donner un examen avec 10 questions fixes. S'il les a apprises par cœur, il a 20/20.
• La méthode ARC-TGI : Lui donner un générateur qui crée 1000 variantes de ces 10 questions. S'il réussit, c'est qu'il a vraiment compris la logique, pas juste les réponses.

En résumé :
ARC-TGI transforme les puzzles statiques en un laboratoire dynamique. Au lieu de demander aux robots de mémoriser un livre, on leur demande de comprendre la logique derrière le livre, avec l'aide de guides explicatifs. C'est un pas de géant pour créer des IA qui raisonnent vraiment, et non pas seulement des IA qui répètent ce qu'elles ont vu.

Résumé technique

1. Problématique

Le Corpus d'Abstraction et de Raisonnement (ARC-AGI) est conçu pour évaluer la capacité des systèmes d'IA à acquérir de nouvelles compétences à partir de peu d'exemples (few-shot) et à induire des règles abstraites à partir de grilles visuelles colorées. Cependant, l'évaluation actuelle repose sur des collections statiques de puzzles créés à la main, ce qui pose plusieurs problèmes majeurs :

• Surapprentissage et fuite de données : Les modèles peuvent mémoriser les puzzles spécifiques plutôt que d'apprendre à généraliser.
• Difficulté de mesure : Il est difficile de distinguer la véritable généralisation de la mémorisation sur des ensembles de données fixes et limités.
• Manque de contrôle : Il est complexe d'effectuer des études contrôlées (en variant un seul facteur comme la taille de la grille ou les couleurs) tout en maintenant la règle sous-jacente constante.
• Absence de contraintes d'épisode : Les méthodes de génération procédurale existantes échouent souvent à garantir que l'ensemble des exemples d'entraînement disambiguise la règle pour le test, ou ne fournissent pas de traces de raisonnement alignées sur chaque instance générée.

L'objectif est donc de passer d'une évaluation sur des instances fixes à une évaluation sur des familles de tâches (distributions paramétrées), permettant un échantillonnage scalable et une analyse robuste.

2. Méthodologie : Le Framework ARC-TGI

Les auteurs introduisent ARC-TGI (ARC Task Generators Inventory), un framework open-source pour créer des générateurs de familles de tâches validés par l'humain.

Représentation et Architecture

Chaque générateur est un module Python compact qui définit une distribution de tâches partageant une règle latente tout en variant les détails parasites (couleurs, positions, tailles). L'architecture repose sur trois étapes clés :

1. Échantillonnage (create_input) : Génération d'entrées en randomisant les facteurs parasites (grille, objets).
2. Transformation (transform_input) : Application déterministe de la règle latente pour produire la sortie.
3. Construction de l'épisode (create_grids) : C'est l'étape centrale. Elle assemble les paires d'entraînement et de test tout en imposant des contraintes au niveau de l'épisode. Contrairement à un échantillonnage indépendant de paires, cette étape garantit que :
   • Les exemples d'entraînement couvrent collectivement les variations nécessaires pour inférer la règle.
   • Aucune caractéristique n'est présente uniquement dans le test (évitant les indices de test).
   • Les raccourcis dégénérés (ex: sortie constante) sont rejetés sauf s'ils sont la règle intentionnelle.

Composants Clés

• Chaînes de raisonnement (Reasoning Chains) : Chaque tâche générée est accompagnée de deux chaînes de raisonnement en langage naturel (templates) :
  • Entrée : Description du contenu de la grille d'entrée.
  • Transformation : Description des étapes de la solution.
    Ces templates sont instanciés dynamiquement avec les paramètres de la tâche, fournissant des explications alignées sur l'instance spécifique.
• Code partiellement évalué : Le framework exporte des programmes Python où les variables échantillonnées sont "inlinées", offrant une interface propre pour les solveurs basés sur le code.
• Validation Humaine en Boucle (Human-in-the-Loop) : Le processus de création combine l'assistance par LLM (pour le brouillon de code) et une réfinition humaine itérative. Les contributeurs valident manuellement que les grilles et les traces de raisonnement restent correctes et naturelles sous variation, corrigeant les bugs subtils qui pourraient rendre la tâche ambiguë.

Vérification Automatique

Le système inclut des exportations auto-vérifiantes :

• Témoin exécutable : Le programme réexécuté sur la grille d'entrée doit reproduire exactement les sorties stockées.
• Vérification des invariants : Contrôle structurel (grilles bien formées, pas de couleurs inattendues au test).
• Filtrage des raccourcis : Détection des trivialités non intentionnelles.

3. Contributions Clés

1. ARC-TGI (Inventaire) : Une bibliothèque open-source de 461 générateurs couvrant :
   • 180 tâches ARC-Mini.
   • 215 tâches ARC-AGI-1 (200 entraînement, 15 test).
   • 66 tâches ARC-AGI-2 (55 entraînement, 11 test).
2. Représentation "Solver-Facing" : Intégration native de traces de raisonnement en langage naturel et de code exécutable pour chaque instance échantillonnée, facilitant l'entraînement et le débogage des modèles.
3. Contraintes d'Épisode : Mécanisme explicite pour garantir la solvabilité humaine et la disambiguation de la règle à travers l'ensemble des exemples d'entraînement, comblant une lacune des générateurs procéduraux précédents.
4. Infrastructure d'Évaluation Scalable : Permet le "matched-distribution benchmarking", les balayages de robustesse et les analyses centrées sur les ensembles de données, impossibles avec des puzzles fixes.

4. Résultats Expérimentaux

Les auteurs ont évalué l'utilité d'ARC-TGI via deux études principales sur des LLMs (Large Language Models) :

A. Performance en Few-Shot (Sans Fine-Tuning)

• Évaluation : 11 LLMs open-source (de 4B à 32B paramètres) et un modèle fermé (Claude Sonnet 4.5) ont été testés sur 10 000 épisodes échantillonnés (50 par générateur sur 200 générateurs).
• Résultats :
  • Les performances globales sont faibles, confirmant la difficulté des transformations 2D pour les LLMs actuels. Le meilleur modèle open-source (Qwen3-30B) atteint 21% de précision exacte.
  • Difficulté par générateur : La difficulté est cohérente d'un modèle à l'autre. Certains générateurs sont résolus par presque tous les modèles, tandis que d'autres (la "longue traîne") restent insolubles.
  • Rôle de la taille : Les modèles plus grands (8B+) surpassent généralement les plus petits (4B), et la famille Qwen surperforme les autres architectures.
  • Analyse des priors : Les tâches les plus difficiles impliquent souvent l'intégration de multiples priors (comptage, directionnalité), tandis que les tâches faciles reposent sur des transformations simples.

B. Impact du Fine-Tuning

• Méthode : Fine-tuning de trois modèles (Qwen3-8B, Llama-3.1-8B, Phi-4) sur l'ensemble de données ARC-TGI.
• Résultats (In-Distribution - ID) :
  • Améliorations massives pour Phi-4 (+100% relatif) et Llama-3.1-8B (+183% relatif).
  • Qwen3-8B a montré une dégradation (-33%), suggérant que l'architecture influence la capacité à bénéficier de ces données.
• Résultats (Out-of-Distribution - OOD) :
  • Le fine-tuning sur ARC-TGI améliore la généralisation vers l'ensemble de test public ARC-AGI-1 pour Phi-4 et Llama-3.1-8B, surpassant le fine-tuning direct sur ARC-AGI-1.
  • Cependant, un écart persiste entre les performances ID et OOD, indiquant que la généralisation à de nouvelles distributions de puzzles reste limitée.
• Analyse par générateur : Le fine-tuning augmente la capacité des modèles à résoudre un plus grand nombre de familles de tâches, mais la performance reste hétérogène selon le générateur.

5. Signification et Conclusion

ARC-TGI représente un changement de paradigme pour l'évaluation du raisonnement en IA :

• De statique à dynamique : Il transforme l'évaluation ARC d'un ensemble de puzzles fixes en une plateforme expérimentale contrôlable et reproductible.
• Diagnostic au-delà du score : Il permet des analyses fines de la robustesse (variation de bruit, taille, couleurs) et de la généralisation (intra-famille vs inter-famille).
• Validation Humaine : Il démontre que pour des benchmarks cognitifs solides, l'automatisation pure est insuffisante ; une boucle humaine est nécessaire pour garantir la solvabilité et la cohérence des règles.
• Infrastructure Communautaire : En fournissant des générateurs, des traces de raisonnement et du code exécutable, ARC-TGI offre une infrastructure partagée pour développer des solveurs plus robustes et des protocoles d'évaluation standardisés.

En résumé, ARC-TGI ne se contente pas de générer plus de données ; il fournit un cadre rigoureux pour comprendre pourquoi et où les modèles échouent, en isolant les facteurs de difficulté et en garantissant la qualité cognitive des tâches générées.