Distill Visual Chart Reasoning Ability from LLMs to MLLMs

## Abstract

Abstract Solving complex chart Q&A tasks requires advanced visual reasoning abilities in multimodal large language models (MLLMs).
Recent studies highlight that these abilities consist of two main parts: recognizing key information from visual inputs and conducting reasoning over it.
Thus, a promising approach to enhance MLLMs is to construct relevant training data focusing on the two aspects.
However, collecting and annotating complex charts and questions is costly and time-consuming, and ensuring the quality of annotated answers remains a challenge.
In this paper, we propose Code-as-Intermediary Translation (CIT), a cost-effective, efficient and easily scalable data synthesis method for distilling visual reasoning abilities from LLMs to MLLMs .
The code serves as an intermediary that translates visual chart representations into textual representations, enabling LLMs to understand cross-modal information.
Specifically, we employ text-based synthesizing techniques to construct chart-plotting code and produce ReachQA , a dataset containing 3 ⁢ k 3 k 3\text{k} 3 k rea soning-intensive ch arts and 20 ⁢ k 20 k 20\text{k} 20 k Q&A pairs to enhance both recognition and reasoning abilities.
Experiments show that when fine-tuned with our data, models not only perform well on chart-related benchmarks, but also demonstrate improved multimodal reasoning abilities on general mathematical benchmarks like MathVista.
The code and dataset are publicly available at https://github.com/hewei2001/ReachQA .

## 1 Introduction

Multimodal large language models (MLLMs) have made significant achievements, particularly in visual recognition tasks (OpenAI, ; Anthropic, ).
While they can handle simple visual inputs well, there has been a growing emphasis on complex chart understanding, driven by the widespread use of charts in real-world contexts (Masry et al., ; Huang et al., ).
However, addressing reasoning-intensive questions involving charts remains challenging for these models.
Existing benchmarks underscore the need for more advanced and generalized visual reasoning abilities, which are still underdeveloped in current MLLMs (Wang et al., ; Lu et al., ).
Our analysis of the error distribution in ChartQA (Figure 1) also highlights two main types of model failure: $62\%$ of errors stem from misrecognition, while $36\%$ arise from reasoning mistakes after correct recognition.
This shows that even advanced MLLMs struggle with basic recognition and often make superficial reasoning errors.
In contrast, humans excel at these tasks by purposefully identifying query-relevant information from images and engaging in step-by-step reasoning (Wang et al., ; ).
In light of these findings, enabling models to solve problems in a human-like manner, becomes essential for advancing visual reasoning performance.

Figure: Figure 1: Error distribution of incorrect answers by MiniCPM-V2.5-Llama3 (Yao et al., ) on ChartQA test set (Masry et al., ), as judged by GPT-4o. We present an example chart from ChartQA along with two error cases: one for recognition and one for reasoning. The “Other Errors” include question misunderstood errors, knowledge and hallucination errors, or refusal to answer.
Refer to caption: x1.png

One promising strategy is to distill the rationales of reasoning from experts, such as human or stronger models (Han et al., ; Meng et al., ; Masry et al., ; )
However, creating high-quality training data for chart-related tasks is costly and time-consuming.
The challenges arise from both the complexity of constructing the chart data and the instruction data.
Collecting charts from specific online sources typically involves manual crawling, filtering, and extensive human annotation to create relevant questions(Masry et al., ; Wang et al., ).
Although some approaches use LLMs to automate Q&A synthesis, they rely on the data table of charts (Han et al., ; Masry et al., ), overlooking critical visual features like color, layout, and structure.
Even with the use of MLLMs for Q&A generation (Masry et al., ), our preliminary analysis (§ 2.2) shows their performance remains suboptimal, struggling to produce accurate and challenging chart-related Q&A pairs.
In contrast, LLMs tend to perform better when processing charts in textual format, demonstrating lower costs and higher accuracy, as also observed by Fu et al. ().

Given the limitations of MLLMs in this task, we propose leveraging the strengths of LLMs through an intermediary representation: code.
Inspired by the concept of intermediary translation (Zarechnak, ; Léon, ), which refers to using a bridge language to improve translation quality across diverse languages in literary studies, we introduce Code-as-Intermediary Translation (CIT).
The code acts as an intermediary, translating chart images into textual representations while preserving visual features faithfully.
This process enables LLMs to interpret cross-modal information and generate more accurate and visually complex Q&A pairs.
Furthermore, it facilitates the adoption of text-based instruction augmentation strategies, such as Self-Instruct (Wang et al., ) and Evol-Instruct (Xu et al., ), to enhance the diversity and complexity of the generated charts.
Starting with $33$ seed codes collected from the Matplotlib gallery, we synthesize more chart-plotting codes covering diverse types and topics, and then complicate them to create richer ones.
Finally, using the synthetic codes as a bridge, we generate charts (via Python) and instructions (via LLMs) in a bi-directional process, ensuring the alignment between the two modalities.

With the CIT approach, we construct ReachQA, a multimodal instruction dataset containing $3,249$ reasoning-intensive charts and $19,963$ Q&A pairs, all at a remarkably low cost of just $\$300$.
The dataset comprises $8\text{k}$ questions focused on visual recognition and $12\text{k}$ on reasoning, designed to address the dual challenges of extracting visual information and performing advanced reasoning.
Additionally, we create $500$ charts and $2,000$ manually verified Q&A pairs to independently assess models’ recognition and reasoning abilities.
When fine-tuning on ReachQA, all models demonstrate substantial performance gains across seven benchmarks, with LLaVA-Next-Llama3-8B (Li et al., ) improving by over $30\%$ on average.
More importantly, we observe that these gains generalized beyond chart-specific tasks to broader multimodal reasoning tasks, such as MathVista and MATH-Vision—an outcome previously unattainable with existing chart-focused datasets.
Furthermore, we conduct experiments to investigate deeper insights, including (1) the real impact of expert rationales on reasoning abilities, (2) the effects of recognition- and reasoning-oriented training data ratios, and (3) the benefits of mixing general-purpose multimodal instruction data.

## 2 Background

### 2.1 Deficiencies in Existing Chart-Related Datasets

**Table 1: Comparison of existing chart-related datasets across three properties. Only the chart question-answering (CQA) task is considered, despite some datasets having multiple tasks. Abbreviations: Vis.=visual, Comp.=complexity, Temp.=template, Refer.=Reference, Reas.=reasoning, Rat.=rationale, Annot.=annotation and Scal.=scalable. Cells marked with “✓ – ” indicate mixed attributes (e.g., partially template-based; scalable Q&A but non-scalable chart data.). “*” indicates that while the chart-plotting codes are public, the Q&A generation still relies on data tables.**
| Datasets | Chart Properties | Q&A Properties | Dataset Properties |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| # Chart<br>Type | # Chart<br>Topic | Textual<br>Format | Vis.<br>Comp. | Temp.<br>Free | Vis.<br>Refer. | Rat.<br>Annot. | Train<br>Set | Test<br>Set | Scal. |  |
| PlotQA (Methani et al., ) | 3 | - | Table | ✗ | ✗ | ✓ | ✗ | ✓ | ✓ | ✗ |
| ChartQA (Masry et al., ) | 3 | 15 | Table | ✗ | ✓ | ✓ | ✗ | ✓ | ✓ | ✗ |
| OpenCQA (Kantharaj et al., ) | 5 | 10 | Caption | ✗ | ✓ | ✗ | ✓ | ✗ | ✓ | ✗ |
| MathVista (Lu et al., ) | - | - | - | ✗ | ✓ | ✗ | ✗ | ✗ | ✓ | ✗ |
| CharXiv (Wang et al., ) | - | - | - | ✓ | ✓<br>– | ✓ | ✗ | ✗ | ✓ | ✗ |
| ChartBench (Xu et al., ) | 9 / 42 | - | Table | ✗ | ✗ | ✗ | ✗ | ✓ | ✓ | ✓ |
| ChartX (Xia et al., ) | 18 | 22 | Code* | ✗ | ✓ | ✗ | ✗ | ✗ | ✓ | ✓ |
| MMC (Liu et al., ) | 6 | 5 | Caption | ✓ | ✓ | ✗ | ✓ | ✓ | ✓ | ✓<br>– |
| ChartLlama (Han et al., ) | 10 | - | Table | ✗ | ✓ | ✗ | ✓ | ✓ | ✓ | ✓ |
| ChartAst (Meng et al., ) | 9 | - | Table | ✗ | ✗ | ✗ | ✓ | ✓ | ✗ | ✓<br>– |
| ChartInstruct (Masry et al., ) | - | - | Table | ✗ | ✓ | ✗ | ✓ | ✓ | ✗ | ✓<br>– |
| ChartGemma (Masry et al., ) | - | - | - | ✗ | ✓ | ✓ | ✓ | ✓ | ✗ | ✓<br>– |
| ReachQA (ours) | 10 / 32 | $\infty$ | Code | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |

Existing chart-related datasets fall into two categories: benchmarks for evaluation and training data for improving model performance.
The charts are either collected from online data sources or generated by models, sometimes requiring manual annotation or automated question generation.
Most of them focus on basic visual recognition tasks.
Though some recent works target more advanced reasoning, they often lack scalability.
Table 1 summarizes these datasets, with further details below.

#### Chart Properties.

The visual diversity is shaped by the variety of chart types and topics (Wang et al., ).
Early datasets like ChartQA and OpenCQA (Kantharaj et al., ), sourced from limited websites, featured uniform styles with minimal diversity.
To address this, recent works like ChartAst (Meng et al., ) synthesize charts with randomized attributes (e.g., color, fonts) using LLMs.
However, beyond the superficial variations in chart appearance, many of them overlook the visual complexity (Zeng et al., ).
As models evolve, simple style changes no longer pose challenges.
Datasets like CharXiv and MMC (Liu et al., ), which include complex scientific charts from arXiv papers, naturally exhibit greater complexity in recognition.
Additionally, the textual format of charts is critical, as it can be used to expand the datasets via language models.

#### Q&A Properties.

Some benchmarks like PlotQA and ChartBench (Xu et al., ) use predefined templates to generate Q&A pairs, resulting in monotonous and simplistic questions.
Other datasets, such as ChartQA and CharXiv, required manual annotation, which improved quality but increased costs and hindered scalability.
With the advent of LLMs, works like ChartLlama (Han et al., ) and ChartInstruct (Masry et al., ) use them to generate diverse questions from data tables while also providing rationale annotations for training.
However, these methods fail to capture fine-grained visual elements like color, layout, and structure because they rely on only the data table.
To address this, ChartGemma (Masry et al., ) uses MLLMs to generate Q&A pairs directly from charts.

#### Dataset Properties.

While manually annotated datasets like MathVista (Lu et al., ) and CharXiv provide high-quality data, their development is resource-intensive, typically resulting in datasets of only a few thousand samples.
In the era of LLMs, such methods are impractical for scaling to the size needed for training large models.
Recent efforts, such as ChartAst, ChartInstruct, and ChartGemma, have explored Q&A generation for dataset expansion, but they remain limited by the difficulty of collecting a large set of charts.
A more scalable approach is to leverage the generative capabilities of LLMs to synthesize charts like ChartBench and ChartX (Xia et al., ).

### 2.2 Can LLMs Understand Charts without Visual Input?

To explore whether there is a more effective textual format for representing visual information than data tables, we propose using code.
By precisely encoding chart structures and details, the code may serve as an ideal bridge between modalities.
We design an experiment to test this hypothesis.

We collect 25 complex charts, along with their corresponding data tables and code, from recent research papers by graduate students in the college.
These charts often feature multiple or overlay plots and dense data groups, with the code averaging over 100 lines.
Such content is unlikely to be included in the training data of current models.
For each sample, GPT-4o receives three types of input—table, code, and chart images—to generate a challenging Q&A pair.
In total, 75 pairs are created, randomly shuffled, and then presented to three annotators for blind evaluation.

**Table 2: Rating results and costs for different input types in our study.**
| Input | Acc. | Reas.<br>Comp. | Vis.<br>Refer. | Cost ($) |
| --- | --- | --- | --- | --- |
| Table | 2.72 | 2.51 | 1.19 | 0.047 |
| Code | 2.60 | 2.56 | 2.15 | 0.092 |
| Chart | 1.91 | 1.53 | 2.36 | 0.107 |

The annotators are asked to rate each pair on accuracy, reasoning complexity, and visual reference, using a scale of 1 (low) to 3 (high).
The results in Table 2 indicate that both text-based inputs outperform visual chart input in the first two aspects, with code scoring 2.60 in accuracy (vs. 1.91) and 2.56 in reasoning complexity (vs. 1.53).
As expected, table input has the lowest visual reference score (1.19), while chart input scores highest in this (2.36), confirming the ability of MLLMs to directly interpret visual information.
Surprisingly, the code achieves a relatively high visual reference score (2.15) even without image input.
It suggests that code has the potential to translate visual charts into textual representations.

## 3 ReachQA : Synthesizing Chart Q&A with CIT

ReachQA is a multimodal Chart Question-Answering (CQA) dataset fully generated by LLMs, consisting of synthetic charts paired with corresponding Q&A.
It is constructed with Code-as-Intermediary Translation (CIT), a data synthesis method for distilling visual reasoning abilities from LLMs to MLLMs, as illustrated in Figure 2.
In the following sections, we describe how we synthesize the codes (§ 3.1), generate charts and instructions (§ 3.2), and ensure data quality (§ 3.3).

Figure: Figure 2: Overview of the Code-as-Intermediary Translation (CIT) method for synthesizing multimodal instruction data. The process begins with 33 seed codes and generates plot codes across various chart types, topics, and complexity levels through the Self-Instruct and Evol-Instruct stages. The chart set and instruction set are constructed bi-directionally, and the final filtered data yields ReachQA, a dataset for distilling visual chart reasoning abilities from LLMs to MLLMs.
Refer to caption: x2.png

### 3.1 Intermediary Code Synthesis

This section describes how the intermediary code is synthesized from the seed code.

#### Seed Code Collection.

We start by collecting a small set of $33$ seed code samples, which we refer to as $C_{\text{seed}}$.
These samples are sourced directly from the official Matplotlib gallery(^1^11https://matplotlib.org/stable/gallery/index.html) to ensure quality and minimize manual effort.
Collectively, the code samples, each averaging around 40 lines in length, cover a diverse range of chart types, including common types like bar, line, and scatter charts, as well as more specialized charts such as bubble, contour, and donut charts.
All samples are verified for executability to guarantee the reliability of the subsequent code synthesis process.

#### Self-Instruct for Diverse Code Generation.

To expand the diversity and coverage of the synthetic chart set, we apply the Self-Instruct method (Wang et al., ), which has been used to generate new instructions by presenting LLMs with existing ones.
Plenty of works have demonstrated its effectiveness (Liu et al., ).
In our approach, instead of instructions, we provide code samples as context, guiding the model to generate novel chart-plotting code.
At each step, $3$ randomly selected code snippets from the code pool serve as few-shot examples (Brown et al., ).

To diversify chart generation, a chart type is randomly chosen from 10 major and 32 minor categories for the model to synthesize.
For chart content, we provide two topic options, allowing the model to freely combine or expand on these themes based on its knowledge, leading to varied topics and data.
A chain-of-thought (CoT) process (Wei et al., ) is used for code generation, starting with the chart’s background and data, followed by the final executable code.
This step-by-step approach ensures logical coherence and code functionality.
The generated codes are referred to as $C_{\text{easy}}$ for use in subsequent phases of the construction.
The chart types and topics are detailed in Appendix A.

#### Evol-Instruct for Complex Code Generation.

To enhance the complexity of the synthetic chart set, we adopt the Evol-Instruct method (Xu et al., ).
Evol-Instruct leverages LLMs to evolve simple chart-plotting code into more intricate versions by presenting existing code alongside an evolution strategy as context.
This approach addresses a key limitation in prior work that emphasizes the quantity of charts while often neglecting the difficulty of chart interpretation.

At each step, we take code samples from $C_{\text{easy}}$ and evolve them with a randomly selected strategy from four predefined directions:
(1) expanding the data size or number of data groups; (2) adding or modifying visual elements to enhance presentation; (3) overlaying a different type of chart on the original plot; (4) introducing an additional subplot beside the original plot.
These strategies ensure that the resulting charts demand more nuanced visual interpretation and in-depth reasoning.
As in previous phases, we follow a CoT process, where the model first analyzes the given code, outlines the evolution details, and then generates the evolved code.
The evolved codes, referred to as $C_{\text{hard}}$, are also added to the code pool for subsequent use.

### 3.2 Bi-directional Translation

This section outlines the bi-directional construction process of charts and instruction sets.

#### Chart Generation through Code Execution and Self-Repair.

We generate charts by executing the Python plotting code.
However, during the generation and evolution process, program errors are inevitable.
To ensure correctness, we will validate the code before adding it to the pool.
When errors occur, the code is not immediately discarded; instead, we apply a Self-Repair method (Chen et al., ), feeding the code and execution results into the LLMs for correction.
This process repeats until the code is fixed or reaches an iteration limit, after which the code is discarded if it remains faulty.
On average, this approach fixes about 15% of the code generated by GPT-4o, with 5% remaining unrepairable and filtered out.

#### Instruction Generation through Guided Prompting.

After verifying the executability of codes, we use them to create instruction sets in the form of question-answer pairs.
Building on prior work of in-context Q&A generation (Chen et al., ; He et al., ), we guide the model through a two-step process: first synthesizing a batch of questions and then generating corresponding answers separately.
To ensure high-quality answers, we also employ a step-by-step approach where the model first generates detailed calculations and analyses, which are subsequently refined into concise, educational answers optimized for learning (Gunasekar et al., ).

The model will generate two types of instructions: recognition-oriented, focusing on visual information retrieval, and reasoning-oriented, requiring both comprehensive recognition and multi-step reasoning.
With minimal constraints on question content, the model is encouraged to explore creative and diverse instructions.
Each chart can be used to generate multiple questions, and we filter redundant ones using ROUGE-L overlap, following the Self-Instruct method (Wang et al., ).

### 3.3 Quality Assurance

This section aims to improve the quality of generated data.

**Table 3: ReachQA dataset statistics. Question and answer lengths are calculated based on the GPT-4o tokenizer.**
| Statistics | Train Set | Test Set |
| --- | --- | --- |
| Total charts | 3,249 | 500 |
| - # Chart types | 10 / 32 | 10 / 32 |
| - # Overlay plots | 1,030 | 220 |
| - # Multiple plots | 593 | 251 |
| - Average size (px) | 2480$\times$1571 | 2798$\times$1601 |
| Unique questions | 19, 963 | 2,000 |
| - # Reco. per chart | 2.53 | 2 |
| - # Reas. per chart | 3.62 | 2 |
| Avg. Reco. Q. length | 22.1 | 21.0 |
| Avg. Reco. A. length | 38.3 | 7.0 |
| Avg. Reas. Q. length | 38.2 | 35.4 |
| Avg. Reas. A. length | 68.4 | 24.9 |

#### Multimodal Validation for Enhanced Data Quality.

Although our dataset is synthesized entirely with LLMs, we recognize the need to integrate visual information for higher data quality (Masry et al., ; Zeng et al., ).
Therefore, we introduce a multimodal validation step, utilizing MLLMs to verify both generated charts and their corresponding instructions.
Due to the variations in model architectures, visual encoders, and training recipes, different models may focus on varying aspects of the images.
Taking this into account, we adopt an “majority voting” strategy using multiple open-source models such as MiniCPM-V2.5-Llama3 (Yao et al., ), InternVL2-8B (Chen et al., ) and Qwen2-VL-8B (Wang et al., ).
This ensures reliable visual validation while remaining cost-effective by ensembling smaller, locally hosted models.

For chart validation, we define a set of criteria for a “good chart”, and each model assigns a score between 1 and 5.
The average score is calculated, and charts falling below a threshold are filtered out.
For instructions, both the Q&A pairs and the associated charts are fed into the models, which verify the answers step-by-step and give a yes/no judgment.
Samples receiving multiple negative votes are discarded.

#### Testing Set Construction and Annotation Refinement.

For the ReachQA testing set, we follow a similar process as in previous data generation, but with stricter filtering criteria to ensure higher quality.
In addition, annotators are recruited for manual review and refinement.
All had at least a bachelor’s degree and are familiar with common chart types.

They also had prior experience in data annotation.
For the charts, annotators first review the images to identify any potential visual errors.
For the Q&A pairs, they ensure the questions are relevant to the chart and answerable, then correct any hallucinations or logical inconsistencies in the answers.
Afterwards, annotators conduct two rounds of review to confirm the data meets the multimodal recognition or reasoning standards in our settings.
Only samples where at least two annotators agree are accepted into our dataset.
The inter-annotator agreement, reflected by a kappa coefficient of $0.82$, demonstrates strong consistency (Landis, ).
Table 3 summarizes the final dataset statistics.

The total cost of data construction, excluding open-source model usage and annotation labor for the testing set, was about $\text{\$}300$. A detailed expense breakdown is provided in Appendix B.
All the prompt templates we use are shown in Appendix D.

## 4 Experiments

### 4.1 Experimental Setups

#### Benchmarks.

We evaluate the models on three categories of tasks.
(1) Traditional chart-related benchmarks focused on recognition tasks, including ChartQA (Masry et al., ), ChartBench (Xu et al., ), and ChartX (Xia et al., ). For ChartQA, we use its 2.5k test set.
For multi-task datasets like ChartBench and ChartX, we only use QA tasks.
Specifically, from ChartBench, we select 2k binary QA samples (Yes/No answers) and 2.1k numerical QA samples.
From ChartX, we use its 6k QA samples.
(2) Novel chart-related benchmarks that assess both recognition and reasoning abilities, including CharXiv (Wang et al., ) and our ReachQA test set.
For CharXiv, we use the validation set, which contains 4k descriptive questions and 1k reasoning questions.
Our ReachQA test set includes 1k recognition-oriented and 1k reasoning-oriented questions.
(3) General multimodal reasoning benchmarks, including MathVista (Lu et al., ) and MATH-Vision (Wang et al., ).
For MathVista, we use the testmini set with 540 math-targeted questions and 460 general VQA questions.
For MATH-Vision, we use its 3,040 math competition problems.

#### Models and baselines.

We evaluate a range of multimodal large language models (MLLMs) across three categories.
(1) Powerful proprietary models, including GPT-4o (OpenAI, ), GPT-4o mini (OpenAI, ), and Claude 3.5 Sonnet (Anthropic, ).
(2) Chart-augmented open-source models, such as ChartInstruct-7B (Masry et al., ), ChartAssistant-13B (Meng et al., ), and ChartGemma-3B (Masry et al., ), which are specifically enhanced for chart-related tasks.
(3) Latest general open-source models, including LLaVA-Next-Llama3-8B (Li et al., ), MiniCPM-V2.5-Llama3-8B (Yao et al., ), and InternVL2-8B (Chen et al., ).
Besides, we provide a text-only baseline, denoted as Random (GPT-4o), where we prompt GPT-4o to reasonably guess the answer without seeing the image following Wang et al. ().

#### Experiment Details.

For each general open-source model, we conduct supervised fine-tuning (SFT) using our ReachQA training set.
We fine-tuned three versions of each model: (1) using 8k recognition-oriented Q&A samples (denoted as Reco.), (2) using 12k reasoning-oriented samples (denoted as Reas.), and (3) a combined version with 20k samples (denoted as All).
We apply Low-rank Adapters (LoRA, Hu et al., ) to all linear layers of the language model and projector, with a LoRA rank of 16, a LoRA alpha of 8 and a learning rate of 2e-5.
To fully leverage their capabilities, we prompt all models with a zero-shot CoT prompt, “Let’s think step by step” (Kojima et al., ), following OpenAI () and Anthropic ().
Thus, to extract answers from the model responses and assess their correctness, we employ the LLM-as-a-judge method (Zheng et al., ) to calculate a relaxed accuracy.
The judge model used is GPT-4o, and the prompt template for evaluation can be found in Appendix D.4.

### 4.2 Experimental Results

**Table 4: Evaluation results on seven benchmarks. Details for these benchmarks and models are presented in § 4.1. The best performance for each category and task is in bold. The percentage of performance improvements compared to the vanilla model is denoted by ($\uparrow$).**
| Models | Avg. ($\uparrow$) | ChartQA | ChartBench | ChartX | ReachQA | CharXiv | MathVista | MATH-V |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| QA | Binary | NQA | QA | Reas. | Reco. | Reas. | Desc. | Math | General | QA |  |  |
| Baselines |  |  |  |  |  |  |  |  |  |  |  |  |
| Human | - | - | - | - | - | 65.10 | 84.60 | 80.50 | 92.10 | 60.30 | 75.66 |  |
| Random (GPT-4o) | 20.82 | 30.04 | 40.21 | 22.73 | 19.85 | 8.20 | 13.30 | 10.80 | 19.85 | 17.90 | 25.36 |  |
| Proprietary Multimodal Large Language Models |  |  |  |  |  |  |  |  |  |  |  |  |
| GPT-4o mini | 49.34 | 77.52 | 70.26 | 34.93 | 35.45 | 27.20 | 53.50 | 34.10 | 74.92 | 56.70 | 28.85 |  |
| GPT-4o | 59.85 | 85.70 | 81.03 | 52.88 | 46.60 | 39.70 | 66.80 | 47.10 | 84.45 | 63.80 | 30.39 |  |
| Claude 3.5 Sonnet | 64.50 | 90.80 | 76.72 | 48.29 | 58.24 | 51.70 | 74.30 | 60.20 | 84.30 | 67.70 | 32.76 |  |
| Chart-augmented Multimodal Large Language Models |  |  |  |  |  |  |  |  |  |  |  |  |
| ChartInstruct-7B | 25.93 | 66.64 | 61.40 | 26.95 | 26.62 | 6.00 | 10.50 | 8.80 | 21.40 | 15.37 | 31.52 | 10.07 |
| ChartAssistant-13B | 28.25 | 79.90 | 58.15 | 24.62 | 23.20 | 10.70 | 19.60 | 11.70 | 16.93 | 17.78 | 39.57 | 8.55 |
| ChartGemma-3B | 33.08 | 80.16 | 78.90 | 34.10 | 35.15 | 9.20 | 27.80 | 12.50 | 21.30 | 19.07 | 38.04 | 7.70 |
| Open-Source Multimodal Large Language Models |  |  |  |  |  |  |  |  |  |  |  |  |
| LLaVA-Next-Llama3-8B | 24.46 | 45.80 | 42.90 | 15.86 | 15.45 | 6.50 | 17.90 | 17.20 | 31.45 | 22.41 | 44.13 | 9.44 |
| + ReachQA (Reco.) | 32.88 (+34.4%) | 66.96 | 56.95 | 29.52 | 27.25 | 8.80 | 29.00 | 22.20 | 32.58 | 27.40 | 49.78 | 11.25 |
| + ReachQA (Reas.) | 32.39 (+32.4%) | 64.48 | 56.80 | 25.14 | 25.90 | 8.40 | 26.30 | 22.70 | 35.67 | 28.89 | 50.65 | 11.38 |
| + ReachQA (All) | 32.98 (+34.8%) | 64.56 | 57.00 | 29.33 | 27.08 | 11.10 | 29.60 | 22.50 | 32.33 | 27.59 | 50.43 | 11.25 |
| \cdashline1-13<br>MiniCPM-V2.5-Llama3 | 33.39 | 66.92 | 48.90 | 22.29 | 23.72 | 10.30 | 25.30 | 22.00 | 46.20 | 37.22 | 53.04 | 11.45 |
| + ReachQA (Reco.) | 38.62 (+15.7%) | 71.12 | 56.65 | 33.29 | 29.53 | 10.60 | 34.10 | 25.60 | 48.75 | 41.48 | 60.43 | 13.22 |
| + ReachQA (Reas.) | 38.52 (+15.4%) | 71.72 | 56.65 | 29.62 | 28.23 | 11.00 | 33.00 | 27.50 | 48.70 | 43.52 | 60.22 | 13.52 |
| + ReachQA (All) | 38.67 (+15.8%) | 71.44 | 55.80 | 30.43 | 29.68 | 11.00 | 35.10 | 28.30 | 47.62 | 42.22 | 60.00 | 13.75 |
| \cdashline1-13<br>InternVL2-8B | 40.03 | 73.80 | 52.05 | 32.86 | 35.10 | 16.20 | 33.70 | 26.30 | 46.10 | 46.11 | 61.74 | 16.38 |
| + ReachQA (Reco.) | 48.21 (+20.4%) | 82.92 | 66.35 | 46.14 | 46.62 | 19.90 | 49.50 | 32.20 | 54.38 | 47.96 | 67.61 | 16.78 |
| + ReachQA (Reas.) | 47.87 (+19.6%) | 82.84 | 64.05 | 46.52 | 44.88 | 20.10 | 49.40 | 32.80 | 52.40 | 49.44 | 66.52 | 17.66 |
| + ReachQA (All) | 48.35 (+20.8%) | 82.44 | 65.90 | 47.29 | 45.38 | 21.30 | 49.80 | 32.70 | 54.83 | 48.89 | 66.30 | 17.01 |

Table 4 presents the quantitative results for all models and baselines across each task, allowing for a clear comparison of their recognition and reasoning abilities.
We can find that:

#### Synthetic datasets can also effectively measure abilities.

Our ReachQA test set effectively evaluates models’ reasoning and recognition skills, showing trends similar to human-annotated datasets like CharXiv.
For instance, GPT-4o exhibits a reasoning score of 39.70 and a recognition score of 66.80 on ReachQA, closely mirroring its performance on CharXiv (i.e., 47.10 and 84.45, respectively).
This consistency suggests that LLM-generated datasets, with minimal human intervention, can rival human-labeled data.
Moreover, ReachQA presents a significant challenge to models’ visual abilities, as random guessing results in very low scores.
In contrast, traditional benchmarks like ChartQA and ChartBench may allow models to leverage pre-existing knowledge, inflating results without truly testing visual capabilities (Yue et al., ; Wang et al., ).

#### Proprietary models demonstrate more balanced performance.

Proprietary multimodal models, including the cost-effective GPT-4o mini, achieve competitive results on both traditional chart-related benchmarks and reasoning-intensive tasks like ReachQA and CharXiv.
In contrast, open-source models, whether chart-augmented or general-purpose, excel in recognition tasks with simpler charts but struggle in complex ones.
This disparity highlights their imbalanced capabilities, and also suggests potential overfitting to traditional benchmarks.
Although proprietary models may not always lead in specific tasks, their stable performance across recognition and reasoning tasks indicates better generalization, making them more suitable for real-world applications.

#### Specialized training data significantly improves model performance.

Models trained on 8k ReachQA recognition data outperform in recognition tasks, while those trained on 12k reasoning data could do better in reasoning tasks.
When both data types are combined (i.e., 20k in total), models see the greatest improvement, with performance increasing by at least 15% across all models we test.
Notably, the LLaVA-Next-Llama3-8B model achieves a 34.8% boost in average performance.
This suggests that a model’s visual capability comprises two complementary aspects, and training on both data types together produces optimal results.
Moreover, despite the absence of math-target data in the training set, the models generalize well to the MathVista and MATH-Vision benchmarks, highlighting the transferability of multimodal reasoning abilities distilled from expert rationales.

## 5 Discussion

Figure: Figure 3: Performance comparison of different Reco.- & Reas.-oriented training data ratios with 8k total data. The dashed line represents the model’s performance trained with full 20k data.
Refer to caption: x3.png

### 5.1 Distilling Expert Rationales Improves Reasoning

To explore the origins of general reasoning abilities, we conduct an experiment comparing several open-source training datasets, including ChartBench (Xu et al., ), ChartAst (Meng et al., ), and ChartGemma (Masry et al., ).
To ensure fairness, we uniformly sample 20,000 instructions from Q&A tasks in each dataset and train LLaVA-Next-Llama3-8B under the same settings.
As shown in Table 5, the model trained on ChartBench performs the worst.
This may be due to its instruction responses, which contain only final answers without the reasoning process, limiting the model to learning the reasoning patterns.
Although ChartAst includes rationale annotations, their effectiveness is constrained by the simplicity of its template-based questions and a lack of reasoning

**Table 5: Performance comparison of models trained on different datasets. The ReachQA and CharXiv scores refer to Reas. splits here.**
| Models | Avg. | ReachQA | CharXiv | MathVista | Math-V |
| --- | --- | --- | --- | --- | --- |
| Base Model | 16.39 | 6.50 | 17.20 | 32.40 | 9.44 |
| + ChartBench | 17.06 | 7.30 | 17.00 | 33.60 | 10.33 |
| + ChartAst | 17.67 | 7.10 | 20.40 | 32.10 | 11.08 |
| + ChartGemma | 19.11 | 10.00 | 19.40 | 36.40 | 10.62 |
| + ReachQA | 20.74 | 11.10 | 22.50 | 38.10 | 11.25 |

depth.
In contrast, the models trained on ChartGemma and ReachQA achieve better performance.
This improvement can be attributed to the distillation of high-quality expert rationales (i.e., from Gemini Flash 1.5 and GPT-4o), which significantly enhance the model’s visual reasoning abilities.

While we only use SFT to train the model, incorporating advanced methods like RL (Xi et al., ) or DPO (Mitra et al., ) could further improve the results.
Additionally, the visual richness of charts, as detailed in Appendix C, may enhance the model’s generalization abilities, too.

### 5.2 Interaction between Recognition and Reasoning Abilities

As mentioned before, the recognition and reasoning abilities are likely interdependent.
Wang et al. () also suggest that recognition skills serve as prerequisites for effective reasoning.
To explore this further, we conduct an experiment by fixing the total training data at 8k and varying the ratio of reasoning to recognition data from $8:0$ to $0:8$.
We train the LLaVA-Next-Llama3-8B model and evaluate them on both recognition-focused benchmarks (i.e., ChartQA, ChartBench, ChartX) and reasoning-focused ones (i.e., ReachQA-Reas., CharXiv-Reas., MathVista).

As shown in Figure 4, increasing the proportion of recognition or reasoning data results in improvements in corresponding task performance.
Notably, models trained with a higher ratio of recognition data outperform those trained on 20k total data in recognition tasks.
In contrast, as the ratio of reasoning data increases, performance gains plateau and even decline when the ratio reaches 100%.
This suggests that simply increasing the proportion or scale of reasoning-oriented data may lead to diminishing returns.
We hypothesize that this is because reasoning abilities are partially dependent on recognition skills.
When a model fails to accurately interpret an image, its reasoning process is likely compromised (Wang et al., ).
Due to resource limitations, we are unable to scale the total data size further in this study.
However, we expect that with larger datasets, the interaction between recognition and reasoning data would become even more significant.

### 5.3 Balancing General Visual Understanding and Specialized Abilities

We are also interested in how models trained on specialized data perform in non-reasoning general-purpose multimodal tasks.
To investigate this, we conduct an experiment using 6 popular general multimodal benchmarks—MME-Reasoning, MME-Perception (Fu et al., ), SeedBench (Li et al., ), CCBench (Liu et al., ), POPE (Li et al., ), and HallusionBench (Guan et al., )—along with 4 specialized benchmarks: ReachQA, CharXiv, MathVista, and MATH-Vision.
We test three versions of LLaVA-Next-Llama3-8B models: the vanilla model, the one trained on 20k ReachQA samples, and another trained on 20k ReachQA samples combined with 20k general-purpose multimodal data randomly selected from the 779k LLaVA-NeXT-Data(^2^22https://huggingface.co/datasets/lmms-lab/LLaVA-NeXT-Data).
This dataset is chosen because the LLaVA-NeXT family of models was officially fine-tuned on it (Li et al., ), allowing us to approximate its original data distribution.

The results are shown in Figure 4.
We can observe that the vanilla model (green area) struggles with reasoning-intensive tasks, while the model trained on 20k ReachQA data (orange area) improves in reasoning but loses general visual performance.
Surprisingly, by incorporating just 20k of general instruction data (blue area), the model not only recovers its general multimodal performance but also retains the enhanced reasoning ability.
This results in a well-balanced model with a significant boost in reasoning improvements and minimal drops in general domains.

### 5.4 Interpretability Study from the Perspective of Attention

Figure: Figure 5: An example of attention visualization from the ChartQA dataset. The top row shows the results from the vanilla LLaVA-Next-Llama3-8B model, while the bottom row displays the results from our fine-tuned model. For each output, we present the attention distribution (highlighted zones) at three key steps, calculated by averaging the attention values of all tokens in each step.
Refer to caption: x5.png

To explore the mechanism behind the improved performance of our fine-tuned model, we conduct an analysis of the attention patterns during the next token prediction (Liang et al., ; Faysse et al., ).
Figure 5 presents a comparative case study between the vanilla model and the fine-tuned model.
Here, we apply full-parameter fine-tuning instead of LoRA to induce more pronounced changes in the attention layers (Hu et al., ).
The results show that the vanilla model produces lengthy outputs with redundant analysis and dispersed attention across the image, reaching a wrong conclusion at the end.
In contrast, the fine-tuned model identifies the key information at each step, with attention that accurately focuses on relevant visual elements (i.e., labels, axes and values).

This suggests that the model not only imitates expert rationales but also learns the underlying attention patterns crucial for effective visual reasoning.
The model automatically establishes a synergistic relationship between recognition and reasoning capabilities, understanding what to recognize during the reasoning process and utilizing these recognition results to guide subsequent reasoning steps.

## 6 Conclusion

In this work, we delve into the core challenges faced by MLLMs in complex chart Q&A tasks, highlighting their deficiencies in both recognition and reasoning.
Building on our analysis of existing datasets and the untapped potential of LLMs, we propose Code-as-Intermediary Translation (CIT) as a novel method to distill LLMs’ abilities and improve MLLMs.
With code as a bridge between visual and textual modalities, CIT enables language models to interpret complex charts more precisely, facilitating the generation of higher-quality Q&A pairs.
Our synthetic dataset, ReachQA, demonstrates significant performance improvements across multiple models and benchmarks, with gains extending beyond chart-specific to broader multimodal reasoning tasks.
We believe that CIT offers a promising direction for scalable and cost-effective multimodal instruction data synthesis.

## Limitations

We summarize the limitations of our method as follows:
(1) While CIT effectively uses code to link text and abstract images like charts and diagrams, applying this approach to natural images remains challenging.
Current text-to-image models still lack precise control over fine details (Betker et al., ; Zhang et al., ), which can lead to misaligned synthetic data.
Once more controllable techniques are developed, the synthesis of multimodal data could become more flexible and applicable.
(2) Although multimodal validation steps were introduced to reduce errors, the synthesized charts and Q&A pairs might still contain occasional inaccuracies.
Therefore, to ensure data quality for larger-scale applications, stronger models and stricter thresholds are essential.

## Appendix

## Appendix A Chart Types and Topics

We predefined several chart types and topics for Self-Instruct prompting. Table 6 presents the 9 major categories we established, along with their corresponding subcategories.
Additionally, Table 7 lists the 38 topics we specified.
It is important to note that these topics do not reflect the actual topic distributions in the generated charts, as we encourage the model to combine and expand upon them.

**Table 6: Major categories and minor categories of charts in ReachQA.**
| Major Category | Minor Category |
| --- | --- |
| Line Charts | line chart, line chart with data annotation, line chart with error bar |
| Pie Charts | pie chart, donut pie chart, sector pie chart, ring chart |
| Bar Charts | bar chart, bar chart with data annotation, stacked bar chart, percentage bar chart, horizontal bar chart |
| 3D Bar Charts | 3D bar chart, stacked 3D bar chart, percentage 3D bar chart |
| Node Charts | directed node chart, undirected node chart |
| Radar Charts | radar chart, radar chart with area filling |
| Area Charts | area chart, stacked area chart |
| Box Charts | vertical box chart, horizontal box chart |
| Scatter Charts | scatter chart, scatter chart with smooth fitting, 3D scatter chart (bubble chart) |
| Specific Charts | heat map, rose chart, funnel chart, waterfall chart, histogram, tree map |

**Table 7: Predefined chart topics in Self-Instruct prompting.**
| Art and Design | Futurism and Innovation | Agriculture and Food Production |
| --- | --- | --- |
| Music and Performance | Astronomy and Space | Transportation and Logistics |
| Business and Finance | Social Media and the Web | Real Estate and Housing Market |
| Travel and Exploration | Society and Community | Government and Public Policy |
| Books and Publishing | Physics and Chemistry | Education and Academics |
| Literature and Writing | Energy and Utilities | Environment and Sustainability |
| History and Culture | Biology and Life Sciences | Language and Communication |
| Architecture and Building | Retail and E-commerce | Social Sciences and Humanities |
| Fashion and Style | Religion and Spirituality | Manufacturing and Production |
| Marketing and Advertising | Food and Beverage Industry | Artificial Intelligence and Robotics |
| Law and Legal Affairs | Healthcare and Health | Human Resources and Employee Management |
| Film and Cinema | Sports and Entertainment | Computer Science and Information Technology |
| Mathematics and Statistics | Science and Engineering |  |

## Appendix B Cost of ReachQA Training Data Construction

Table 8 provides a detailed expense breakdown. We executed Self-Instruct and Evol-Instruct 3,000 times each to synthesize chart-plotting code, theoretically generating 6,000 charts. However, after accounting for non-executable code and images filtered out by MLLM rating, we ultimately produced 3,249 charts for Q&A synthesis.

**Table 8: The average number of input and output tokens is calculated for each step in the ReachQA construction process. In the equation, each term represents the average number of tokens per step (used only in a multi-step framework), while each multiplier corresponds to the number of times that step is executed. The pricing for GPT-4o-2024-08-06 is $2.50 per 1M input tokens and $10.00 per 1M output tokens. As a result, the total cost amounts to approximately $303.95.**
| Step | Avg. #tokens of Input | Avg. #tokens of Output | Times | Cost ($) |
| --- | --- | --- | --- | --- |
| Self-Instruct | $1,500+2,000=3,500$ | $500+500=1,000$ | 3,000 | $\sim 56.25$ |
| Evol-Instruct | $700+1,300=2,000$ | $300+700=1,000$ | 3,000 | $\sim 45.00$ |
| Self-Repair | $500$ | $500$ | 1,500 | $\sim 9.38$ |
| Reas-QA-Gen. | $1,000+1,500\times 4=7,000$ | $500+300\times 4=1,700$ | 3,249 | $\sim 112.09$ |
| Reco-QA-Gen. | $800+1,200\times 4=5,600$ | $300+200\times 4=1,100$ | 3,249 | $\sim 81.23$ |

## Appendix C Visualization of Charts in Different Dataset

We randomly sample several charts from the training set of ChartQA (Masry et al., ), ChartBench (Xu et al., ), ChartAst (Meng et al., ), ChartGemma (Masry et al., ), and ReachQA.
The visualization of the results is presented in Figure 6.

Figure: (a) ChartQA contains 3 types of charts collected from 4 websites.
Refer to caption: extracted/5951789/figure/Visualizations/ChartQA.jpg

## Appendix D Prompt Templates

Here, we present the prompt templates used in this paper.

### D.1 Intermediary Code Synthesis

The prompts used for code generation via the Self-Instruct method are presented in Figure 7, and Figure 8 shows the prompts for the Evol-Instruct method. As illustrated in Figure 9, we utilize four predefined directions to evolve the simple chart-plotting code.

Figure: Figure 7: Prompt template for code generation via Self-Instruct method.

Figure: Figure 8: Prompt template for code generation via Evol-Instruct method.

Figure: Figure 9: Predefined evolution directions for Evol-Instruct method.

### D.2 Bi-directional Translation

The prompt used for the Self-Repair method is presented in Figure 10.
Additionally, the prompt templates for generating reasoning-oriented questions and answers are listed in Figure 11 and Figure 12.
The prompt details for generating recognition-oriented questions and answers are listed in Figure 13 and Figure 14.

Figure: Figure 10: Prompt template for Self-Repair.

Figure: Figure 11: Prompt template for generating reasoning-oriented questions.

Figure: Figure 12: Prompt template for generating reasoning-oriented answers.

Figure: Figure 13: Prompt template for generating recognition-oriented questions.

Figure: Figure 14: Prompt template for generating recognition-oriented answers.

### D.3 Quality Assurance

The prompt details for rating charts and Q&A are illustrated in Figure 15 and 16.

Figure: Figure 15: Prompt template for rating the chart quality.

Figure: Figure 16: Prompt template for rating Q&A quality.

### D.4 Evaluation

In the evaluation process, we utilize the LLM-as-a-judge method. The detailed prompt template is illustrated in Figure 17.

Figure: Figure 17: Prompt template for evaluating the model prediction with LLMs.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: See Weaknesses
soundness: 2
strengths: Utilizing code as a generative engine is a sound approach to creating new chart images.

Experimental results indicate that the new dataset significantly enhances specific performance metrics.
summary: This paper proposes a novel pipeline for constructing multi-modality chart datasets. The central idea is the introduction of the “Code-as-Intermediary Translation” concept, which facilitates the creation of chart datasets for MLLMs (Multimodal Large Language Models). Experimental results demonstrate that the proposed datasets not only enhance chart-related QA capabilities but also improve overall reasoning performance.
weaknesses: The use of code as a tool for rendering the chart dataset appears similar to the concept presented in [1]. Furthermore, data augmentation through code is reminiscent of [2]. Could you elaborate on how your approach differentiates from these works?

The model fine-tunes general MLLM models. How would the performance change if an equivalent amount of chart data were selected from general datasets for fine-tuning the MLLMs? A comparative analysis might be insightful.

Why is the chart type described as ∞? Are there any specific chart types that cannot be generated using Python code? 

What is the accuracy or success rate of MLLMs when generating code?

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 3
questions: See above
soundness: 3
strengths: 1. The inspiration of the method is interesting and leverages the translation principle to incorporate an intermediate language. By using code as an intermediate language, the method is interesting and novel. 
2. The steps behind the method are clear and reasonable, first use code to generate charts, and then generate QA pairs. The authors use multiple methods, such as Evol-instruct, self-instruct, llm-as-judge and so on to make the generated data to be high quality and diversity.
3. The experiments are extensive to show the effectiveness of the method and the study is also good.
summary: This paper aims to distill the visual chart reasoning ability from LLMs to MLLMs through a code-as-intermediary translation (CIT) method. The motivation behind the work lines the concern of current MLLMs and then distill the LLMs knowledge about reasoning to MLLMs is a way. The method separates two steps, recognition and reasoning, then the authors try to generate more codes for chart generation, and then generate instruction-answer pairs. Besides, the authors also propose a ReachQA dataset for training and evaluation. Through multiple experiments, the authors demonstrate the effectiveness of the method, the dataset with strong performances.
weaknesses: 1. The main concern is about the motivation or the story. While the authors mention that the existing MLLMs are struggle in the recognition and reasoning abilities, the authors then want to use distill LLMs' reasoning ability to MLLMs. However, it is clear that Claude and GPT-4o are smart in these ways. Therefore, the problem is not about existing MLLMs but the open-sourced, or freely sourced MLLMs. I encourage the authors to rephrase the story, which then could introduce the method more clearly. 
2. Though the steps are great and the authors use multiple existing methods to generate and guarantee the data quality. The novelty of the method/framework is clearly not that big, but I like the code-as-intermediate translation method. 
3. In detail, the analysis of the question types should be reported, which could show the diversity and quality; from the experiments, strong improvements are achieved but still largely fail behind the close models; the self-repair method is good but the prompt is too simple, I am curious about other clear prompts; as the authors show figure 1 as a motivation, it is still necessary to better analyse the two type errors in the final trained model, not like figure 3, but like figure 1 to show the improvement.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Please refer to above.
soundness: 3
strengths: - The overall writing is clear and easy to follow.
- The idea of CIT is straightforward, effective and easily scalable.
- CIT addressed an important gap in MLLM training in lacking accurate textual annotations of visual diagrams.
- The resulting dataset has high quality. Althought only with 3K images and 20K QAs, the perforamnce of MLLMs improves by at most 35 percent. In addition, when trained a mixture with general multimodal dataset, the model can effectively retain its general MM benchmarks.
summary: This paper purpose CiT (Code-as-Intermediary Translation), a data synthesis method for distilling visual reaoning abilities from LLM to MLLMs. In CiT, code are rendered to charts and translated to instruction tuning by LLMs. Using this pipeline, this paper developed ReachQA, which is an effective benchmark and training dataset.
weaknesses: - As authors claimed, the MLLMss ability consist of two main parts, 1. recognizing key information from visual inputs 2. conducting reasoning over it. The design of ReachQA is rich in both parts, so it's unclear which part improves models' over performance the most, the reviewer is aware that similar analysis is conducted in section 5, but an error analysis (similar with figure 1) on before/after ReachQA training can make it more clear. 
- Dataset volume is a concern. As a training dataset, only 3K images is not sufficient, especially for cross-modal training. So it's likely that the improvement gained by training on ReachQA is that the model learns reasoning better rather than recogonition.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Please refer to the weaknesses section.
soundness: 3
strengths: 1. CIT incorporates the characteristics of the chart tasks to generate high-quality data.
2. This paper attempts to deconstruct the capability of chart-based question answering into recognition and reasoning and provides thorough justification based on this approach.
summary: This paper proposes an efficient method (CIT) that aims to use code as a bridge and incorporates certain characteristics of diagram research (such as visual complexity) to generate data (REACHQA). On this basis, the paper deconstructs the capabilities required for the Chart QA task into recognition and reasoning, and demonstrates through experiments that the proposed method is effective.
weaknesses: 1. The authors should consider and attempt to provide data on the overlap between the generated data, the validation set, and relevant benchmark datasets to further substantiate the validity of the experiments.
2. I hope the authors can provide more evaluation results on benchmarks that are specific to recognition [1] and reasoning [2] to demonstrate that the method has strong generalization capabilities. If the results do not decline, that would be an even more interesting observation.

[1] OCRBench: On the Hidden Mystery of OCR in Large Multimodal Models
[2] We-Math: Does Your Large Multimodal Model Achieve Human-like Mathematical Reasoning?

Meta-review: (a) Summary:
The paper introduces Code-as-Intermediary Translation (CIT), a scalable method for synthesizing chart datasets to enhance reasoning abilities in Multimodal Large Language Models (MLLMs). It contributes the ReachQA dataset, demonstrating improved performance on chart-related tasks and general reasoning benchmarks.

(b) Strengths:
The paper addresses an important gap in MLLM training, proposing a novel and efficient data synthesis pipeline. Extensive experiments show measurable performance improvements, and the dataset exhibits high quality despite its small size.

(c) Weaknesses:
The novelty of the CIT framework is incremental, as it builds on existing techniques. Concerns include limited dataset volume, lack of sufficient qualitative examples, and questions regarding scalability with cheaper models.

(d) Decision:
While the paper is well-executed with valuable contributions, concerns about limited novelty and dataset sufficiency remain. I recommend rejection.

Decision: Reject