Resolving Parameter Interference in Model Merging

36 concepts29 papers1 proposal

When we fine-tune a large language model or vision transformer on a specific task, we alter its weights to specialize its behavior. If we fine-tune the same base model on several different tasks—such as mathematics, coding, or translation—we end up with a collection of specialized, homologous models.

The goal of model merging is to combine these distinct experts into a single, multi-task model without undergoing the prohibitive computational expense of retraining.

The simplest way to combine these models is through linear weight averaging. However, naive averaging frequently results in a "jack of all trades, master of none" scenario where performance plummets. This failure is driven by parameter interference and neuron cancellation. When independent training runs modify the same parameter in opposing directions, averaging them drives the value toward zero, effectively erasing the specialized knowledge acquired during fine-tuning.

To solve this, a powerful paradigm has emerged: treating model merging not as a blind numerical average, but as an interference-aware resolution process operating on task vectors (the delta changes between the fine-tuned weights and the base model).

Task Vector (ΔW) = W_finetuned - W_base

By isolating, filtering, and voting on these delta parameters, interference-aware merging techniques successfully blend disparate capabilities into a single architecture.


Magnitude Resolution: Pruning the Background Noise

The first key intuition behind resolving parameter interference is that not all weight updates are important. During fine-tuning, a model modifies millions of parameters, but many of these updates are minor, acting as stochastic noise rather than critical feature extractors. When multiple task vectors are merged, this background noise accumulates, diluting the core signals.

To combat this, researchers introduce sparsity before merging. Yu et al. demonstrated this with DARE (Drop And REscale), showing that between 90% and 99% of fine-tuning delta parameters can be dropped entirely (set to zero) without degrading the model's performance. By aggressively sparsifying each task vector, the probability that two models will compete for the same parameter drops significantly, clearing the stage for the most impactful updates to be merged cleanly.

This strategy of magnitude-based trimming is a cornerstone of modern merging pipelines:

  • Kulshreshtha et al. prune low-magnitude values in task vectors during sequential updates to prevent catastrophic forgetting in speech recognition models.
  • Tam et al. show that filtering out low-magnitude updates reduces parameter-level competition, allowing merged models to maintain better stability when scaling up the number of combined tasks.
  • Li utilizes magnitude trimming to streamline the transfer of textual preferences into vision-language models, dropping redundant delta parameters to prevent performance degradation.

Sign Resolution: Voting and Consensus

Even after removing low-magnitude noise, models will inevitably disagree on the direction of critical parameter updates. This directional conflict is quantified by Nguyen et al. through a metric called the Fraction of Sign Difference (FSD). When the FSD between two models is high, simple averaging causes weight nullification—the opposing signs pull the parameter in a tug-of-war that destroys the learned features of both models.

To resolve these directional stalemates, modern merging algorithms implement sign consensus or sign election mechanisms. Instead of averaging conflicting values, the system votes on the correct direction for each parameter.

Model A: ΔW = +0.4  (Coding Expert)
Model B: ΔW = +0.5  (Math Expert)
Model C: ΔW = -0.3  (Translation Expert)

Sign Election -> Dominant Sign is Positive (+)
The negative update from Model C is rejected or masked to prevent cancellation.

This voting process typically follows one of two strategies:

1. Majority/Dominant Sign Election

Huang et al. (EMR-Merging) and Wang et al. resolve conflicts by calculating a dominant sign based on the cumulative magnitude of updates across all specialized models. The parameter update that aligns with this dominant direction is preserved (often choosing the maximum absolute value among the agreeing tasks), while the conflicting updates are discarded. Tao et al. leverage a similar approach to merge instruction-following capabilities with low-resource language models without destructive interference.

2. Strict Sign Consensus Masking

Rather than choosing a dominant winner, some frameworks demand absolute agreement. In NegMerge, developed by Kim et al., if the sign of a weight update is inconsistent across the ensemble, the parameter is masked to zero. This ensures that the merged model only retains updates where all constituent models agree on the direction of change, effectively filtering out training-run noise. Mammadov et al. similarly apply sign conflict resolution to prevent neuron cancellation when fusing digital pathology models.


Rescaling and Optimization: Restoring the Signal

When you drop 90% of a model's weight updates or zero out parameters due to sign conflicts, you alter the mathematical variance of the weight matrices. If you pass an input through a layer where most updates have been zeroed out, the scale of the activations will collapse, breaking the deeper layers of the network.

Therefore, conflict resolution must be paired with rescaling. As pioneered by Yu et al., when delta parameters are dropped, the remaining weights are rescaled upwards to ensure that the expected value and variance of the weight matrix match the original un-sparsified distribution. The authors of MergeME similarly employ a two-stage process that pairs redundant weight trimming with task vector rescaling to preserve distinct expert capabilities within a combined mixture-of-experts framework.

Going a step further, some approaches move away from heuristic voting rules entirely, framing conflict resolution as a mathematical optimization problem. Cheng et al. introduce a layer-by-layer optimization framework where an optimizer treats task vectors as proxies for data distributions, explicitly calculating a merged weight vector that minimizes interference between specialized expert weights.


Side Effects: Security, Unlearning, and Safety

The mechanics of interference-aware merging—dropping non-essential updates and enforcing sign consensus—have powerful, unexpected applications beyond multi-task learning.

  • Sanitizing Backdoored Models: Arora et al. discovered that model merging acts as a zero-cost defense against malicious backdoor attacks. Because backdoor triggers are typically injected via isolated data points, their corresponding weight updates lack magnitude and sign consensus when merged with other clean models. The conflict resolution process naturally treats the backdoor as noise and prunes it away.
  • Preserving Safety: When merging utility-focused models, critical safety alignments can be accidentally overwritten. Liu et al. (LED-Merging) solve this by isolating conflicting parameter updates through set difference operations, ensuring that utility updates are prevented from modifying critical safety logic.
  • IP Protection Vulnerabilities: The efficiency with which these methods strip away non-consensual weights creates challenges for intellectual property protection. Cong et al. demonstrate that quantization-based model watermarks are easily "washed away" by interference-aware merging algorithms, forcing a shift toward behavioral fingerprinting methods that survive parameter-space optimization.

Key Foundational Work

TIES-Merging: Resolving Interference When Merging Models (2023) — contributed 2 concept elements to this direction.
Matching and Merging of Statecharts Specifications (2007) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_parameter_conflict_resolution_9533217f,
  title = {parameter conflict resolution},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/parameter-conflict-resolution/rdr_9533217fe1f14218bcbcb38bdb2149b9},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_parameter_conflict_resolution_9533217f_v1,
  title = {parameter conflict resolution},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/parameter-conflict-resolution/rdr_9533217fe1f14218bcbcb38bdb2149b9/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake