The Surprising Effectiveness of Deleting Weights in LLM Post-Training

Jack Lu1*, Zhenbang Yang1*, Mike Lasby2, Tejas Pote2, Yani Ioannou2, and Mengye Ren1

1New York University, 2University of Calgary
*Equal contribution

Advances in Neural Information Processing Systems 39 (NeurIPS 2026)

TL;DR: Setting fewer than 0.05% of a pretrained LLM's weights to zero, with no other change, matches full fine-tuning at scale across reinforcement learning, supervised fine-tuning, and on-policy distillation.

Abstract

How little of a pretrained large language model (LLM) has to change for it to acquire new capabilities? We find that zeroing fewer than 0.05% of its weights, with no other modification, matches full fine-tuning (FFT) at scale across three LLM post-training regimes: reinforcement learning with verifiable rewards, supervised fine-tuning, and on-policy distillation. Our method, Deletion Tuning, learns a binary mask over the gate projection of transformer blocks. Two practical advantages follow: the trained mask is hundreds to thousands of times smaller than the corresponding FFT checkpoint, and Deletion Tuning forgets far less, which addresses a central challenge in continual learning. Under reinforcement learning, its prior-task accuracy stays near the base level while FFT, LoRA, and random sparse fine-tuning lose up to 5.4 points. To understand why masking alone suffices, we analyze the geometry of the learned weight changes under reinforcement learning using stable rank, spectrum drift, and principal-weight overlap. Compared with LoRA and random sparse fine-tuning, Deletion Tuning is closest to FFT across the three measures.

Overview

Deletion Tuning learns which pretrained weights to delete and writes no new values. The pretrained weights $W$ stay frozen, and each is paired with a trainable logit in $G$, the only parameters that post-training updates. During training, each weight is multiplied by $\sigma(\alpha G)$, a smooth mask between 0 and 1. The sharpness $\alpha$ rises over training until the sigmoid becomes a hard threshold at $G = 0$. At deployment, weights with positive logits (blue) keep their pretrained values and weights with negative logits (red) are set to zero (crossed out), so the trained adapter is one bit per weight.

Full fine-tuning (FFT), LoRA, and sparse fine-tuning all write new values into a pretrained model. We introduce Deletion Tuning to test whether deleting pretrained weights alone can match FFT.

  • Deletion alone matches full fine-tuning. Deletion Tuning is on par with FFT at the largest scale we test in GRPO, SFT, and on-policy distillation (SDFT), up to a 30B mixture-of-experts model. Under GRPO, it also solves problems that the base model fails in all 128 sampled attempts.
  • Deletion Tuning is compact and forgets less. Its masks are orders of magnitude smaller than FFT checkpoints in all three regimes, and it keeps prior-task accuracy throughout training.
  • Deletion Tuning's learned updates have FFT-like geometry. Its weight updates resemble FFT's on three geometric measures, which helps explain its accuracy.

Deletion Tuning

Deletion Tuning freezes the pretrained model and gives every weight of each gate projection its own trainable logit. During training, the weight matrix $W$ is multiplied elementwise by the soft mask $\sigma(\alpha G)$, an annealed sigmoid of the logits $G$ that lets gradients reach them:

$$ \widetilde{W} = W \odot \sigma(\alpha G). $$

The sharpness $\alpha$ rises linearly over training, so the soft mask approaches the hard mask that Deletion Tuning deploys, a binary mask that keeps each pretrained weight with a positive logit and deletes the rest:

$$ \widehat{W} = W \odot \mathbf{1}[G > 0]. $$

We initialize the logits from Wanda pruning scores and set no sparsity target, so training decides how many weights to delete. Bit-packed and compressed with zstd, the hard mask takes only 1.0 MB for Llama1B and 8.4 MB for Llama8B, whose fully fine-tuned checkpoint takes 30,633 MB. This makes adapters cheap to store and to switch: changing tasks loads only a small bitmask, applied to one shared copy of the base weights, rather than a separate full model checkpoint.

Matching Full Fine-Tuning with Reinforcement Learning

We train Deletion Tuning with GRPO in two settings. The first trains Llama3 Instruct models from 1B to 8B on GSM8K. The second trains Qwen2.5 base models from 0.5B to 14B and the Qwen3-30B-A3B mixture-of-experts model on the SimpleRL-Zoo math corpus and evaluates them on six held-out math benchmarks. We name each model by its family and size, such as Llama8B and Qwen7B. Besides FFT, we compare against LoRA at ranks 1 and 4 and against random sparse fine-tuning (MTH, from The Multiple Ticket Hypothesis) at 99% and 99.95% sparsity, across six backbones from 0.5B to 8B. Every Deletion Tuning run deletes fewer than 0.05% of the model's weights.

Deletion Tuning has the smallest adapter at every scale and matches FFT at the largest backbone of each family. Best-checkpoint validation accuracy (%) and adapter size (MB) under GRPO, on GSM8K for Llama and on the six-benchmark SimpleRL-Zoo mean for Qwen.
Llama, GSM8KQwen, SimpleRL-Zoo
1B3B8B0.5B3B7B
MethodAcc.SizeAcc.SizeAcc.SizeAcc.SizeAcc.SizeAcc.Size
Base1.21053.53060.27010.44037.73040.180
FFT60.50471482.491225683.243063319.01188544.351177251.8929051
LoRA r=159.292.782.395.883.3810.020.302.143.557.152.139.6
LoRA r=460.5810.882.4423.282.8740.020.308.443.5928.651.7038.5
MTH 99%60.7368.280.53177.483.31443.621.8427.344.16170.452.03420.7
MTH 99.95%58.614.182.1710.783.0726.620.161.743.8713.751.2425.3
Deletion Tuning54.441.081.493.183.558.417.640.541.982.752.326.9

Tuning FFT's learning rate and KL coefficient does not change the parity at 7B and 8B. At smaller sizes, Deletion Tuning recovers 90% to 99% of FFT's accuracy, and the gap closes as models grow. For the mixture-of-experts model, we mask the gate projection inside each of its 128 experts and leave the router unchanged.

Deletion Tuning matches FFT on dense and mixture-of-experts models from 7B to 30B with an adapter thousands of times smaller. Best-checkpoint validation accuracy (%) and adapter size (MB) under GRPO.
Llama8BQwen7BQwen14BQwen3-30B-A3B
GSM8KSimpleRL-ZooSimpleRL-ZooSimpleRL-Zoo
MethodAcc.SizeAcc.SizeAcc.SizeAcc.Size
Base60.27040.18044.37049.410
FFT83.243063351.892905154.875634358.43116471
Deletion Tuning83.558.452.326.955.4311.458.5429.6

Acquiring New Capabilities

On pass@k, Deletion Tuning leads the base model at every $k$. Even at $k = 128$, the base model stays 4.3 and 6.1 points below Deletion Tuning on Llama8B and Qwen7B.

Deletion Tuning acquires new capabilities. Pass@k (%), the share of problems solved within $k$ attempts, estimated from 128 samples per problem at temperature 1.0. A lead at large $k$ means solving problems the base model misses even with many attempts.
Llama8B, GSM8KQwen7B, SimpleRL-Zoo
Methodk=12832128k=12832128
Base53.2066.7583.6492.4095.2927.3538.7556.1866.2674.01
Deletion Tuning81.7588.5195.7598.4499.6249.3953.2264.6473.2380.08

Learning the Mask Drives the Gains

Wanda one-shot pruning supplies Deletion Tuning's starting scores. Applied without training, it changes accuracy by at most 2.4 points on all six backbones, while Deletion Tuning gains up to 53.2 points.

Wanda alone stays near the base model. Validation accuracy (%) of the base model, of Wanda one-shot pruning at the best of eight sparsity levels, and of the best checkpoint of the Deletion Tuning mask trained with GRPO.
Llama, GSM8KQwen, SimpleRL-Zoo
Method1B3B8B0.5B3B7B
Base1.2153.5360.2710.4437.7340.18
Wanda (best $\eta$)1.5952.4660.6511.4238.7042.49
Deletion Tuning54.4481.4983.5517.6441.9852.32

Matching Full Fine-Tuning beyond Reinforcement Learning

Deletion Tuning even matches FFT under SFT on MMLU-Pro and BBEH, and under the on-policy distillation method Self-Distillation Fine-Tuning (SDFT) on tool use (ToolAlpaca) and science questions (Science). SFT imitates fixed targets token by token and produces dense updates, while reinforcement-learning updates are sparse. In SDFT, the student samples its own responses and a teacher supplies a target at every token.

Under SFT, Deletion Tuning matches FFT at 3B. Best-checkpoint evaluation accuracy (%), averaged over the 14 MMLU-Pro subjects and the 23 BBEH subtasks, and adapter size (MB) for Llama1B and Llama3B.
MMLU-ProBBEH
1B3B1B3B
MethodAcc.SizeAcc.SizeAcc.SizeAcc.Size
Base10.37012.6302.1708.870
FFT16.97471421.19122568.35471411.3912256
Deletion Tuning18.621.022.283.15.651.011.393.1
Under SDFT, Deletion Tuning matches FFT on Qwen7B. Best-checkpoint exact-match accuracy (%) and adapter size (MB) on ToolAlpaca tool use and Science.
ToolAlpacaScience
MethodAcc.SizeAcc.Size
Base41.24032.350
FFT68.042905171.2029051
Deletion Tuning69.0727.170.6147.1

Deletion Tuning Forgets Less

During GRPO on GSM8K, Deletion Tuning's mean accuracy on six prior tasks (HellaSwag, MMLU, TruthfulQA, WinoGrande, IFEval, and HumanEval) stays within one point of the base model. FFT ends 1.3 to 3.1 points below the base, and LoRA and MTH fall up to 5.4 points. Following RL's Razor, we also track the forward KL to the base policy: Deletion Tuning's stays at or below 0.05, while FFT's reaches 1.0 on Llama1B and 1.5 on Llama8B. MTH at 99.95% sparsity trains 0.05% of all parameters, comparable to the 0.035% to 0.046% that Deletion Tuning deletes at these scales, which suggests that deletion itself keeps forgetting low. Learning new tasks while keeping old ones makes Deletion Tuning a promising candidate for continual learning.

Forward KL and change in prior-task accuracy over GRPO training on Llama1B, Llama3B, and Llama8B: Deletion Tuning stays near zero on both while FFT, LoRA, and MTH drift.
Deletion Tuning keeps prior-task accuracy at every Llama scale while the baselines drift. (a) Forward KL between the trained and base policies on GSM8K during GRPO training, the forgetting predictor of RL's Razor. (b) Change in mean accuracy on a six-task prior-task suite from the base model (dashed line).

Why Deletion Tuning Works

We compare each method's weight updates on three measures of update geometry: stable rank (how many directions an update uses), spectrum drift (how far the singular values move), and principal-weight overlap (how many changed weights fall on the base model's principal weights). The last two come from The Path Not Taken, which studies the updates of reinforcement learning with verifiable rewards. Like FFT, Deletion Tuning barely moves the spectrum (its drift stays within 1.4× of FFT's) and changes fewer principal weights than chance (an overlap of 0.43 to 0.46, against FFT's 0.41 to 0.46), while LoRA stays near the random baseline of 0.5 and MTH sits at it.

Stable rank, spectrum drift, and principal-weight overlap of each method's update for Llama8B and Qwen7B: Deletion Tuning is the method closest to FFT on all three.
Deletion Tuning (blue) tracks FFT (red) most closely across three update-geometry metrics. Values at the saved GRPO checkpoint for Llama8B (filled) and Qwen7B (open): (a) stable rank of $\Delta W$, (b) spectrum drift, and (c) principal-weight overlap.

LoRA caps the rank of its update, and MTH trains weights chosen at random before training. Deletion Tuning has neither restriction, which helps explain how its updates come close to FFT's without writing new values.

Deletion Tuning Is Robust to Hyperparameter Changes

Deletion Tuning works across a range of values for its hyperparameters: the initial sparsity (how many weights the Wanda initialization deletes), the learning rate, and the regularization strength (how strongly the mask is pushed to keep large weights). Across all 12 combinations we sweep, every setting lands within 1.6 points of the best run on Llama8B GSM8K and within 3.2 points on Qwen7B SimpleRL-Zoo, and varying the initial sparsity fourfold changes accuracy by at most 0.8 and 1.7 points.

BibTeX

@inproceedings{lu2026deleting,
  title     = {The Surprising Effectiveness of Deleting Weights in {LLM} Post-Training},
  author    = {Lu, Jack and Yang, Zhenbang and Lasby, Mike and Pote, Tejas and Ioannou, Yani and Ren, Mengye},
  booktitle = {Advances in Neural Information Processing Systems (NeurIPS)},
  year      = {2026}
}