ChartEditBench: Evaluating Grounded Multi-Turn Chart Editing in Multimodal Language Models

1. Problématique

Bien que les Modèles de Langage Multimodaux (MLLM) excellent dans la génération de graphiques en un seul tour (single-turn), leur capacité à soutenir l'analyse exploratoire de données dans des scénarios réels reste sous-évaluée. Dans la pratique, les utilisateurs n' créent pas de visualisations en une seule étape ; ils les raffinent de manière itérative via des interactions multi-tours. Cela nécessite de maintenir un « terrain d'entente » (common ground), de suivre les modifications précédentes et de s'adapter aux préférences évolutives.

Les benchmarks existants se concentrent souvent sur la génération à partir de zéro ou la compréhension statique, ignorant la complexité de la modification incrémentielle de code. De plus, les méthodes d'évaluation actuelles (comme les juges basés sur LLM ou les métriques de similarité d'embeddings comme CLIP) souffrent de limitations : elles manquent de granularité, sont sensibles aux variations d'échantillonnage et échouent à capturer les écarts sémantiques subtils ou les erreurs d'exécution de code.

2. Méthodologie et Proposition : ChartEditBench

Les auteurs introduisent ChartEditBench, un benchmark synthétique conçu pour évaluer la capacité des modèles à modifier du code de graphique de manière incrémentielle et ancrée visuellement.

A. Définition des Tâches

Le benchmark propose deux tâches complémentaires simulées sur des conversations multi-tours :

1. Modification Code-à-Code : Étant donné le code initial ($c_1$), l'image du graphique ($p_1$) et une image cible modifiée ($p_2$), le modèle doit prédire le nouveau code ($c_2$).
2. Modification par Delta Naturel (NL Delta) : Étant donné le code initial ($c_1$), l'image ($p_1$) et une instruction en langage naturel ($\delta_{nl}$), le modèle doit générer le code modifié ($c_2$).

Dans les deux cas, chaque tour s'appuie sur la prédiction du tour précédent, créant une chaîne de dépendances qui teste la robustesse face à l'accumulation d'erreurs.

B. Construction du Dataset

• Génération Synthétique : Un pipeline automatisé génère 5 000 instances (4 142 utilisées dans l'expérience finale) couvrant 37 types de graphiques (matplotlib) et 35 types de modifications.
• Structure des Tours : Chaque instance comprend 6 tours (1 initial + 5 modifications). La difficulté progresse :
  • Tours 1 : Changements de style (couleurs, titres).
  • Tours 2-3 : Modifications structurelles (marqueurs, échelles).
  • Tours 4-5 : Transformations complexes (changement de type de graphique, sous-graphiques, axes doubles).
• Validation Rigoureuse : Un système de validation à quatre étapes (AST, exécution dans un bac à sable, rendu d'image, structure) garantit que seuls les graphiques valides sont conservés. Un sous-ensemble de 430 exemples a été vérifié par des experts humains.

C. Cadre d'Évaluation Hybride

Pour pallier les défauts des juges LLM purs, les auteurs proposent une métrique composite :

1. Taux d'Exécution (Execution Rate) : Vérifie que le code généré s'exécute sans erreur et produit une image valide.
2. Score de Respect des Instructions (Instruction Following) :
   • Instructions programmatiques : Vérification par assertions (ex: marker='*').
   • Instructions sémantiques : Évaluation par un modèle LLM (Chart-R1) sur une échelle de 1 à 5.
3. Score de Qualité du Code (Code Quality) : Vérification de la structure (imports, fermeture des figures, etc.).
4. Score de Similarité Visuelle (Visual Similarity) : Un modèle LLM (Chart-R1) compare l'image générée à l'image cible en listant les différences majeures (type de graphique erroné) et mineures (couleurs, espacement).

3. Résultats Expérimentaux

Les auteurs ont évalué six modèles (propriétaires et open-source) sur ce benchmark.

A. Performance Globale

• Meilleurs modèles : Claude Haiku 4.5 obtient le score global le plus élevé (2.187/5), suivi de près par Qwen3-VL-30B-A3B (2.139).
• Compromis : GPT-5-mini excelle dans le respect des instructions explicites mais montre une fidélité visuelle moindre.
• Modèles petits : Les modèles plus petits (ex: InternVL3-1B) montrent des écarts de performance significatifs, notamment dans l'exécution des instructions complexes.

B. Dégradation Multi-Tours (Accumulation d'Erreurs)

C'est la découverte majeure : la performance se dégrade systématiquement à chaque tour de conversation.

• Tous les modèles subissent une baisse de performance de 20 % à 33 % entre le premier et le cinquième tour.
• Les erreurs s'accumulent : une erreur de code à un tour $t$ corrompt l'état d'entrée pour le tour $t+1$.
• Les modèles plus petits sont plus sensibles à cette dégradation, ce qui élargit l'écart de performance entre les modèles forts et faibles au fil du temps.

C. Analyse par Type de Modification

• Modifications de Style : Les modèles réussissent bien (changement de couleurs, polices).
• Modifications Centrées sur les Données : Les modèles échouent fréquemment sur des opérations mathématiques complexes comme les moyennes mobiles (rolling averages). Les erreurs incluent des décalages d'index (off-by-one) et des mauvais traitements des cas limites.
• Taux de Rendu : Les modèles propriétaires maintiennent un taux de succès de rendu de 85-90 %, tandis que les modèles open-source varient de 46 % à 90 % selon la complexité.

D. Instructions Programmatiques vs Sémantiques

Les modèles performants sur les instructions précises (assertions) ne sont pas toujours les meilleurs sur les instructions sémantiques (jugement LLM), et vice-versa. Cela valide l'approche d'évaluation hybride.

4. Contributions Clés

1. Formalisation du Benchmark : Définition de la modification incrémentielle de code de graphique comme une tâche centrale pour les assistants multimodaux.
2. Dataset ChartEditBench : Création d'un ensemble de données contrôlé en difficulté (5 000 instances, 35 types de modifications) avec un sous-ensemble vérifié par l'homme.
3. Cadre d'Évaluation Robuste : Introduction d'une métrique composite intégrant l'exécution de code, la similarité visuelle ancrée et la vérification logique, surpassant les juges LLM traditionnels.

5. Signification et Implications

ChartEditBench met en lumière une limite fondamentale des MLLM actuels : bien qu'ils soient compétents pour la génération en un seul tour, ils peinent à maintenir un contexte cohérent et à exécuter des transformations de données complexes sur plusieurs tours.

• Pour la recherche : Le benchmark établit un test rigoureux pour les agents de programmation multimodaux, similaire à ce que SWE-bench représente pour le génie logiciel.
• Pour le développement : Il souligne la nécessité d'améliorer la capacité des modèles à raisonner sur les opérations séquentielles de données et à gérer l'état (state management) dans des flux de travail itératifs.
• Évaluation : Il démontre que les métriques d'évaluation doivent aller au-delà de la simple similarité visuelle pour inclure la validité d'exécution et la fidélité sémantique des modifications de code.

En résumé, ChartEditBench révèle que l'adoption réelle des MLLM pour l'analyse de données dépendra de leur capacité à gérer la complexité des interactions multi-tours et à éviter l'accumulation d'erreurs, un défi que les modèles actuels ne maîtrisent pas encore pleinement.