Natively Unlearnable Large Language Models

Gaurav R. Ghosal, Pratyush Maini, Aditi RaghunathanarXiv 2026 · arXiv

TL;DR

Standard language model training hopelessly entangles data sources, making it incredibly difficult to cleanly "unlearn" copyrighted or private data without expensive retraining. This paper introduces NULLs (Natively Unlearnable LLMs), an architecture that trains a shared neuron backbone alongside a pool of sparsely activated, source-specific "sink" neurons. By simply turning off a source's corresponding sinks at deployment, NULLs achieves instant, robust unlearning that matches the gold standard of retraining from scratch without sacrificing general performance.

What Problem Does This Paper Address?

As large language models (LLMs) scale, they inevitably ingest copyrighted material, private personal information, and regulated content. When legal or privacy mandates require removing this data, developers face a major challenge: standard gradient descent entangles all data sources into a single shared set of weights.

Existing solutions fall into two flawed camps. Post-hoc unlearning attempts to fine-tune a trained model to forget specific data, but this often causes collateral damage to unrelated knowledge and is easily reversed by adversarial attacks. Conversely, source isolation methods train separate modules or experts for each data source; while this makes deletion easy, it prevents the model from learning jointly across diverse data and scales poorly when dealing with millions of individual documents. NULLs bridges this gap, enabling both joint learning and clean, native data removal.

Methods

NULLs builds unlearnability directly into the model's architecture during pre-training by modifying the multi-layer perceptron (MLP) blocks of a standard Transformer. The hidden neurons in each MLP layer are partitioned into two groups:

  1. Shared Backbone: A set of neurons ($N_{gen}$) that remain active across all training data to capture general language capabilities and shared knowledge.
  2. Sink Pool: A larger pool of neurons ($N_{pool}$) where each data source is assigned a deterministic, sparse activation mask generated from its unique source ID.

During training, a document activates the shared backbone plus its source-specific sink neurons via a simple elementwise multiplication on the MLP activations.

NULLs Architecture Overview

The authors leverage a fascinating training dynamic: because the backbone is active for every document, it experiences constant gradient interference from conflicting data sources. Unique, source-specific facts face far less interference in the sparsely activated sinks, causing the model to naturally store unique facts in the sinks and shared facts in the backbone. Unlearning then becomes trivial: at inference time, you simply disable the target source's mask ("Sink-Off" mode), routing the activation to the next-closest source or zeroing it out entirely.

NULLs MLP Code Modification

Datasets

The authors evaluated NULLs across two primary scales of source granularity:

  • Wikipedia Corpus: ~6 million unique articles treated as independent, fine-grained sources to test surgical article-level unlearning.
  • C4 Corpus + Harry Potter: The C4 corpus was clustered into 5,000 topically coherent sources, with the 7 Harry Potter books added as an additional coarse-grained cluster to evaluate topic-level unlearning.
  • Downstream Benchmarks: To ensure general capabilities were preserved, the models were tested on standard language benchmarks: ARC-E, Winogrande, PIQA, and SciQ.

Key Insights and Ideas

  • Zero-Supervision Disentanglement: The separation of unique vs. shared facts happens completely automatically. The model doesn't need to be told what information is unique to a document; the training dynamics naturally push high-interference shared data to the backbone and low-interference unique data to the sinks.
  • Combinatorial Scaling: Because sources are mapped to sparse masks over a shared pool rather than dedicated physical parameters, NULLs can scale to millions of sources (like Wikipedia articles) without a linear explosion in parameter count.
  • Inherent Adversarial Robustness: Post-hoc unlearning methods typically leave latent traces of the forgotten data in the weights. Because NULLs physically isolates the source-specific knowledge into distinct activation pathways, removing the mask completely cuts off access, making it highly resilient to adversarial extraction.

Key Results

  • Matches Gold-Standard Retraining: On Wikipedia article unlearning, disabling an article's sink ("Sink-Off") caused the recall of unique facts to collapse to zero, perfectly mirroring a model retrained from scratch without that article. Meanwhile, shared facts remained completely unharmed, avoiding the topic-level erasure that plagues post-hoc methods like Negative Preference Optimization (NPO).
Wikipedia Unlearning Performance
  • Resists Relearning Attacks: In the Harry Potter case study, an adversary attempting to recover the unlearned text via fine-tuning succeeded in just 10 steps against an NPO-unlearned model. In contrast, NULLs exhibited the exact same slow relearning curve as a model that had never seen the books before.
  • No General Performance Penalty: NULLs achieved an average downstream benchmark accuracy of 56.0%, matching a standard parameter-matched Transformer (55.5%) within one standard deviation, proving that native unlearnability doesn't degrade general intelligence.

Limitations and Future Work

  • Scale Constraints: The experiments were conducted on 1B-parameter models; validating NULLs on much larger LLMs (7B+ parameters) remains to be demonstrated.
  • Pre-defined Granularity: Unlearning requests must align with the source boundaries defined during pre-training. If a user requests the removal of a specific concept or cross-cutting subset of data that wasn't pre-defined as a source, NULLs cannot natively handle it.
  • Post-Training Integration: The paper focuses on pre-training from scratch. Figuring out how to maintain these unlearning properties during subsequent instruction fine-tuning or RLHF without leaking data back into the backbone is an open challenge.

Summary updated

Abstract

Unlearning aims to remove the influence of specific training data sources, but this has proved challenging because the contributions of different sources are entangled within the model. Isolating source contributions to disjoint parameters makes removal easier, though it obstructs joint learning across sources. We propose NULLs (Natively Unlearnable LLMs), a model class that satisfies the two opposing goals of isolating source-specific contributions and learning jointly across sources, by training a set of shared backbone neurons alongside a pool of sparsely activated sinks. During training, information specific to a source naturally concentrates in its sinks while information shared across sources accumulates in the backbone. A source is then unlearned at deployment by disabling its corresponding sinks, with no gradient updates and no access to the retained data. We show that NULLs scales to Wikipedia's ~6M articles, isolating each as an independent source. Unlearning a single article removes knowledge specific to it while preserving facts shared with semantically related articles, closely matching retraining from scratch. We note that unlearning with NULLs is also robust: in a case study of unlearning the Harry Potter books, NULLs resists both adversarial extraction and relearning that reverses post-hoc unlearning. Finally, NULLs preserves general language capabilities, matching a standard transformer on downstream benchmarks. Together, these results suggest that source-level unlearning need not be an afterthought. It can be built natively into LLM training while retaining the benefits of shared representation learning.
BibTeX
@misc{ghosal2026natively,
  author = {Gaurav R. Ghosal and Pratyush Maini and Aditi Raghunathan},
  title = {{Natively Unlearnable Large Language Models}},
  year = {2026},
  eprint = {2606.13873},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2606.13873},
}
Figure