← Deep dives

Deep dives · 2026-11-17 · Advanced · By bombong

Sparse fine-tuning: changing a model by editing only a tiny fraction of its weights

Sparse fine-tuning selects and edits only a tiny fraction of a pretrained model's weights. It aims to come close to full fine-tuning performance while reducing forgetting and storage costs. The key is the criterion for deciding where to edit, and recent research has gone as far as showing that the places to edit differ by training method (SFT vs. RL).

Contents
Key points
  • Unlike LoRA, sparse fine-tuning does not attach new matrices. It selects a subset of existing weights and edits their values directly. It leaves the shape of the change free and limits only the number of weights edited.
  • Performance depends heavily on which weights are selected. A simple criterion based only on weight magnitude was weak for LLMs, and criteria such as low-rank approximation, relative magnitude and activation-weighted scores made up for that weakness.
  • Deletion Tuning reported that merely zeroing out less than 0.05% of the weights matched full fine-tuning across several post-training settings, with far less forgetting.
  • One analysis finds that RLVR learns by avoiding principal directions, while SFT targets principal weights. So a selection criterion that works well for SFT is not guaranteed to work for RL.
  • "Editing few weights" and "using little GPU memory" are different things. Optimizer memory and actual training speed need to be measured separately.

Why it was needed: neither editing everything nor adding on was satisfying

The most direct way to adapt a large language model (LLM) to your own work is full fine-tuning (FFT). Because it retrains every parameter, it has the most expressive power. But as the Super-Tuning study paper summarizes, it takes a lot of memory and compute, and a full-size checkpoint has to be stored separately for each task. LIFT paper adds that when data is scarce, full fine-tuning is prone to overfitting and catastrophic forgetting (losing original abilities while learning a new task).

This is why PEFT (Parameter-Efficient Fine-Tuning) emerged. Its best-known example, LoRA, freezes the original weights and attaches two small low-rank matrices alongside them, changing the weights only by their product. It is cheap and simple, but the change is confined to a fixed "low-rank" shape. Depending on the goal, this constraint can be a cost. SAFT paper, for example, points out that using LoRA for adversarial training gives noticeably lower robustness than training all parameters.

Sparse fine-tuning takes a different path. Instead of attaching new matrices, it selects a tiny fraction of the existing weights and edits their values directly. In effect, it leaves the shape of the change free but limits the count. According to LIFT paper, this approach once produced notable results but fell behind in the LLM era because it was hard to find the parameters that really matter for reasoning. Recent studies have revived sparse fine-tuning by tackling exactly this question of where to edit.

One note on terminology. Some papers, such as DeFT-X paper, abbreviate sparse fine-tuning as SFT. In the industry, however, SFT usually means supervised fine-tuning. In this article, SFT refers only to supervised fine-tuning, and sparse fine-tuning is always written out in full.

Core idea: don't add on, just tighten the few strings that are out of tune

As an analogy, it is like tuning an old piano. Full fine-tuning restrings the whole piano. LoRA attaches a small auxiliary keyboard next to the piano and blends in its sound. Sparse fine-tuning finds the few out-of-tune strings among thousands and tightens only those. Since only a few strings are touched, the rest of the sound stays as it was, and it is easy to record what was changed.

The key in this analogy is the ear that can tell which strings are out of tune. The design of sparse fine-tuning ultimately comes down to three questions. First, which weights to edit (the selection criterion). Second, how many to edit in each layer (budget allocation). Third, how to change the selected positions: their values can be learned anew, zeroed out, or represented as a sparse matrix that is added on. Most of the studies covered below offer a new answer to one of these three.

The trade-off is also clear. LoRA changes things "a little everywhere, but in a fixed shape," while sparse fine-tuning changes "only a few fixed places, but with no shape constraint." So if the places to edit are chosen well, the sparse approach loses less of the original ability and has less to store. If they are chosen poorly, performance drops sharply. This is also why LIFT paper reported that sparse fine-tuning based only on weight magnitude remains a weak baseline for LLMs.

Three fine-tuning approaches

Full fine-tuningUpdates all weights

  • Most expressive
  • Stores a full-size model per task
  • Risk of overfitting and forgetting with little data

LoRAAdds low-rank matrices

  • Cheap and simple
  • Changes constrained to a low-rank shape
  • Performance gap for some goals (e.g., adversarial training)

Sparse fine-tuningUpdates only some existing weights

  • Limits count only, no shape constraint
  • Less forgetting, small storage
  • Performance depends on choosing where to update

공통 All are ways to adapt a pretrained model to a new task

Cost and risk depend on what is changed, how much, and in what shape.

How it works: scoring, masking, training, storing

Most methods go through four steps. 1) Scoring. Each weight in the pretrained model gets a score for how worthwhile it is to edit. The simplest score is the weight's magnitude. Other approaches multiply it by the magnitude of the input signal (activation) flowing into that weight, look at the gradient (how much the value should change to reduce the loss), or approximate the matrix as low-rank and then look at magnitudes. Using activations or gradients requires passing a small amount of calibration data through the model once.

2) Choosing the mask. A mask is built with 1 for weights that score high (or meet the criterion) and 0 for the rest. How the total budget is split across layers is also decided at this step. 3) Training only the masked positions. During training, only positions where the mask is 1 change; the rest stay frozen. There is a common pitfall here. SNELLA paper points out that masking the gradients still loads the full weight matrices into the optimizer (the part that computes weight updates), so it uses a lot of memory. Editing few weights does not mean using little GPU memory.

4) Storing and combining only the difference. After training, only the changed positions and their new values, that is, a sparse "difference vector," need to be stored. The composable approach that DeFT-X paper builds on uses this property. It trains a difference for task knowledge and a difference for language knowledge separately, then adds both to the pretrained model. This lets a task learned only from source-language task data be performed in a low-resource language that has no labeled data (zero-shot cross-lingual transfer).

Four stages of sparse fine-tuningPretrained model → Importance scores; Calibration data → Importance scores; Importance scores → Set the mask; Set the mask → Train only masked positions; Train only masked positions → Sparse difference vector; Sparse difference vector → Base model + difference(Add)Pretrained modelCalibration dataSmall, single passImportance scoresMagnitude · activation· gradientSet the maskTop fraction +per-layer budgetTrain only maskedpositionsFreeze the restSparse differencevectorOnly changed positionsand valuesBase model +differenceCombine task andlanguage differencesAdd
Four stages of sparse fine-tuning The top row is the flow of choosing where to update and training; the bottom row is the flow of storing only the difference from training and combining it.

How it developed: the changing criteria for where to edit

DeFT-X paper and LIFT paper both addressed the noise sensitivity of the magnitude criterion from a low-rank perspective. Earlier composable sparse fine-tuning set its masks with simple magnitude-based pruning (a technique that cuts away low-importance weights). DeFT-X removes noise from the weight matrices with singular value decomposition (SVD, a method that splits a matrix into directions ordered by importance) before pruning, and matched or beat existing methods on sentiment classification (NusaX) and natural language inference (AmericasNLI) in extremely low-resource languages. LIFT showed that in training LLMs for reasoning, the magnitude criterion becomes effective again if the matrix is first approximated as low-rank and the large-magnitude "Principal Weights" are selected. By continually updating only the top 5%, it consistently outperformed full fine-tuning on reasoning tasks. Its memory use was on par with typical PEFT methods, and it preserved up to 20% more of the original domain knowledge than full fine-tuning and LoRA.

GEM paper proposed looking at changes in relative terms. Existing PEFT methods increase the absolute size of updates regardless of the original magnitude. But changing a large weight slightly barely alters model behavior. GEM uses the gradient-to-weight ratio to select positions that will change a lot relative to their original values, and allocates the number of weights to edit in each layer based on the entropy of that layer's weight value distribution. It reported up to 1.6% higher accuracy than full fine-tuning while updating only 0.1% of parameters (GLUE, SuperGLUE, GSM8k, MBPP).

Super-Tuning paper reused scores originally designed for pruning to decide where to edit. It introduced Super, which fixes the positions to edit with a Wanda-style activation-weighted magnitude score, and also proposed Supra, a hybrid that splits the same parameter budget between sparse updates and LoRA. In Math17K arithmetic experiments with Llama-3.2-1B and Meta-Llama-3-8B, the best Super/Supra settings had the highest average accuracy among the adapters compared. However, the experiments used a single seed, and the authors also reported that selecting low-scoring positions can be effective as well.

Some studies have tailored the selection criterion to new goals. SAFT paper starts from the observation that adversarial-training gradients concentrate on a small number of "robustness-critical parameters (RCPs)" and updates only those. Changing only about 5% of parameters, it achieved higher clean accuracy and robust accuracy than LoRA-based methods, and its robustness approached or exceeded that of full-parameter adversarial training. TopKLoRA paper made the inside of LoRA sparse to aim for interpretability. By letting only the k largest latent units activate per token, it found and removed the circuits implementing sleeper backdoors planted through poisoned data. The circuits it found were up to an order of magnitude smaller than with standard LoRA, and the malicious behavior could be removed while leaving instruction-following performance intact. In image generation, sparse-coding-based fine-tuning paper represented features as sparse combinations of "feature dictionary atoms." Dropping unimportant atoms improved text alignment in image editing.

Where it is heading now: zeroing out alone can work, and RL edits different places

Deletion Tuning paper pushes sparse fine-tuning to the extreme. It learns no values. It learns only a binary mask that picks which weights in the transformer block's gate projection (the part of the feed-forward layer that decides how much signal passes through) to set to zero. Zeroing out less than 0.05% of all weights was enough to match full fine-tuning across three kinds of post-training: RLVR, SFT and On-policy Distillation. This held as the model was scaled up. The learned masks are hundreds to thousands of times smaller than full fine-tuning checkpoints for the same task, and they cause far less forgetting. In reinforcement learning, accuracy on prior tasks stayed at the base model's level. By contrast, full fine-tuning, LoRA and random sparse fine-tuning lost up to 5.4 points.

'The Path Not Taken' paper digs into why RLVR appears to change only some parameters. The study argues that sparsity is only a surface phenomenon. For the same pretrained model, updates always concentrate in similar regions, even with different datasets or RL recipes. The study explains the cause through three gates. The KL constraint limits the size of updates, the model's geometry steers updates into a low-curvature subspace away from the principal directions, and numerical precision hides very small updates, making them look sparse. In short, RLVR learns off the principal directions and barely disturbs the spectrum. SFT, by contrast, targets principal weights and distorts the spectrum. The study questions carrying PEFT methods built in the SFT era straight over to RL. Deletion Tuning paper uses the same 'weight geometry' lens. By analyzing the learned changes through stable rank, spectral shift and overlap with principal weights, it showed that they are closer to full fine-tuning than LoRA or random sparse methods are.

On the vision side, work tackles the memory problem head-on. SNELLA paper sees two problems with the two-stage approach of 'first choose the positions, then train.' It cannot reflect weight changes that happen during training, and it uses a lot of memory. So it merges the two stages into one. It adds to the original weights a sparse matrix built by merging two low-rank trainable matrices, and uses a nonlinear kernel to raise the rank of the merged matrix. It also has weights compete through importance scores, across and within layers, to divide up the budget. Like Supra paper and TopKLoRA paper, this is part of a trend in which the line between sparse fine-tuning and LoRA is blurring.

Share of weights updated, by study

Under 0.05%Share zeroed out by Deletion Tuning
0.1%Share updated by GEM
Top 5%Principal weights updated by LIFT
About 5%Share updated by SAFT
Ratios as reported by each study. Models, tasks and methods differ, so they cannot be compared directly.

Limitations and open questions: when to use it and when to avoid it

First, the right selection criterion differs by training method. LIFT paper says to update principal weights in SFT-style reasoning training, but 'The Path Not Taken' paper finds that RLVR learns off the principal components. A mask criterion that worked well for SFT needs separate validation before being used for RL. The result in Super-Tuning paper that choosing low-scoring positions also worked is a sign that our understanding of 'why these positions matter' is not yet complete.

Second, efficiency should not be judged only by the number of weights changed. In implementations that apply the mask to gradients, the optimizer holds the full matrix, so the memory gain can be small (SNELLA paper). Also, operations that update scattered positions generally do not use the GPU as efficiently as dense matrix multiplication. It is safer to measure actual training speed and VRAM use yourself. The storage benefit, on the other hand, is clear. Each task needs only a small difference vector or mask, which helps when managing many tasks or many customer-specific variants (Deletion Tuning paper).

Third, check how far the evidence applies. Many results come from specific model sizes, a single seed or specific benchmarks. A report that a method 'beats full fine-tuning' is a result within that setting, not a guarantee that it will reproduce on your data. As baselines, it is good to include a random sparse mask alongside LoRA. As Deletion Tuning paper shows, the gap over random sparse fine-tuning is the value of the selection criterion itself. Always measure prior-task performance as well.

In summary, it is worth using when preserving the original capabilities matters, when you need to store and combine many task-specific variants, when you need to track or remove the changed positions (as in backdoor removal with TopKLoRA paper), or when LoRA struggles to reach the goal (as in adversarial training with SAFT paper). Conversely, it is better not to rush when LoRA already reaches the target performance and operational simplicity matters more, or when you have no evaluation set to validate the selection criterion.

Checklist before adopting sparse fine-tuning

Selection criteria

  • Does the criterion fit the training method (SFT or RL)?
  • Did you compare against a random sparse mask?
  • Did you set a per-layer budget allocation?

Efficiency

  • Is the optimizer avoiding holding the full matrix?
  • Did you measure actual VRAM and training speed?
  • Do you store only per-task differences?

Evaluation

  • Did you measure whether prior-task performance is retained?
  • Does it reproduce across multiple seeds?
Check selection criteria, real efficiency and evaluation scope separately.

Further study

Start with LIFT paper to grasp 'why the magnitude criterion was weak and what low-rank approximation changed.' Then look at GEM paper for relative magnitude and per-layer budget allocation, and Super-Tuning paper for reusing pruning scores and mixing in LoRA. These three papers cover most of the main branches of selection criteria.

Next, read two recent papers as a pair. Use 'The Path Not Taken' paper to understand how RLVR and SFT move differently in weight space, then read Deletion Tuning paper. Read together, the result that 'deletion alone is enough' and its geometric analysis help explain each other.

You can also choose by application interest. For multilingual and low-resource languages, start with DeFT-X paper; for security and robustness, SAFT paper; for interpretability and backdoor removal, TopKLoRA paper. For vision models and memory efficiency, SNELLA paper is the starting point, and for image generation, sparse-coding-based fine-tuning paper.

Related terms

LoRA Fine-tuning Post-training RLVR SFT Interpretability Backdoor attack Model merging

References

Foundational papers

Recent research

Written by AI from the listed references and reviewed. Please check the original sources for details.