回到部落格
一般文章

兩個模型相加除以二,為什麼會有用?

2016 年,Google 把兩個手寫數字模型的權重平均,起點不同的壞掉了,起點相同的反而比兩個都好。十年後,Cohere 用同樣的平均把六個專家併成 1,110 億參數的 Command A,DeepSeek-V4 卻改用蒸餾。從一個筆電跑得動的小實驗出發,看模型合併靠什麼成立、在排行榜上紅過哪一陣,現在又走到哪裡。

2016 年 2 月,Google 的 Brendan McMahan 等人把一篇論文放上 arXiv,提出後來稱為 FedAvg 的聯邦學習演算法。每台裝置用自己的資料訓練模型,伺服器只負責把收回來的權重平均。

這個做法有個明顯的疑慮。神經網路的損失函數不是凸的,作者自己也寫,在參數空間裡平均兩個模型,結果可能壞到任何程度。

於是他們先做了一個小實驗。兩個有兩層隱藏層的 MNIST 分類器,各拿 600 張互不重疊的手寫數字訓練 240 步,再把兩組權重按比例混合,看混出來的模型在整個訓練集上的損失。

兩個模型的初始權重若用不同的亂數種子,混到一半,損失就衝得老高。改用同一個種子,平均出來的模型,損失反而比兩個父模型都低。FedAvg Figure 1

先看作者實際量到的曲線。橫軸是兩組權重的混合比例,縱軸是在整個 MNIST 訓練集上的損失;左右兩張圖的縱軸刻度不同。左圖的中間鼓起一座山,右圖的中間卻低於兩個端點。

原論文 Figure 1(McMahan 等人),取自 PDF 第 4 頁。兩圖都保留原始刻度。

這個觀察只佔論文第二節的一張小圖。

八年後,Hugging Face 的 Open LLM Leaderboard 前排擠滿了合併出來的模型。社群的教學文章說,合併是做新模型的便宜方法,「不需要 GPU」;到了 2024 年 3 月,排行榜團隊已經把合併模型預設隱藏起來。

再過一年,Cohere 用加權平均把六個專家併成 1,110 億參數的 Command A,和各自的專家相比,平均只掉了 1.8%。2026 年 4 月,DeepSeek-V4 也先訓練一群專家,最後卻選擇用蒸餾把它們教進同一個模型;技術報告特別提到,這樣可以避開權重合併常見的效能衰退。

這篇從那張小圖出發。我們先在筆電上把兩個模型平均一次,看它怎麼壞、怎麼修,再沿著時間往後走,看「相加除以二」怎麼從聯邦學習的一個小實驗,變成排行榜上的煉金術,又怎麼走進各家的訓練流程。

圖:本文整理的時間線,依論文或模型首次公開的時間排列。各項的來源附在正文對應段落。

前半段講原理,看不同起點為什麼不能平均,對齊與共同起點又各自怎麼解決。

後半段講應用,從微調模型的湯、任務向量,一路看到排行榜與各家的訓練流程。

先在筆電上平均一次

我們照 FedAvg 的設定重做一次。MNIST 換成 scikit-learn 內建的 digits,1,797 張 8×8 的手寫數字,不用另外下載。模型、學習率、批次大小與步數都照論文設定,兩層各 200 個單元的隱藏層、學習率 0.1、批次 50,訓練 240 步。

python
import torch
import torch.nn as nn
from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)                    # 1,797 張 8×8 的手寫數字
X = torch.tensor(X / 16.0, dtype=torch.float32)
y = torch.tensor(y)
perm = torch.randperm(len(X), generator=torch.Generator().manual_seed(0))
idx_a, idx_b, idx_test = perm[:600], perm[600:1200], perm[1200:]

def make(seed):
    torch.manual_seed(seed)                            # 種子決定初始權重
    return nn.Sequential(nn.Linear(64, 200), nn.ReLU(),
                         nn.Linear(200, 200), nn.ReLU(),
                         nn.Linear(200, 10))

def train(model, idx, seed):
    opt = torch.optim.SGD(model.parameters(), lr=0.1)
    g = torch.Generator().manual_seed(seed)            # 種子決定資料順序
    for epoch in range(20):                            # 600 張、批次 50,共 240 步
        order = idx[torch.randperm(len(idx), generator=g)]
        for b in order.split(50):
            loss = nn.functional.cross_entropy(model(X[b]), y[b])
            opt.zero_grad()
            loss.backward()
            opt.step()
    return model

make 的種子決定初始權重,train 的種子決定資料順序。兩份訓練資料各 600 張,互不重疊,剩下的 597 張留著測試。

接著寫兩個小工具。mix 按比例 tt 混合兩組權重:

θ(t)=t θA+(1−t) θB\theta(t) = t\,\theta_A + (1-t)\,\theta_B

t=0.5t = 0.5 就是相加除以二。evaluate 回報兩份訓練資料合起來的損失,以及測試集的準確率。

python
def mix(m1, m2, t):
    sd1, sd2 = m1.state_dict(), m2.state_dict()
    merged = make(0)
    merged.load_state_dict({k: t * sd1[k] + (1 - t) * sd2[k] for k in sd1})
    return merged

@torch.no_grad()
def evaluate(model):
    seen = torch.cat([idx_a, idx_b])                   # 兩份訓練資料合起來
    loss = nn.functional.cross_entropy(model(X[seen]), y[seen]).item()
    acc = (model(X[idx_test]).argmax(1) == y[idx_test]).float().mean().item()
    return f"loss {loss:.3f}, 測試 {acc:.1%}"

for name, seed_a, seed_b in [("不同起點", 1, 2), ("同一起點", 1, 1)]:
    A = train(make(seed_a), idx_a, seed=10)
    B = train(make(seed_b), idx_b, seed=20)
    print(name)
    print("  A   :", evaluate(A))
    print("  B   :", evaluate(B))
    print("  平均:", evaluate(mix(A, B, 0.5)))
text
不同起點
  A   : loss 0.264, 測試 92.1%
  B   : loss 0.270, 測試 93.0%
  平均: loss 1.277, 測試 83.4%
同一起點
  A   : loss 0.264, 測試 92.1%
  B   : loss 0.266, 測試 93.3%
  平均: loss 0.252, 測試 93.6%

不同起點的兩個模型,測試準確率各有九成二、九成三,平均之後掉到 83.4%,損失從 0.27 左右跳到 1.277。

同一起點的那組,平均出來的模型損失 0.252,比 A 的 0.264 和 B 的 0.266 都低;測試準確率 93.6%,也比兩個父模型高。兩個模型各自只看過一半的資料,平均之後,在兩份合起來的訓練資料上比它們都好。我們在小資料上重現了 FedAvg 那張圖右半邊的趨勢。

不過這裡只做一次分開訓練、一次平均。完整 FedAvg 會把平均後的模型再送回裝置,各自更新幾步,再收回來依資料量加權,反覆進行。這個小實驗用等量資料,所以相加除以二就夠;裝置資料量不同時,權重比例也要跟著變。先把這一輪算懂,再看多輪聯邦訓練會比較清楚。

把 tt 從 0 掃到 1,畫成曲線更清楚:

圖:本文實驗的結果,tt 每隔 0.05 取一點。白色虛線是不同起點直接平均,橘線是同一起點,淺藍線是下一節對齊排列之後的結果。

換五組種子重做,結論都一樣。五組平均起來,父模型的測試準確率是 92.9%;不同起點直接平均,掉到 80.2%;同一起點平均,是 93.6%。換一台機器或另一個 PyTorch 版本,小數點後的數字可能略有不同。

同一個網路,換個順序

不同起點為什麼不能平均?先看一個更極端的例子。

隱藏層裡的 200 個單元沒有固定的順序。把第 3 號和第 7 號單元對調,只要下一層讀取輸入的位置也跟著對調,整個網路算出來的東西完全一樣。權重矩陣的列換了位置,函數沒有變。

圖:本文整理的示意。三個單元代表任意三個隱藏單元,偵測的筆畫只是為了方便說明。

這種排列的對稱性,1990 年 Hecht-Nielsen 就討論過。Git Re-Basin §1

我們的網路有兩層、各 200 個單元,光是這樣換位,就有 200!×200!200! \times 200! 種寫法,大約是 6×107496 \times 10^{749},每一種都是同一個模型。

那就拿模型 A 和「打亂順序的 A」來平均:

python
def permute(model, p1, p2):
    sd = {k: v.clone() for k, v in model.state_dict().items()}
    sd["0.weight"], sd["0.bias"] = sd["0.weight"][p1], sd["0.bias"][p1]  # 第一層的 200 個單元換位
    sd["2.weight"] = sd["2.weight"][:, p1]                              # 下一層讀輸入的順序跟著換
    sd["2.weight"], sd["2.bias"] = sd["2.weight"][p2], sd["2.bias"][p2]  # 第二層的 200 個單元換位
    sd["4.weight"] = sd["4.weight"][:, p2]
    out = make(0)
    out.load_state_dict(sd)
    return out

A = train(make(1), idx_a, seed=10)
g = torch.Generator().manual_seed(100)
A2 = permute(A, torch.randperm(200, generator=g), torch.randperm(200, generator=g))

print(torch.allclose(A(X), A2(X), atol=1e-5))         # 每一張圖的輸出都一樣嗎?
print("A   :", evaluate(A))
print("A2  :", evaluate(A2))
print("平均:", evaluate(mix(A, A2, 0.5)))
text
True
A   : loss 0.264, 測試 92.1%
A2  : loss 0.264, 測試 92.1%
平均: loss 1.215, 測試 84.3%

True 表示 1,797 張圖的輸出都相同,誤差在十萬分之一以內,兩者的準確率也都是 92.1%。可是相加除以二,就掉到 84.3%。

同一個模型跟自己平均也會壞,問題出在對位。平均是逐個位置做的,A 的第 3 號單元,會和 A2 排在第 3 號的單元平均;後者其實是 A 的另一個單元,負責的是另一種特徵。兩個不相干的特徵偵測器各取一半,得到的偵測器往往兩邊都不像。

不同種子訓練出來的兩個模型,情況差不多。它們可能學到了相似的特徵,只是擺在不同的位置。

先對齊,再平均

既然是順序的問題,就先把順序排好。2021 年,Entezari 等人提出一個大膽的猜想,只要把所有換位的可能都考慮進去,SGD 找到的解之間,沿直線混合多半不會遇到障礙。Entezari 等人

2022 年的 Git Re-Basin 提出了找排列的方法,其中最簡單的一種叫權重比對(weight matching),不需要任何資料。對每一層,計算 A 和 B 每一對單元有多像,再解一個線性指派問題(經典解法是匈牙利演算法),找出總相似度最高的一對一配對。比較的是單元的輸入權重、偏差,以及它送往下一層的權重。兩層的排列互相牽動,所以來回多做幾輪。

python
from scipy.optimize import linear_sum_assignment

def match(ref, other, iters=20):
    a, b = ref.state_dict(), other.state_dict()
    p1, p2 = torch.arange(200), torch.arange(200)
    for _ in range(iters):
        # 第一層:比對每個單元的輸入權重、偏差,以及它送往下一層的權重
        s1 = (a["0.weight"] @ b["0.weight"].T
              + torch.outer(a["0.bias"], b["0.bias"])
              + a["2.weight"].T @ b["2.weight"][p2])
        p1 = torch.as_tensor(linear_sum_assignment(s1.numpy(), maximize=True)[1])
        # 第二層:同樣的比對,輸入端改用剛排好的 p1
        s2 = (a["2.weight"] @ b["2.weight"][:, p1].T
              + torch.outer(a["2.bias"], b["2.bias"])
              + a["4.weight"].T @ b["4.weight"])
        p2 = torch.as_tensor(linear_sum_assignment(s2.numpy(), maximize=True)[1])
    return permute(other, p1, p2)

A = train(make(1), idx_a, seed=10)
B = train(make(2), idx_b, seed=20)
B2 = match(A, B)
print(torch.allclose(B(X), B2(X), atol=1e-5))         # 換位不改變 B 的功能
print("直接平均  :", evaluate(mix(A, B, 0.5)))
print("對齊後平均:", evaluate(mix(A, B2, 0.5)))
text
True
直接平均  : loss 1.277, 測試 83.4%
對齊後平均: loss 0.383, 測試 91.6%

換位之後,B2 的輸出和 B 完全一樣;拿去跟 A 平均,測試準確率從 83.4% 回到 91.6%,損失從 1.277 降到 0.383。前面那張圖裡的淺藍線就是這一組,中間的山矮了很多。

五組種子的平均,是從 80.2% 回到 92.2%。對齊救回了大部分,但還差同一起點的 93.6% 一點,損失也沒有低過兩個父模型。

Git Re-Basin 在更大的模型上看到類似的趨勢。CIFAR-10 上,把 ResNet-20 加寬到 32 倍,兩個獨立訓練的模型對齊後可以做到零障礙,作者說這是他們所知的第一次;ImageNet 上標準寬度的 ResNet-50,障礙降了 67%,沒有歸零。網路越寬,對齊之後越容易連通。Git Re-Basin

這組插值曲線把成功和限制放在同一排。灰色是直接混合,綠色是 weight matching;第三張加寬的 ResNet-20 幾乎拉平,最右邊標準寬度的 ResNet-50 仍留下隆起。實線量訓練損失,虛線量測試損失,不能只看其中一條。

原論文 Figure 2(Ainsworth 等人),取自 PDF 第 5 頁,CC BY 4.0。

CIFAR 那組還把正規化換成 LayerNorm;ImageNet 保留 BatchNorm,插值後重新估計統計量。對齊時得一起處理偏置、正規化與殘差分支,單純把每層的列排序完,還不算完成。剛才的 MLP 沒有這些元件,才適合用幾十行程式走完。

這條路走得通,但每一層都要解一次配對問題,網路還得夠寬。

從同一個起點出發

另一條路省下了先找排列的步驟,讓兩個模型共用一段訓練路徑。

FedAvg 用的就是同一組初始權重。2019 年,Frankle 等人把這件事做成系統化的測試。同一個網路複製兩份,用不同的資料順序和資料增強繼續訓練,再看兩個結果之間沿直線有沒有障礙。他們發現,只有最小的 MNIST 網路從初始化開始就沒有障礙;其他網路要先一起訓練一小段,CIFAR-10 上的 ResNet-20 大約是全程的 3%,ImageNet 上的 ResNet-50 是 20%。過了那個點,在抽樣的多組訓練裡,終點會落進線性連通的區域。Frankle 等人 §1

他們量的「穩定」是兩個終點之間的最高錯誤率,扣掉兩端平均,低於 2 個百分點。ResNet-20 剛達到這個條件時,測試錯誤率還約 25%,最終可以降到 8.3%。網路還沒有學完,只是後續訓練的終點已經比較容易直接混合。共享初始化、共享一段已訓練的路徑,兩者的效果要分開看。

把複製的時間點沿橫軸往後推,就得到下面五張圖。縱軸是不穩定度,紅線看測試集、紫線看訓練集;MNIST 的 LeNet 一開始就貼近零,其他模型要先共享一段訓練。前三張用 iteration,後兩張用 epoch,時間單位也要一起讀。

原論文 Figure 3(Frankle 等人),取自 PDF 第 4 頁。

我們的小 MLP 大概也屬於最小的那一類;前面的實驗裡,同一個種子就夠了。

圖:本文整理的示意,左圖畫的是共享路徑且已形成線性連通的情況。實際地形每個參數就是一個維度,本文的小 MLP 有五萬多個;圖中只表達相對位置。

不同的谷之間也未必隔絕。2018 年,Garipov 等人和 Draxler 等人分別發現,獨立訓練的兩個解之間,可以找到一條損失幾乎不變的彎曲路徑;只是走直線,中間就會撞上高牆,就像上圖右邊那條虛線。Garipov 等人、Draxler 等人

原圖裡的色階才是實際量到的損失。左邊三個獨立解之間,直線會穿過高損失區;中間的 Bezier 曲線和右邊的折線,則沿著低損失區把兩端接起來。這裡多出來的是一條訓練得到的路徑,兩端中點的位置沒有跟著移動。

原論文 Figure 1(Garipov 等人),取自 PDF 第 2 頁。

同一年,Garipov 的共同作者 Izmailov 等人提出 SWA。他們平均的是同一次訓練裡的多個時間點。學習率保持在較高的常數或循環變動,讓 SGD 在谷底附近來回走,再把走過的權重等權平均。論文提到,沿著 SGD 軌跡維持權重平均的想法,可以追溯到 Ruppert 1988 年的工作。ImageNet 上的 ResNet-50,從訓練好的模型再用 SWA 多跑 10 個 epoch,top-1 從 76.15% 升到 76.97%;作者認為,平均點落在更平坦的區域,泛化因此比較好。SWA Table 2

下面的 CIFAR-100/ResNet-164 切面讓這個解釋具體一些。左圖的三個叉號是 FGE 樣本,平均點落在中間;中圖看測試錯誤率,右圖看訓練損失。SGD 和 SWA 在兩張圖裡的相對表現不同,訓練損失最低的位置,未必也是測試錯誤率最低的位置。

原論文 Figure 1(Izmailov 等人),取自 PDF 第 2 頁。本圖是 CIFAR-100 分析,前段的 ImageNet 數字來自另一組實驗。

這三件事其實分工不同。模式連通告訴我們能繞著走,找彎曲路徑仍然要訓練;線性模式連通要求兩點之間那條直線也走得通,才直接關係到權重平均;SWA 則沿同一條軌跡收集近鄰,把部署模型收成一份。若中間只是有一條彎曲通道,取兩端的平均仍然可能掉到通道外。

SWA 還給了一個「平均為什麼像集成」的局部解釋。令幾個 checkpoint 的平均為 θˉ\bar\theta,每個偏移是 di=θi−θˉd_i=\theta_i-\bar\theta,因此 ∑idi=0\sum_i d_i=0。在平均附近展開網路輸出:

1n∑if(x;θi)=f(x;θˉ)+1n∑iJf(x;θˉ)di+O ⁣(max⁡i∥di∥2).\frac1n\sum_i f(x;\theta_i) = f(x;\bar\theta)+\frac1n\sum_i J_f(x;\bar\theta)d_i +O\!\left(\max_i\lVert d_i\rVert^2\right).

中間的一次項剛好相消,輸出集成與平均權重的差,剩下二階項。這就是近鄰 checkpoint 有機會用單一模型近似集成的原因。點離得太遠、附近非線性太強時,二階項就不能忽略;BatchNorm 的統計量也得對應平均後的模型重新估計。先確認近、確認沿線好用,這個推導才接得上實作。

讓「同一個起點」變得隨處可得的,是預訓練模型。2020 年,Neyshabur 等人觀察到,從同一個預訓練權重出發微調的多個模型,會留在損失地形的同一個盆地裡,特徵相似,參數也靠得很近;從隨機初始化訓練的模型就沒有這個性質。Neyshabur 等人

大家都從同一個 CLIP、同一個 Llama 出發,微調出來的模型自然是同一個起點的兄弟。模型合併的主戰場,從這裡開始轉向微調。

一鍋湯

訓練模型的標準流程,是用不同的超參數訓練一批,挑驗證集上最好的一個,其餘的丟掉。

2021 年的 WiSE-FT 先做了一個簡單的版本。CLIP 的零樣本模型在各種分布偏移下都還算穩;微調之後,ImageNet 變強了,遇到偏移的資料卻變差。WiSE-FT 把零樣本與微調後的兩組權重線性混合,在 ImageNet 衍生的五個分布偏移資料集上,比先前的方法高 4 到 6 個百分點,ImageNet 本身也多了 1.6 個百分點,推論成本不變。WiSE-FT

六個資料集的係數曲線可以直接看。橫軸 α=0\alpha=0 是零樣本模型,α=1\alpha=1 是微調模型,粉紅線是兩組權重之間的模型;水平點線標出兩端較好的成績。好幾個資料集的最佳位置落在中間,但位置各不相同,沒有一個係數能自動包辦所有分布。

原論文 Figure 6(Wortsman 等人),取自 PDF 第 11 頁。

2022 年的 Model Soups 把對象換成「被丟掉的那一批」。作者用隨機搜尋的超參數,把 CLIP ViT-B/32 在 ImageNet 上微調了 72 次,結果如下:

  • 最好的單一模型:80.38%
  • 72 個全部平均(uniform soup):79.97%,比最好的那個還差
  • 貪婪湯(greedy soup):81.03%
  • 72 個模型的輸出集成:81.19%,但推論要跑 72 次

這幾個數字在原表的 ImageNet 欄。右邊的 Dist. shifts 是五個分布偏移資料集的平均,uniform soup 在那一欄反而高於 greedy soup。挑模型用哪份驗證資料,會改變最後比較擅長哪一種測試。

原論文 Table 3(Wortsman 等人),取自 PDF 第 6 頁。

貪婪湯的做法很樸素。先把模型按驗證集準確率排好,從最好的開始,一個一個試著加進鍋裡,驗證集變好就留下,變差就跳過。有些超參數(例如太大的學習率)會讓模型跑到別的盆地,全部平均就會被拖累,貪婪湯會把它們擋在鍋外。

這鍋 CLIP 最後留下 5 個成員。湯裡已有 nn 個模型時,新候選是 (nθsoup+θi)/(n+1)(n\theta_{\text{soup}}+\theta_i)/(n+1),逐次各取一半會讓越晚進來的模型權重越大。配方在從 ImageNet 訓練集留出的約 2% 資料上挑選,官方 validation 仍留作測試。每次嘗試都要評一個新候選,只是不用再做反向傳播。

貪婪湯保證的是這份選模資料上不退步,測試集仍要另外量。輸出集成還有機率校準較好的優勢,模型湯在論文的校準實驗裡沒有同樣收益。因此只需要一個模型、重視分類準確率時,湯很吸引人;若要用輸出機率決定拒答或人工複核,也要把校準列入比較。

在 JFT-3B 預訓練的 ViT-G/14 上,貪婪湯從 58 個微調模型裡挑了 14 個,ImageNet 達到 90.94%,超過當時最好的 CoAtNet-7(90.88%),推論的計算量還少了 25%。Model Soups Table 1、Table 3

這一鍋湯裡,每個模型做的是同一個任務。下一步,是把不同任務的模型放進同一鍋。

任務向量

2022 年底,Ilharco 等人把微調看成一個方向。預訓練權重是 θpre\theta_{\text{pre}},在任務 A 上微調後是 θA\theta_A,兩者相減:

τA=θA−θpre\tau_A = \theta_A - \theta_{\text{pre}}

τA\tau_A 叫任務向量(task vector),記錄為了任務 A,每個權重往哪裡移、移了多少。有了它,就可以做算術:

θ=θpre+λ∑tτt\theta = \theta_{\text{pre}} + \lambda \sum_t \tau_t

幾個任務的向量加起來,嘗試讓一個模型同時處理這些任務;把某個向量取負號再加,則測試能否降低對應能力、同時保留其他行為。係數 λ\lambda 用保留的驗證資料來挑。

圖:本文整理的示意,對照任務算術論文 Figure 1 的三種操作。

論文用 CLIP 在八個影像分類資料集上做實驗,從汽車型號、紋理、衛星影像到門牌數字都有。兩個任務的向量相加,在這兩個任務上平均保留專家 98.9% 的準確率;八個向量都可供選擇時,找到的最佳多任務模型是 91.2%。直接用八個任務的資料做多任務微調則是 99.4%,合併省下重新訓練與取得原始資料的需求,也留下了能力差距。Task Arithmetic §4、附錄 D

這張 ViT-L/14 圖的縱軸,是把八個任務各自除以單任務專家的準確率,再取平均;淡點是不同向量子集,深色折線是同一數量下的平均。加入更多任務向量,整體能力往上走,但距離每個任務都由專家自己處理的 1.0,還有一段距離。

原論文 Figure 3(Ilharco 等人),取自 PDF 第 5 頁,CC BY 4.0。

減法也有效。把 GPT-2 Large 在有毒留言上微調的任務向量減掉,固定提示下的 1,000 段生成中,被毒性分類器判定為有毒的比例從 4.8% 降到 0.8%,WikiText-103 困惑度從 16.4 到 16.9。這是在指定評測中改變行為,若要確認某筆資訊已從模型移除,還需要另一套驗證。Task Arithmetic §3

加法為什麼行得通?2023 年,Ortiz-Jimenez 等人認為關鍵在權重的「解耦」,也就是不同任務的向量,影響的是輸入空間裡互不重疊的區域,加在一起才不會互相干擾。他們把同樣的實驗搬到隨機初始化的 ViT 上,任務向量加起來,多任務的準確率和亂猜差不多。這組對照支持預訓練為任務解耦提供了結構。Ortiz-Jimenez 等人 §6.2

所以任務算術的前提和 FedAvg 那張圖一樣,大家得從同一個起點出發,而且這個起點最好是預訓練過的。

相同起點提供共同座標,任務向量仍會在各個位置重疊。原論文量到,多數 CLIP 任務向量的餘弦相似度只有 0.01 到 0.03,MNIST 與 SVHN 這種相近任務則較高,約 0.18。接近正交有助理解干擾為何可以較小,卻還要看每個改動如何影響實際輸出。後面的 TIES 正是在處理整體任務向量接近正交、局部參數仍衝突的情況。

參數打架

前面的 91.2% 是相對專家的保留率。再看另一組較小的模型設定,TIES-Merging 論文的 CLIP ViT-B/32,在八個任務上各自微調,平均準確率是 90.5%;用任務算術合成一個模型,就算用驗證集挑係數,也只有 70.1%。這組原始準確率顯示,同時保住八種能力仍有很大難度。TIES-Merging Table 1

先沿著原表的 ViT-B/32 欄往下讀。90.5 是專家各自上場,70.1 是有驗證集的任務算術,TIES 到 73.6。上半與下半的 Validation 欄不同,70.1 和上半的 60.4 來自不同的選係數條件,不能混成同一條比較線。

原論文 Table 1(Yadav 等人),取自 PDF 第 6 頁。

TIES-Merging 的作者 Yadav 等人認為,損失來自兩種干擾。第一種是冗餘,微調時很多參數只動了一點點,這些小變化對任務幾乎沒有貢獻,加總時卻會稀釋別人的大變化。第二種是正負號衝突,同一個參數,任務 A 要它變大,任務 B 要它變小,直接相加就互相抵消。他們統計過,只合併兩個模型就會有衝突,模型越多,衝突的參數越多。TIES-Merging §3

拿三個任務、六個參數的小例子算一次,數字是為了示範編的:

python
import numpy as np

tau = np.array([[ 0.8, -0.1,  0.5,   0.02, -0.6, 0.3 ],   # 任務 A
                [-0.7,  0.4,  0.6,  -0.03,  0.1, 0.05],   # 任務 B
                [ 0.9, -0.2, -0.05,  0.01, -0.5, 0.4 ]])  # 任務 C

print("直接平均:", tau.mean(0).round(3))

# 1. Trim:每個任務只留絕對值最大的一半
k = tau.shape[1] // 2
cut = np.sort(np.abs(tau), axis=1)[:, -k][:, None]
trimmed = np.where(np.abs(tau) >= cut, tau, 0.0)
print(trimmed)

# 2. Elect:每個參數用剩下數值的總和投票,決定正負號
sign = np.sign(trimmed.sum(0))

# 3. Merge:只平均和投票結果同號的值
agree = (np.sign(trimmed) == sign) & (trimmed != 0)
ties = (trimmed * agree).sum(0) / np.maximum(agree.sum(0), 1)
print("TIES    :", ties.round(3))
text
直接平均: [ 0.333  0.033  0.35   0.    -0.333  0.25 ]
[[ 0.8  0.   0.5  0.  -0.6  0. ]
 [-0.7  0.4  0.6  0.   0.   0. ]
 [ 0.9  0.   0.   0.  -0.5  0.4]]
TIES    : [ 0.85  0.4   0.55  0.   -0.55  0.4 ]
圖:上面這段程式的計算過程,本文整理。

先看第 0 個參數。A 和 C 都要它變大(+0.8、+0.9),B 要它變小(−0.7),直接平均只剩 0.333。TIES 先讓三個任務投票,總和是正的,就只平均同號的 A 和 C,得到 0.85。

第 1 個參數是冗餘的例子。只有 B 認真改了它(+0.4),A 和 C 只動了 −0.1、−0.2,平均後被抵消成 0.033。把這些小值修剪掉,B 的 0.4 就留了下來。第 3 個參數,三個任務都只動了零點零幾,修剪後乾脆歸零。

方法的名字就來自這三步,修剪(Trim)、選出正負號(Elect sign)、只合併同號的值(Merge)。論文裡每個任務保留絕對值最大的 20%,作者事先確認過,只留兩成的任務向量,單一任務的表現和全部保留差不多。合併完一樣乘上係數 λ\lambda,再加回預訓練權重。

第 2 步看的是正負總量,+0.9+0.9 遇到兩個 −0.1-0.1,仍然選正。最後也只除以這一格留下的同號成員數,被修剪成 0 的成員不算。原論文用來支持「留兩成就夠」的是 T0-3B 的參數高效微調實驗,再把這個配方拿去測全參數的 T5 與 CLIP;自己的任務最好仍掃一次保留比例。

ViT-B/32 的八個任務上,有驗證集時,TIES 是 73.6%,比任務算術的 70.1% 高;沒有驗證集時是 72.4%,任務算術只有 60.4%。離各自微調的 90.5%,仍然差了一大截。

作者還做了一個上限實驗,從已訓練的多任務模型取出符號,代替 TIES 的總量投票。十一個參數高效微調任務上,這樣合併是 72.0%,多任務模型是 73.1%,原本 TIES 是 66.4%。方向選得更好,確實有很大的改善空間;只是這個 oracle 已經用過完整多任務訓練,實際部署時不能免費取得。

丟掉九成

2023 年 11 月的 DARE 走得更遠。它把每個微調模型和預訓練模型的差值(論文叫 delta 參數)隨機丟掉比例 pp,剩下的乘上 1/(1−p)1/(1-p)。

為什麼要乘回去?每個值被保留的機率是 1−p1-p,保留後放大 1/(1−p)1/(1-p) 倍,期望值剛好等於原本的值:

E[mi1−p δi]=1−p1−p δi=δi,mi∼Bernoulli(1−p)\mathbb{E}\left[\frac{m_i}{1-p}\,\delta_i\right] = \frac{1-p}{1-p}\,\delta_i = \delta_i,\qquad m_i \sim \text{Bernoulli}(1-p)

丟掉的比例可以非常大。作者觀察到,語言模型經過監督式微調,delta 參數大多在 0.002 以內,冗餘極高,丟掉 90% 甚至 99% 都不太影響能力;模型越大,能容忍的 pp 越高,到了 700 億參數,丟掉 99% 的影響也很小。DARE 只負責丟,丟完再交給任務算術或 TIES 合併。DARE §1

左圖把這個規模差別畫得很清楚。橫軸是丟棄率,縱軸是 GSM8K 準確率,7B 到 0.99 時急跌,70B 仍然接近原分數。右圖則換成合併後的三種評測,語言、數學、程式能力的保留要分開看。

原論文 Figure 1(Yu 等人),取自 PDF 第 1 頁。

delta 一大就不行,論文也寫得很清楚。經過持續預訓練的模型,delta 會到 0.03 左右,DARE 就失效。WizardCoder-Python-13B 是從 CodeLlama-13b-Python 微調來的,相對它的 delta 在 0.0002 以內,相對 Llama 2 卻常常超過 0.01;拿 Llama 2 當基底來丟,就會出問題。

這組失敗很劇烈,只丟 10%,HumanEval 和 MBPP 的 pass@1 就從 63.41、55.4 掉到 0。前面的期望值等式依然成立,但單次抽樣的變異數是 pδi2/(1−p)p\delta_i^2/(1-p);delta 大了,高丟棄率再把少數殘值放大,就很難保住輸出。0.002 是論文觀察到的尺度,還得配合各層與資料分布來看,不能拿來當所有模型通用的門檻。

當合併前處理時,DARE 也有輸有贏。兩個 13B 指令與數學專家用任務算術合併,GSM8K 原本是 66.34%,加 DARE 是 66.26%;改用 TIES,DARE 則把 15.77% 拉回 36.16%。三個專家一起合的任務算術,GSM8K 又從 58.45% 降到 56.48%。TIES 解決方向與平均時的干擾,DARE 減少差值的重疊,兩者修的是不同環節,搭配後仍要實測。

還有一件容易看錯。丟掉的是 delta,基底的完整權重一直留著,最後重建的仍是同樣大小的 dense 模型。保留 1% 改動,推論量沒有自動變成 1%;它幫忙的是合併和差值的稀疏化,部署加速要另外處理。

DARE 論文最後還用這套方法合併出一個 7B 模型,登上 Open LLM Leaderboard 7B 級的第一名,全程只用 CPU。

差不多同一時間,社群已經玩得很起勁。

不用 GPU 的煉金術

2023 年 11 月 5 日,Hugging Face 上出現一個叫 Goliath-120B 的模型。作者把兩個 Llama 2 70B 的微調版本 Xwin 與 Euryale 分段取出,交錯疊成一個更深的模型,合併時沒有再做梯度訓練。Goliath-120B 模型卡 這種拼法在社群叫 frankenmerge,名字取自科學怪人,意思是用不同模型的零件拼出一個新模型。嚴格說來,它一個權重都沒有平均。

拼裝用的工具是 Charles Goddard 寫的 mergekit。線性平均、SLERP、任務算術、TIES、DARE,以及直接疊層的 passthrough,都只要寫一份設定檔就能跑,記憶體不夠時用 CPU 也能合併。2024 年 3 月的論文說,它已經促成了上千個模型的合併。Upstage 的 SOLAR-10.7B 也用了同一種疊層當第一步,之後再接著做持續預訓練。MergeKit

「不用 GPU」說的是把來源張量讀出、混合、寫成一個新 checkpoint 的步驟。模型本來的訓練已經付過計算成本,合併後要評測或提供推論,還是得負擔完整模型的運算。Goliath 把層疊深後,推論的路徑和權重儲存也跟著變大;它省下了額外梯度訓練,沒有省掉 120B 級模型的部署需求。

這也讓「合併」這個名字包了不同操作。固定層數的權重插值維持原架構;passthrough 直接改變串接的層數;SOLAR 在疊層後再訓練,還多了一個學習階段。要比較是否便宜,至少得分開模型產生、評測與部署三個階段。

為什麼要走弧線

SLERP 全名是球面線性插值,出自 Ken Shoemake 1985 年一篇電腦動畫的論文,原本用來在兩個旋轉之間平滑過渡。2024 年初,它是社群最流行的合併法,只是一次只能合併兩個模型。

它想處理的事情,兩個向量就能看懂。兩個長度為 1、互相垂直的向量 (1,0)(1, 0) 和 (0,1)(0, 1),直接平均得到 (0.5,0.5)(0.5, 0.5),長度只剩 0.5≈0.707\sqrt{0.5} \approx 0.707。SLERP 沿著圓弧走,中點是 (0.707,0.707)(0.707, 0.707),長度維持 1:

slerp⁡(a,b;t)=sin⁡((1−t)Ω)sin⁡Ω a+sin⁡(tΩ)sin⁡Ω b,cos⁡Ω=a⋅b∥a∥ ∥b∥\operatorname{slerp}(a, b; t) = \frac{\sin\big((1-t)\Omega\big)}{\sin\Omega}\,a + \frac{\sin(t\Omega)}{\sin\Omega}\,b,\qquad \cos\Omega = \frac{a \cdot b}{\lVert a\rVert\,\lVert b\rVert}
圖:本文整理的示意。

社群的說法是,高維空間裡的直線混合會讓權重向量變短,權重方向的變化也往往比長度更有意義。Labonne,2024-01-09 上面的長度比較用的是等長單位向量;實際模型每一層的範數與夾角還要量。若兩個微調模型相對共同基底的改動很小、彼此夾角也很小,sin⁡Ω≈Ω\sin\Omega\approx\Omega,公式的兩個係數就會接近 1−t1-t 和 tt,SLERP 因而接近線性插值。這是公式的小角度近似,單靠 DARE 報告的某個 delta 絕對值,還推不出整個模型的夾角。後面會看到,Cohere 在 1,110 億參數模型上試過 SLERP,沒有看到明顯的好處。

排行榜

2024 年 1 月 9 日,Maxime Labonne 在 Hugging Face 部落格寫了一篇 mergekit 教學,開頭說,合併是做新模型的便宜方法(不需要 GPU),在 Open LLM Leaderboard 上產生了不少頂尖模型。他自己用 SLERP 合併的 Marcoro14-7B-slerp,在 1 月初成為排行榜上最好的 7B 模型。同一篇文章裡,他也直接寫道,合併最好的模型,也會把它們的污染一起合進來,「可以放心假設 Marcoro14-7B-slerp 被污染了」。Labonne,2024-01-09

污染(contamination)指評測題目混進了訓練資料。排行榜的題目是公開的,有人會拿題目訓練模型;合併模型的問題在於很難查,一個合併模型的父母可能也是合併來的,每一代又各自做過微調。

2024 年 3 月,Sakana AI 發表演化式模型合併。論文開頭寫著,Open LLM Leaderboard 現在被合併模型占據,合併也被很多人看成一種「黑魔法或煉金術」,靠的是作者的直覺。他們的解法是讓演化演算法去搜尋合併配方,並搜尋資料在不同模型的層之間怎麼流動。合併出來的日文數學模型 EvoLLM-JP 只有 7B,在日文數學評測 MGSM-JA 上拿到 52.0,在幾項日文評測上也勝過先前幾個 70B 的日文模型。Akiba 等人

後續版本把這組設定交代得更完整。來源是三個 Mistral-7B 系列的日文、數學模型,主結果每個來源只搜尋 density 和 weight,沒有必要逐層加滿自由度;搜尋用另外翻譯的 1,069 道題,最終 MGSM-JA 的 250 題保留不動。參數空間合併是 52.0%,再接資料流搜尋可到 55.2%,模型也從 7B 增成 10B。配方由測試任務以外的資料決定,這才有空間檢查能力是否真的遷移。Akiba 等人 §3.1

原圖用層的顏色區分這幾種操作。PS 把來源張量混成新張量,DFS 選來源層與經過次序,兩者一起做時,才同時改張量內容與資料流。三種搜尋最後得到的模型大小與前向路徑,也可能不同。

原論文 Figure 1(Akiba 等人),取自 PDF 第 5 頁。

這時候,排行榜已經把合併模型預設隱藏起來。3 月 11 日,一位合併模型的作者開了討論串抗議。他的模型多次拿到第一名,卻因為帶著 merge 標籤被藏起來,和被標記、被刪除的模型放在一起,形同被貼上負面標籤。

Hugging Face 的 Clémentine Fourrier 回覆,根本原因是幾乎不可能看清楚模型的血統。微調一個 Llama,你知道基底模型和微調資料;合併模型卻有「合併的合併的合併、還有已刪除的模型」,資料內容難以追溯,很容易不小心被污染。經過幾輪合併、微調、再合併、DPO 之後,這些模型的學術分數往往無法轉換成實際使用的表現。「所以它們預設被隱藏。」Open LLM Leaderboard 討論 #629

這場爭議同時牽涉來源透明度與評測選擇。把一份評測分數當成挑父模型、挑係數的依據,做過很多次之後,那份評測就已參與配方搜尋;是否碰過原始測試題,還要另外查資料血統。對合併模型的判斷,最好保留一份未參與選配方的測試,再看實際用途的輸出。討論串提出了污染疑慮與管理理由,沒有逐一證實每個合併模型都受污染。

走進訓練流程

排行榜之外,合併也在各家自己的訓練流程裡普及了。

公開技術報告裡最常見的,是把同一套配方跑出來的幾個結果平均:

  • Llama 3(2024 年 7 月):獎勵模型、SFT、DPO 每個階段,都把用不同版本的資料或超參數跑出來的模型平均。Llama 3 §4.1.5 影像能力的 SFT 先掃一輪超參數,按表現排序,平均前 K 名;作者寫道,平均後的模型一致比格點搜尋找到的最好單一模型好,對超參數也比較不敏感。Llama 3 §7.5.2
  • Gemma 2(2024 年 7 月):把同一套後訓練流程用不同超參數跑出的模型平均,引用的是 Google DeepMind 的 WARP。Gemma 2 §4
  • OLMo 2(2024 年 12 月):7B 模型的 mid-training,同一份 50B tokens 的資料用三種順序各跑一次再平均。六種資料配方都試過,平均後等於或優於其中最好的一份。OLMo 2 Table 14
  • Tülu 3(2024 年 11 月):試過把不同種子的 SFT 模型做成湯,發現最好的單一種子和最好的湯差不多,最後為了一致,直接用最好的那一次。Tülu 3 Table 14

Tülu 3 那一條值得留意,平均也有沒幫上忙的時候。

預訓練也開始用。字節跳動 Seed 團隊的 PMA,在固定學習率下平均檢查點,從 4.11 億參數的稠密模型一路試到 2,000 億參數的 MoE;平均出來的模型表現更好,也能提早預測學習率退火之後的表現。螞蟻集團的 WSM 更進一步,用檢查點合併取代學習率的衰減階段。PMA、WSM

這幾種做法平均的對象也有差別。SWA 與固定學習率的 checkpoint averaging 收的是同一條軌跡的時間點;Model Soups 與不同資料順序的實驗,則從共同 checkpoint 分岔,再各自訓練。前者需要決定從哪裡開始收樣、收多長;後者需要決定哪些分支能進湯。共同的工程條件,是保持相容的參數座標,並在平均後重新檢查任務表現。

六個專家,兩鍋湯

Cohere 在 2025 年 4 月發表的 Command A 技術報告,把合併放在流程的正中央。

圖:本文依 Command A 技術報告 Figure 3 與 DeepSeek-V4 技術報告 §5.1 整理。

1,110 億參數的 Command A 先訓練一個基本的指令模型。從這個模型出發,分頭訓練程式、安全、RAG、數學、多語言與長上下文通用能力六個專家。六個 SFT 專家合併成一個「SFT 湯」,再從湯出發做各領域的偏好最佳化與強化學習,得到報告所稱的六個 RL 專家,再合併一次,最後打磨。Command A §3

合併用的是最簡單的線性加權平均,權重靠經驗法則加上暴力搜尋。報告寫道,他們試過 SLERP 和任務向量這些更複雜的方法,沒有明顯的進步,複雜度卻增加了。線性合併在工程上還有一個好處,合併的合併仍然可以寫成一次合併,整條流程比較好追蹤。

但係數要一路保留下來。先平均 A、B,再和 C 各取一半,得到的是 0.25A+0.25B+0.5C0.25A+0.25B+0.5C;它能攤平成一次線性合併,和三個模型等權平均的 13(A+B+C)\tfrac13(A+B+C) 卻有不同配方。共同起點之外,記錄每層來源、每步係數與途中是否再訓練,才能知道最後的模型是怎麼來的。

結果,合併後的模型和各領域最好的專家相比,平均只掉了 1.8%,大多數指標都在 2.5% 以內,掉最多的是程式。在這個規模下,就算大幅調動專家的權重,對應領域的表現也只變動 2% 到 3%。合併完再用低學習率做少量 SFT,很多指標就能回到、甚至超過專家。Command A §4.9

這裡可以直接看合併掉了哪些分數。左圖把指標按「合併分數減去專家分數」分組,右圖再按領域平均,誤差線是標準差。程式那一欄下降較多,RAG 比較接近零;整體平均很小,仍可能掩蓋某一類工作比較明顯的損失。

原論文 Figure 12(Team Cohere),取自 PDF 第 35 頁,CC BY 4.0。

報告裡幾條經驗,讀起來很像當年那張圖的延伸:

  • 共同的起點:所有專家都從同一個通用的指令模型出發。工具呼叫用的特殊 token 也一樣,大家從同一個起點出發、照常合併,效果比只從訓練過這些 token 的專家挑出來合併好得多。
  • 留一法:每次拿掉一個專家再合併,找出拖累其他能力的專家。為了減少這種衝突,每個專家的訓練資料都摻一點其他領域的資料;連共同資料的風格或格式有些微差異,都會造成衝突。
  • 合併很便宜,評測很貴:最後的模型參考了 500 個評測指標,每個合併候選都要花大量的推論算力評估。

讓模型少想一點

推理模型興起之後,合併也被拿來縮短模型的思考。

Kimi k1.5 的報告(2025 年 1 月)把長思考鏈模型和短思考鏈模型的權重直接平均,改善了 token 效率。不過在他們的比較裡,平均並不是最好的;專門設計的 long2short 強化學習,token 效率最高。Kimi k1.5 §2.4、§3.4

這裡要同時看答題表現與生成長度。只把模型弄得更不會推理,也會讓回答變短,卻失去原本要保留的能力。Kimi 把不同方法放在成績與 token 數的關係裡比較;權重平均是免額外訓練的候選,rejection sampling、DPO、long2short RL 則利用額外學習換取更好的長度與正確率取捨。合併最便宜的那一步,仍然需要和訓練方法放在同一張取捨圖上看。

德國的 TNG Technology Consulting 在 2025 年 4 月做了一個更大的。他們把 DeepSeek-V3-0324 和 DeepSeek-R1 這兩個 6,710 億參數的 MoE 模型組成 R1T Chimera。注意力層與共享專家沿用 V3-0324,路由專家的權重則整組取自 R1。依他們自己的評測,Chimera 保留了 R1 的推理表現,輸出的 token 少了約 40%。報告還提到,他們用不同比例插值出的一系列中間模型,幾乎沒有一個是壞的。Assembly of Experts

成績單

這幾年,研究端也累積了不少系統性的比較,結論比各篇方法論文保守。

Yang 等人的綜述在 2025 年底的版本裡,用統一的設定重跑了一輪。ViT-B/32 合併八個影像任務,各自微調的上限是 90.3%,直接平均只有 66.5%,加權與子空間類的方法能縮小一部分差距。換到 Llama-3.1-8B 合併五個領域專家,所有方法都落在預訓練模型和專家之間,最好的也只有專家的 84.8%;更複雜的子空間或加權方法,有時還不如最基本的任務算術。Yang 等人 §3.2

Yadav 等人在 2024 年把規模拉到 640 億參數,用不同大小的 PaLM-2 訓練專家再合併。他們把兩種基底、四種大小、四種方法、2/4/6/8 個專家放進同一個矩陣。大模型和指令微調過的基底通常更好合,64B 的 IT 基底合併八個專家時,四種方法的 held-in 都是約 0.93。換到 24B,相同設定的平均權重是 0.77、任務算術是 0.92,方法的差距仍然很明顯。Yadav 等人

這裡 held-in 除以各自專家的成績,held-out 則除以基底。64B 的八專家任務算術,在新任務上的比值是 1.09,優於多任務訓練的 1.05;但學過任務的 0.93 又低於多任務模型的 0.99。它支持的是一種取捨,合併保留了可用的專家能力,也可能讓新任務的泛化更好,兩項指標要一起看。

64B 的四種方法在這兩張柱狀圖裡幾乎重疊。左邊的 1.0 是單任務專家,右邊的 1.0 是 PaLM-2-IT 基底;相同的高度在兩張圖裡有不同的分母。合併八個專家時,右邊超過基底,左邊仍未回到專家水準。

原論文 Figure 7 右側兩張 64B 子圖(Yadav 等人),取自 PDF 第 10 頁,CC BY 4.0。

TMLR 在 2026 年 3 月刊出的一篇研究,看的是更接近實際的情況。每個基底模型找來 12 個 Hugging Face 上公開的微調版本,它們的訓練目標可能重疊,甚至互相衝突;四個模型、16 項評測、六類合併方法比下來,簡單的任務算術最穩定,進步幅度有限。TIES 與 Model Stock 大致靠近基底,TSV-Merge、Iso-C 則隨版本增加而退步,TA 加 Subspace Boosting 仍接近 TA 自己的趨勢。Hitit 等人

尤其要注意這份研究的 normalization 開著,λ=1\lambda=1 的任務算術實際取各差值的平均;若直接加總十二份差值,尺度會放大十二倍。附錄關掉 normalization 後,成績對 λ\lambda 明顯敏感。這也是合併配方常被低估的一部分,同樣寫「TA」或「TIES」,還有正規化、保留比例與尺度要對齊。

把原圖上下放在一起看,少抄一個 normalization 設定的差別就很大。兩圖的橫軸都是 λ\lambda、縱軸都是平均準確率,顏色是四種基底。上圖開啟 normalization,在一般係數範圍內大致平穩;下圖關閉後,係數往上加,表現便快速下滑。上圖最右還多測了 10,橫軸顯示的是列出的係數位置。

原論文 Figure 11(Hitit 等人),取自 PDF 第 26 頁。
原論文 Figure 12(Hitit 等人),取自 PDF 第 26 頁。

這份研究也分開問「是否超過基底」和「是否超過整個模型池最好的微調版本」。前者做到,後者仍可能失敗。Llama 3.1 8B 就有一個很強的現成版本,合併始終沒超過它。合併產生了新 checkpoint,價值還是得和原本可選的模型比較。

然後是 DeepSeek-V4。2026 年 4 月的技術報告裡,DeepSeek 同樣先為數學、程式、agent、指令遵循等領域各訓練一個專家,每個專家都做過 SFT 和 GRPO 強化學習。整合的方式卻是多教師的同策略蒸餾(on-policy distillation),讓學生模型自己生成回答,再向十多個專家老師學習它們在這些回答上的輸出分布。報告寫道,專家的知識因此在 logit 的層次對齊到同一組參數裡,「實際上避開了傳統權重合併或混合強化學習常見的效能衰退」。DeepSeek-V4 §5.1

Cohere 和 DeepSeek 都先培養領域專家,差別在整合的空間。Command A 直接組合相容的權重;V4 讓學生在自己生成的路徑上,學習老師給出的機率分布。前者省掉整合時的梯度訓練,後者花額外訓練,把不同老師的行為教進學生。兩份報告的模型、資料、目標都不同,這兩個案例沒有構成合併與蒸餾誰普遍更好的對照實驗。

再把常一起出現的 MoE 放進來,幾個選項就清楚了:

整合方式最後保留什麼推論時怎麼跑主要要確認的條件
權重平均/任務向量一份同架構模型原架構的一次前向基底、張量語意與能力是否相容
固定路徑疊層選出的來源層每次走同一條新路徑表示銜接、深度與推論成本
MoE多組內部專家與路由每個 token 選部分專家路由、負載與儲存的專家權重
多教師蒸餾學生模型學生自己的架構老師評分、訓練資料與學生容量

本文依前面的模型與流程整理。這些操作可以搭配,例如把多個完整領域模型蒸餾到一個本身採 MoE 架構的學生。

Command A 的「六個專家」是六個完整 checkpoint,和 MoE 層內的專家模組是不同層次。V4 選用蒸餾,也仍然可以保留 MoE 的稀疏推論架構;Chimera 則直接替換既有 MoE 裡的一組參數。先分清楚整合的對象與部署路徑,才知道各自省的是哪一段。

合得快,怎麼還要測這麼久

到這裡,評測成本已經出現好幾次。貪婪湯每試一個成員,就要跑一次選模資料;演化合併做上千個候選;大型研究把不同基底、規模、任務子集交叉展開。逐參數相加只是讀寫張量,真正要知道「這一份能不能用」,還得讓完整模型處理各種輸入。

如果自己要做一輪比較,可以先固定資料與提示,保留基底、最好單一模型、線性平均三個參考,再把方法參數放進小範圍搜尋。選配方的驗證資料與最後測試分開,測試同時看要增加的能力、不能丟的能力,以及回答長度或拒答等行為。像 Command A 的留一法,還能指出某個來源加進去究竟改善了什麼、犧牲了什麼。

這些比較會決定哪種方法值得留下。若線性平均已經足夠,沒有必要先加上更複雜的投影;若重要能力持續掉分,可以再比合併後的少量訓練、重新安排專家資料,或蒸餾。評測資料若只剩排行榜那幾項,配方很容易只學會迎合那幾項。

所以,相加除以二有沒有用?

回到標題,答案要看你平均的是什麼:

  1. 同一個起點、同一個任務:不同種子、不同超參數、同一次訓練的不同時間點。這是最穩的一種,從 SWA、Model Soups 到 Llama 3、OLMo 2,已經寫進不少公開的訓練流程;偶爾也會像 Tülu 3 那樣,平均了也沒有比較好。
  2. 同一個起點、不同的能力:任務算術、TIES、DARE,還有 Command A 的專家合併。有用,但通常比不上各自的專家。在大模型上,簡單的線性合併常常就夠;專家之間保持一致,比各自衝到最高分重要。DeepSeek-V4 在這一步改用了蒸餾。
  3. 不同的起點:要先處理神經元的排列,網路還要夠寬,才有機會接近零障礙。大型語言模型幾乎都繞過了這一題,因為大家都從同一個預訓練模型出發。

如果你手上剛好有幾個從同一個基底微調出來的模型,先試最笨的線性平均,係數用驗證集挑;模型一多,可以學 Cohere 做一下留一法,看看是誰在扯後腿。評測集夠不夠完整,對結果的影響可能比挑哪一種合併方法更大。

十年前,FedAvg 的作者擔心平均兩個模型會得到任意糟糕的結果。後來的研究逐步找到比較可靠的條件,共享訓練路徑、相容的參數座標、受控制的微調改動,以及真的能檢查退化的評測。要把不同的本事放進同一組權重,每一項都得留心。

合併只要相加除以二。

麻煩的是除完之後,還有 500 個評測等著跑。