betaFeedback

WorksComputer Science

Simple Test-Time Refinement for Plot-to-Code Generation via Visual-Code Diagnostics

Abstract

Plot-to-code generation has been greatly advanced by recent multimodal large language models (MLLMs). However, existing studies mainly focus on one-pass generation or iterative sampling guided by verifier-based filtering, which does not align with the typical human programming workflow of generate first, then iteratively error-location and fix. This naturally motivates a test-time refinement paradigm for plot-to-code generation. In this work, we present the first study on plot-to-code generation via iterative test-time refinement. We propose a Visual-Code Diagnostics framework that enables refinement through visual feedback from source code. Specifically, we first categorize generation errors into four coarse-grained types, and then train lightweight discriminators to recognize and localize these errors based on the rendered visual outputs and corresponding code. Unlike traditional compiler- or debugger-based verification, our approach performs iterative refinement guided by one diagnostics system, enabling more effective semantic and visual correction during test time. Extensive experiments demonstrate that our method consistently improves generation quality across diverse generators and significantly outperforms strong test-time scaling baselines.

Introduction

Plot-to-code generation [1, 2, 3, 4, 5] aims to synthesize executable plotting programs that faithfully reproduce a given reference chart. This task has attracted growing attention due to its applications in visual chart understanding [6, 7], data visualization [1, 8], and code generation [9, 10, 11]. Recent advances in large multimodal language models (MLLMs) [12, 13, 14, 15, 16, 17, 18] have substantially improved performance by enabling joint visual and textual reasoning. Nevertheless, generating visually accurate plotting code remains challenging, especially for complex charts requiring precise structural layouts, data mappings, and stylistic consistency.

Most existing approaches [19, 4, 20, 3, 5] formulate plot-to-code generation as a direct program synthesis problem, where the model generates plotting code from the input chart in a single pass. Although recent MLLMs [21, 22, 18, 23, 24, 25] demonstrate strong generation capabilities, such methods remain highly sensitive to visual-semantic errors, including incorrect data encodings, missing visual elements, layout and styling mismatches. In practice, we observe that these failures exhibit recurring visual patterns and can be grouped into several coarse-grained categories of visual errors. Once such errors appear in generated code, they are often difficult to correct through single-pass decoding alone.

To alleviate generation failures, recent works have begun exploring test-time scaling strategies such as iterative repeated sampling [26]. Repeated sampling methods improve performance by generating multiple candidate programs and selecting outputs using execution-based or verifier-based filtering. However, these approaches repeatedly regenerate the entire program, leading to substantial inference cost and token consumption, especially for long and structurally complex code. More importantly, existing verification signals are typically coarse-grained, only indicating whether a generated result is acceptable without identifying the underlying causes of visual discrepancies. Such paradigms do not align with the typical human programming workflow, where developers usually generate an initial code first, then iteratively inspect outputs, localize errors, and revise only problematic code regions. This naturally motivates a test-time refinement paradigm for plot-to-code generation.

Iterative refinement provides a more promising direction by progressively correcting generation errors through multiple rounds of revision [27]. However, effective refinement for plot-to-code generation requires more than holistic correctness evaluation. Existing approaches still lack fine-grained visual-semantic diagnostics that can explicitly connect rendering errors with suspicious code regions. As a result, refinement often remains inefficient, requiring redundant regeneration and suffering from accumulated error propagation. This limitation becomes particularly pronounced in multi-agent refinement settings, where the absence of structured diagnostic feedback leads to ineffective interactions between generation and revision agents.

To address these challenges, we propose a Visual-Code Diagnostics framework for efficient test-time refinement in plot-to-code generation. As shown in Figure 1, instead of repeatedly regenerating the full plotting program, our framework iteratively diagnoses visual-code inconsistencies from rendered charts and performs localized code patch refinement. Specifically, we introduce a lightweight visual-code diagnostic verifier that identifies visual discrepancy categories and localizes suspicious code regions associated with rendering errors. The resulting diagnostic feedback serves as a structured interaction bridge for iterative refinement, enabling targeted code modification with substantially lower token consumption and improved correction efficiency.

Figure 1. Comparison of one-pass generation-based repeat sampling and our visual-code diagnostic-guided test-time refinement.

To train the verifier, we construct a visual-code error discrimination dataset using controlled code mutations generated by MLLMs to simulate realistic plotting errors. We further employ an improved line-level Levenshtein distance algorithm [28, 29] to localize modified code regions and build structured supervision signals that associate visual discrepancies with corresponding code edits, enabling the verifier to learn visual-semantic diagnostic reasoning over chart-code pairs. At inference time, our framework follows an iterative refinement pipeline: generate, render, diagnose, and patch-refine. Unlike conventional test-time scaling approaches that repeatedly regenerate complete programs, our method only revises localized suspicious code segments during refinement, significantly improving inference efficiency while maintaining strong correction capability.

We evaluate our approach on Chart2Code-160k [3], ChartMimic [1], and Plot2Code [2]. Experimental results demonstrate that our method consistently improves generation quality across multiple generators and substantially outperforms strong test-time scaling baselines. Furthermore, compared with existing iterative refinement methods, our framework achieves superior performance with considerably lower inference cost.

Our contributions can be summarized as follows:

  • We present a simple test-time refinement for plot-to-code generation, creating a diagnostic system to guide the iterative refinement while reducing inference cost.

  • We build a lightweight visual-code diagnostic verifier that is able to detect visual discrepancies and localize them to specific code regions based on an automatically built dataset.

  • We show that our method is effective on plot-to-code benchmarks, outperforming strong baselines, including one-pass generation and other test-time scaling strategies at low cost.2

Related Work

Plot-to-Code Generation. With the rapid development of multimodal large language models (MLLMs) [21, 22, 18, 23, 24], plot-to-code generation has attracted increasing attention. Recent works have constructed various benchmarks and training datasets for this task, including ChartMimic [1], Plot2Code [2], ChartEdit [30], ChartX [31], ReChartPrompt-240K [4], Chart2Code160K [3], and Chart2Code53 [5]. VisCodex [32] and JanusCode [33] further extend multimodal code generation to broader tasks such as webpage and UI generation.

Beyond dataset construction, researchers have explored different training paradigms for improving plot-to-code generation. Zhang et al. [19] optimize generation using preference learning and DPO, while ChartMaster [4] and MSRL [20] employ reinforcement learning with visual and attribute-level rewards. ChartCoder [3] and Chart2Code53 [5] perform supervised fine-tuning on large-scale chart-code datasets. Most existing methods formulate plot-to-code as direct program synthesis, where the entire plotting program is generated in a single pass. In contrast, our work focuses on efficient test-time refinement through visual-code diagnostics.

Test-Time Scaling and Iterative Refinement. Test-time scaling [26, 34] has recently become an effective strategy for improving code generation performance. A common approach is repeated sampling [26], where multiple candidate programs are generated and filtered using execution feedback, reward models, or verifier-based selection [35]. However, such methods repeatedly regenerate complete programs, resulting in high inference cost and suboptimal results.

Recent works have also explored iterative and multi-agent refinement for plot-to-code generation. METAL [27] introduces a multi-agent framework for chart-to-code generation with iterative collaboration between multiple GPT-4o-based agents. While effective, existing refinement frameworks still rely on holistic conversational feedback and repeated full-program generation, making them vulnerable to inefficient revisions and error propagation.

Different from prior work, our framework performs localized patch-based refinement through visual-code diagnostics. By identifying visual discrepancy categories and suspicious code regions, our method enables targeted iterative correction with substantially improved inference efficiency.

Method

Given a reference chart image II, plot-to-code generation aims to synthesize an executable plotting program CC using an MLLM generator DD, such that the rendered chart I^\hat{I} faithfully matches II. Instead of treating this task as one-pass generation, we propose the test-time refinement strategy, where an initially generated program is iteratively corrected according to visual-code diagnostic feedback. Specifically, we introduce visual-code diagnostic verification: V(I,I^,C)→(e,L)V(I,\hat{I},C) \rightarrow(e,L), where ee denotes the visual error category and LL denotes the suspicious code regions associated with the discrepancy. Based on (e,L)(e,L), the generator performs localized patch-based refinement instead of full-program regeneration, enabling more efficient and targeted correction.

This section introduces our framework (Figure 2), including visual error taxonomy and dataset construction, diagnostic verifier training, and visual-code diagnostics-guided test-time refinement.

Figure 2. Overview of test-time refinement for plot-to-code generation via visual-code diagnostics.

Visual-Code Diagnostic Verification

We model visual-code diagnostics as structured errors that can be detected from rendered outputs and localized to specific code segments. This subsection describes how we define error structures, construct supervision, and train the verifier.

Error Modeling and Diagnostic Categories

To better understand failure patterns in plot-to-code generation, we conduct a systematic analysis of real-world errors produced by several representative MLLMs, including ChartMaster-7B [4], Qwen-VL-2B-Instruct, Qwen-VL-32B-Instruct [12], and GPT-4o [13]. Our analysis shows that visual discrepancies typically exhibit structured and localized patterns, rather than arbitrary mismatches. Instead of defining a rigid taxonomy, we adopt a set of coarse-grained diagnostic categories that capture common failure modes in Matplotlib-based [36, 37] plot generation. These categories broadly include: 1). compiler failures that prevent successful rendering, 2). data-related error in plotted shapes or values, 3). local styling errors affecting specific visual elements, and 4). global layout or styling inconsistencies involving plot-level components.

Importantly, these errors are often associated with localized code regions, suggesting that effective refinement requires not only detecting whether a chart is incorrect, but also identifying where the error likely originates in the code. This observation motivates our diagnostic verifier, which produces structured feedback grounded in code structure and visual discrepancies. Detailed error definitions, examples, and distribution statistics of real-world errors are provided in Appendix § 7.

Structured Diagnostic Dataset Construction

To train the visual-code diagnostic verifier, we construct a structured dataset that provides supervision for both visual error detection and code localization. Each sample consists of a generated plot, a reference plot, and the code that produces the generated plot, with supervision signals including the visual error type and code-grounded diagnostic annotations.

We build this dataset from correct chart-code pairs in Chart2Code-160K [3]. To simulate realistic errors, we perform error-aware code mutation using GPT-4o [13]. Specifically, for each seed program, we generate three mutated variants corresponding to data error, local style error, and global style error, while keeping other parts of the code unchanged. Compiler errors are excluded from mutation, as they can be directly identified via execution feedback. To improve diversity, mutation types are applied in random sequential orders across samples.

Given one seed program and its mutated variants, we construct pairwise diagnostic samples by selecting two programs (C1C_1, C2C_2), where C1C_1 is treated as the generated code and C2C_2 as the reference. The corresponding plots (I1I_1, I2I_2) are rendered, and the visual error label is determined by the mutation type that differentiates C1C_1 from C2C_2. This pairwise construction yields diverse visual-code discrepancies and expands the dataset size (up to 12×12 \times per seed example).

To obtain code-region supervision, we introduce a line-level alignment algorithm based on an improved Levenshtein distance algorithm [28]. The method identifies inserted, deleted, and modified code segments between C1C_1 and C2C_2, and maps them to candidate error regions. The algorithm details are placed in Appendix § 8.§ 2. Instead of predicting explicit line indices, we represent localization signals by inserting TODO comments into the code near the identified regions, forming structured diagnostic annotations that are more robust for the generation paradigm of MLLMs.

This process converts synthetic visual-code differences into structured supervision and enables the scalable construction of structured diagnostic supervision without manual annotation, allowing the verifier to learn both error classification and fine-grained code localization. Detailed construction procedures are provided in Appendix § 8.

Visual-Code Diagnostic Verifier Training

We train a compact visual-code diagnostic verifier that takes the reference chart II, rendered chart I^\hat{I}, and generated code CC as input, and outputs structured visual-code diagnostics (e,L)(e, L), where visual diagnostic ee is the visual error type from our taxonomy and code diagnostic LL is localized code feedback. Specifically, instead of predicting line indices, it generates the code with TODO comments inserted near erroneous regions, providing generation-friendly and context-aware localization.

We train the verifier using a combination of supervised fine-tuning and reinforcement learning. While supervised training teaches the model the basic diagnostic format, reinforcement learning further improves the accuracy and usefulness of the diagnostic outputs. To this end, we design a reward function for GRPO training [38] that evaluates both visual error prediction and code localization quality: r=rvisual+rcoder = r_{\mathrm{visual}} + r_{\mathrm{code}}. Both components are computed using Jaccard similarity [39]:

r(X,Y)=∣X∩Y∣∣X∪Y∣,r(X,Y) = \frac{|X \cap Y|}{|X \cup Y|},

where XX and YY denote the predicted and ground-truth sets, respectively.

For visual diagnostics, rvisualr_{\mathrm{visual}} measures the overlap between predicted and ground-truth error types. For code diagnostics, we represent each predicted diagnostic action as a tuple (i,a,j)(i, a, j), where ii denotes the line position of the inserted TODO comment, a∈{add,modify,delete}a \in\{\mathrm{add}, \mathrm{modify}, \mathrm{delete}\} denotes the repair action type, and jj denotes the number of affected lines. The reward rcoder_{\mathrm{code}} is computed as the Jaccard similarity between predicted and ground-truth sets of such tuples.

This training formulation aligns the verifier with its diagnostic role: it encourages accurate identification of visual discrepancies while producing precise, code-grounded localization signals. Notably, a compact 2B model is sufficient to perform joint visual-code diagnostics, eliminating the need for complex multi-agent reasoning while enabling efficient test-time refinement with significantly reduced inference cost.

Visual-Code Diagnostics-Guided Test-Time Refinement

Given a reference chart II, the generator DD first produces an initial program C0C_0, which is rendered into I^0\hat{I}_0. The diagnostic verifier then analyzes the visual discrepancy between II and I^t\hat{I}_t, together with the associated code CtC_t, and produces structured diagnostic feedback (et,Lt)(e_t, L_t), where ete_t denotes a coarse-grained error category and LtL_t indicates the suspicious code region.

Based on this feedback, the generator produces a localized code patch ΔCt\Delta C_t targeting the identified region LtL_t. The patch is then merged back into the original program to obtain the refined code:

(et,Lt)=V(I,I^t,Ct),ΔCt=D(Ct,et,Lt),Ct+1=Merge⁡(Ct,ΔCt).(1)(e_t, L_t) = V(I, \hat{I}_t, C_t), \qquad\Delta C_t = D(C_t, e_t, L_t), \qquad C_{t+1} = \operatorname{Merge}(C_t, \Delta C_t). \tag*{(1)}

This process can be iteratively repeated to progressively improve chart correctness. Unlike one-pass regeneration methods, our approach performs localized refinement while preserving correct code regions, reducing unnecessary modifications and mitigating error propagation. Moreover, compared to multi-agent refinement frameworks that require repeated interactions among multiple large models, our method relies on a lightweight diagnostic verifier to provide explicit and structured feedback, resulting in a substantially more efficient test-time refinement process.

Experiments

We conduct experiments to verify the effectiveness and efficiency of our proposed visual-code diagnostic verifier and test-time refinement strategy. In addition, we also perform experimental analyses to gain a deeper understanding of plot code diagnostics and repair.

Experiment Setting

Datasets. We sample 1,000 examples from Chart2Code-160k [3] to build our visual-code diagnostic verification dataset that consists of 12,000 examples. ChartMimic [1] and Plot2Code [2] are used as test datasets to verify our visual-code diagnostic verifier and test-time plot-to-code refinement.

Evaluation. The code execution success rate (E) is the basic evaluation metric. Following [1], we calculate Text score (TT), Layout score (LO), Type score (TP), Color score (CL) and their average score (L) as fine-grained visual metrics, which are the F1 scores of these elements between the generated and the reference plot. Besides, we employ GPT-4o to evaluate high-level (H) scores [1].

Baselines. To evaluate the generalization of test-time refinement methods, we conduct experiments across multiple generators of different scales and architectures, including Qwen3-VL (8B/32B) and GPT-4o. This setup allows us to assess whether test-time refinement strategies can consistently improve performance across diverse plot-to-code generators.

We compare our method with several representative baselines, including vanilla one-pass generation, multi-agent cooperative generation, and representative test-time refinement methods: Best-of-N sampling and self-debugging. Best-of-N selects the best output from multiple candidates, while self-debug iteratively refines outputs using self-feedback.

For multi-agent methods, we follow the standard setting in [27]. Under the GPT-4o setting, we directly report the original results from [27]. For other generators, we reproduce the multi-agent framework using the same backbone model as the generator, where all agents share the same base model, ensuring a fair and controlled comparison.

We further include our methods, Ours-SFT-2B and Ours-RL-2B, where a compact 2B visual-code verifier is used to guide test-time refinement. To evaluate the effectiveness of learned diagnostic verification, we also compare with untrained verifiers of different scales (2B and 32B), highlighting the importance of training for accurate visual-code diagnostics.

Main Results

Table 1 reports the main results across different generators and test-time scaling methods.

ModelsChartMimicPlot2Code
ETTLOTPCLLHETTLOTPCLLH
Qwen3-VL-8B-Instruct As Generator
Vanilla77.863.273.675.752.166.264.476.541.562.854.337.949.248.7
Best-of-N79.064.274.276.353.066.965.277.342.863.855.539.050.349.5
Self-debug79.864.874.876.853.867.665.878.043.564.556.239.851.050.2
Multi-agent83.070.080.574.056.870.367.286.449.576.560.844.057.757.8
Qwen3-VL-2B85.669.081.574.155.370.065.792.447.978.559.343.357.258.1
Qwen3-VL-32B83.670.781.174.557.270.967.588.650.477.361.544.858.558.3
Ours-SFT-2B86.371.083.676.058.072.169.296.250.978.660.843.858.559.0
Ours-RL-2B90.072.485.377.258.873.471.893.251.679.663.545.360.060.4
Qwen3-VL-32B-Instruct As Generator
Vanilla75.566.773.976.052.567.365.978.647.869.759.346.455.856.3
Best-of-N77.068.075.076.253.068.167.079.548.870.260.046.856.556.8
Self-debug77.868.675.676.553.568.667.579.549.370.860.547.156.957.0
Multi-agent79.672.079.276.354.070.469.880.350.266.561.247.256.357.2
Qwen3-VL-2B82.572.881.076.955.771.670.683.352.572.462.649.359.259.8
Qwen3-VL-32B80.372.779.976.654.370.970.275.050.766.861.847.556.757.5
Ours-SFT-2B84.874.583.377.857.673.373.687.955.476.064.752.362.161.7
Ours-RL-2B86.776.585.578.659.875.175.990.957.078.765.954.264.063.4
GPT-4o As Generator
Vanilla92.478.192.779.975.881.682.889.457.078.371.157.866.166.6
Best-of-N92.879.593.581.076.882.783.590.958.579.572.558.867.367.5
Self-debug93.080.294.081.877.583.484.090.959.280.273.259.568.068.2
Multi-agent [27]–86.395.584.279.986.5––––––––
Qwen3-VL-2B92.782.393.882.577.083.983.891.759.379.772.960.168.068.3
Qwen3-VL-32B92.984.694.583.278.185.184.792.460.881.074.261.669.469.5
Ours-SFT-2B93.187.195.084.379.686.585.892.461.982.275.662.770.671.1
Ours-RL-2B93.388.895.585.181.087.686.693.262.883.476.764.371.873.1

Table 1. Main results of plot-to-code generation across different generators, visual-code diagnostic verifiers, and test-time scaling methods. Vanilla represents one-pass generation.

Overall improvements across generators. Our method consistently improves over vanilla generation across all generators and benchmarks. Both Ours-SFT-2B and Ours-RL-2B achieve notable gains on all evaluation metrics, demonstrating that the test-time refinement approach via structured visual-code diagnostics effectively corrects generation errors.

Comparison with test-time scaling baselines. Compared with representative test-time scaling methods such as Best-of-N and Self-debug, our approach achieves stronger and more consistent improvements. While these methods rely on heuristic sampling or implicit self-feedback, our method provides explicit diagnostic signals, leading to more stable refinement behavior across different generators. The results verify the effectiveness of the proposed simple test-time refinement strategy based on visual-code diagnostics.

Comparison with multi-agent methods. Multi-agent approaches improve performance by coordinating multiple large models (e.g., Qwen3-VL-8B/32B or GPT-4o) for iterative generation and critique. In contrast, our method uses a single compact 2B verifier to guide refinement. Despite this significantly smaller model size, Ours-RL-2B achieves competitive or superior performance across most settings, indicating that learned visual-code diagnostics can effectively replace complex multi-agent reasoning for error correction.

Effect of verifier training. Comparing Ours-SFT-2B and Ours-RL-2B, we observe that reinforcement learning further improves diagnostic quality and downstream generation performance. This highlights the importance of optimizing diagnostic signals beyond supervised learning.

Generalization across model scales. Our method demonstrates consistent gains when applied to generators of different scales, from 8B to 32B models and GPT-4o. This suggests that diagnostic verification captures general error patterns that are complementary to model scaling, and can be effectively integrated with diverse base generators.

Inference Token Cost. Table 2 compares the inference token consumption of different refinement strategies. Compared with Best-of-N sampling and multi-agent refinement based on GPT-4o, our method uses a lightweight Qwen3-VL-2B diagnostic verifier to guide localized refinement.

MethodModelLTokensTimes
Best-of-NGPT-4o82.73047.63.7x
Multi-agentGPT-4o86.511264.01.0x
OursQwen3-VL-2B87.61859.36.1x

Table 2. Comparison of inference token consumption.

Despite using substantially fewer tokens, our method achieves the best visual score (LL: 87.6). Compared with multi-agent refinement, our approach reduces inference tokens from 11,264.0 to 1,859.3, corresponding to a 6.1×6.1 \times reduction in inference cost. These results show that structured visual-code diagnostics enable efficient and effective test-time refinement.

Analyses

Performances over Refinement Iterations. We analyze the effectiveness of visual-code diagnostics across refinement iterations on ChartMimic. Figure 3 compares untrained models (Qwen-2B, Qwen-32B) and our trained verifiers (SFT and RL). Curves denote execution success rate (E), while bars report the visual metric (L). Starting from one-pass generation (iteration 0), all methods improve with iterative refinement, confirming that test-time refinement can progressively correct both execution and visual errors. However, the quality of diagnostic signals plays a critical role. While larger untrained models such as Qwen-32B provide moderate gains, both trained 2B-scale verifiers consistently achieve stronger refinement performance, showing that learned visual-code diagnostics are more effective than model scale alone.

Plot-to-code generation results of refinement iterations across different visual-code diagnostic verifiers

Figure 3. Plot-to-code generation results of refinement iterations across different visual-code diagnostic verifiers.

We further observe different refinement behaviors across verifiers. Qwen-2B achieves rapid early gains in execution success rate but provides limited improvement in visual quality, suggesting that it mainly resolves simple execution issues while struggling with more complex visual discrepancies. In contrast, trained verifiers produce more informative diagnostic feedback, enabling progressively better visual refinement over iterations. Among all methods, the RL-trained verifier achieves the best execution and visual performance, indicating that reinforcement learning further improves diagnostic quality and refinement effectiveness.

Analysis on Specialized Plot-to-Code Generators. We further evaluate ChartMaster-7B [4], a model specialized for direct plot-to-code generation. As shown in Table 3, strong one-pass generation does not necessarily translate into effective refinement. On ChartMimic, Ours-RL-2B reduces execution success from 93.7 to 71.9 and visual similarity (LL) from 79.4 to 63.4; performance also declines on Plot2Code. This failure extends across different feedback strategies: self-debug, multi-agent refinement, and untrained verifiers also degrade performance, while Best-of-N provides almost no visual improvement.

ModelsChartMimicPlot2Code
ETTLOTPCLLHETTLOTPCLLH
Vanilla93.780.091.679.167.079.485.190.157.282.462.951.063.464.5
Best-of-N94.279.492.279.866.579.584.791.756.881.563.550.863.264.0
Self-debug91.077.089.577.564.077.082.586.455.079.061.549.561.362.0
Multi-agent88.574.586.575.562.574.880.584.853.076.560.048.559.560.5
Qwen3-VL-2B78.363.374.380.058.969.171.283.348.371.661.952.958.760.3
Qwen3-VL-32B67.059.970.980.056.766.969.966.643.770.262.552.557.258.4
Ours-SFT-2B73.358.069.676.054.164.467.682.650.273.260.052.058.959.9
Ours-RL-2B71.956.667.976.252.963.465.587.151.270.060.753.558.959.3

Table 3. Main results of plot-to-code generation based on ChartMaster-7B [4] as Generator.

These results suggest that the generator’s ability to revise code is a key bottleneck. ChartMaster-7B is trained for direct generation but is not explicitly trained for instruction-following code revision, whereas general-purpose MLLMs can use their broader instruction-following capabilities to act on diagnostic feedback. To further investigate this explanation, we conduct a manual case analysis in which ChartMaster-7B receives human-annotated gold visual-code diagnostics specifying the correct error types and erroneous code regions. Even with this accurate feedback, the model still fails to correct the identified errors in the inspected cases. This qualitative evidence indicates that inaccurate diagnostics alone cannot explain the failures and supports insufficient code-revision ability as an important contributing factor.

ChartMaster-7B therefore illustrates an applicability boundary: effective test-time refinement requires a generator that can reliably translate diagnostic feedback into correct code edits. This behavior suggests a trade-off in ChartMaster-7B’s domain-specific fine-tuning: gains in one-pass plot-to-code generation may come at the cost of general instruction-following and code-editing capabilities.

Improving verifier quality alone may be insufficient when this capability is lacking, even for a generator with strong one-pass performance. Training generators to follow diagnostic instructions and perform reliable code revision is an important direction for future work.

Ablation Study on Visual-Code Diagnostic Signals. We conduct ablation experiments on the ChartMimic dataset using Qwen3-VL-8B as the generator to analyze the contribution of visual and code diagnostics. As shown in Table 4, both visual-only and code-only settings improve over vanilla generation, indicating that each type of signal provides useful guidance for refinement.

VisualCodeETTLOTPCLLH
✓✗84.269.980.175.756.970.766.6
✗✓86.571.383.476.058.072.270.4
✓✓90.072.485.377.258.873.471.8

Table 4. Ablation experiments for visual-code diagnostics.

Comparing the two, code localization leads to stronger gains than visual-only signals, suggesting that precise, code-grounded feedback is particularly important for correcting errors. However, the best performance is achieved when combining both signals. This demonstrates that visual and code diagnostics are complementary: visual signals identify what is wrong, while code localization specifies where to fix. Their joint modeling enables more accurate and effective refinement, supporting our formulation of structured visual-code diagnostics.

Ablation Study on Reward Function. We examine different reward functions by training verifiers from the same SFT checkpoint using exact match, set F1, or Jaccard similarity for both the visual and code rewards, while retaining their uniform weighting. Table 5 reports downstream execution success (E) and fine-grained visual similarity (L) on ChartMimic using Qwen3-VL-8B as the generator.

Reward functionEL
Exact match87.271.9
F189.873.4
Jaccard90.073.4

Table 5. Ablation experiments for reward functions.

Jaccard similarity provides partial credit for overlap between variable-size sets of error types or localization actions, while normalizing for set size and penalizing both missing and spurious predictions. In contrast, exact match assigns zero reward to a component whenever its predicted set differs from the reference, even if some predictions are correct. Set F1 is a monotonic transformation of Jaccard similarity for each prediction/reference pair and captures similar overlap information.

Jaccard and F1 achieve the same L score of 73.4 and nearly identical execution success rates (90.0 and 89.8, respectively), suggesting limited sensitivity to the choice between these two overlap metrics in this setting. Exact match yields lower scores (E: 87.2; L: 71.9), consistent with its sparser reward discarding useful partial matches and providing less informative feedback during training.

Diagnostic Verification Performance. In addition to evaluating end-to-end plot-to-code generation, we directly assess the quality of visual-code diagnostic verification on the error discrimination dataset. We use 6,000 and 5,000 samples for SFT and RL training, respectively, and reserve 1,000 samples for evaluation. Table 6 reports the results across different verifiers. We evaluate both visual error prediction (PEF) and code localization quality (CEP, CER, CEF), where code errors are defined based on the structured tuples (i,a,j)(i, a, j) described in § 3.1.3.

ModelPEFCEPCERCEF
Qwen3-VL-2B70.550.220.128.7
Qwen3-VL-32B74.759.440.948.4
Ours-SFT-2B80.865.862.163.9
Ours-RL-2B87.273.280.776.8

Table 6. Visual-code diagnostic verification results across different verifiers.

Our trained verifiers significantly outperform untrained models of both smaller (Qwen3-2B) and larger (Qwen3-32B) scales. Notably, Ours-RL-2B achieves the best performance across all metrics, demonstrating that a compact model can effectively learn structured visual-code diagnostics when trained with our dataset and objectives. We further observe that untrained models exhibit imbalanced precision and recall in code localization, indicating unreliable and incomplete diagnostic signals. In contrast, our trained models achieve more balanced performance, suggesting more accurate and comprehensive identification of error regions. These results validate the effectiveness of our diagnostic dataset and training strategy, and explain the strong gains observed in test-time refinement: improved diagnostic signals directly translate into more precise and effective code updates.

Case Study. Figure 4 illustrates a representative example of our visual-code diagnostics-guided test-time refinement. Iteration 0 corresponds to direct generation, which exhibits noticeable discrepancies compared to the reference chart. With iterative refinement, the generated plot progressively aligns with the reference. Early iterations correct prominent errors such as axis configuration and styling attributes, while later iterations refine more detailed visual elements. This demonstrates that the verifier provides structured diagnostic signals that enable the generator to perform targeted updates rather than full regeneration.

Figure 4. A case of our test-time refinement for plot-to-code generation.

We observe that some corrections may not succeed in early iterations but are resolved in subsequent steps, indicating that refinement benefits from accumulating diagnostic feedback over iterations. Meanwhile, later iterations tend to introduce fewer changes, suggesting convergence as major errors are resolved. Despite these improvements, certain fine-grained discrepancies remain (e.g., subtle styling differences), even after multiple iterations. This highlights the remaining challenges in precisely aligning low-level visual details and suggests that further improving diagnostic granularity or generator editing capability could yield additional gains.

Conclusion

We study plot-to-code generation from the perspective of test-time refinement and identify diagnostic verification as a key component for improving generation quality. We propose a visual-code diagnostic framework that produces structured signals to detect visual discrepancies and localize code errors. By constructing a scalable diagnostic dataset and training a compact verifier, our method enables effective and targeted code refinement. Experiments show that a 2B verifier consistently improves generation performance, outperforming larger untrained models and achieving competitive results compared to multi-agent approaches with substantially lower cost. We further analyze limitations on specialized plot-to-code generators, highlighting the importance of revision capability for effective refinement. Our results suggest that learned diagnostic verification is a promising direction for efficient multimodal code generation.

Acknowledgments and Disclosure of Funding

This work was supported by the National Natural Science Foundation of China under Grant 62336008, the Guangdong Provincial Key Laboratory of Artificial General Intelligence and Large Models under Grant 2026B1212010005, and the CCF-Huawei Populus Grove Fund under Grant CCF-HuaweiSE2025021.

Plot Error Taxonomy and Distribution

Plot Error Types

Examining all results and considering the programming logic and coding style of the Matplotlib [36, 37] code, we categorize generation errors into four coarse-grained types:

  • Compiler error, where the generated code fails to execute and render the plot.

  • Data error, where the number and values of shapes and data points are incorrect.

  • Local style error, where styles of specific graphic shapes and elements are wrong, such as incorrect colors, markers, or line styles.

  • Global style error, where styles of global elements for the plot are misaligned, like axes, grid, titles, or extra texts.

Figure 5 demonstrates examples of four error types. The compiler error does not render the reference plot image, while the data error contains an extra box and incorrect lower and upper quartiles. There are wrong shapes and colors for the lines, dots, and boxes in the local style error, while extra x tick label and title in the global style error. In particular, the categorization basis of the latter three error types is primarily derived from the Matplotlib [36] code. A standard Matplotlib program consists of three components. The first component is data loading, the second involves invoking the core plotting APIs, where the local properties of plot elements can be configured, and the third sets global elements such as the title, axes, and additional annotations. Accordingly, these three categories of plot errors directly correspond to errors in the code, enabling efficient localization of code errors from plot errors. This correspondence reduces the burden on the subsequent Plot&Code discriminator, allowing even relatively small-scale MLLMs to effectively handle this task and thereby improve the iterative refinement performance of the plot-to-code generator.

Figure 5. Error types for plot-to-code generation.

Plot Error Distribution

We sample 100 instances from the ChartMimic dataset and use four representative plot-to-code models to directly generate code outputs. The three authors of this paper first independently inspect the code and rendered plots produced by the large language models, and then jointly discuss and establish the error taxonomy by synthesizing their individual judgments. Subsequently, all samples are annotated by the three authors. For cases with annotation disagreements, the final labels are determined through group discussion. Figure 6 presents the distribution of error types across different models: Qwen3-VL-8B, Qwen3-VL-32B, ChartMaster and GPT-4o.

Stacked bar chart showing plot error distributions for ChartMaster-7B, Qwen3-VL-8B, Qwen3-VL-32B, and GPT-4o, with compile error, data error, local style error, and global style error segments

Figure 6. Distribution of plot error types.

Dataset Construction

Process

Error-Aware Code Mutation

Given a correct chart-code pair (I,C)(I, C), we construct synthetic erroneous samples by applying controlled code mutations. We focus on three types of visual errors: data errors, local style errors, and global style errors. Compiler errors are excluded from mutation, as they can be directly identified from execution feedback. For each seed program, we employ GPT-4o to sequentially generate three mutated variants, each introducing one type of error while preserving other parts of the code. The prompts of GPT-4o for code mutation are listed in Appendix § 8.§ 3. The order of mutation types is randomly permuted across samples to improve diversity and avoid positional bias.

Pairwise Sample Construction

Given one seed program and its three mutated variants, we construct pairwise diagnostic samples by selecting two programs (C1,C2)(C_1, C_2). The corresponding rendered plots (I1,I2)(I_1, I_2) are obtained via execution. We treat C1C_1 as the generated code and C2C_2 as the reference. The visual error label is determined by the mutation type that differentiates C1C_1 from C2C_2. This pairwise construction produces multiple combinations per seed example, resulting in up to 12 samples per original chart-code pair.

Code Region Alignment

To obtain code localization supervision, we align C1C_1 and C2C_2 using a line-level variant of the Levenshtein distance algorithm (in Appendix § 8.§ 2). The alignment identifies inserted, deleted, and modified code segments between the two programs. We further refine the alignment by applying code-aware constraints to ensure valid line matching and reduce noise. The resulting regions are treated as candidate error locations.

Diagnostic Annotation Format

Instead of predicting explicit line indices, we convert localization signals into a generation-friendly format by inserting TODO comments near the identified code regions in C1C_1. This produces structured diagnostic annotations that preserve code context and are more robust for language models. Each final training instance consists of: 1. Generated plot I1I_1, 2. Reference plot I2I_2, 3. Generated code C1C_1 with diagnostic annotations, 4. Visual error label. This construction provides scalable supervision for both error classification and fine-grained code localization without requiring manual annotation of code regions.

Postprocessing Algorithm

We adopt line-level Levenshtein distance algorithm to compare two codes and extract the inserted/deleted/modified code line numbers, which is detailed in algorithm 1. In concrete terms, the condition control statement in lines 20-23 for replace_distance is different from the conventional Levenshtein distance algorithm.

Prompts

We mutate plot code by GPT-4o based on the proposed taxonomy of plot error during dataset construction. Prompts for code mutation are listed in Figure 7.

Dataset Construction Prompts

Figure 7. Dataset Construction Prompts.

Test-Time Refinement for Plot-to-Code Generation via Visual-Code Diagnostics

During iterative refinement, we use prompts in Figure 8 to instruct the visual-code diagnostic verifier and Figure 9 for the plot-to-code generator, respectively.

Prompt of visual-code diagnostic verifier

Figure 8. Prompt of visual-code diagnostic verifier.

Prompt of test-time refinement for plot-to-code generator, showing instructions for revising Python matplotlib code to reproduce a reference chart image

Figure 9. Prompts of test-time refinement for plot-to-code generation via visual-code diagnostics.

Experiments

Hyperparameters

We train the visual-code diagnostic verifier based on Qwen3-VL-2B-Instruct [12]. For the SFT stage, we conduct training on the 6,000 samples for 2 epochs. Our implementation is based on LLaMA-Factory [40] with batch size 64, learning rate 1e-5, cutoff length 16,000. For the reinforcement learning stage, we continually train the SFT model on the other 5,000 samples for 3 epochs. Our training is based on VERL [41] with global batch size 32, ppo_mini_batchsize 16, learning rate 1e-6, rollout_n 8, sampling temperature 1.0, top_p 1.0. For the inference stage, we repeat iterative refinement N=5N = 5 times. We set the temperature to 0.7, top_p 0.8 for our verifiers, while default sampling parameters for all plot-to-code generators. All experiments are conducted on 8 Nvidia A6000 GPUs.

Case Study

Figure 10 illustrates a case of test-time refinement for plot-to-code generation with different visual-code diagnostic verifiers.

Figure 10. A case of test-time refinement for plot-to-code generation with different visual-code diagnostic verifiers.

Algorithm 1: Adapted Line-level Levenshtein distance algorithm
Input: Two code strings code1, code2
Output: inserted, deleted, replaced pairs of code line numbers in code1 and code2
1 lines1 ← SplitLines(code1);
2 lines2 ← SplitLines(code2);
3 n ← |lines1|, m ← |lines2|;
4 Initialize DP table;
5 dp ← Matrix(n + 1, m + 1, 0);
6 for i ← 0 to n do
7   dp[i][0] ← i;                                      // delete i lines
8 end
9 for j ← 0 to m do
10  dp[0][j] ← j;                                      // insert j lines
11 end
12 Fill DP table;
13 for i ← 1 to n do
14  for j ← 1 to m do
15    if lines1[i − 1] = lines2[j − 1] then
16      dp[i][j] ← dp[i − 1][j − 1]
17    else
18      delete_distance ← dp[i − 1][j] + 1;
19      insert_distance ← dp[i][j − 1] + 1;
        // The following condition control for replace_distance is
           different from the conventional Levenshtein distance
           algorithm
20      if common_prefix_length(lines[i − 1], lines2[j − 1]) >= 6 then
21        replace_distance ← dp[i − 1][j − 1] + 1;
22      else
23        replace_distance ← dp[i − 1][j − 1] + 999;
24      dp[i][j] ← min(delete_distance, insert_distance, replace_distance);
25    end
26  end
27 Backtracking to extract operations pairs;
28 i ← n, j ← m;
29 inserted, deleted, replaced ← [ ], [ ], [ ];
30 while i > 0 or j > 0 do
31  if i > 0 and j > 0 and lines1[i − 1] = lines2[j − 1] then
32    i ← i − 1, j ← j − 1;                             // match
33  else if j > 0 and dp[i][j] = dp[i][j − 1] + 1 then
34    inserted.append((i, j));
35    j ← j − 1;                                        // insert
36  else if i > 0 and dp[i][j] = dp[i − 1][j] + 1 then
37    deleted.append((i, j));
38    i ← i − 1;                                        // delete
39  else if i > 0 and j > 0 and dp[i][j] = dp[i − 1][j − 1] + 1 then
40    replaced.append((i, j));
41    i ← i − 1, j ← j − 1;                             // replace
42  else
43    raise ValueError(“Unexpected Case”);
44  end
45 return inserted, deleted, replaced;

References

  1. [1]Cheng Yang, Chufan Shi, Yaxin Liu, Bo Shui, Junjie Wang, Mohan Jing, Linran XU, Xinyu Zhu, Shiheng Li, Yuxiang Zhang, Gongye Liu, Xiaomei Nie, Deng Cai, and Yujiu Yang. Chartmimic: Evaluating LMM’s cross-modal reasoning capability via chart-to-code generation. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum?id=sGpCzsfd1K.arxiv.org/abs/2406.09961
  2. [2]Chengyue Wu, Zhixuan Liang, Yixiao Ge, Qiushan Guo, Zeyu Lu, Jiahao Wang, Ying Shan, and Ping Luo. Plot2Code: A comprehensive benchmark for evaluating multi-modal large language models in code generation from scientific plots. In Findings of the Association for Computational Linguistics: NAACL 2025, pages 3006–3028, 2025. ISBN 979-8-89176-195-7. doi: 10.18653/v1/2025.findings-naacl.164. URL https://aclanthology.org/2025.findings-naacl.164/.
  3. [3]Xuanle Zhao, Xianzhen Luo, Qi Shi, Chi Chen, Shuo Wang, Zhiyuan Liu, and Maosong Sun. ChartCoder: Advancing multimodal large language model for chart-to-code generation. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 7333–7348, 2025. ISBN 979-8-89176-251-0. doi: 10.18653/v1/2025.acl-long.363. URL https://aclanthology.org/2025.acl-long.363/.DOI
  4. [4]Wentao Tan, Qiong Cao, Chao Xue, Yibing Zhan, Changxing Ding, and Xiaodong He. Chart-master: Advancing chart-to-code generation with real-world charts and chart similarity reinforcement learning. arXiv preprint arXiv:2508.17608, 2025. URL https://arxiv.org/abs/2508.17608.
  5. [5]Tianhao Niu, Yiming Cui, Baoxin Wang, Xiao Xu, Xin Yao, Qingfu Zhu, Dayong Wu, Shijin Wang, and Wanxiang Che. ChartCode53: A large-scale diverse and complex dataset for enhancing chart-to-code generation. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 15839–15855, 2025. doi: 10.18653/v1/2025.emnlp-main.799. URL https://aclanthology.org/2025.emnlp-main.799/.
  6. [6]Zhengzhuo Xu, Bowen Qu, Yiyan Qi, SiNan Du, Chengjin Xu, Chun Yuan, and Jian Guo. Chartmoe: Mixture of diversely aligned expert connector for chart understanding. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openreview.net/forum?id=o5TWTuSEF.arxiv.org/abs/2409.03277
  7. [7]Yuwei Yang, Zeyu Zhang, Yunzhong Hou, Zhuowan Li, Gaowen Liu, Ali Payani, Yuan-Sen Ting, and Liang Zheng. Effective training data synthesis for improving mllm chart understanding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2653–2663, October 2025. URL https://openaccess.thecvf.com/content/ICCV2025/html/Yang_Effective_Training_Data_Synthesis_for_Improving_MLLM_Chart_Understanding_ICCV_2025_paper.html.arxiv.org/abs/2508.06492
  8. [8]James Ford, Xingmeng Zhao, Dan Schumacher, and Anthony Rios. Charting the future: Using chart question-answering for scalable evaluation of LLM-driven data visualizations. In Proceedings of the 31st International Conference on Computational Linguistics, pages 7497–7510, 2025. URL https://aclanthology.org/2025.coling-main.501/.arxiv.org/abs/2409.18764
  9. [9]Chengqi Duan, Kaiyue Sun, Rongyao Fang, Manyuan Zhang, Yan Feng, Ying Luo, Yufang Liu, Ke Wang, Peng Pei, Xunliang Cai, et al. Codeplot-cot: Mathematical visual reasoning by thinking with code-driven images. arXiv preprint arXiv:2510.11718, 2025. URL https://arxiv.org/abs/2510.11718.
  10. [10]Ahmed Masry, Megh Thakkar, Aayush Bajaj, Aaryaman Kartha, Enamul Hoque, and Shafiq Joty. ChartGemma: Visual instruction-tuning for chart reasoning in the wild. In Proceedings of the 31st International Conference on Computational Linguistics: Industry Track, pages 625–643, 2025. URL https://aclanthology.org/2025.coling-industry.54/.arxiv.org/abs/2407.04172
  11. [11]Victor Carbune, Hassan Mansoor, Fangyu Liu, Rahul Aralikatte, Gilles Baechler, Jindong Chen, and Abhanshu Sharma. Chart-based reasoning: Transferring capabilities from LLMs to VLMs. In Findings of the Association for Computational Linguistics: NAACL 2024, pages 989–1004, Mexico City, Mexico, 2024. doi: 10.18653/v1/2024.findings-naacl.62. URL https://aclanthology.org/2024.findings-naacl.62/.DOI
  12. [12]Qwen Team. Qwen3-vl technical report. arXiv preprint arXiv:2511.21631, 2025. URL https://arxiv.org/pdf/2511.21631.
  13. [13]Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al. Gpt-4o system card. arXiv preprint arXiv:2410.21276, 2024. URL http://arxiv.org/abs/2410.21276.
  14. [14]Yuan Yao, Tianyu Yu, Aо Zhang, Chongyi Wang, Junbo Cui, Hongji Zhu, Tianchi Cai, Chi Chen, Haoyu Li, Weilin Zhao, et al. Efficient gpt-4v level multimodal large language model for deployment on edge devices. Nature Communications, 16(1):5509, 2025. URL https://www.nature.com/articles/s41467-025-61040-5.DOI
  15. [15]Weiyun Wang, Zhangwei Gao, Lixin Gu, Hengjun Pu, Long Cui, Xingguang Wei, Zhaoyang Liu, Linglin Jing, Shenglong Ye, Jie Shao, et al. Internvl3. 5: Advancing open-source multimodal models in versatility, reasoning, and efficiency. arXiv preprint arXiv:2508.18265, 2025. URL https://arxiv.org/abs/2508.18265.
  16. [16]Wenyi Hong, Wenmeng Yu, Xiaotao Gu, Guo Wang, Guobing Gan, Haomiao Tang, Jiale Cheng, Ji Qi, Junhui Ji, Lihang Pan, et al. Glm-4.1 v-thinking: Towards versatile multimodal reasoning with scalable reinforcement learning. arXiv preprint arXiv:2507.01006, 2025. URL https://arxiv.org/abs/2507.01006.
  17. [17]Dong Guo, Faming Wu, Feida Zhu, Fuxing Leng, Guang Shi, Haobin Chen, Haoqi Fan, Jian Wang, Jianyu Jiang, Jiawei Wang, et al. Seedl. 5-vl technical report. arXiv preprint arXiv:2505.07062, 2025. URL https://arxiv.org/abs/2505.07062.
  18. [18]Zhiyu Wu, Xiaokang Chen, Zizheng Pan, Xingchao Liu, Wen Liu, Damai Dai, Huazuo Gao, Yiyang Ma, Chengyue Wu, Bingxuan Wang, et al. Deepseek-vl2: Mixture-of-experts vision-language models for advanced multimodal understanding. arXiv preprint arXiv:2412.10302, 2024. URL https://arxiv.org/abs/2412.10302.
  19. [19]Zhihan Zhang, Yixin Cao, and Lizi Liao. Boosting chart-to-code generation in mllm via dual preference-guided refinement. In Proceedings of the 33rd ACM International Conference on Multimedia, MM ’25, 2025. URL https://arxiv.org/pdf/2504.02906.
  20. [20]Lei Chen, Xuanle Zhao, Zhixiong Zeng, Jing Huang, Liming Zheng, Yufeng Zhong, and Lin Ma. Breaking the SFT plateau: Multimodal structured reinforcement learning for chart-to-code generation. In The Fourteenth International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=14qYxv2jki.arxiv.org/abs/2508.13587
  21. [21]Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao, et al. Kimi k1. 5: Scaling reinforcement learning with llms. arXiv preprint arXiv:2501.12599, 2025. URL https://arxiv.org/abs/2501.12599.
  22. [22]Jingyi Zhang, Jiaxing Huang, Sheng Jin, and Shijian Lu. Vision-language models for vision tasks: A survey. IEEE Transactions on Pattern Analysis and Machine Intelligence, 46(8):5625–5644, 2024. doi: 10.1109/TPAMI.2024.3369699.DOI
  23. [23]Jiaxing Huang, Jingyi Zhang, Kai Jiang, Han Qiu, Xiaoqin Zhang, Ling Shao, Shijian Lu, and Dacheng Tao. Visual instruction tuning towards general-purpose multimodal large language model: A survey. International Journal of Computer Vision, 133(11):8151–8189, 2025. URL https://link.springer.com/article/10.1007/s11263-025-02572-7.DOI
  24. [24]Siyu Cao, Hangting Chen, Peng Chen, Yiji Cheng, Yutao Cui, Xinchi Deng, Ying Dong, Kipper Gong, Tianpeng Gu, Xiusen Gu, et al. Hunyuanimage 3.0 technical report. arXiv preprint arXiv:2509.23951, 2025. URL https://arxiv.org/abs/2509.23951.
  25. [25]Peiming Guo, Sinuo Liu, Yanzhao Zhang, Dingkun Long, Pengju Xie, Meishan Zhang, and Min Zhang. An end-to-end model for photo-sharing multi-modal dialogue generation. In 2025 IEEE International Conference on Multimedia and Expo (ICME), pages 1–7, 2025. doi: 10.1109/ICME59968.2025.11208999. URL https://ieeexplore.ieee.org/abstract/document/11208999.DOI
  26. [26]Bradley Brown, Jordan Juravsky, Ryan Ehrlich, Ronald Clark, Quoc V Le, Christopher Ré, and Azalia Mirhoseini. Large language monkeys: Scaling inference compute with repeated sampling. arXiv preprint arXiv:2407.21787, 2024. URL https://arxiv.org/abs/2407.21787.
  27. [27]Bingxuan Li, Yiwei Wang, Jiuxiang Gu, Kai-Wei Chang, and Nanyun Peng. METAL: A multi-agent framework for chart generation with test-time scaling. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 30054–30069, 2025. ISBN 979-8-89176-251-0. doi: 10.18653/v1/2025.acl-long.1452. URL https://aclanthology.org/2025.acl-long.1452/.
  28. [28]VI Levenshtein. Binary codes capable of correcting deletions, insertions, and reversals. In Soviet physics doklady, volume 10, pages 707–710, 1966. URL https://nymity.ch/sybilhunting/pdf/Levenshtein1966a.pdf.
  29. [29]Robert A. Wagner and Michael J. Fischer. The string-to-string correction problem. J. ACM, 21 (1):168–173, 1974. ISSN 0004-5411. doi: 10.1145/321796.321811. URL https://doi.org/10.1145/321796.321811.
  30. [30]Xuanle Zhao, Xuexin Liu, Yang Haoyue, Xianzhen Luo, Fanhu Zeng, Jianling Li, Qi Shi, and Chi Chen. ChartEdit: How far are MLLMs from automating chart analysis? Evaluating MLLMs’ capability via chart editing. In Findings of the Association for Computational Linguistics: ACL 2025, pages 3616–3630, 2025. ISBN 979-8-89176-256-5. doi: 10.18653/v1/2025.findings-acl.185. URL https://aclanthology.org/2025.findings-acl.185/.DOI
  31. [31]Renqiu Xia, Hancheng Ye, Xiangchao Yan, Qi Liu, Hongbin Zhou, Zijun Chen, Botian Shi, Junchi Yan, and Bo Zhang. Chartx and chartvlm: A versatile benchmark and foundation model for complicated chart reasoning. IEEE Transactions on Image Processing, 34:7436–7447, 2025. doi: 10.1109/TIP.2025.3607618. URL https://ieeexplore.ieee.org/abstract/document/11202357.DOI
  32. [32]Lingjie Jiang, Shaohan Huang, Xun Wu, Yixia Li, Guanhua Chen, Dongdong Zhang, and Furu Wei. Viscodec: Unified multimodal code generation via merging vision and coding models. In The Fourteenth International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=hUXzPauNEM.arxiv.org/abs/2508.09945
  33. [33]Qiushi Sun, Jingyang Gong, Yang Liu, Qiaosheng Chen, Lei Li, Kai Chen, Qipeng Guo, Ben Kao, and Fei Yuan. Januscoder: Towards a foundational visual-programmatic interface for code intelligence. In The Fourteenth International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=N4BB09TXad.arxiv.org/abs/2510.23538
  34. [34]Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024. URL https://arxiv.org/abs/2408.03314.
  35. [35]Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=v8L0pN6E0i.arxiv.org/abs/2305.20050
  36. [36]J. D. Hunter. Matplotlib: A 2d graphics environment. Computing in Science & Engineering, 9 (3):90–95, 2007. doi: 10.1109/MCSE.2007.55.DOI
  37. [37]Charles R Harris, K Jarrod Millman, Stéfan J Van Der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J Smith, et al. Array programming with numpy. nature, 585(7825):357–362, 2020. URL https://www.nature.com/articles/s41586-020-2649-2.
  38. [38]Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shiron Ma, Xiao Bi, et al. Deepseek-r1 incentivizes reasoning in llms through reinforcement learning. Nature, 645(8080):633–638, 2025. URL https://www.nature.com/articles/s41586-025-09422-z.DOI
  39. [39]Paul Jaccard. Étude comparative de la distribution florale dans une portion des alpes et des jura. Bull Soc Vaudoise Sci Nat, 37:547–579, 1901. URL https://cir.nii.ac.jp/crid/1573387450552842240.
  40. [40]Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, and Zheyan Luo. LlamaFactory: Unified efficient fine-tuning of 100+ language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations), pages 400–410, 2024. doi: 10.18653/v1/2024.acl-demos.38. URL https://aclanthology.org/2024.acl-demos.38/.DOI
  41. [41]Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. Hybridflow: A flexible and efficient rlhf framework. In Proceedings of the Twentieth European Conference on Computer Systems, EuroSys ’25, page 1279–1297, 2025. ISBN 9798400711961. doi: 10.1145/3689031.3696075. URL https://doi.org/10.1145/3689031.3696075.

Paper details

vlnc:W_kxrxpedm
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents