Catastrophic Failure of LLM Unlearning via Quantization

Zhiwei Zhang, Fali Wang, Xiaomin Li, Zongyu Wu, Xianfeng Tang, Hui Liu, Qi He, Wenpeng Yin, Suhang Wang

TL;DR

Machine unlearning aims to erase sensitive or copyrighted data from LLMs without full retraining, but this paper reveals a "catastrophic failure": standard 4-bit quantization can restore up to 83% of the knowledge an LLM was supposed to have forgotten. To fix this, the authors propose SURE (Saliency-Based Unlearning with a Large Learning Rate), a method that forces significant weight changes in key model modules to ensure unlearning sticks even after compression.

What Problem Does This Paper Address?

As Large Language Models (LLMs) are trained on massive, often uncurated datasets, they inevitably ingest copyrighted material, private information, and harmful biases. "Machine unlearning" has emerged as a surgical way to remove this specific knowledge while keeping the rest of the model’s utility intact.

However, the authors identify a critical oversight: unlearning is typically evaluated only in full precision (FP32). In the real world, LLMs are almost always quantized (e.g., to 4-bit or 8-bit) to fit on consumer hardware. This paper demonstrates that current unlearning techniques are "skin deep"—they shift the model's weights just enough to hide the information in high precision, but not enough to move them into different quantization buckets. Consequently, when the model is compressed, the "forgotten" knowledge reappears.

Figure 1: Illustration of the failure of unlearning for LLMs via quantization.

Methods

The researchers first benchmarked six common unlearning combinations, including Gradient Ascent (GA) and Negative Preference Optimization (NPO), paired with utility-preserving regularizers like KL Divergence Minimization (KLR). They tested these against standard quantization methods like Round-to-Nearest (RTN), AWQ, and GPTQ.

To address the recovery issue, they introduced SURE (Saliency-Based Unlearning with a Large Learning Rate). The logic is simple but effective:

  1. Identify Salient Modules: They calculate a saliency score for each module (like attention heads or feed-forward layers) based on the gradient of the "forget" loss.
  2. Selective Updates: Instead of updating the whole model, they update only the most influential modules.
  3. Aggressive Learning Rate: By restricting the update area, they can use a much larger learning rate. This forces the weights to change enough to cross quantization boundaries, ensuring the unlearning persists after the model is compressed.

Datasets

The study utilizes two primary benchmarks:

  • MUSE: Consists of two subsets: NEWS (recent BBC articles) and BOOKS (the Harry Potter series, where the goal is to forget the books but retain general domain knowledge).
  • RWKU: A benchmark focused on forgetting information about famous individuals scraped from Wikipedia.

Key Insights and Ideas

  • The Quantization Trap: Most unlearning methods use tiny learning rates to avoid "catastrophic forgetting" of useful skills. This results in weight changes so small that 4-bit quantization maps the "unlearned" weights back to the same discrete values as the original "knows-everything" weights.
  • Precision Matters: The failure is most prominent at 4-bit precision. 8-bit quantization is more sensitive to small weight changes and thus less likely to recover forgotten data, but 4-bit is the industry standard for efficient deployment.
  • Theoretical Thresholds: The authors provide a theoretical explanation showing that for a weight change to survive quantization, it must exceed the quantization step size ($\Delta$). Figure 2 illustrates how float-32 values within a range map to the same integer bucket, effectively erasing the "unlearning" update.
Figure 2: Example of precision loss during model pa- rameter quantization from float-32 to int-4/int-8, with max |w| = 200. Float values within certain ranges are rounded to the nearest integer.

Key Results

The quantitative results are striking. On the MUSE BOOKS dataset:

  • Full Precision: An unlearned model (using GA_KLR) appears successful, retaining only 13% of the forgotten knowledge.
  • 4-bit Quantization: The same model suddenly retains 89% of that knowledge.
  • SURE Effectiveness: When the SURE framework is applied, the recovery is significantly mitigated. For example, NPO_GDR + SURE maintains near-zero verbatim memorization even after 4-bit quantization, whereas the standard version jumps to a high error rate.
Table 1: Comparison of unlearning performance between full-precision and quantized models on NEWS and BOOKS datasets. ↑implies higher is better, ↓means lower is better, and →0 indicates closer to zero is better. Results are presented without percentage symbols, consistent across all tables.

Limitations and Future Work

While SURE provides a path forward, the authors note it is highly sensitive to hyperparameter selection (like the saliency threshold and learning rate), which can make the unlearning process unstable. Furthermore, while the method protects against quantization, there is still a fundamental trade-off between how much a model forgets and how much of its general "intelligence" (utility) it retains.

Future work will likely focus on making these quantization-robust methods more stable and exploring whether even lower-bit formats (like 1-bit or 2-bit) present even greater challenges for authentic unlearning.

Summary updated

Abstract

Large language models (LLMs) have shown remarkable proficiency in generating text, benefiting from extensive training on vast textual corpora. However, LLMs may also acquire unwanted behaviors from the diverse and sensitive nature of their training data, which can include copyrighted and private content. Machine unlearning has been introduced as a viable solution to remove the influence of such problematic content without the need for costly and time-consuming retraining. This process aims to erase specific knowledge from LLMs while preserving as much model utility as possible. Despite the effectiveness of current unlearning methods, little attention has been given to whether existing unlearning methods for LLMs truly achieve forgetting or merely hide the knowledge, which current unlearning benchmarks fail to detect. This paper reveals that applying quantization to models that have undergone unlearning can restore the "forgotten" information. To thoroughly evaluate this phenomenon, we conduct comprehensive experiments using various quantization techniques across multiple precision levels. We find that for unlearning methods with utility constraints, the unlearned model retains an average of 21\% of the intended forgotten knowledge in full precision, which significantly increases to 83\% after 4-bit quantization. ... Our code is available at: \href{https://github.com/zzwjames/FailureLLMUnlearning}{https://github.com/zzwjames/FailureLLMUnlearning}.
BibTeX
@inproceedings{zhang2025catastrophic,
  author = {Zhiwei Zhang and Fali Wang and Xiaomin Li and Zongyu Wu and Xianfeng Tang and Hui Liu and Qi He and Wenpeng Yin and Suhang Wang},
  title = {{Catastrophic Failure of LLM Unlearning via Quantization}},
  booktitle = {International Conference on Learning Representations},
  year = {2025},
  url = {https://openreview.net/forum?id=lHSeDYamnz},
}
Figure