Technical Summary: Smaller Models, Unexpected Costs: Trade-offs in LLM Quantization for Automated Program Repair

Problem Statement

Large Language Models (LLMs) have become powerful tools for complex software engineering tasks, including Automated Program Repair (APR). However, the increasing number of parameters in these models imposes substantial memory requirements and operational costs, hindering local deployment and integration into existing pipelines. While quantization is a popular technique to reduce memory footprints by lowering weight precision (e.g., from 32-bit floating point to 8-bit integers), its impact on APR is not fully understood. Existing studies on quantization for code-related tasks are often limited to single benchmarks, single quantization methods, or focus on only one efficiency metric (e.g., memory or energy). Furthermore, standard benchmark scores often mask changes in model behavior and non-functional overheads, such as inference time and energy consumption. There is a lack of comprehensive empirical evidence regarding the trade-offs between effectiveness (repair capability and behavioral consistency) and efficiency (memory, time, energy) when applying quantization to APR.

Methodology

The authors conducted an extensive empirical study evaluating 13 quantization configurations across six representative LLMs (ranging from 6.7B to 70B parameters) from three model families: Llama, DeepSeek-Coder, and Mistral. The study utilized two APR benchmarks: HumanEval-Java (164 coding problems) and Defects4J (525 single-function bugs).

Quantization Configurations:
The study focused on Post-Training Quantization (PTQ) methods, categorized by their target components:

1. Model Weight Quantization: Five methods were evaluated:
   • AQLM: Additive Quantization of Language Models (data-aware, 2-bit).
   • AWQ: Activation-aware Weight Quantization (data-aware, 4-bit).
   • BNB: BitsAndBytes (calibration-free, 4-bit).
   • HQQ: Half-Quadratic Quantization (calibration-free, 2/3/4/8-bit).
   • Quanto: Hugging Face integrated method (calibration-free, 2/4/8-bit).
2. KV Cache Quantization: HQQ and Quanto were applied exclusively to the Key-Value cache (2/4/8-bit), keeping model weights in full precision.

Evaluation Metrics:

• Effectiveness:
  • Plausibility: Measured via pass@10 (whether any of 10 generated patches pass all tests).
  • Consistency: Introduced a new metric, Jaccard Consistency Rate (JCR), to distinguish between a simple reduction in the number of solved problems versus a shift in which problems are solved (behavioral drift).
• Efficiency:
  • Inference time (seconds).
  • GPU energy consumption (Joules).
  • Memory footprint (In-memory model size and peak inference memory).

Experimental Setup:
Experiments were conducted on an HPC cluster with Nvidia GH200 Hopper GPUs. The study used default "out-of-the-box" settings to reflect typical practitioner usage. Statistical rigor was ensured using bootstrapped confidence intervals (10,000 iterations) for relative changes, and trade-offs were analyzed using Pareto dominance.

Key Contributions

1. Comprehensive Empirical Study: An evaluation of 13 quantization configurations across six LLMs and two APR benchmarks, covering weight-only and KV-cache settings from 2 to 8 bits.
2. New Consistency Metric: The proposal of the Jaccard Consistency Rate (JCR) to reveal that similar plausibility counts can mask substantial shifts in the specific set of bugs a model can repair.
3. Efficiency Quantification: Detailed reporting of non-functional effects (inference time, energy, memory) using bootstrapped confidence intervals, revealing that quantization often increases time and energy despite reducing memory.
4. Trade-off Analysis: A Pareto dominance analysis showing that nearly half of the evaluated configurations are strictly dominated by alternatives, highlighting the sensitivity of trade-offs to model architecture and task complexity.
5. Replication Package: Public release of all scripts, generated patches, and efficiency metrics.

Key Results

Effectiveness (RQ1)

• Plausibility: Contrary to expectations, quantization does not necessarily degrade performance. In 11 out of 12 model cases, at least one quantized configuration generated more plausible patches than the base model. For instance, hqq4(KV) improved Llama-70B's performance on HumanEval, and quanto4(M) improved DeepSeek-6.7B by 19%.
• Consistency (JCR): While aggregate counts might remain similar, the set of repaired bugs often shifts significantly. Low JCR values indicate that quantized models repair a different set of problems than the base model, not just a subset. High-bit configurations (e.g., 8-bit) generally showed better consistency than extreme quantization (2-3 bits), though even 8-bit quantization could introduce non-trivial drift.

Efficiency (RQ2)

• Inference Time & Energy: All quantization configurations increased inference time and energy consumption compared to the base model. This is attributed to suboptimal hardware utilization (GPUs are optimized for FP32/FP16, not low-bit integers) and dequantization overhead.
  • hqq3 consistently showed the worst performance, increasing inference time by up to +885.99% and energy by up to +1524.46%.
  • quanto4(M) was the most efficient configuration in 50% of scenarios, with the smallest increases in time and energy.
• Memory Footprint: Quantization successfully reduced memory footprints by up to 85%.
  • Model weight quantization (e.g., aqlm2) was highly effective, reducing in-memory size significantly.
  • KV-cache quantization offered minimal memory savings (often <5%) because the KV cache size depends on prompt length, which was not always large enough to dominate memory usage in this setup.

Trade-offs (RQ3)

• Pareto Dominance: 48% of the evaluated quantization configurations were strictly dominated by alternative settings (either the base model or another quantization method) in terms of the combined effectiveness and efficiency metrics.
• Configuration Sensitivity: No single "best" configuration exists.
  • awq4 and bnb4 generally offered balanced trade-offs across models.
  • quanto4 and quanto8 performed well on specific models (e.g., DeepSeek) but were less consistent across the board.
  • hqq3 and hqq4 (model weights) were frequently dominated due to high time/energy costs.

Significance and Claims

The paper claims that while quantization is effective for reducing memory footprints, it does not automatically translate to improved efficiency in terms of speed or energy; in fact, it often degrades these metrics for APR tasks. The study emphasizes that trade-offs are highly sensitive to the underlying model architecture and the specific task.

The authors argue that practitioners should not assume a universal "optimal" quantization method. Instead, they must carefully select configurations based on their specific constraints (e.g., memory vs. time). The introduction of JCR highlights that relying solely on aggregate repair rates is insufficient; the behavioral shift (which bugs are fixed) is a critical factor in deployment. The findings suggest that for strict time or energy constraints, quantized models may currently be detrimental for APR, whereas for memory-constrained environments, careful selection of configurations (like awq4 or quanto4) can yield significant memory savings with manageable or even improved repair effectiveness.

The paper concludes that future work should focus on routing policies to dispatch tasks to the most suitable model (quantized or full-precision) and further investigation into the specific shifts induced by quantization on problem-solving capabilities.