Model Merging, Playable

EP 01

The impossible average — slide between two experts

Two models fine-tuned from the same base: one great at task A (french), hopeless at B (python); the other the reverse. Drag the merge slider — the merged weights are (1−α)·A + α·B, a straight-line blend. Watch both skill meters. Your intuition screams the middle should be garbage (average of two different experts = expert at nothing). Instead there's a fat middle zone where the merge is good at both at once.

✓ good case: α ≈ 0.5 — both skills near their peaks simultaneously; one model, two jobs, zero training✗ bad case: your prior — "averaging two different networks must give mush" (run it; it doesn't)

merge α (A ↔ B) 0.50 —

Skill curves follow the empirically observed shape: because both experts descend from the same base into the same loss basin, the segment between them stays low-loss — this is the "linear mode connectivity" that makes soups possible. Toy dynamics, real phenomenon.

This is a "model soup" (Wortsman et al.): average several fine-tunes of the same base and often beat every ingredient. It costs one addition and works because same-base fine-tunes don't wander into different valleys — they stay in one, and the valley floor is flat enough to walk across.

EP 02

Task vectors — skills you can add like Lego

The deeper idea: define a task vector = (fine-tuned weights − base weights). It's the direction in weight-space that "installs" a skill. And these vectors add: base + french_vector + python_vector ≈ a model that knows both. Toggle skill vectors on and off below and watch them compose onto the base model — installing capabilities like apps, no retraining.

✓ good case: base + (french + python + math) vectors — a triple-skilled model assembled from three cheap edits✗ bad case: scale the vectors up 3× to "install harder" — you overshoot the basin and every skill degrades together

vector strength 1.0× —

Each skill is a vector added to the base; the model's competence per skill is computed from how well the summed vector lands in that skill's region. Strength > ~1.5 pushes the sum outside the shared basin — measured, not asserted.

Task arithmetic (Ilharco et al.) turned skills into composable objects: you can add them, average them, even publish a library of "skill vectors" for one base model. LoRA adapters are a low-rank cousin of exactly this — a stored direction that installs a behavior.

EP 03

Subtract a skill — negation is the spooky part

If adding a vector installs a skill, subtracting it uninstalls one — and this actually works, which is genuinely unsettling. Take a base model and subtract a "toxicity" task vector: the model gets measurably less toxic while keeping its other abilities. Drag the subtraction strength on the two vectors below and watch the target behavior fall — then watch collateral damage rise if you subtract too hard.

✓ good case: −0.8× toxicity vector — toxicity drops 60%, general ability barely moves✗ bad case: −3× — toxicity floored, but you've torn a hole in the weights and fluency collapses with it

subtract toxicity 0.8× —

Two meters: target behavior (want it down) and general fluency (want it steady). The collateral curve reflects the real finding that mild negation is clean but aggressive negation damages shared weights the skill relied on.

Behavior editing by arithmetic is a real alignment tool — "forget this concept," "reduce this bias" — done by subtracting a direction instead of retraining. It's powerful and blunt: skills share weights, so subtraction always risks the neighbors. Surgery, not a dial.

EP 04

The interference wall — when merging turns to mud

Merging isn't magic — it has a hard limit. When two task vectors want to move the same weights in opposite directions, naive averaging cancels both to zero: interference. Crank the "conflict" between two skills and watch the merged model's combined score collapse. Then switch on TIES-merging (keep only the largest, agreeing changes; drop the sign-conflicted ones) and watch the wall move back.

✓ good case: low conflict OR TIES-merge on — the merge keeps ~90% of both skills✗ bad case: high conflict + naive average — opposing edits cancel, combined score craters toward the base

skill conflict 0.60 —

Conflict = fraction of weights the two vectors push oppositely. Naive averaging halves those to near-zero; TIES resolves by sign-election and magnitude-pruning — both computed on a simulated weight population each drag.

Every merging method after v1 is an interference-management scheme — TIES, DARE, model breadcrumbs. The frontier question isn't "can you merge" (yes, cheaply) but "how many skills before they start fighting over the same parameters" — and the answer is why 50-way merges need cleverness, not just addition.

EP 05

Why it works at all — the basin you can't average across (unless you can)

The load-bearing fact: averaging weights only works if both models live in the same loss basin. Two models trained from different random seeds sit in different valleys, and the straight line between them climbs a huge loss barrier — average them and you get true garbage. Same-base fine-tunes share a valley (no barrier). Toggle the two scenarios and walk the interpolation path; the loss-along-the-path curve tells you instantly whether a merge is even legal.

✓ good case: shared base — the path between them is flat (linear mode connectivity); merge freely✗ bad case: different seeds — a mountain of loss sits at the midpoint; the average is worse than either endpoint by far

—

The interpolation-loss curve is the real diagnostic used in the field: flat = mergeable, humped = a barrier. (Permutation methods like Git Re-Basin can sometimes flatten even the different-seed case by re-aligning neurons first — a hint shown when you pick that mode.)

Model merging is a gift of geometry, not a law of averages. It works because pretraining carves one enormous shared basin that fine-tuning barely leaves — so the whole neighborhood is walkable. Understand that basin and every merging result (and every failure) stops being magic and becomes a map-reading exercise.