An Empirical Study and Theoretical Explanation on Task-Level Model-Merging Collapse

This paper identifies and theoretically explains "task-level merging collapse," a phenomenon where incompatible task representations cause catastrophic performance degradation in merged LLMs, demonstrating that representational incompatibility—not parameter-space conflicts—is the primary driver of failure and establishing fundamental limits on task mergeability via rate-distortion theory.

The Gist

Imagine you have a team of expert chefs. One is a master of Italian pasta, another is a genius at Japanese sushi, and a third is a wizard at French pastries. Each has spent years perfecting their craft using the same basic kitchen equipment (the "Base Model").

Now, imagine you want to create a "Super Chef" who can cook all three cuisines perfectly at the same time. Instead of hiring a new chef and training them from scratch (which is expensive and slow), you decide to merge the brains of these three experts into one person. You take their recipes, mix them together, and hope the result is a culinary masterpiece.

This is essentially what Model Merging does with Artificial Intelligence. It tries to combine different AI models into one super-model without retraining.

However, the authors of this paper discovered a scary problem: Sometimes, when you mix these experts, the result isn't a super-chef; it's a disaster. The new model forgets everything and can't cook anything. The authors call this "Merging Collapse."

Here is the simple breakdown of what they found, using our kitchen analogy:

1. The Old Belief: "It's Just a Clash of Ingredients"

For a long time, scientists thought the problem was like mixing oil and water. They believed that if Chef A's recipe said "add salt" and Chef B's recipe said "add sugar" for the same dish, the instructions would cancel each other out, ruining the meal.

In AI terms, they thought the problem was Parameter Conflicts. They thought if the numbers inside the AI's brain moved in opposite directions, the merge would fail. They spent years trying to fix the "mixing spoon" (the merging algorithm) to make sure the ingredients didn't clash.

2. The New Discovery: "It's About the Chefs' Minds"

The authors ran hundreds of experiments and found something surprising: It doesn't matter how good your mixing spoon is. Even the best mixing techniques fail if you try to combine certain chefs.

They found that the real problem isn't the ingredients (the numbers); it's the mental map the chefs use.

• The Italian chef thinks of "pasta" as a long, winding road.
• The Sushi chef thinks of "rice" as a tight, compact ball.
• If you try to force the Italian chef to suddenly think of pasta as a tight ball, their brain breaks.

In AI language, this is Representational Incompatibility. The way the models "see" and "understand" the world is fundamentally different. When you force them to share a brain, their different ways of seeing the world crash into each other, causing the model to collapse.

3. The "Distance" Test

To prove this, the authors invented a new way to check if two models can be merged before actually doing it.

Imagine you ask the Italian chef and the Sushi chef to describe a "dinner party."

• If they describe it in very similar ways (e.g., "people eating, talking, having fun"), they are compatible. You can merge them.
• If they describe it in completely opposite ways (e.g., one says "it's a silent meditation" and the other says "it's a loud rave"), they are incompatible. Merging them will cause a crash.

The authors call this the Hidden-State Distance. They found that if the "mental distance" between two models is too big, merging them is impossible, no matter what fancy math you use.

4. The Theoretical "Speed Limit"

The paper also uses a complex math concept called Rate-Distortion Theory (which is usually used for compressing music or video files) to explain why this happens.

Think of it like this:
Imagine you have a map of a city.

• Chef A's map shows the streets as straight lines.
• Chef B's map shows the same streets as winding curves.
• You try to draw one map that is a perfect average of both.

The math proves that there is a hard limit to how accurate that average map can be. If the original maps are too different, the average map will be so distorted that it's useless. You can't "fix" the map by drawing it better; the geometry of the problem makes it impossible.

The Big Takeaway

The paper teaches us three main lessons:

1. Don't blame the tool: It's not the fault of the merging software (the "mixing spoon").
2. Check the compatibility first: Before you try to merge two AI models, check if they "think" similarly. If their internal representations are too far apart, don't bother merging them; the result will be a failure.
3. Some things can't be combined: Just like you can't easily merge a deep-sea diver and a mountain climber into one person who is perfect at both without losing their specific skills, some AI tasks are just too different to be combined into a single model.

In short: Merging AI models isn't just about mixing numbers; it's about making sure the models speak the same "language" of thought. If they don't, the merger will collapse, no matter how hard you try.

Technical Summary

Here is a detailed technical summary of the paper "An Empirical Study and Theoretical Explanation on Task-Level Model-Merging Collapse."

1. Problem Statement

The paper addresses the phenomenon of Model Merging Collapse, where combining independently fine-tuned Large Language Models (LLMs) derived from the same base model results in catastrophic performance degradation, despite the individual models performing well in isolation.

• Context: Model merging is a computationally efficient alternative to retraining, aiming to consolidate specialized capabilities (e.g., different tasks) into a single unified model by averaging parameters or task vectors.
• The Gap: While existing literature often attributes merging failures to parameter-space conflicts (e.g., opposing signs in weight updates or magnitude disparities), the authors observe that certain task combinations fail consistently across all merging methods, suggesting the root cause lies deeper than simple parameter disagreements.
• Core Question: What fundamental limitations govern which tasks can be successfully merged, and why do specific task combinations trigger collapse regardless of the merging technique used?

2. Methodology

The authors employ a mixed approach combining extensive empirical analysis with a novel theoretical framework based on information theory.

A. Empirical Investigation

• Datasets & Models:
  • Models: 5 diverse architectures (Llama3.2-3B, Llama3.1-8B, Qwen2.5-3B/7B/14B, T5-Base/Large/XL) covering different scales and types (decoder-only vs. encoder-decoder).
  • Tasks: 8 GLUE tasks (COLA, MNLI, MRPC, etc.) and 64 checkpoints from the "Lots-of-LoRAs" collection.
• Merging Techniques: Five state-of-the-art methods were tested:
  1. Linear Averaging (LA)
  2. Task Arithmetic (TA)
  3. TIES (Task-Interference Elimination via Sign)
  4. DARE (Drop and Rescale)
  5. SLERP (Spherical Linear Interpolation)
• Metrics:
  • Merging Loss: Quantified as the percentage drop in performance compared to the original fine-tuned model.
  • Parameter Conflict Metrics: Sign change ratio, magnitude change ratio, and cosine similarity of task vectors.
  • Proposed Metric: Hidden-State Distance Similarity, measuring the $L_2$ distance between hidden representations of different models on the same input.
  • Merging Difficulty Score (MDS): A derived metric based on the reciprocal of average representational similarity, acting as a proxy for "resistance" to merging.

B. Theoretical Framework

• Rate-Distortion Theory: The authors model the merging process through the lens of rate-distortion theory (Berger, 2003).
• Locally Modified Components (LMC) Assumption: They assume linear mode connectivity, where convex combinations of fine-tuned minima maintain low training loss.
• Theorem 1 (Hidden-State Diameter Control): They prove that for representations in $\mathbb{R}^d$, the minimum achievable hidden-state distortion ($\delta_{max}$) for any convex merge is bounded by the diameter ($\Delta$) of the task-specific representation clusters:
  $$\delta_{max} \geq \frac{1}{4}\Delta^2$$
  This establishes a fundamental limit: if the distance between task representations ($\Delta$) is too large, no merging method can achieve low distortion (i.e., high performance).

3. Key Contributions

1. Identification of Task-Level Merging Collapse:
   The paper formally defines and characterizes "merging collapse," demonstrating that it is a systematic failure mode where specific task combinations degrade performance catastrophically across all merging methodologies, not just specific algorithms.

2. Paradigm Shift: Representational vs. Parameter Incompatibility:
   The study challenges the conventional wisdom that parameter-space conflicts are the primary cause of failure. Through statistical analysis (ANOVA and Pearson correlation), the authors show:

   • Parameter metrics (sign/magnitude conflicts) have minimal correlation with merging loss ($p > 0.05$).
   • Task-level representational incompatibility (hidden-state distances) has a strong correlation with merging collapse.

3. Dimension-Dependent Theoretical Bound:
   The authors provide the first theoretical explanation for merging collapse using rate-distortion theory. They prove that the "mergeability" of tasks is fundamentally constrained by the geometry of their hidden representations (specifically the diameter of the representation clusters), establishing a lower bound on distortion that is independent of the merging algorithm.

4. Practical Metric for Task Selection:
   The introduction of Hidden-State Distance Similarity and the Merging Difficulty Score (MDS) provides a actionable tool. The authors demonstrate that by calculating MDS, practitioners can predict which task combinations will fail and strategically select compatible tasks to avoid collapse.

4. Key Results

• Universality of Collapse: Across 5 models, 8 tasks, and 5 merging techniques, merging collapse is the norm rather than the exception. Even the best-performing configurations showed double-digit performance losses (up to -48% on specific tasks like WNLI).
• Method Independence: Statistical tests (ANOVA) revealed that the choice of merging technique had negligible impact on performance compared to the specific combination of tasks. Some tasks (e.g., MRPC, WNLI) failed regardless of whether LA, TIES, or DARE was used.
• Correlation Validation:
  • Parameter conflict metrics showed $p$-values $> 0.05$ when correlated with merging loss.
  • Hidden-state similarity showed highly significant correlations ($p < 0.05$, often $< 0.01$) with merging performance.
• Predictive Power of MDS: Tasks with high MDS (low representational similarity) consistently exhibited the worst merging losses. Replacing high-MDS tasks with low-MDS alternatives in experimental groups successfully reduced merging collapse.

5. Significance

• Theoretical Foundation: The paper moves the field from heuristic parameter manipulation to a rigorous information-theoretic understanding of model merging, establishing fundamental limits on what can be merged.
• Practical Guidance: It offers a concrete solution to the "black box" nature of model merging. Practitioners can now pre-evaluate task compatibility using hidden-state distances before attempting to merge, saving computational resources and preventing deployment of degraded models.
• Redefining the Problem: By shifting the focus from "fixing the algorithm" to "selecting compatible tasks," the paper suggests that the bottleneck in model merging is not the merging method itself, but the inherent incompatibility of the knowledge representations learned by different tasks.

In summary, this work proves that task-level representational incompatibility is the root cause of model merging collapse, providing both a theoretical bound and a practical metric to guide the selection of mergeable tasks.