Self-Evolving Code-with-Image Reasoning
Cet article introduit « Code-with-Image », un cadre d'auto-évolution sans entraînement où des modèles multimodaux implémentent des algorithmes visuels en code pour résoudre des tâches complexes au niveau du pixel, utilisant une boucle de réflexion exécutable pour affiner itérativement leurs capacités de raisonnement et obtenir des gains de performance significatifs sur le CwI-Bench.
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
Le dilemme du détective : quand voir ne suffit plus
Imaginez que vous êtes un détective essayant de résoudre un mystère, mais au lieu d'examiner des indices, vous fixez une seule photographie en haute résolution. Dans le monde de l'intelligence artificielle, c'est ce que font les « modèles multimodaux » : ils regardent des images et tentent de répondre à des questions à leur sujet. Pendant longtemps, ces détectives de l'IA se sont améliorés en apprenant à utiliser des « outils ». Si un indice est trop petit pour être vu, ils apprennent à zoomer. Si un texte est flou, ils apprennent à éclaircir l'image. C'est ce qu'on appelle « réfléchir avec des images ». C'est comme donner au détective une loupe et une lampe de poche.
Cependant, il y a un piège. Certains mystères ne se résolvent pas simplement en regardant de plus près. Imaginez un puzzle où vous devez compter exactement combien de pixels se trouvent dans un motif spécifique, ou déterminer l'angle précis selon lequel un anneau caché a été pivoté. Aucun zoom ou éclaircissement ne vous aidera à « voir » la réponse avec vos yeux. Vous devez la calculer. C'est là que l'ancienne façon de penser se heurte à un mur. L'IA peut décrire les étapes pour résoudre le puzzle avec des mots, mais les mots ne peuvent pas faire de mathématiques sur une image. Ce document s'attaque à cette lacune, en posant une question simple mais profonde : et si l'IA ne se contentait pas de décrire la solution, mais écrivait réellement un programme informatique pour l'exécuter ?
La grande idée du papier : coder comme mode de pensée
Ce document présente une nouvelle façon pour l'IA de résoudre des énigmes visuelles appelée Code-with-Image. Au lieu de demander à l'IA de simplement « regarder » une image et de deviner la réponse, ou d'utiliser une liste d'outils préétablis comme « recadrer » ou « pivoter », les chercheurs lui donnent une toile blanche et un interprète Python (un outil qui exécute du code informatique). Le travail de l'IA consiste à écrire un programme qui manipule directement les pixels de l'image pour trouver la réponse.
Voyez cela ainsi : de l'ancienne manière, si vous demandiez à une IA : « Combien de points rouges y a-t-il dans cette image ? », elle essaierait de décrire les points ou d'utiliser un outil pour les mettre en évidence. Avec Code-with-Image, l'IA doit écrire un script qui dit : « Parcourez chaque pixel, vérifiez s'il est rouge, comptez-le, et affichez le total. » Le programme est le raisonnement. Si le code est juste, la réponse est juste. Si le code est faux, la réponse est fausse. Cela déplace le défi de « voir » la réponse vers la « construction » de la réponse.
Le problème : l'IA peut décrire, mais ne peut pas agir
Les chercheurs ont découvert que même les modèles d'IA les plus intelligents sont en difficulté face à cela. Ils ont testé un benchmark massif appelé CwI-Bench (Code-with-Image Bench), qui contient 30 types différents d'énigmes visuelles. Ces énigmes sont conçues de telle sorte que vous ne pouvez pas simplement les « regarder » pour obtenir la réponse ; vous devez effectuer un calcul multi-étapes sur les pixels.
Lorsque l'IA tentait de résoudre ces énigmes en utilisant uniquement des mots (même avec son mode de « réflexion » activé), elle échouait lamentablement. Par exemple, le modèle de pointe, GPT-5.6-luna, obtenait moins de 30 % de bonnes réponses. Il pouvait décrire les étapes parfaitement (« Je dois faire pivoter l'image et compter les pixels »), mais il ne pouvait pas réellement faire le calcul. C'était comme un chef qui pourrait décrire une recette dans les moindres détails mais qui serait incapable de cuisiner le plat.
Cependant, lorsque les chercheurs ont donné à l'IA un interprète Python et lui ont dit d'écrire du code pour résoudre le problème, les scores ont bondi. La précision de GPT-5.6-luna est passée à 43 %. Le modèle open-source Qwen3.5-27B est passé de 12,6 % à 32,6 %. Le code a permis à l'IA de réellement traiter les données de l'image, transformant un jeu de devinettes en un calcul.
La recette secrète : s'enseigner à soi-même le débogage
Mais voici le plus surprenant : même avec la capacité d'écrire du code, l'IA commettait encore des erreurs. Elle écrivait un programme qui semblait correct mais qui contenait une erreur minuscule et invisible — comme compter un pixel de trop ou utiliser le mauvais chiffre pour une rotation. L'IA exécutait le code, obtenait la mauvaise réponse, puis essayait simplement d'écrire un nouveau programme, faisant souvent la même erreur.
Pour corriger cela, les auteurs ont créé une boucle d'« auto-évolution » appelée Self-Reflection over Executable Reasoning (Réflexion sur le raisonnement exécutable). C'est la partie la plus ludique de l'histoire. Imaginez que l'IA est un étudiant passant un examen. Lorsqu'elle obtient une mauvaise réponse, au lieu de passer à la suite, elle est forcée de :
- Examiner son échec : Lire le code qu'elle a écrit et la mauvaise réponse obtenue.
- Lancer une simulation : Réexécuter le code dans un « bac à sable » (sandbox) sécurisé pour voir exactement où cela a échoué.
- Corriger le bug : Modifier le code pour corriger l'erreur.
- Sauvegarder la leçon : Si la correction fonctionne, elle sauvegarde le code corrigé en tant que « compétence » (un morceau de texte) dans une bibliothèque.
Cela se produit sans que l'IA ait besoin d'être réentraînée ou que son cerveau soit remodelé. Elle apprend simplement de ses propres échecs. Le papier montre que cette boucle d'auto-apprentissage est incroyablement puissante.
- Pour le modèle GPT-5.6-luna, l'utilisation de ces compétences auto-évoluées a fait grimper sa précision de 43 % à 67 %.
- Pour le modèle Qwen3.5-27B, elle est passée de 32,6 % à 55,9 %.
Pourquoi cela importe : des compétences que l'on peut copier et coller
L'une des découvertes les plus intéressantes est que ces « compétences » ne sont que du texte brut. Elles ne sont pas verrouillées à l'intérieur du cerveau de l'IA. Les chercheurs ont montré qu'ils pouvaient prendre les compétences apprises par un modèle énorme et puissant (comme le modèle à 27 milliards de paramètres) et les coller dans un modèle beaucoup plus petit et plus faible (un modèle à 9 milliards de paramètres).
Le plus petit modèle, qui ne pouvait pas résoudre les problèmes par lui-même, s'est soudainement beaucoup amélioré simplement en lisant le « guide de référence » écrit par le plus grand modèle.
- Le modèle 9B est passé d'une précision de 11,1 % à 34,5 % simplement en utilisant les compétences développées par le modèle 27B.
- Plus surprenant encore, ces compétences fonctionnaient à travers différents types de modèles d'IA. Une compétence apprise par une famille de modèles aidait une famille de modèles totalement différente à s'améliorer.
Ce que ce papier exclut
Le papier est très clair sur ce qui ne fonctionne pas. Il soutient que le simple fait de donner à une IA une liste d'outils (comme « zoom », « recadrer » ou « rechercher ») ne suffit pas pour ces types de problèmes spécifiques. L'IA doit écrire son propre algorithme de zéro. Il montre également que le simple fait de « réfléchir » plus intensément avec des mots n'aide pas ; le goulot d'étranglement n'est pas un manque d'idées, mais un manque d'exécution. L'IA peut décrire l'algorithme, mais sans exécuter le code, elle ne peut pas résoudre l'énigme.
L'essentiel
Ce papier suggère que pour les problèmes visuels nécessitant un calcul précis, la meilleure façon pour une IA de réfléchir est d'écrire du code. Mais la véritable percée est que ces modèles d'IA peuvent s'enseigner à eux-mêmes à devenir meilleurs dans l'écriture de ce code en déboguant leurs propres erreurs. Ils n'ont pas besoin d'un enseignant humain pour corriger leur code ; ils ont juste besoin d'un bac à sable pour l'exécuter, d'un miroir pour voir où ils ont échoué, et d'un peu de patience pour réessayer.
Les résultats sont mesurés et précis : sur un benchmark de 30 familles de tâches, les compétences auto-évoluées ont élevé la performance des meilleurs modèles de la quarantaine basse à la soixantaine haute (en pourcentage de précision). Bien que le papier ne prétende pas résoudre chaque problème visuel, il prouve que pour les tâches où la réponse réside dans les mathématiques des pixels plutôt que dans l'inspection visuelle, le codage est la clé, et l'auto-réflexion est la clé maîtresse.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.