ShapeCodeBench: A Renewable Benchmark for Perception-to-Program Reconstruction of Synthetic Shape Scenes

L'article présente ShapeCodeBench, un benchmark synthétique renouvelable conçu pour évaluer les modèles sur des tâches de reconstruction de programmes à partir de la perception, en les contraignant à générer des programmes de dessin exécutables à partir d'images rendues, révélant ainsi que, bien que les modèles multimodaux actuels préservent la structure du premier plan, ils peinent toujours à obtenir une correspondance exacte en raison d'erreurs mineures de paramètres.

L'essentiel

Imaginez que vous êtes un détective essayant de résoudre un mystère. On vous remet un dessin achevé — une image en noir et blanc de cercles et de carrés sur un fond blanc. Votre tâche ne consiste pas seulement à décrire l'image ; vous devez écrire le code informatique exact qu'un robot utiliserait pour dessiner cette image à partir de zéro.

Voici le défi de ShapeCodeBench, un nouveau « test » créé par le chercheur Shivam Kumar pour évaluer la performance des modèles d'IA modernes dans cette tâche précise.

Voici une explication de son fonctionnement, de ce qui le rend spécial et de ce que les résultats révèlent, en utilisant des analogies simples.

1. Le Jeu : « Rétro-ingénierie d'un dessin »

Imaginez les modèles d'IA comme des élèves passant un examen très strict.

• L'entrée : L'élève voit une image (un « raster ») de formes noires sur une toile blanche.
• La tâche : L'élève doit taper un programme utilisant un langage minuscule et spécifique (un « DSL ») qui indique à un ordinateur comment dessiner ces formes exactes.
• Les règles : Le langage ne propose que quatre actions : dessiner un cercle plein, un cercle en contour, un carré plein ou un carré en contour. La toile fait toujours 512x512 pixels.
• La notation : Un ordinateur ne se contente pas de lire le code de l'élève ; il l'exécute. Il redessine l'image à partir du code et compare le nouveau dessin à l'original. Si même un seul pixel est mal placé, la réponse n'est pas « parfaite ».

2. Pourquoi ce test est différent : Le « Papier frais infini »

La plupart des tests d'IA utilisent un ensemble fixe de questions (comme un test de mathématiques standard). Une fois qu'une IA a mémorisé les réponses, le test devient inutile. C'est ce qu'on appelle la « contamination ».

ShapeCodeBench est comme une machine à dessiner magique.

• Chaque fois que vous voulez un nouveau test, vous tournez une manivelle (une « graine »).
• La machine génère instantanément un ensemble entièrement nouveau et unique de formes, avec des tailles, des chevauchements et des positions différents.
• Parce que les chercheurs peuvent générer un nouvel ensemble de données « hors test » (held-out set) à partir d'une nouvelle graine à tout moment, cela réduit le risque de contamination par des instances exactes — c'est-à-dire le risque que le modèle ait déjà vu les questions de test spécifiques lors de son entraînement.

3. Les niveaux de difficulté

Le test comporte trois niveaux, comme un jeu vidéo :

• Facile : Quelques formes, éloignées les unes des autres, ne se touchant pas.
• Moyen : Plus de formes, certaines se rapprochant ou se chevauchant légèrement.
• Difficile : Beaucoup de formes, toutes tassées ensemble, se chevauchant fortement, certaines coupées par le bord de la page.

4. Les concurrents

L'article a testé deux types d'« élèves » :

1. Le Robot Vieux Jeu (Heuristique) : Un programme informatique traditionnel qui examine l'image, repère des taches d'encre noire et devine : « C'est un cercle », « C'est un carré ». Il est rapide et bon pour les choses simples, mais se perd lorsque les formes se chevauchent.
2. La Super-IA (Modèles Multimodaux) : Deux des modèles d'IA les plus intelligents au monde (Claude Opus 4.7 et GPT-5.5) ont été invités à regarder l'image et à écrire le code. Ils ont été testés avec différents niveaux d'« effort de réflexion » (comme leur demander de « réfléchir plus fort » ou de « prendre plus de temps »).

5. Les Résultats : Un conte de deux forces

Les résultats ont été surprenants et ont montré qu'aucun des deux côtés n'est encore parfait.

• Sur les niveaux faciles : Le Robot Vieux Jeu a en fait gagné ! Il était meilleur pour obtenir le code exact correct pour des formes simples et non chevauchantes. Les Super-IA obtenaient souvent les bonnes formes mais gâchaient les détails minuscules (comme un rayon décalé de quelques pixels).

  • Analogie : Le robot est comme un menuisier capable de mesurer parfaitement une planche unique et isolée. L'IA est comme un artiste créatif qui sait à quoi ressemble une chaise mais peine à mesurer les jambes au millimètre près.

• Sur les niveaux difficiles : Lorsque les formes étaient empilées les unes sur les autres, le Robot Vieux Jeu se perdait et voyait souvent une grosse tache unique au lieu de formes distinctes. Les Super-IA ont conservé davantage de structure spatiale dans ces scènes plus complexes — en particulier tel que mesuré par l'IoU (Intersection over Union) du premier plan, qui évalue le chevauchement des régions peintes — et ont produit du code capturant la disposition générale de la pile. Mais aucun des deux côtés n'a maîtrisé les scènes difficiles : même les Super-IA ont eu du mal à reconstruire les détails exacts au niveau des pixels.

  • Analogie : Le robot voit une pile de linge sale et dit : « C'est une pile ». L'IA voit la pile et dit : « C'est une chemise, une chaussette et un chapeau tous emmêlés ensemble », mais elle a encore du mal à placer chaque vêtement à la position exacte.

• Le problème du « Score Parfait » : Même le meilleur modèle d'IA obtenait rarement un score parfait de 100 % (où l'image redessinée correspond pixel par pixel à l'original). Ils obtenaient généralement la structure correcte (les bonnes formes aux bons endroits) mais échouaient sur la précision (les nombres exacts pour la taille et la position).

6. Ce que cela signifie

L'article conclut que nous n'avons pas « terminé » avec ce problème.

• Le test n'est pas saturé (il n'est pas trop facile).
• Les modèles d'IA actuels sont excellents pour comprendre la grande image (la structure spatiale) mais peinent encore avec les détails minuscules (les paramètres exacts).
• Le test offre un moyen clair de mesurer les progrès : à mesure que l'IA s'améliore, elle devrait commencer à battre le Robot Vieux Jeu sur les niveaux faciles tout en maintenant son avance sur les niveaux difficiles.

En bref, ShapeCodeBench est un terrain de jeu frais et renouvelable où nous pouvons voir exactement où l'IA est forte (comprendre des scènes complexes) et où elle est encore maladroite (mesurer des détails précis).

Résumé technique

Résumé Technique : ShapeCodeBench

Énoncé du Problème

L'article aborde le défi de la reconstruction perception-vers-programme : étant donné une image raster rendue, un modèle doit émettre un programme de dessin exécutable qui, lorsqu'il est à nouveau rendu par un évaluateur déterministe, produit une image identique ou quasi identique. Bien que les modèles multimodaux modernes soient de plus en plus évalués sur des tâches d'image-vers-code (par exemple, capture d'écran-vers-HTML, extraction de structure), les benchmarks existants manquent souvent d'une combinaison d'exécution déterministe, de notation basée sur le rendu et de renouvelabilité. La plupart des benchmarks ne satisfont qu'un ou deux de ces critères, et peu permettent la régénération de jeux de test frais et non contaminés sans annotation manuelle. ShapeCodeBench est conçu pour combler cette lacune en fournissant un benchmark synthétique et renouvelable pour les graphiques inverses sur un Langage Spécifique à un Domaine (DSL) contraint.

Méthodologie

1. Conception du Benchmark

ShapeCodeBench se compose de quatre composants couplés :

• DSL (Langage Spécifique à un Domaine) : Un ensemble minimal de quatre primitives opérant sur une toile fixe de $512 \times 512$ pixels noirs sur fond blanc : filled_circle, circle, filled_square et square. Le langage prend en charge des paramètres entiers pour les coordonnées, la taille/rayon et la largeur du trait. Le analyseur est une implémentation stricte de liste blanche basée sur le module ast de Python, rejetant les imports, les boucles et les littéraux non entiers.
• Générateur de Scènes : Un générateur de nombres aléatoires (RNG) amorcé crée des scènes par échantillonnage par rejet de formes candidates. Il impose des contraintes spécifiques basées sur trois niveaux de difficulté (Facile, Moyen, Difficile) concernant le nombre de formes, l'étendue (rayon/taille), la largeur du trait, la probabilité de recadrage sur la toile et le chevauchement des boîtes englobantes.
• Rendeur : Utilise la bibliothèque Pillow pour rendre de manière déterministe le programme DSL en une image en niveaux de gris sur 8 bits. L'ordre de rendu est préservé, mais la palette binaire rend les scènes invariantes à l'ordre concernant l'ajout de pixels d'arrière-plan (les formes ultérieures ne peuvent pas effacer les formes antérieures).
• Évaluateur : Analyse le programme prédit par le modèle, le rend à nouveau et compare le raster résultant avec la vérité terrain.

2. Métriques d'Évaluation

Le système rapporte cinq métriques principales :

1. Correspondance Exacte : Égalité pixel par pixel entre l'image cible et l'image rendue à nouveau.
2. Précision des Pixels : Fraction de pixels correspondants.
3. IoU de l'Arrière-plan : Intersection sur Union des pixels noirs.
4. Succès de l'Analyse : Si le programme est syntaxiquement valide.
5. Succès de l'Exécution : Si le programme se rend sans erreur.

3. Configuration Expérimentale

Les auteurs ont évalué six systèmes sur une partition figée (eval_v1) de 150 échantillons (50 par niveau de difficulté) :

• Lignes de Base : Un plancher "Programme-Vide" et une ligne de base "CV-Heuristique" (vision par ordinateur classique utilisant des composantes connexes, une érosion morphologique et des rapports aire/périmètre pour estimer les paramètres de forme).
• Modèles Multimodaux :
  • Claude Opus 4.7 (1M de contexte) : Testé avec un effort de raisonnement "élevé" et "max".
  • GPT-5.5 : Testé avec un effort de raisonnement "moyen" et "très élevé".
• Protocole : Tous les modèles ont utilisé un prompting sans exemple (zero-shot) avec des contraintes de formatage strictes. Aucune chaîne de pensée ni aucun exemple à peu d'exemples (few-shot) n'a été utilisé.

Contributions Clés

1. Publication de ShapeCodeBench : Une suite complète de benchmarks incluant le DSL, un analyseur restreint sécurisé, un générateur de scènes amorcé avec trois niveaux de difficulté et un évaluateur basé sur le rendu.
2. Partition d'Évaluation Figée (eval_v1) : Un ensemble déterministe de 150 échantillons avec des hachages SHA-256 publiés pour une reproductibilité exacte entre plateformes.
3. Flux de Travail Renouvelable : Un mécanisme pour générer de nouvelles partitions de test retenues à partir de nouvelles graines et les noter automatiquement, atténuant la contamination par des instances exactes sans nécessiter d'annotation humaine.
4. Lanceur Indépendant du Fournisseur : Un outil pour enregistrer les invites, les configurations, les sorties brutes et les métriques, rendant les évaluations auditable.
5. Résultats de Référence : Une présentation complète de quatre configurations multimodales par rapport aux lignes de base non-LLM, révélant des modes de défaillance distincts et des écarts de performance.

Résultats

Performance Globale

• Correspondance Exacte : Le benchmark est loin d'être saturé. Le meilleur taux de correspondance exacte atteint par tout modèle multimodal est de 0,027 (GPT-5.5 moyen), tandis que la ligne de base heuristique classique atteint 0,087.
• IoU de l'Arrière-plan : Les modèles multimodaux surpassent nettement l'heuristique sur cette métrique. GPT-5.5 (très élevé) atteint une IoU moyenne de l'arrière-plan de 0,87, conservant la majeure partie de la structure spatiale.
• Succès de l'Analyse : Les LLM atteignent des taux de succès d'analyse élevés (0,97–1,00), les échecs étant principalement dus à des paramètres hors plage ou à des largeurs de trait invalides.

Croisement Dépendant du Niveau

Une découverte critique est le croisement dépendant du niveau entre l'heuristique et les LLM :

• Niveau Facile : L'heuristique classique mène en correspondance exacte (0,26) car les scènes sont composées de formes séparées et non chevauchantes que les composantes connexes peuvent individuer parfaitement. Les modèles multimodaux peinent ici, manquant souvent la correspondance exacte à cause de petites erreurs de paramètres (décalage de quelques pixels).
• Niveaux Moyen/Difficile : L'heuristique s'effondre car les formes chevauchantes fusionnent en composantes connexes uniques, empêchant l'individuation. Les modèles multimodaux conservent la structure spatiale (IoU élevé) et peuvent énumérer les formes chevauchantes, bien qu'ils échouent toujours à atteindre des correspondances exactes pixel par pixel en raison de problèmes de précision des paramètres sous occlusion.

Modes de Défaillance

• LLM : Les échecs sont dominés par les erreurs "out_of_range" (coordonnées/taille hors des limites valides) et "invalid_stroke". Ils ont également du mal avec l'estimation précise des paramètres (par exemple, rayon exact ou largeur de trait) et la distinction entre les formes creuses et pleines lorsque les traits sont fins.
• Heuristique : Échoue à individuer les formes chevauchantes ou recadrées, entraînant une chute brutale de l'IoU sur les niveaux plus difficiles.

Importance et Revendications

L'article positionne ShapeCodeBench non pas comme un remplacement des benchmarks existants comme TurtleBench ou Image2Struct, mais comme un outil complémentaire qui privilégie le contrôle et la reproductibilité au réalisme.

• Valeur Diagnostique : Le benchmark expose avec succès des modes de défaillance distincts : les LLM peinent avec l'émission précise de paramètres même lorsqu'ils comprennent la structure de la scène, tandis que la vision par ordinateur classique échoue à l'individuation dans des scènes complexes.
• Renouvelabilité : En permettant la génération de nouvelles partitions, le benchmark offre une boucle de rétroaction durable pour le développement de modèles, évitant les problèmes de "contamination" courants dans les jeux de données statiques.
• Portée Modeste : Les auteurs déclarent explicitement que la version actuelle est une "v1" avec des limitations délibérées (palette monochrome, quatre primitives, zero-shot uniquement). Ils ne prétendent pas avoir résolu le problème de l'induction de programmes visuels, mais fournissent plutôt un environnement rigoureux et renouvelable pour mesurer les progrès et identifier des lacunes spécifiques entre la perception et l'émission de code structuré.

L'article conclut que, bien que les modèles de pointe actuels montrent des promesses en matière de raisonnement spatial (IoU élevé), ils sont loin de la précision requise pour la reconstruction exacte de programmes, et l'écart entre la performance heuristique sur des tâches simples et la performance des LLM sur des tâches complexes souligne la nécessité de recherches supplémentaires en estimation de paramètres et en raisonnement sur l'occlusion.