💻 computer science

REChart: Reasoning-Efficient Chart Editing with Large Reasoning Models

This paper introduces REChart, a two-stage training framework that leverages process-level supervision and a novel efficiency reward to mitigate the "overthinking" problem in large reasoning models, thereby achieving state-of-the-art chart editing performance while significantly reducing reasoning token usage.

Original authors: Yuanbang Liu, Chenxi Ruan, Yihan Hou, Qiong Luo, Wei Zeng

Published 2026-08-19

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yuanbang Liu, Chenxi Ruan, Yihan Hou, Qiong Luo, Wei Zeng

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the world of data, a chart is more than just a picture; it is a precise instruction manual for how numbers should look. Scientists and business analysts rely on these visualizations to spot trends, but the work of creating them is often tedious. If a researcher wants to change a color, add a new data point, or switch a bar graph to a line graph, they usually have to rewrite the computer code that built the chart from scratch. Recently, a new generation of artificial intelligence has emerged that can read these images and write the code for them, acting like a digital assistant that understands both pictures and programming. These systems are designed to think through problems step-by-step, much like a human would, to ensure the final result is accurate. However, there is a growing concern that these smart systems might be thinking too much. Just as a person can over-analyze a simple decision until they forget the original goal, these machines can get lost in their own internal monologue, inventing details that aren't there or getting stuck in loops that waste time and energy.

A team of researchers from HKUST(GZ) set out to solve this specific problem of "overthinking" in the context of chart editing. They discovered that while giving an artificial intelligence more time to think often helps it solve hard problems, there is a tipping point. If the system is allowed to reason for too long, its performance actually drops. The machine begins to hallucinate, seeing features in the chart that do not exist, or it circles back on itself, repeating the same observations without making progress. To fix this, the researchers developed a new training method called REChart. Instead of simply telling the AI to produce the correct code, they taught it how to think efficiently. They created a massive library of 200,000 examples where the thinking process was carefully monitored and corrected. In this library, an AI system was guided through a cycle of planning, reasoning, scoring its own work, and refining its approach until it got it right. This process ensured that the AI learned to stop thinking once it had enough information, rather than continuing to wander into unproductive mental territory.

The researchers then took this trained system and applied a second layer of learning, similar to how a student might be rewarded not just for getting the right answer, but for getting there quickly and without wasting effort. They gave the AI a specific "budget" for how much it could think before it had to provide an answer. If the AI tried to think beyond this limit, the system would cut it off and reward it based on how much the final step of its thinking contributed to the correct solution. This encouraged the model to be concise and direct. The results were striking. When tested on standard benchmarks for chart editing, this new model outperformed all other open-source models of a similar size, even those with many more internal components. It achieved higher accuracy in generating the correct code and producing charts that looked exactly as intended. Perhaps more importantly, it became vastly more efficient. By using this new training method, the model reduced its average thinking time by nearly 80 percent compared to its untrained version, while still delivering better results.

The study suggests that for complex tasks like editing visual data, the key to success is not simply making the AI think longer, but teaching it to think smarter. The researchers found that the best performance came from a balance where the system gathered enough visual evidence to understand the chart and the user's request, but stopped before it started to invent false details. This approach allows the AI to act as a more reliable partner for scientists and analysts, capable of making precise adjustments to data visualizations without getting bogged down in unnecessary mental gymnastics. By refining how these machines process information, the researchers have shown that it is possible to build systems that are both highly accurate and remarkably efficient, turning a potentially slow and error-prone process into a streamlined tool for understanding the world through data.

Technical Summary: REChart – Reasoning-Efficient Chart Editing with Large Reasoning Models

1. Problem Definition

Chart editing is a complex multimodal task requiring a model to infer and modify visualization code based on a reference chart image and a natural language editing instruction. This task demands fine-grained visual reasoning, strict instruction following, and the synthesis of executable code. While Large Reasoning Models (LRMs) with extended Chain-of-Thought (CoT) capabilities show promise for such tasks, the authors identify a critical inefficiency: an "inverted-U" relationship between reasoning length and performance.

Preliminary studies reveal that while initial reasoning expansion improves accuracy, excessive reasoning leads to "overthinking." In this state, models drift toward hallucinated visual details, get stuck in redundant reasoning loops, or amplify initial errors, ultimately degrading the fidelity of the generated chart and the correctness of the code. Current approaches often lack supervision over intermediate reasoning steps, leading to correct code generated via inconsistent or inefficient thought processes.

2. Methodology

The authors propose REChart, a two-stage training framework designed to enhance both editing fidelity and reasoning efficiency by providing process-level supervision.

Stage 1: Supervised Fine-Tuning (SFT) with Structured Trajectories

To address the lack of high-quality reasoning data, the authors construct a dataset of 200,000 reasoning trajectories using a role-specialized, multi-agent Reason-Score-Refine workflow:

Data Construction: A corpus of 709k image-instruction-code triplets is synthesized from arXiv papers, involving chart collection, code synthesis via cascaded generators, and editing augmentation.
Multi-Agent Pipeline: The trajectory synthesis involves five agents:
- Planner (P): Decomposes the task into high-level steps.
- Reasoner (T): Generates step-wise reasoning episodes.
- Generator (G): Produces candidate Python code.
- Critic (C): Identifies weaknesses in failed candidates and generates refine instructions (self-correction).
- Finalizer (F): Composes a concluding thought before the final code.
Reason-Score-Refine Loop: An external scorer evaluates the rendered chart against the reference. If the score does not improve (stagnation), the system prunes the unproductive reasoning segments, rolls back the context, and redirects the trajectory via the Critic. This ensures that only reasoning steps contributing to measurable progress are retained in the SFT data.

Stage 2: Reinforcement Learning (RL) with Hybrid Rewards

To prevent overfitting to synthetic data and further optimize efficiency, the model is fine-tuned using Reinforcement Learning (specifically GRPO) with two complementary rewards:

Fidelity Reward ( $R_{fid}$ ): Evaluates the final output across three dimensions:
- Code Similarity: Measured via CodeBLEU.
- Structural Similarity: Compares simplified DOM trees of the generated and ground-truth SVGs.
- Visual Fidelity: Uses a multimodal embedding model to assess instruction-following quality.
Efficiency Reward ( $R_{eff}$ ): Addresses the credit-assignment problem by randomly sampling a "thinking budget" for each rollout. If the budget is reached before the model stops naturally, the reasoning is truncated. The reward credits only the final reasoning segment preceding the answer if it improves the fidelity score compared to the truncated context. This encourages the model to make the reasoning immediately preceding generation concise and useful, rather than generating long, redundant chains.

3. Key Contributions

Empirical Discovery: A systematic study revealing the inverted-U relationship between reasoning token length and chart-editing performance, demonstrating that excessive reasoning triggers hallucinations and performance degradation.
REChart Framework: A novel two-stage training framework combining SFT with a structured Reason-Score-Refine trajectory dataset and RL with a hybrid reward system that jointly guides reasoning efficiency and output fidelity.
State-of-the-Art Performance: The proposed model achieves superior results on chart editing benchmarks compared to existing open-source models of comparable and larger scales.

4. Experimental Results

The model was evaluated on the ChartEdit and ChartMIMIC benchmarks (including Customized and Direct Mimic tasks).

Performance Gains: The REChart model (based on an 8B parameter base) achieves a 13.3-point average overall performance gain across the three benchmarks (ChartEdit, ChartMIMIC Customized Mimic, and ChartMIMIC Direct Mimic) compared to the base model.
- On ChartEdit, it scores 79.71, surpassing larger open-source models like Qwen3-VL-32B-Thinking (74.6) and Qwen3-VL-32B-Instruct (71.2).
- On ChartMIMIC Customized Mimic, it scores 70.09, outperforming Qwen3-VL-32B-Thinking (69.6).
- On ChartMIMIC Direct Mimic, it scores 77.15, outperforming specialized models like ChartCoder (73.3).
Reasoning Efficiency: The method significantly reduces computational cost. Under a maximum thinking budget of 16,384 tokens, the average reasoning token usage is reduced by 79.0% compared to the base model. The efficiency reward alone contributes to a 37.0% reduction in token usage on ChartEdit compared to standard GRPO training.
Error Reduction: Training reduces visual hallucinations and edit intent drift, though it slightly increases "details missing" errors relative to SFT alone, suggesting a shift toward suppressing spurious reasoning rather than uniformly improving all error categories.

5. Significance and Claims

The paper claims that REChart effectively bridges the gap between the high reasoning capabilities of LRMs and the specific demands of chart editing. By explicitly supervising the reasoning process and penalizing inefficiency, the framework mitigates the "overthinking" phenomenon that plagues current models.

The authors assert that their approach allows an 8B open-source model to achieve state-of-the-art performance in chart editing, narrowing the gap with proprietary models (e.g., Gemini-2.5-Pro) while drastically reducing inference costs. The work highlights that for complex multimodal tasks requiring precise visual perception and code synthesis, reasoning efficiency is as critical as reasoning depth, and that uncontrolled extended CoT can be detrimental.

Limitations: The authors note that the framework was fine-tuned on an 8B model due to computational constraints, and scaling to larger LRMs may yield further gains. Additionally, the current scope is limited to chart editing, with broader visual code generation tasks (e.g., HTML/SVG illustrations) left for future work.