🤖 AI

Who Leads Now? Token-Level Modality Arbitration for Chart-to-Code Generation

Le document présente MoCA, un nouveau cadre qui emploie un bloc d'arbitrage cross-modal pour séparer et coordonner dynamiquement les branches visuelle et de code distinctes au niveau du jeton, surmontant ainsi l'interférence inhérente aux méthodes actuelles de chart-to-code et atteignant une performance supérieure grâce à un arbitrage de modalité structuré.

Auteurs originaux : Qinghao Fu, Yarong Wang, Shunlei Ning, Yilin Wang, Shunwen Bai, Xinda Wang, Jiaotuan Wang, Yinan Nie, Wei Zhou

Publié 2026-08-18

📖 7 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Qinghao Fu, Yarong Wang, Shunlei Ning, Yilin Wang, Shunwen Bai, Xinda Wang, Jiaotuan Wang, Yinan Nie, Wei Zhou

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

À l'ère du numérique, les données sont souvent présentées sous forme de graphiques : des diagrammes à barres, des tracés linéaires et des diagrammes circulaires qui transforment les chiffres en récits visuels. Pendant des décennies, les ordinateurs ont été excellents pour lire ces images afin de répondre à des questions simples, telles que « quelle est la valeur la plus élevée ? » ou « quelle est la couleur de la plus grande part ? ». Cependant, un défi plus difficile est apparu : demander à un ordinateur non seulement de lire un graphique, mais de le reconstruire de toutes pièces en utilisant du code. Cette tâche exige qu'une machine regarde une image statique, comprenne les données cachées ainsi que les choix de conception spécifiques derrière elle, puis écrive un ensemble d'instructions capables de dessiner une image identique sur un écran. C'est un test qui sollicite simultanément deux compétences très différentes. La machine doit être un observateur au regard aiguisé, capable de remarquer des détails subtils comme la nuance exacte d'une ligne ou la position précise d'une étiquette, et elle doit également être un architecte discipliné, capable d'écrire un code logique et sans erreur pour reproduire ces détails.

Pendant longtemps, les chercheurs ont tenté d'apprendre aux ordinateurs à faire ces deux choses à la fois, en fusionnant la compréhension visuelle et la capacité de codage en un seul cerveau massif. L'hypothèse était qu'un modèle pouvait apprendre à voir et à écrire du code simultanément. Pourtant, cette approche menait souvent à la confusion. Lorsqu'un graphique était visuellement complexe, le modèle pouvait avoir du mal à écrire le code. Lorsqu'un graphique exigeait une logique complexe, le modèle pouvait échouer à percevoir les détails. Les deux compétences, bien que nécessaires pour le même travail, semblaient se gêner lorsqu'elles étaient forcées de partager les mêmes voies internes. Une nouvelle étude de chercheurs de l'Université de Zhejiang, d'Ant Group et d'autres institutions suggère que la solution n'est pas de fusionner ces capacités, mais de les garder séparées et de les laisser prendre tour à tour la direction du travail.

Les chercheurs, dirigés par Qinghao Fu et Wei Zhou, ont développé un système qu'ils appellent MoCA. Au lieu de forcer un seul modèle à tout faire, ils ont construit un cadre doté de deux voies distinctes : l'une dédiée à la compréhension visuelle et l'autre dédiée au codage. Imaginez une équipe de construction où une équipe se spécialise dans l'inspection des matières premières et l'autre dans la construction proprement dite. Dans MoCA, ces deux équipes travaillent côte à côte, mais elles ne fusionnent pas en une entité unique et confuse. Au lieu de cela, un décideur léger et peu encombrant, que les auteurs appellent un arbitre, surveille le travail en temps réel. À chaque mot de code généré par le système, cet arbitre décide de la part d'aide à solliciter de l'équipe visuelle et de la part de confiance à accorder à l'équipe de codage.

Cette prise de décision est constante et change d'un moment à l'autre. Lorsque le système tente de déterminer la couleur d'une barre spécifique dans un graphique, l'arbitre s'appuie fortement sur la voie visuelle. Lorsqu'il doit décider comment empiler ces barres ou calculer la hauteur totale, l'arbitre transfère sa confiance vers la voie du codage. Les chercheurs ont découvert que ce basculement dynamique n'est pas aléatoire ; il suit un schéma structuré. Dans les premières étapes de la génération d'un graphique, le système s'appuie davantage sur le traitement visuel pour comprendre l'entrée. À mesure qu'il progresse dans la tâche, il bascule vers la génération de code pour construire la structure. Enfin, lorsqu'il termine, il peut revenir à l'affinement visuel pour s'assurer que les détails correspondent à l'image originale. Cette coordination fluide permet au système de gérer des graphiques aussi bien visuellement désordonnés que logiquement complexes, sans rester bloqué.

Pour apprendre à ce système comment travailler, les chercheurs ont utilisé un processus d'apprentissage en deux étapes. D'abord, ils ont montré au modèle des milliers d'exemples de graphiques et de leur code correspondant, mais ils ne lui ont pas seulement demandé le code final. Ils ont également fourni un « processus de pensée », une décomposition étape par étape de la manière de regarder le graphique et de le traduire en instructions. Cela a aidé le modèle à apprendre à connecter ce qu'il voyait avec ce qu'il devait écrire. Dans la seconde étape, le système a été autorisé à s'exercer par lui-même. Il générait du code, et si le code s'exécutait avec succès et que l'image résultante ressemblait à l'originale, il recevait une récompense. Si le code échouait ou si l'image était incorrecte, il était corrigé. Ce cycle d'essais et d'erreurs, guidé par des récompenses spécifiques pour la logique du code et la précision visuelle du résultat, a affiné la capacité du système à coordonner ses deux branches.

Les résultats de cette approche ont été testés par rapport à plusieurs autres modèles avancés sur trois bancs d'essai conçus pour évaluer la génération de code à partir de graphiques. Le nouveau système, MoCA, a surpassé la concurrence dans des domaines clés. Sur un test majeur, il a réussi à générer du code fonctionnel pour 88,83 % des graphiques, une amélioration significative par rapport aux autres modèles spécialisés. Il a également obtenu des scores plus élevés sur les mesures évaluant la correspondance entre le code généré et le texte ainsi que la structure du graphique d'origine. Peut-être plus important encore, les chercheurs ont montré que ces gains ne provenaient pas simplement du fait que le modèle était plus grand ou possédait plus de données d'entraînement. Lorsqu'ils ont testé des versions du système utilisant la même puissance de calcul mais dépourvues de mécanisme de basculement dynamique, les performances ont chuté. Cela a confirmé que le secret de la réussite ne résidait pas seulement dans une plus grande puissance de calcul, mais dans une manière plus intelligente de l'organiser.

L'étude a également révélé que le décideur du système a appris à être très spécifique. Il n'appliquait pas une règle fixe, telle que « toujours utiliser 50 % d'aide visuelle et 50 % d'aide au codage ». Au contraire, il ajustait sa stratégie en fonction du graphique spécifique qu'il examinait et de la partie du code qu'il écrivait. Pour certains graphiques, la branche visuelle pouvait dominer l'ensemble du processus. Pour d'autres, la branche de codage pouvait prendre la direction presque immédiatement. Cette flexibilité a permis au système de s'adapter aux exigences uniques de chaque tâche, qu'il s'agisse d'un simple graphique linéaire ou d'un diagramme multicouche complexe.

En séparant les compétences de vision et d'écriture, puis en leur attribuant un gestionnaire dédié pour coordonner leurs efforts, les chercheurs ont résolu un problème qui avait entravé les tentatives précédentes. Ils ont démontré que pour des tâches complexes comme la reconstruction d'un graphique à partir d'une image, le tout est supérieur à la somme de ses parties uniquement si les parties sont autorisées à fonctionner selon leurs propres forces. Le système ne cherche pas à être un maître de tout à la fois ; il sait exactement quand regarder et quand écrire, produisant des résultats qui sont à la fois fidèles visuellement et logiquement cohérents. Cette approche offre un nouveau modèle pour la façon dont l'intelligence artificielle pourrait traiter d'autres tâches nécessitant un mélange de types d'intelligences très différents, passant de l'idée d'un modèle unique et polyvalent vers un avenir plus coordonné et adaptable.

Résumé Technique : MoCA – Arbitrage de Modalité au Niveau du Token pour la Génération de Code à partir de Graphiques

Définition du Problème

La génération de code à partir de graphiques nécessite qu'un modèle interprète les détails visuels fins d'une image de graphique et produise un code de traçage exécutable qui reproduit fidèlement l'original. Cette tâche présente un défi unique : les exigences en matière de fondement visuel (reconnaissance des étiquettes, des couleurs, des mises en page) et de génération de code (construction de la logique, des axes et des structures) ne sont pas uniformes selon les entrées.

Graphiques visuellement complexes : Nécessitent une reconnaissance précise des étiquettes denses et des variations visuelles subtiles, mais peuvent avoir une logique de traçage plus simple.
Graphiques exigeant du code : Peuvent présenter des visuels simples mais nécessiter des structures logiques complexes (ex: barres empilées, axes personnalisés).

Les approches existantes entraînent généralement les capacités visuelles et de codage séparément ou affinent un modèle unique où ces capacités sont entremêlées. Aucune de ces stratégies ne modélise explicitement l'interaction dynamique entre ces deux capacités distinctes, ce qui conduit souvent à des échecs où le modèle interprète mal les détails visuels ou génère un code syntaxiquement incorrect. De plus, les techniques de fusion de modèles existantes reposent souvent sur des coefficients de paramètres statiques et indépendants de l'entrée, échouant ainsi à s'adapter aux demandes variables de chaque instance de graphique.

Méthodologie : MoCA (Mixture of Cross-modal Arbitration)

Les auteurs proposent MoCA, un cadre conçu pour séparer les capacités visuelles et de codage en voies distinctes tout en coordonnant dynamiquement leurs contributions pendant la génération.

1. Architecture : Bloc d'Arbitrage Cross-modal (CAB)

MoCA repose sur une architecture à double branche où une Branche Visuelle et une Branche de Code opèrent comme des transformations distinctes au sein du modèle.

Initialisation : Le cadre utilise Qwen2.5-VL-7B comme squelette multimodal et Qwen2.5-Coder-7B pour initialiser la branche de code. Plus précisément, la Branche Visuelle est initialisée à partir des paramètres du réseau de propagation avant (FFN) du modèle de vision-langue, tandis que la Branche de Code est initialisée à partir des paramètres FFN correspondants du modèle de code.
L'Arbitre : Au cœur de MoCA se trouve un Arbitre léger au sein de chaque CAB. Pour chaque token $t$ à chaque couche $l$ , l'Arbitre prend la représentation cachée intermédiaire $h_{i,l,t}$ et prédit les poids des branches $\alpha_{i,l,t} = (\alpha^{vis}, \alpha^{code})$ .
Coordination Dynamique : La sortie du CAB est une somme pondérée des deux branches :
$z_{i,l,t} = \alpha^{vis}_{i,l,t} B^{vis}(h_{i,l,t}) + \alpha^{code}_{i,l,t} B^{code}(h_{i,l,t})$
Cela permet au modèle d'allouer les contributions en fonction de l'instance d'entrée spécifique, de la profondeur de la couche du réseau et du token de génération actuel, plutôt que d'utiliser des coefficients globaux fixes.

2. Cadre d'Entraînement

MoCA emploie une stratégie d'entraînement en deux étapes pour aligner le raisonnement structuré avec la génération de code exécutable :

Étape 1 : Fine-Tuning Supervisé (SFT) avec SoT Auto-Distillé
- Le modèle est entraîné sur des paires de données graphique-code augmentées de trajectoires de Snippet-of-Thought (SoT).
- Ces trajectoires décomposent la correspondance de l'entrée visuelle vers le code en étapes intermédiaires explicites.
- Auto-distillation : Au lieu d'utiliser des données SoT brutes générées par un enseignant, les auteurs appliquent l'auto-distillation pour produire des trajectoires qui s'alignent mieux avec la propre distribution de génération de MoCA, réduisant ainsi l'écart entre l'entraînement et l'inférence.
- Le modèle est optimisé via une perte d'entropie croisée autorégressive standard sur les séquences combinées SoT et code.
Étape 2 : Apprentissage par Renforcement (RL)
- Le modèle est davantage optimisé en utilisant l'Optimisation de Politique Relative de Groupe (GRPO).
- Une fonction de récompense multidimensionnelle est employée, agrégeant cinq signaux :
  1. Consistance de Format ( $R_{fmt}$ ) : Respect de la structure de sortie.
  2. Consistance de Raisonnement ( $R_{con}$ ) : Alignement entre le SoT et le code généré.
  3. Fidélité Structurelle ( $R_{str}$ ) : Reconstruction des attributs du graphique via l'analyse AST.
  4. Validité d'Exécution ( $R_{exec}$ ) : Si le code s'exécute avec succès.
  5. Similitude Visuelle ( $R_{vis}$ ) : Comparaison entre le graphique rendu et l'image de référence.
- Ces récompenses fournissent une supervision tant au niveau du processus (raisonnement) que du résultat (exécution/visuel).

Principales Contributions

Formulation de la Coordination Adaptative : L'article cadre la génération de code à partir de graphiques comme un problème de coordination de capacités cross-modales, arguant que le fondement visuel et la génération de code sont des capacités complémentaires mais hétérogènes qui nécessitent une interaction dynamique explicite.
Architecture MoCA : Introduction d'une architecture à double branche avec le Bloc d'Arbitrage Cross-modal (CAB). Cela préserve l'expertise visuelle et de code distincte tout en utilisant un Arbitre léger, conditionné par l'entrée, pour allouer dynamiquement les contributions au niveau du token et de la couche.
Cadre de Formation et d'Analyse : Établissement d'un pipeline d'entraînement combinant la supervision SoT auto-distillée avec des récompenses RL multidimensionnelles. Les auteurs fournissent des preuves empiriques que l'Arbitre apprend des motifs d'allocation structurés (variant systématiquement selon les tokens, les couches et les instances) plutôt que des poids arbitraires ou uniformes.

Résultats Expérimentaux

MoCA a été évalué sur trois benchmarks : ChartMimic, Plot2Code et ChartX.

Performance : MoCA a obtenu des résultats de pointe ou compétitifs à travers les modèles de domaine général et spécialisés en graphiques.
- Sur ChartMimic, il a obtenu la meilleure performance sur les trois métriques (Taux d'exécution : 88,83, Bas niveau : 75,13, Haut niveau : 73,48), surpassant largement les bases de référence les plus fortes.
- Sur Plot2Code, il a atteint le taux de passage de code le plus élevé (87,88), dépassant de 2,27 points la base de référence suivante.
- Il a maintenu des performances compétitives sur les métriques sémantiques (Text Match) et perceptuelles (GPT Score), surpassant souvent des modèles beaucoup plus grands (ex: Qwen2.5-VL-72B) en termes d'exécution et de fidélité de reconstruction.
Études d'Ablation :
- Étapes d'Entraînement : Il a été démontré que le SFT et le RL étaient tous deux nécessaires ; le SFT établit une correspondance stable, tandis que le RL améliore l'exécutabilité et la fidélité visuelle.
- Initialisation des Branches : Une variante avec deux branches visuelles (Visuel + Visuel) a moins bien performé que MoCA, confirmant que les gains proviennent de l'initialisation d'expertises complémentaires, et non simplement du nombre de paramètres.
- Arbitrage : Une variante avec des poids de branche fixes (0,5/0,5) a été moins performante que MoCA, démontrant la nécessité d'un arbitrage conditionné par l'entrée.
- Fusion Statique : MoCA a nettement surpassé les approches de fusion de paramètres statiques (comme VisCodex), soulignant la limite des coefficients fixes pour les tâches hétérogènes.

Signification et Revendications

L'article affirme que les gains de performance de MoCA ne peuvent être attribués uniquement à la taille plus grande du modèle ou à des données d'entraînement supplémentaires. Au contraire, les améliorations découlent des contributions conjointes de :

Initialisation de Branches Complémentaires : Exploitation de l'expertise pré-entraînée tant en vision qu'en code.
Arbitrage Conditionné par l'Entrée : Capacité d'ajuster dynamiquement la dépendance envers les branches visuelles ou de code en fonction des besoins spécifiques de l'entrée et du contexte de génération.

Les auteurs concluent qu'un modèle explicite de l'interaction entre le fondement visuel et la synthèse de code via un arbitrage au niveau du token est une étape cruciale pour la génération de code à partir de graphiques, permettant aux modèles de s'adapter aux diverses exigences des différents types de graphiques. Des travaux futurs sont suggérés pour explorer des paradigmes de fusion plus économes en paramètres afin d'atteindre une intégration similaire sans augmenter le nombre de paramètres du modèle.