🤖 machine learning

Consistency-Driven Co-Evolution for Self-Supervised Cross-Representation Learning

Ce document présente CoCoEvolve, un cadre d'apprentissage auto-supervisé qui améliore la compréhension inter-représentations entre graphiques, tableaux et code en définissant des correspondances explicites de un à un et en optimisant la cohérence via un processus de coévolution tant lors de l'entraînement que lors de l'inférence, éliminant ainsi le besoin d'annotations coûteuses tout en améliorant les performances sur de multiples bancs d'essai.

Auteurs originaux : Xuehang Guo, Pengyuan Li, Tom Hope, Tirthankar Ghosal, Manling Li, Qingyun Wang

Publié 2026-08-06

📖 4 min de lecture☕ Lecture pause café

CC BY 4.0

Auteurs originaux : Xuehang Guo, Pengyuan Li, Tom Hope, Tirthankar Ghosal, Manling Li, Qingyun Wang

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

Imaginez que vous essayez d'apprendre à un robot à comprendre le monde, mais que vous ne lui donnez que trois langages différents pour décrire la même chose : une image de graphique, un tableur de nombres et le code informatique utilisé pour dessiner le graphique. C'est le défi de l'« apprentissage entre représentations » (cross-representation learning). Dans le monde réel, les données ne sont pas qu'une seule chose ; c'est un diagramme que vous voyez, un tableau que vous lisez et les instructions qu'un ordinateur suit pour les créer. Le problème est que ces trois choses ne correspondent pas toujours parfaitement. Une image peut être dessinée à partir de nombreux tableurs différents, et un tableur peut être transformé en de nombreux codes différents. C'est comme essayer de traduire un poème en une chanson et en une peinture, mais sans avoir de dictionnaire, et le traducteur ne cesse de deviner.

Pendant longtemps, les scientifiques ont tenté de résoudre cela en embauchant des humains pour écrire la « traduction parfaite » pour chaque exemple. Mais c'est coûteux, lent et souvent impossible car il n'existe pas une seule bonne réponse. La grande question a été : pouvons-nous apprendre aux ordinateurs à établir ces connexions sans avoir besoin d'un enseignant humain pour chaque étape ? Pouvons-nous amener l'ordinateur à vérifier son propre travail en voyant si l'image, les nombres et le code racontent tous la même histoire ?

C'est là qu'intervient une nouvelle idée appelée CoCoEvolve. Voyez cela comme une partie de « téléphone arabe » jouée par trois amis qui essaient de décrire le même objet secret. Dans ce jeu, un ami dessine l'objet, un autre note ses mesures, et le troisième écrit les instructions pour le construire. Habituellement, s'ils commettent une erreur, l'histoire s'effondre. Mais CoCoEvolve change les règles. Au lieu d'attendre qu'un professeur dise « Bon travail » ou « Réessaie », les trois amis se vérifient constamment les uns les autres. Si le dessin ne correspond pas aux mesures, ou si les instructions construisent un mauvais dessin, ils savent que quelque chose ne va pas. Ils utilisent ce « décalage » comme un signal pour s'améliorer, sans jamais avoir besoin qu'un humain leur donne la réponse.

Le document présente un système où deux modèles d'IA jouent le rôle de ces amis. Un modèle tente de transformer l'image d'un graphique en un tableau et en un code, tandis que l'autre tente de transformer ce tableau à nouveau en code. Ils travaillent en cycle, évoluant constamment ensemble. Si le code qu'ils génèrent peut réellement s'exécuter et dessiner un graphique qui ressemble à l'image originale, ils reçoivent une « récompense ». Si le code échoue ou si le graphique semble étrange, ils apprennent de cet échec. Les chercheurs ont découvert qu'en forçant l'IA à maintenir l'image, les nombres et le code en parfait accord, les modèles comprenaient bien mieux les données.

L'équipe a testé cela sur quatre benchmarks (ensembles de questions de test) et a constaté que CoCoEvolve améliorait considérablement les performances de l'IA. Dans certains cas, les modèles étaient jusqu'à 37,91 % meilleurs pour traduire des graphiques en code sur de nouvelles données inédites, et jusqu'à 46,88 % meilleurs dans d'autres scénarios complexes. Plus impressionnant encore, le système a fonctionné sans avoir besoin d'étiquettes humaines supplémentaires pour l'enseigner. Il a simplement utilisé la cohérence entre les différentes formes de données comme son propre enseignant.

Le document argumente également contre l'ancienne méthode, qui supposait que chaque graphique avait exactement un tableau parfait et un code parfait. Les chercheurs ont montré que cette hypothèse du « un-à-un » est en réalité un piège. Parce qu'un graphique peut être décrit de nombreuses manières valides, forcer l'IA à choisir une seule réponse « correcte » la confond souvent et dégrade ses performances. En embrassant l'idée qu'il existe de nombreuses façons valides de décrire les données, mais que toutes les façons valides doivent être d'accord entre elles, CoCoEvolve évite ces pièges.

En résumé, le document suggère qu'au lieu d'embaucher une armée d'enseignants pour corriger chaque devoir, nous pouvons apprendre à l'IA à être son propre professeur en faisant en sorte que ses différents « langages » (images, tableaux et code) racontent une histoire cohérente. Les résultats suggèrent que cette méthode est un moyen plus puissant, moins coûteux et plus flexible d'aider l'IA à comprendre le monde complexe et multifacette des données.

Résumé Technique : CoCoEvolve

Énoncé du Problème

L'article traite des défis fondamentaux de la compréhension inter-représentations à travers trois modalités : les images de graphiques ( $V$ ), les données tabulaires ( $T$ ) et le code de visualisation ( $C$ ). Les systèmes d'IA actuels peinent face à cette tâche en raison de trois goulots d'étranglement principaux :

Ambiguïté intrinsèque de type Un-vers-Plusieurs : Une seule image de graphique peut correspondre à plusieurs représentations tabulaires valides et à plusieurs programmes de rendu valides. Les benchmarks existants supposent souvent des vérités de terrain (ground truths) un-vers-un non contraintes, ce qui est mal défini et ne parvient pas à capturer la redondance et l'ambiguïté naturelles de ces correspondances.
Ambiguïté et coût de la supervision : L'étiquetage précis de l'espace vaste des correspondances potentielles est excessivement coûteux, entraînant une rareté d'annotations de haute qualité et rigoureuses.
Absence de signaux d'optimisation fondés sur des principes : Les méthodes existantes reposent sur des objectifs fixes et spécifiques à une tâche (ex: graphique-vers-tableau ou graphique-vers-code). Ces objectifs locaux ne parviennent pas à imposer une correction sémantique globale et ne se généralisent pas aux directions inversées (ex: tableau-vers-graphique) ou aux combinaisons de représentations inédites (ex: tableau-vers-code).

Méthodologie : CoCoEvolve

Les auteurs introduisent CoCoEvolve, un cadre de co-évolution piloté par la cohérence, conçu pour optimiser les modèles sans annotations supplémentaires en exploitant l'accord mutuel entre les représentations.

1. Définition de Contraintes Fondées sur des Principes

Pour résoudre l'ambiguïté un-vers-plusieurs, le cadre ancre les correspondances un-vers-plusieurs à des correspondances un-vers-un précises en augmentant les fonctions de correspondance avec des contraintes descriptives auxiliaires ( $s \in S$ ). Cela permet d'ancrer les correspondances de sorte qu'une image de graphique $v$ , un tableau $t$ et un extrait de code $c$ soient traités comme plusieurs représentations d'une même sémantique sous-jacente, conditionnées par des contraintes spécifiques.

2. Cadre de Co-Évolution

Le cadre emploie deux modèles, $M_\theta$ (gérant $V \to T$ et $V \to C$ ) et $M_\psi$ (gérant $T \to C$ ), qui co-évoluent à travers un cycle de représentation ( $V \to T \to C \to V$ ).

CoCoEvolve@Train (Temps d'Entraînement) : Les modèles sont entraînés conjointement sur des images de graphiques non annotées. Au lieu de s'appuyer sur des étiquettes de vérité de terrain, le signal d'entraînement est dérivé de la cohérence inter-représentation.
- Récompenses Hiérarchiques : Le système calcule une récompense partagée basée sur :
  - Cohérence du Code ( $F_c$ ) : Mesure l'accord sémantique entre le code généré par les deux modèles via le succès d'exécution et la similitude d'embedding.
  - Cohérence Visuelle ( $F_v$ ) : Mesure l'accord visuel entre les graphiques rendus en utilisant quatre métriques : la similitude sémantique CLIP, la similitude structurelle SSIM, la précision textuelle OCR et la similitude perceptuelle DINOv2.
  - Récompense de Format ( $F_f$ ) : Garantit des sorties structurées bien formées.
- Optimisation Couplée : Les modèles sont couplés par échantillonnage et récompense. $M_\psi$ est conditionné par la sortie de $M_\theta$ , et l'avantage de chaque modèle est dérivé d'un fonctionnel de récompense qui dépend de la sortie de l'autre modèle. Cela empêche les solutions dégénérées où les modèles colludent pour produire des sorties mutuellement cohérentes mais sémantiquement incorrectes en incorporant des récompenses d'ancrage individuelles par rapport au graphique original.
CoCoEvolve@Test (Temps de Test) : Lors de l'inférence, le cadre applique le même objectif de cohérence pour co-optimiser les modèles. Étant donné une entrée, il génère plusieurs itérations (rollouts) à partir des deux modèles et sélectionne la meilleure sortie basée sur les récompenses de cohérence, affinant ainsi la prédiction au moment de l'inférence sans mettre à jour les poids du modèle.
Extension Supervisée : Le cadre peut intégrer de manière transparente un module enseignant ( $M$ ) lorsque des annotations de haute qualité sont disponibles. Cela permet une stratégie d'amortissement linéaire où le système passe d'un co-entraînement guidé par l'enseignant à une co-évolution entièrement auto-supervisée.

3. Suite d'Évaluation (CoCoEvolve@Eval)

Les auteurs proposent une suite d'évaluation unifiée qui évite le manque de fiabilité consistant à réduire des évaluations complexes en scores uniques. Elle décompose l'évaluation en métriques multidimensionnelles interprétables :

Règle-en-tant-que-Juge (Rule-as-Judge) : Métriques déterministes pour la précision structurelle, sémantique, perceptuelle et textuelle dans les graphiques ; l'exécutabilité et la qualité du code dans le code ; et la précision du schéma/des valeurs dans les tableaux.
LLM-en-tant-que-Juge & MLLM-en-tant-que-Juge : Notation fine (échelle 0-5) sur des dimensions telles que la justesse des données, le type de graphique, la fidélité structurelle et le style visuel, plutôt qu'un score unique à large étendue.

Contributions Clés

Définition de Contraintes Fondées sur des Principes : L'article introduit une définition formelle pour ancrer les correspondances un-vers-plusieurs intrinsèques à des correspondances un-vers-un précises, comblant une lacune négligée par les benchmarks existants.
Cadre CoCoEvolve : Un nouveau cadre de co-évolution qui transforme la cohérence inter-représentation en un signal d'auto-supervision fondé sur des principes et sans annotation. Il permet l'optimisation tant au temps d'entraînement qu'au temps de test, agnostique aux directions de tâches et aux combinaisons de représentations.
Suite d'Évaluation Unifiée : Une suite d'évaluation systématique couvrant les six tâches de cross-représentation dans le cycle, utilisant des évaluations multidimensionnelles pour surmonter les limites des approches actuelles de jugement basées sur LLM/MLLM.
Validation Empirique : Expérimentations approfondies démontrant des gains de performance significatifs sur plusieurs benchmarks et architectures de modèles.

Résultats

Les expériences ont été menées sur quatre benchmarks (ChartCoder, ChartNet, ChartMimic, Chart2Code) en utilisant divers MLLM et LLM (ex: Qwen3-VL, InternVL3.5, DeepSeek-Coder).

Gains de Performance : CoCoEvolve améliore systématiquement les performances dans les contextes de temps d'entraînement et de temps de test.
- Sur des ensembles de test non chevauchants, il produit des gains allant jusqu'à 37,91 %.
- Dans des contextes hors domaine, les améliorations atteignent jusqu'à 46,88 %.
- Les taux de succès d'exécution du code se sont considérablement améliorés, certaines configurations atteignant 100,00 % de succès d'exécution en bac à sable (sandbox).
Généralisabilité : La méthode démontre une robustesse de généralisation aux tâches hors domaine (complexités et domaines variés comme la physique, la finance, la biologie) et à différents algorithmes d'apprentissage par renforcement (GRPO, DAPO, GSPO).
Études d'Ablation : L'inclusion d'un module enseignant aux temps d'entraînement et de test offre la performance la plus équilibrée, tandis que l'optimisation au temps de test seule améliore systématiquement les résultats pour les six tâches.

Signification et Revendications

L'article affirme que CoCoEvolve offre une alternative scalable aux pipelines gourmands en annotations pour les tâches de raisonnement structuré. En traitant la cohérence inter-modale comme un signal de supervision fiable, le cadre permet aux modèles de "co-évoluer de manière symbiotique", où l'amélioration d'un modèle fournit une supervision plus forte pour l'autre. Les auteurs soutiennent que cette approche répond efficacement à l'ambiguïté de la supervision et au manque de signaux d'optimisation adaptables à la direction, menant à une compréhension inter-représentation améliorée qui se généralise à travers les tâches, les directions et les domaines. Le travail suggère que l'imposition d'une correction sémantique globale par la cohérence est une voie viable pour le raisonnement multimodal sans dépendre de labels de vérité de terrain fixes.