🤖 machine learning

From I/O to Code with Discovery Agent

Cet article présente DIO-Agent, un cadre de découverte qui résout le problème difficile IO2Code en formulant la synthèse de programmes comme une recherche évolutionnaire guidée par les erreurs d'exécution et une « prémisse de priorité de transformation » pour privilégier les hypothèses simples, démontrant des performances supérieures aux méthodes existantes sur un IO2CodeBench nouvellement construit.

Auteurs originaux : Yihong Dong, Jiaru Qian, Haoran Zhang, Peixu Wang, Binhua Li, Zhi Jin, Yongbin Li, Ge Li, Xiaokang Yang, Xue Jiang

Publié 2026-05-18

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Yihong Dong, Jiaru Qian, Haoran Zhang, Peixu Wang, Binhua Li, Zhi Jin, Yongbin Li, Ge Li, Xiaokang Yang, Xue Jiang

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous essayiez d'enseigner à un robot comment réaliser un tour de magie.

L'Ancienne Méthode (NL2Code) :
Habituellement, vous dites au robot : « Veuillez trier ces nombres du plus petit au plus grand. » Le robot lit vos mots, se souvient des tours similaires qu'il a appris en étudiant, et exécute la tâche. Cela s'appelle NL2Code (Langage Naturel vers Code). C'est comme donner une recette à quelqu'un et lui demander de préparer le plat.

Le Nouveau Défi (IO2Code) :
Maintenant, imaginez que vous ne pouvez pas parler au robot. Vous ne pouvez pas lui donner de recette. À la place, vous lui montrez simplement quelques exemples du tour en action :

Vous mettez une balle rouge, et il sort une balle bleue.
Vous mettez deux balles rouges, et il sort une balle bleue et une balle verte.
Vous mettez une balle bleue, et il ne sort rien.

Le robot doit déduire la règle secrète derrière la magie en observant uniquement les entrées et les sorties. Il doit deviner la « recette » sans jamais se voir dire quels sont les ingrédients. L'article appelle cela IO2Code (Entrée-Sortie vers Code).

Le problème est que cela est incroyablement difficile. Si le robot se contente de mémoriser les exemples (« Si rouge, alors bleu »), il échoue lorsque vous lui donnez une nouvelle couleur. S'il devine une règle complexe trop rapidement, il risque de se retrouver dans une impasse.

La Solution : L'« Agent de Découverte » (DIO-Agent)

Les auteurs ont créé un nouvel agent IA appelé DIO-Agent pour résoudre ce puzzle. Ils n'ont pas simplement laissé l'IA deviner au hasard ; ils lui ont donné une stratégie spécifique basée sur la façon dont les programmeurs humains apprennent réellement.

Voici comment fonctionne le DIO-Agent, en utilisant une analogie simple :

1. Le « Programme d'Enseignement » (Apprentissage par Étapes)

Imaginez un jeu vidéo où vous commencez en « Mode Facile » et débloquez progressivement des niveaux plus difficiles.

La Stratégie : Au lieu de montrer à l'IA tous les exemples d'un coup, le DIO-Agent ne lui montre d'abord que les plus faciles.
Pourquoi cela aide : L'IA apprend une règle simple qui fonctionne pour les cas faciles. Ensuite, elle reçoit quelques exemples plus difficiles. Si la règle simple échoue, l'IA sait qu'elle doit améliorer sa règle, mais elle conserve les parties qui fonctionnaient déjà. Elle construit la complexité étape par étape, plutôt que d'essayer de résoudre tout le puzzle d'un seul bond géant.

2. La « Priorité de Transformation » (La Règle de Simplicité)

L'article utilise un concept du génie logiciel appelé la Prémisse de Priorité de Transformation (TPP). Considérez cela comme une règle stricte sur la façon dont l'IA est autorisée à modifier sa hypothèse.

La Règle : L'IA est contrainte d'essayer d'abord l'explication la plus simple possible.
- Niveau 1 : « La réponse est-elle juste un nombre constant ? » (Par exemple : Toujours renvoyer 5).
- Niveau 2 : « Dépend-elle directement de l'entrée ? » (Par exemple : Renvoyer le nombre que vous m'avez donné).
- Niveau 3 : « Avons-nous besoin d'une décision ? » (Par exemple : Si le nombre est pair, faites X ; si impair, faites Y).
- Niveau 4 : « Avons-nous besoin d'une boucle ? » (Par exemple : Continuez à faire cela jusqu'à ce que le nombre soit petit).
Pourquoi cela aide : Cela empêche l'IA de sauter directement vers une solution super-complexe et désordonnée qui fonctionne par hasard pour les exemples spécifiques mais qui est en réalité fausse. Cela force l'IA à « épuiser » les idées simples avant d'essayer les complexes, tout comme un détective écarte les suspects simples avant de chercher un cerveau criminel.

3. La « Rétroaction Fondée sur les Erreurs » (Apprendre des Erreurs)

Lorsque l'IA essaie une hypothèse et échoue, elle ne reçoit pas juste un score « Faux ».

La Stratégie : Le système montre à l'IA exactement où elle a échoué. « Vous avez eu les trois premiers exemples corrects, mais vous avez échoué sur le quatrième parce que vous avez oublié de gérer les nombres négatifs. »
Pourquoi cela aide : Cela agit comme un entraîneur pointant une erreur spécifique dans un exercice sportif, plutôt que de dire simplement « Vous avez perdu le match ». Cela guide l'IA pour corriger cette faille spécifique dans sa logique.

Les Résultats

Les chercheurs ont testé cet nouvel agent sur un vaste ensemble de puzzles (appelé IO2CodeBench) allant des mathématiques simples à la géométrie complexe, et même à l'analyse d'images.

Le Gagnant : Le DIO-Agent a battu toutes les autres méthodes, y compris les outils de programmation traditionnels et d'autres agents IA avancés d'« évolution ».
Efficacité : Il n'a pas gagné simplement en faisant plus d'essais ; il a gagné en faisant des essais plus intelligents. Il a trouvé les règles correctes et simples plus rapidement et avec moins d'effort « gaspillé » que ses concurrents.
Généralisation : L'IA ne s'est pas contentée de mémoriser les exemples d'entraînement ; elle a réellement déduit la logique sous-jacente, lui permettant de résoudre correctement de nouveaux problèmes jamais vus auparavant.

En Résumé

L'article soutient que si l'IA est excellente pour suivre des instructions écrites (NL2Code), elle peine à déduire des règles à partir du comportement seul (IO2Code). En forçant l'IA à apprendre par étapes, à privilégier les solutions simples aux solutions complexes, et à apprendre spécifiquement de ses erreurs, le DIO-Agent peut réussir à « découvrir » les règles cachées d'un système, agissant comme un véritable détective scientifique plutôt que comme une simple machine de mémorisation.

Résumé technique : De l'E/S au code avec l'agent de découverte

Définition du problème : IO2Code

L'article aborde un défi fondamental en synthèse de programmes, distinct du paradigme dominant du langage naturel vers le code (NL2Code). Alors que NL2Code repose sur l'alignement sémantique entre les descriptions en langage naturel et le code acquis lors du préentraînement, IO2Code (Entrée-Sortie vers Code) exige la synthèse d'un programme généralisé strictement à partir d'un ensemble limité de paires entrée-sortie (E/S), sans aucune spécification en langage naturel.

Les auteurs soutiennent que IO2Code pose des défis nettement plus sévères que NL2Code :

Induction vs Composition : NL2Code se réduit largement à la composition et à la réutilisation de motifs de code alignés avec des descriptions apprises. En revanche, IO2Code exige l'induction et la découverte, obligeant le modèle à révéler des structures algorithmiques latentes, à inférer des relations causales et à construire de manière autonome une logique complète à partir d'un comportement computationnel concret.
Sous-spécification : Les observations E/S sont intrinsèquement sous-spécifiées ; plusieurs programmes distincts peuvent être cohérents avec un ensemble fini d'exemples. Cela crée un vaste espace d'hypothèses où les agents risquent de surapprendre des motifs fallacieux (mémorisation) ou de s'égarer dans des « impasses » structurellement complexes mais incorrectes.
Modes d'échec : L'article identifie deux modes d'échec principaux dans les approches existantes :
1. Le piège du surapprentissage : Les modèles mémorisent des exemples spécifiques (par exemple, des tables de recherche) plutôt que de généraliser, échouant sur des entrées non vues.
2. Le piège de la mutation aveugle : La recherche évolutionnaire sans guidage structurel produit des programmes syntaxiquement complexes mais sémantiquement erronés, conduisant à des impasses structurelles difficiles à quitter.

Méthodologie : DIO-Agent

Pour répondre à ces défis, les auteurs proposent DIO-Agent, un agent de découverte qui formule IO2Code comme une recherche évolutionnaire sur l'espace discret des programmes. La méthode intègre trois composants principaux :

1. Évolution par curriculum

Le processus de recherche est organisé en étapes de difficulté croissante.

Construction du curriculum : Les exemples visibles sont triés du plus facile au plus difficile en fonction de la complexité des entrées/sorties.
Progression par étape : L'agent commence avec un sous-ensemble d'exemples faciles ( $C_1$ ) et introduit progressivement des exemples plus difficiles ( $C_2, \dots, C_S$ ).
Initialisation : Pour chaque nouvelle étape $s$ , la recherche est initialisée avec le meilleur programme trouvé à l'étape $s-1$ , plutôt que de redémarrer à zéro. Cela permet à l'agent d'affiner des programmes partiellement corrects plutôt que de redécouvrir une logique de base.

2. Mutation guidée par le Principe de Priorité de Transformation (TPP)

Inspiré du Principe de Priorité de Transformation (TPP) issu du développement piloté par les tests (TDD), DIO-Agent introduit une priorité structurelle pour biaiser le Grand Modèle de Langage (LLM) lors de la mutation.

Complexité ordonnée : Le LLM est instruit d'appliquer des transformations dans un ordre spécifique de complexité structurelle croissante : nil $\to$ constante $\to$ variable $\to$ inconditionnel $\to$ conditionnel $\to$ itération $\to$ récursion.
Mécanisme : L'agent doit épuiser les hypothèses plus simples (par exemple, retourner une constante ou une variable) avant d'essayer des constructions plus complexes (par exemple, des boucles ou des conditionnels). Cela empêche la recherche de sauter prématurément vers des solutions complexes et de surapprentissage, et force l'agent à identifier la règle minimale suffisante.
Implémentation : Le LLM est invité à proposer des diffs RECHERCHE/REMPLACER plutôt que des réécritures complètes, préservant ainsi le code fonctionnel tout en respectant l'ordre de complexité.

3. Feedback ancré sur les erreurs

Au lieu de se fier uniquement à des scores de précision scalaires, DIO-Agent utilise des artefacts de feedback structurés.

Cas d'échec concrets : L'évaluateur exécute les programmes candidats sur l'ensemble du curriculum actuel et sur un ensemble de relecture d'exemples antérieurs. Il renvoie des cas d'échec spécifiques (sorties non correspondantes ou erreurs d'exécution).
Chaîne de feedback : Ces erreurs concrètes, ainsi qu'une chaîne de feedback héritée des programmes ancêtres, sont injectées dans l'invite pour les mutations ultérieures. Cela fournit au LLM des preuves de débogage explicites plutôt que des récompenses abstraites.
Notation : Un score de sélection au niveau de l'étape équilibre la précision sur le curriculum actuel contre des pénalités pour la complexité et la mémorisation (chevauchement entre les E/S fournies et le code généré).

Contributions clés

Formalisation de IO2Code : L'article définit IO2Code comme une tâche distincte axée sur l'induction et la découverte, la contrastant avec la tâche NL2Code, riche en composition.
IO2CodeBench : Les auteurs construisent un nouveau benchmark couvrant quatre niveaux de difficulté : Base (opérations scalaires/listes), Algorithme (raisonnement complexe), Géométrie (calcul spatial) et Multimodal (extraction image-vers-numérique). Le benchmark comprend 125 tâches avec des séparations strictes entraînement-test pour éviter les fuites.
Architecture DIO-Agent : La proposition d'une boucle évolutionnaire structurée combinant l'apprentissage par curriculum, la mutation guidée par le TPP et le feedback ancré sur les erreurs pour naviguer dans l'espace de programmes sous-spécifié.
Exploration active : L'article démontre la capacité de l'agent dans un cadre de « Découverte Autonome » où le modèle conçoit activement ses propres exemples E/S pour interroger une oracle de vérité terrain, validant davantage la capacité de l'agent à résoudre des ambiguïtés logiques.

Résultats expérimentaux

Des expériences extensives sur IO2CodeBench démontrent que DIO-Agent surpasse systématiquement les approches existantes :

Performance : DIO-Agent obtient des résultats de pointe à tous les niveaux de difficulté.
- Niveau Base : 61,29 % (à égalité avec la meilleure référence).
- Niveau Algorithme : 71,43 % (dépassant toutes les références).
- Niveau Géométrie : 61,11 % (une amélioration substantielle par rapport aux 44,44 % de CodeEvolve).
- Niveau Multimodal : 40,67 % (presque le double des 22,00 % d'AlphaEvolve).
Généralisabilité : La méthode montre des gains de performance robustes à travers divers LLM de base (DeepSeek V3.2, Qwen-3.6-Plus, Claude-Sonnet-4.6), confirmant qu'elle est agnostique au modèle.
Efficacité : DIO-Agent est plus économe en tokens que d'autres références évolutionnaires (par exemple, 3 738 tokens/itération contre 5 829 pour CodeEvolve), indiquant un processus de recherche ciblé plutôt qu'une génération de force brute.
Comparaison avec le scaling : DIO-Agent surpasse nettement les stratégies de scaling au moment du test (Direct, Best-of-N, Auto-cohérence) même lorsque ces références se voient accorder des budgets d'échantillonnage équivalents (N=40). Cela suggère qu'un raffinement systématique via une recherche itérative est supérieur à un échantillonnage indépendant répété pour la découverte de programmes.
Études d'ablation : La suppression de l'Évolution par curriculum a entraîné la plus forte baisse de performance (de 58,63 % à 51,33 %), soulignant son rôle critique dans l'élagage des chemins improductifs. La suppression du TPP a également conduit à des baisses significatives, en particulier dans les tâches de Géométrie et d'Algorithme.

Importance et affirmations

L'article affirme que IO2Code représente un « graal » de l'informatique qui reste largement non résolu par rapport à NL2Code. L'importance de ce travail réside dans :

Le changement de paradigme : Passer au-delà de la génération de code pilotée par le langage naturel vers la découverte de programmes pilotée par le comportement, ce qui est essentiel pour des tâches telles que la migration de systèmes hérités, le rétro-ingénierage d'APIs boîtes noires et l'abduction d'algorithmes scientifiques.
Contraintes structurelles : Démontrer que l'application de principes d'ingénierie logicielle (spécifiquement le TPP issu du TDD) en tant que contrainte structurelle dans des agents autonomes atténue efficacement le surapprentissage et guide la recherche à travers de vastes espaces d'hypothèses.
Généralisabilité : Prouver qu'une recherche évolutionnaire structurée et pilotée par le feedback peut considérablement améliorer les capacités d'induction et de découverte des LLM à travers divers domaines et architectures de modèles, repoussant le plafond de la découverte de programmes automatisés au-delà de ce qui est réalisable par de simples invites ou un scaling.

Les auteurs concluent que leur travail attire l'attention sur le problème plus large de la découverte de programmes à partir du comportement E/S et inspire une exploration plus poussée au-delà de la génération pilotée par le langage naturel.