- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
-
This paper proposes CoCoEvolve, a framework for converting between chart images, data tables, and visualization code. It adds a textual constraint description to resolve the one-to-many ambiguity between these representations.
-
This paper trains a vision-language model and a language model jointly with reinforcement learning. The reward is based on cross-representation consistency, including code executability, agreement between the two models’ outputs, and visual similarity to the input chart. The same reward is used at test time to select the best candidate outputs.
-
This paper introduces an evaluation suite covering all six conversion directions, combining rule-based metrics with multi-dimensional LLM and MLLM judges.
Critical strengths
-
The paper takes advantage of the fact that visualization code can be executed and rendered, which turns agreement between chart, table, and code into an automatically computable reward. This matters because labeled cross-representation data is scarce and costly. A scalable, verifiable signal that needs no human annotation addresses a real bottleneck in chart understanding.
-
The improvements hold across many open models, RL algorithms, and both in-domain and out-of-domain chart benchmarks, including harder chart modification tasks. This breadth suggests the gains are not specific to a single model or setting, which supports the framework’s practical usefulness.
Critical weaknesses
-
The title and framing overstate the scope. The title presents a general self-supervised cross-representation learning method. However, the rewards, metrics, and all experiments are specific to the chart–table–code setting, and no evidence is given that the method transfers to other representations.
-
The core claims are not supported by evidence. The paper does not verify that constraint descriptions remove the ambiguity between representations. It also does not test whether the gains come from the two models’ mutual agreement rather than from a standard reward that compares the rendered chart with the input chart. As a result, the novelty of the contribution is unclear.
-
The evaluation may overstate the gains. The test-time method is compared unequally with baselines, the training rewards overlap with the evaluation metrics, and the reference answers are LLM-generated without human verification. This makes the true improvement difficult to assess.
Questions for authors
-
Constraint descriptions: Section 3.1 introduces constraint descriptions to turn one-to-many mappings into one-to-one correspondences. However, reference constraints are kept only if they improve downstream code generation (Appendix C.2), which shows they are useful but not that they determine a unique answer. How do the authors verify that a table plus a constraint corresponds to a single correct chart or code?
-
Source of the gains: The vision-language model’s reward has three main parts (Table 6): a weight of 0.7 on how closely the chart rendered from its own code matches the input chart; a weight of 0.05 on how similar its code is to the code written by the language model; a weight of 0.05 on how similar the two rendered charts are. Since the method’s novelty lies in the last two terms, how does performance change when they are removed, leaving only the comparison with the input chart?
-
Test-time comparison: CoCoEvolve@Test selects the best of four samples (Eq. 9), while baselines report the average of four (Table 1). Moreover, the image metrics in the reward (Eq. 5) also appear in the evaluation (Appendix F.1.1). How does CoCoEvolve@Test compare with a best-of-four baseline that uses a selector independent of the evaluation metrics, such as code executability?
-
Experimental setup: Section 4.1 lists three vision-language and six language models but does not state how they are paired. Which models were trained together for each row in Tables 1–2?
-
Comparison with existing chart-to-code systems: The baselines in Tables 1–2 are only untuned base models. Comparisons with established systems would show whether CoCoEvolve’s gains hold against prior work:
(1) ChartCoder (Zhao et al., ACL 2025), whose data CoCoEvolve already uses for training; (2) ChartMaster (Tan et al., arXiv:2508.17608, 2025), which also trains chart-to-code models with GRPO and a reward based on similarity between the rendered and input charts. This closely resembles the dominant part of CoCoEvolve’s reward.
6 comments
Author Response (2/2): Thank you for your valuable review and insightful comments
| Model | Method | Execution | Rule-as-judge code | LLM-as-judge code | Rule-as-judge chart | MLLM-as-judge chart |
|---|---|---|---|---|---|---|
| = Qwen3-VL-4B | Best-of-four by executability | 90.36 | 55.04 | 48.37 | 76.41 | 60.52 |
| = Qwen3-VL-4B | CoCoEvolve@Test | 93.54 | 58.73 | 51.78 | 77.92 | 62.96 |
| = Qwen3-4B | Best-of-four by executability | 93.04 | 51.06 | 50.40 | 74.05 | 60.69 |
| = Qwen3-4B | CoCoEvolve@Test | 99.08 | 57.38 | 55.81 | 83.45 | 71.04 |
3. Metric overlap (W3 "the training rewards overlap with the evaluation metrics", Q3). The rule-based chart score shares the reward's image metrics by design, since comparing the drawn chart with the input chart needs no annotation. In our main results, the reward never uses reference code, reference tables, or judges, and the scores it does not compute also improve, including: the LLM-as-judge code and MLLM-as-judge chart scores (tables above), the rule-based code score against the reference code (§F.1.2), and the table scores (Fig. 3).
4. LLM-generated references (W3 "LLM-generated without human verification"). Code and chart outputs (Tabs. 1-2, Fig. 9) are scored against each benchmark's original ground-truth code and charts, not against LLM-generated references. Gemini-3.1-Pro references serve only to score table and constraint outputs (Fig. 3), since ChartCoder provides no ground-truth tables and constraints are new in this work (§3.1), and each passed the quality check of Stage 3 (§C.2). On ChartNet, whose test set has its own human-verified tables, CoCoEvolve also raises 's table scores in every setting (Fig. 9), e.g., rule-as-judge table from 40.97 to 47.42 (@Train+@Test).
Q4: Model pairing
Thank you for kindly noting this. To keep the rows comparable, every row (Qwen3-VL-2B, Qwen3-VL-4B, InternVL3.5-4B) is paired with = Qwen3-4B, and every row (Llama-3.2-3B, DeepSeek-Coder-1.3B and 6.7B, Qwen3-1.7B, 4B, and 8B) with = Qwen3-VL-4B, in every block (@Train, @Test, @Train+@Test). Each row thus varies one model while its partner stays fixed. We have added this to §4.1.
Q5: ChartCoder and ChartMaster
Thank you for your kind suggestion. We add both comparisons below.
1. Comparison (Q5 "whether CoCoEvolve's gains hold against prior work"). ChartCoder and ChartMaster are trained for chart-to-code only, on 160K and about 240K chart-code pairs, respectively, while CoCoEvolve co-evolves two models for all six tasks from 10,298 unlabeled charts. For a fair comparison, we train CoCoEvolve on the same base model (Qwen2.5-VL-7B) as ChartMaster-7B, and at the same 7B scale as ChartCoder. All three are evaluated on the same out-of-domain chart-to-code sets (Tab. 3), with the same instruction, decoding (four samples, m@4), and judge. CoCoEvolve@Train-7B is the highest on every score:
| Data | System | Execution | Rule-as-judge code | LLM-as-judge code | Rule-as-judge chart | MLLM-as-judge chart |
|---|---|---|---|---|---|---|
| ChartMimic | ChartCoder-7B | 79.38 | 52.96 | 47.86 | 63.78 | 45.65 |
| ChartMimic | ChartMaster-7B | 87.36 | 52.14 | 49.23 | 70.68 | 56.23 |
| ChartMimic | CoCoEvolve@Train-7B (ours) | 89.67 | 54.26 | 53.17 | 73.73 | 60.71 |
| Chart2Code | ChartCoder-7B | 82.20 | 49.52 | 33.47 | 64.28 | 41.35 |
| Chart2Code | ChartMaster-7B | 88.84 | 50.38 | 36.72 | 68.72 | 50.79 |
| Chart2Code | CoCoEvolve@Train-7B (ours) | 92.07 | 52.43 | 41.12 | 74.78 | 56.91 |
| ChartNet | ChartCoder-7B | 78.04 | 42.79 | 43.51 | 67.34 | 49.22 |
| ChartNet | ChartMaster-7B | 87.18 | 43.52 | 45.68 | 75.83 | 61.86 |
| ChartNet | CoCoEvolve@Train-7B (ours) | 89.85 | 45.61 | 49.42 | 79.11 | 68.31 |
2. ChartMaster's reward (Q5 "closely resembles the dominant part of CoCoEvolve's reward"). ChartMaster's reward compares only the drawn chart with the input chart. CoCoEvolve adds agreement between two co-evolving models across six tasks without annotations: learns from an evolving , which in return pushes to read input charts more accurately. The second table above (W2+Q2) is the controlled comparison: with the same models, data, and budget, adding the agreement terms raises every score.
3. ChartCoder's data (Q5 "whose data CoCoEvolve already uses for training"). CoCoEvolve uses only the chart images of 10,298 ChartCoder samples, not the full 160K data that their ChartCoder is trained on. To validate cleanly, we compare on the same out-of-domain sets (table above).
Thank you for your valuable review and constructive feedback. We sincerely hope our response and clarifications above can meaningfully address your remaining concerns, and we will make sure to apply them to our revisions to further enhance our paper quality.
Author Response: Thank you for your valuable review and insightful comments
Thank you very much for your valuable review and thoughtful comments. We sincerely hope our responses can meaningfully address your remaining concerns. As the rebuttal period is approaching its deadline, we would be more than happy to provide any further clarifications or address any remaining questions you may have. We would greatly appreciate it if you could kindly take our responses into consideration in your final assessment of our paper. Thank you again for your valuable time and consideration.
Author Response (1/2): Thank you for your valuable review and insightful comments
Thank you for your careful review and constructive feedback, and for recognizing our verifiable reward that needs no annotation and the breadth of our improvements across models, RL algorithms, and benchmarks. We hope to further address your remaining concerns below.
W1: Title and scope
Thank you for kindly noting this. Yes, our abstract introduces CoCoEvolve "to improve consistency across chart, table, and code representations", and §3.1 defines cross-representation understanding as six tasks among chart images, tables, and code. We make no empirical claim beyond these three representations: the design needs only representations that can be checked against each other automatically, such as code that executes into a chart. We are also happy to make our experiment scope explicit in the title, for example "Consistency-Driven Co-Evolution for Self-Supervised Chart-Table-Code Cross-Representation Learning".
W2+Q1: Constraint descriptions
Thank you for your insightful question. We hope to respectfully show how the constraint narrows the chart.
1. What one-to-one means (Q1 "a single correct chart or code"). The table fixes the data, and the constraint fixes what the table leaves open (chart type, visual encodings, colors, labels, and layout). So the one-to-one correspondence is between a table+constraint and a chart. Code is not unique, since different programs can draw the same chart. Thus, our rewards compare drawn charts and code embeddings and never require one exact program.
2. Direct measurement (Q1 "How do the authors verify", W2). Beyond the Stage 3 check (§C.2), we add a direct measurement: on in-domain test charts, base Qwen3-4B writes four codes from the reference table alone and four from the table+constraint, scored by the rule-based chart score. With the constraint, the drawn charts match the original chart better (+11.58, 95% CI [+10.46, +12.72]) and agree more with each other (+2.75, 95% CI [+1.13, +4.39]):
W2+Q2: Source of the gains
Thank you for your insightful question. We add this ablation below.
1. Removing the agreement terms (Q2 "how does performance change when they are removed"). We train and compare both models using the same reward equation (Eq. 7), only different in with or without the agreement terms. Without them, execution and chart scores still rise over the base model, but code quality barely changes. With them, every score of both models is higher:
2. Small weights (Q2 "a weight of 0.05"). A small weight does not mean a small effect: GRPO normalizes rewards within each group of four candidates, so when candidates score similarly on the input-chart term, the agreement terms decide their ranking.
3. Novelty (W2 "the novelty of the contribution is unclear"). The novelty is co-evolution as a whole: the two models are coupled through the agreement terms and through sampling, as Mψ learns from an evolving Mθ (Eq. 8) and Mθ needs to look at the input charts more carefully to provide accurate tables and constraints to better guide the evolving Mψ, so both learn from unlabeled charts alone. Training Mψ on its own would instead need reference tables and constraints as inputs (the "Baseline" in Tab. 5).
W3+Q3: Test-time comparison and evaluation
Thank you for your thoughtful questions. We hope to respectfully show each part below.
1. Training gains (W3 "compared unequally"). The @Train rows compare one sampled output with one sampled output (m@4 on both sides), so the training gains involve no test-time selection.
2. Best-of-four baseline (Q3 "a best-of-four baseline"). Each @Test run samples 4 Mθ and 4 Mψ candidates and selects with the annotation-free reward (Eq. 9), never with a reference or a judge, and m@4 averages four runs. We add your suggested best-of-four baseline on the same test set, with the same number of samples. CoCoEvolve@Test is higher on all five scores of both models, including the two judge scores that no selector sees:
(Very sorry there is not enough space left, so we respectfully put the table in the next Author Response 2/2. Many thanks!)