RealChart2Code: Advancing Chart-to-Code Generation with Real Data and Multi-Task Evaluation

Ce papier présente RealChart2Code, un nouveau benchmark à grande échelle évaluant la capacité des modèles vision-langage à générer des visualisations complexes à partir de données réelles, révélant ainsi des limitations significatives des modèles actuels face à des tâches analytiques authentiques.

L'essentiel

🎨 Le Grand Défi : Transformer un Dessin en Recette de Cuisine

Imaginez que vous avez un magnifique gâteau (un graphique complexe) devant vous. Vous voulez que votre robot de cuisine (l'intelligence artificielle) le refasse exactement pareil, mais en vous donnant la recette (le code informatique) pour le cuisiner lui-même.

C'est ce qu'on appelle le "Chart-to-Code" (du graphique au code). Jusqu'à présent, les robots étaient très bons pour copier des gâteaux simples : un petit muffin ou un cookie rond. Mais dès qu'on leur montrait un gâteau d'anniversaire à plusieurs étages avec des décorations complexes, ils paniquaient et faisaient n'importe quoi.

🚀 La Nouvelle Épreuve : RealChart2Code

Les chercheurs de cet article ont créé un nouveau terrain de jeu (un benchmark) appelé RealChart2Code. C'est comme passer d'un entraînement sur un terrain de tennis vide à un match en pleine tempête, avec des vents changeants et des obstacles imprévus.

Voici ce qui rend ce nouveau défi spécial :

1. Des Données Réelles, pas du Fictif :

   • L'ancien jeu : On utilisait des données inventées, comme des listes de fruits fictifs. C'était trop facile.
   • Le nouveau jeu : On utilise de vraies données, comme les ventes réelles d'une entreprise ou les statistiques de santé d'un pays. C'est "sale", complexe et plein de surprises, comme la vraie vie.

2. Trois Types de Missions :

   • La Copie (Replication) : Le robot voit le gâteau et doit écrire la recette.
   • La Reproduction (Reproduction) : Le robot voit le gâteau ET a les ingrédients bruts (les données). Il doit comprendre comment assembler les pièces. C'est comme si on lui donnait la farine et les œufs en plus de la photo du gâteau.
   • La Réparation (Refinement) : C'est le plus dur. Le robot fait une première recette, le gâteau sort moche (trop de sucre, couleur bizarre), et vous lui dites : "Hé, corrige ça !" Il doit alors modifier sa recette sans casser le reste. C'est comme un dialogue avec un chef qui apprend de ses erreurs.

📉 Ce que les chercheurs ont découvert

Ils ont testé 14 robots intelligents (des modèles d'IA les plus avancés du monde, comme les versions de Claude, GPT, Gemini, etc.) sur ce nouveau terrain.

Le résultat est sans appel :

• Les champions du "facile" sont des débutants dans le "difficile" : Des robots qui avaient 95/100 sur les vieux tests simples sont tombés à 50/100 sur ce nouveau test. C'est comme un élève qui a 20/20 en calcul mental mais qui rate un problème de physique complexe.
• Le fossé entre les géants et les autres : Les robots "privés" (ceux qu'on paye, comme les versions Pro de Claude ou GPT) sont bien meilleurs que les robots "gratuits" (open-source), mais même les meilleurs ont du mal. Ils arrivent à faire un petit dessin, mais dès qu'il faut faire un tableau de bord avec 10 graphiques différents qui interagissent, ils se perdent.

🔍 Pourquoi échouent-ils ? (Les erreurs typiques)

Les chercheurs ont analysé les erreurs comme un détective :

• L'architecte aveugle : L'IA arrive à dessiner un rond ou une barre, mais elle ne sait pas organiser la "pièce". Elle met les graphiques les uns sur les autres, comme si on empilait des meubles n'importe où dans un salon.
• Le hallucinateur de code : Parfois, l'IA invente des commandes qui n'existent pas. C'est comme si un chef disait : "Ajoutez une pincée de sel de lune". Le robot croit que c'est vrai, mais le code plante.
• La perte de contexte : Quand on lui demande de corriger une erreur, il répare le problème mais casse tout le reste du graphique. C'est comme si vous demandiez à un peintre de changer la couleur du ciel, et qu'il peignait tout le tableau en noir par erreur.

💡 La Conclusion en une phrase

Ce papier nous dit que l'IA est très douée pour imiter des dessins simples, mais elle n'est pas encore prête à comprendre et créer des visualisations de données complexes et réelles comme le ferait un humain expert.

C'est une étape importante : en montrant où les robots échouent vraiment, les chercheurs peuvent maintenant les entraîner pour qu'ils deviennent de véritables assistants de data scientists, capables de gérer le chaos des vraies données.

Résumé technique

1. Le Problème : Limites des Benchmarks Actuels

Bien que les Modèles de Langage Visuel (VLM) et les LLM démontrent des capacités impressionnantes dans la génération de code, leur aptitude à reproduire des visualisations complexes issues de données réelles reste largement inévaluée.

• Défaut des benchmarks existants : Des benchmarks antérieurs comme Plot2Code ou ChartMimic se concentrent sur des graphiques simples, à panneau unique, et utilisent souvent des données synthétiques ou des paires image-code préexistantes sur Internet (risque de fuite de données).
• Le fossé de complexité : Les modèles actuels échouent souvent à générer des structures de graphiques complexes (multi-panneaux, composites) à partir de données brutes volumineuses et réelles. Ils peinent également à itérer et à corriger le code lors de conversations multi-tours, une compétence essentielle dans les flux de travail réels.

2. Méthodologie : Le Benchmark RealChart2Code

Pour combler ce vide, les auteurs introduisent RealChart2Code, un benchmark à grande échelle conçu pour évaluer rigoureusement les capacités de génération de code de visualisation.

A. Construction des Données

• Source authentique : Les données proviennent de la plateforme Kaggle, après un filtrage rigoureux de plus de 8 000 jeux de données (sélection de 1 036 jeux de haute qualité).
• Volume : Le benchmark contient 2 896 instances au total, couvrant environ 860 millions de lignes de données brutes.
• Diversité : Il couvre 8 domaines thématiques (Finance, Santé, Recherche, etc.), 35 sous-thèmes et 50 types de graphiques distincts, avec un accent mis sur les mises en page composites et complexes.

B. Définition des Trois Tâches Principales

Le benchmark évalue les modèles sur trois variantes de la tâche "Chart-to-Code" :

1. Réplication de Graphique (Chart Replication) : Le modèle reçoit uniquement l'image du graphique et doit inverser le processus pour générer le code (Image $\to$ Code). Cela teste la capacité de traduction visuelle pure.
2. Reproduction de Graphique (Chart Reproduction) : Le modèle reçoit l'image, les données brutes (CSV) et les métadonnées. Il doit générer le code en utilisant les données réelles fournies (Image + Données $\to$ Code). Cela teste la capacité à manipuler de grandes structures de données.
3. Raffinement de Graphique (Chart Refinement) : Un scénario interactif où le modèle reçoit un graphique erroné (avec des bugs injectés manuellement) et une instruction de correction en langage naturel. Il doit déboguer et modifier le code en plusieurs tours de conversation.

C. Évaluation et Métriques

• Environnement d'exécution : Un bac à sable (sandbox) Dockerisé avec Python 3.13, Matplotlib, Seaborn, etc., pour garantir l'exécution sûre et reproductible du code.
• Métriques :
  • Taux de réussite (Pass Rate) : Le code s'exécute-t-il sans erreur ?
  • Précision Visuelle (Score 0-2) : Évaluée par un panel de juges multi-agents sur 8 critères (type de graphique, mise en page spatiale, texte, axes, couleurs, style, complétude des composants, cohérence des motifs de données).
  • Alignement des Données : Pour la tâche de reproduction, une vérification au niveau du code assure que les transformations de données sont computationnellement équivalentes à la référence, et non seulement visuellement similaires.
  • Qualité d'exécution : Clarté visuelle, équilibre compositionnel et qualité typographique.

3. Contributions Clés

1. Premier benchmark basé sur des données réelles : Contrairement aux approches synthétiques, RealChart2Code utilise des jeux de données authentiques et des scénarios d'analyse réels.
2. Évaluation Multi-Tâche et Interactive : C'est le premier benchmark à évaluer systématiquement le raffinement itératif du code dans un contexte conversationnel (multi-tours).
3. Analyse Comparative Rigoureuse : Évaluation de 14 modèles VLM leaders (5 propriétaires et 9 open-weight) sur une échelle de difficulté inédite.
4. Validation Humaine et Automatique : Démonstration d'une forte corrélation ($\kappa \approx 0.83$) entre les juges automatisés multi-agents et l'évaluation humaine, validant la robustesse de la méthodologie.

4. Résultats Principaux

L'évaluation révèle des performances décevantes pour les modèles actuels face à la complexité réelle :

• Dégradation des performances : Les modèles qui excellent sur des benchmarks simples (ex: ChartMimic avec des scores >90%) subissent un effondrement de performance sur RealChart2Code (chute à ~50% pour les modèles propriétaires, <25% pour les modèles open-weight).
• Écart Propriétaire vs Open-Source :
  • Modèles Propriétaires : Claude-4.5-Opus se distingue avec le meilleur score global (8.2/10), suivi de Gemini-3-Pro-Preview (8.1). Ils montrent une meilleure compréhension visuelle et spatiale.
  • Modèles Open-Source : Les meilleurs modèles (ex: Qwen3-VL-235B, Intern-VL-3.5-241B) obtiennent des scores inférieurs à 4, soit moins de la moitié des modèles propriétaires.
• Analyse des Erreurs :
  • Modèles Open-Source : Souffrent principalement d'erreurs de syntaxe et d'exécution (hallucination de bibliothèques inexistantes, fonctions invalides) et de défaillances dans le raisonnement spatial (superposition de sous-graphiques).
  • Modèles Propriétaires : Génèrent du code syntaxiquement correct mais échouent souvent sur le mappage des données (mauvais axe, données incorrectes) et négligent parfois les instructions de raffinement, introduisant de nouvelles erreurs lors de la correction ("Regressive Editing").
• Limites du Raisonnement Spatial : Même les meilleurs modèles peinent à gérer les mises en page hiérarchiques complexes (ex: grilles imbriquées, graphiques joints) et l'équilibre global de la figure.

5. Signification et Perspectives

• Révélation d'un "Fossé de Complexité" : L'étude démontre que les capacités actuelles des LLM/VLM sont largement surévaluées par les benchmarks synthétiques. La transition vers des données réelles et des tâches complexes expose des lacunes fondamentales en raisonnement logique et spatial.
• Guide pour la Recherche Future : Les résultats suggèrent que l'amélioration des modèles nécessite non seulement plus de données d'entraînement, mais aussi des approches spécifiques pour le raisonnement spatial, la gestion de l'état dans les conversations multi-tours et la compréhension profonde des structures de données.
• Ressources Ouvertes : Les auteurs publient le benchmark, le code et les données sur HuggingFace et GitHub, établissant une nouvelle référence pour l'évaluation de la génération de code de visualisation.

En conclusion, RealChart2Code marque un tournant dans l'évaluation des VLM, passant d'une vérification de la syntaxe de base à une évaluation rigoureuse de la capacité à transformer des données complexes en visualisations fidèles et fonctionnelles, un défi que même les modèles les plus avancés n'ont pas encore totalement résolu.