QiMeng-PRepair: Precise Code Repair via Edit-Aware Reward Optimization

1. Problem Statement

While Large Language Models (LLMs) have shown strong capabilities in program repair, they suffer from a critical flaw known as over-editing.

• The Issue: Existing models, when trained with standard Reinforcement Learning (RL) objectives that focus solely on correctness, tend to regenerate large portions of the code rather than making minimal, targeted fixes.
• Consequences:
  1. Reduced Maintainability: Over-editing destroys the original code structure, making it difficult for developers to review changes.
  2. Poor Bug Localization: The model fails to identify the specific buggy lines, instead "guessing" a correct solution by rewriting the entire function.
  3. Inefficiency: Excessive edits reduce the effectiveness of speculative decoding techniques, slowing down inference.
• The Gap: There is a lack of training data containing realistic, localized bugs within correct code, and existing metrics (like pass@k) do not penalize unnecessary modifications.

2. Methodology: The PRepair Framework

The authors propose PRepair, a framework designed to enforce "precise repair" (maximizing the reuse of correct logic while fixing only buggy parts). It consists of two main stages:

A. Self-Breaking (Data Generation)

To address the scarcity of realistic buggy data:

• Process: The model is prompted to inject subtle bugs into "golden" (correct) code.
• Strategy: A Min-Max Sampling strategy is employed. The system generates many buggy variants and selects a subset that maximizes the pairwise edit distance (diversity) while minimizing similarity. This ensures the training data covers diverse bug patterns without over-concentrating on specific types.

B. Self-Repairing (Training with EA-GRPO)

The core innovation is Edit-Aware Group Relative Policy Optimization (EA-GRPO).

• Dynamic Edit-Aware Reward: Unlike standard GRPO which rewards only correctness, EA-GRPO introduces a penalty for excessive edits only when the model achieves a certain level of group-level correctness.
  • Group Accuracy Threshold ($\alpha$): The edit penalty is triggered only if the group of generated solutions has a high average accuracy. This prevents the model from learning to produce "safe" but incorrect minimal edits.
  • Penalty Calculation: For correct samples, a penalty is applied based on the normalized Edit Distance Cost ($DEC$) relative to the mean and standard deviation of the group's edit costs.
  • Reward Function: $R = 1 - T(G) \cdot \beta \cdot P_G$, where $T(G)$ is the threshold trigger, $\beta$ is the penalty coefficient, and $P_G$ is the standardized edit penalty.
• Goal: This encourages the model to find the "minimal sufficient edit" that fixes the bug.

C. Speculative Edits

The paper leverages the reduced edit cost of PRepair to accelerate inference. By using Prompt Lookup Decoding (a form of speculative decoding), the system reuses the input buggy code as a draft. Since PRepair makes fewer changes, the acceptance rate of these draft tokens is significantly higher, leading to faster throughput.

3. Key Contributions

1. Identification of Over-Editing: The paper systematically quantifies the negative impact of over-editing in LLM-based code repair and argues that correctness alone is an insufficient objective.
2. New Metric ($fixp@k$): Introduces the first metric specifically for evaluating precise repair. It jointly considers repair correctness and the edit cost (number of modified lines), defined as the ratio of acceptable edit cost to the theoretical minimum.
3. PRepair Framework: Proposes a self-supervised pipeline (Self-Breaking + Self-Repairing) that generates high-quality training data without human annotation and trains models using EA-GRPO.
4. Theoretical & Empirical Validation: Proves that minimizing edit cost improves speculative decoding throughput and demonstrates superior performance across different languages and model sizes.

4. Experimental Results

The authors evaluated PRepair on Python (HumanEval-Fix) and Verilog (QiMeng-CodeV-R1) benchmarks using Qwen2.5-Coder models (3B and 7B).

• Precision Improvement:
  • Python: $fix1@1$ (precision at top-1) improved by 20.95% compared to the baseline.
  • Verilog: $fix1@1$ improved by 31.41%.
  • In contrast, standard GRPO training often degraded precision (e.g., Verilog $fix1@1$ dropped from 36.70% to 8.49% with standard GRPO due to over-editing).
• Correctness: PRepair maintained or slightly improved overall correctness ($pass@k$) while drastically reducing unnecessary edits.
• Cross-Domain Generalization: Models trained with EA-GRPO showed better stability and precision when transferring between languages (e.g., Python-trained models on Verilog tasks) compared to standard GRPO models.
• Inference Speed: When combined with speculative editing, PRepair increased decoding throughput by up to 15% (due to higher draft acceptance rates), whereas standard GRPO caused a throughput degradation of up to 35%.

5. Significance

• Practical Utility: PRepair addresses a real-world bottleneck: developers spend significant time reviewing AI-generated diffs. By minimizing changes, PRepair reduces the cognitive load on developers and improves code maintainability.
• Efficiency: The method demonstrates that optimizing for "minimal edits" is not just a quality metric but an efficiency booster, enabling faster inference through speculative decoding.
• Generalizability: The approach is language-agnostic (demonstrated on both high-level Python and hardware description Verilog) and model-agnostic, suggesting a new paradigm for training code repair agents that prioritize precision over brute-force regeneration.