回到部落格
一般文章

圖解梯度下降法

1847 年,Cauchy 為了算天體軌道,寫下「沿著負梯度走一步」。今天訓練大型語言模型,optimizer.step() 做的還是同一件事,只是這一步怎麼走,已經長出 SGD、Adam、AdamW、Lion、Muon 一整個家族。用十二個包裹的運費畫出一道斜斜的山谷,配上三十多張即時計算的動圖,看每個方法補上了前一個方法的哪個缺口。

打開一份 PyTorch 的訓練程式,迴圈裡幾乎都有這兩行:

python
loss.backward()
optimizer.step()

backward() 算出每個參數該往哪個方向改,step() 真的動手去改。這篇要講的,就是 step() 裡面那幾行。

方向都已經算好了,照著走不就好了?聽起來沒什麼好講。可是光是「這一步怎麼走」,從 SGD、Momentum、AdaGrad、Adam、AdamW 一路到 Lion、Muon,長出了一整個家族。每個新方法出現,幾乎都是因為前一個方法在某種地形上走不好。

我們從最基礎的地方開始,用一條直線和十二個包裹。先把「梯度」畫出來,再讓它走過狹長的山谷、隨機的雜訊、懸崖和鞍點,看每個方法補上了前一個方法的哪個缺口。

出發前,先看一眼整條路線。每一列是一個方法,後面寫的是它要補的缺口:

每個方法,補的是哪一個缺口從 BGD 出發,每一行寫出這個方法要補的缺點。

基本款

  1. BGD起點:每一步都看完全部資料。
  2. SGD · MBGD每步看完全部資料太慢 → 抽一筆或一小批。
  3. SGDM之字形與雜訊 → 累積速度。
  4. NAG動量衝過頭 → 在前方的位置算梯度。

每個參數各自的步長

  1. AdaGrad所有參數共用一個學習率 → 依累積梯度各自縮放。
  2. RMSProp · AdaDeltaAdaGrad 的學習率只降不升 → 改用會遺忘的移動平均。
  3. Adam · Nadam合併動量與各自的步長,並修正從零起步的偏差。

修補 Adam

  1. AMSGradAdam 可能收斂到錯的地方 → 讓 v 不再變小。
  2. AdamWL2 正則化在 Adam 裡被除掉 → 把權重衰減拆出來。
  3. Warmup · Cosine · SGDR · RAdam · Schedule-Free學習率要怎麼變?Adam 為何要暖身?→ 排程、修正變異,或乾脆不排程。

規模與幾何

  1. LARS · LAMB超大 batch 時各層 ‖w‖/‖g‖ 差很多 → 逐層信任比。
  2. Adafactor · GaLore優化器狀態吃掉記憶體 → 分解它,或放進低秩子空間。
  3. SAM低損失卻落在窄谷 → 比較 ρ 範圍內最壞的損失。
  4. Shampoo · SOAP · Sophia對角縮放救不了斜的山谷 → 矩陣預條件,或曲率加裁剪。
  5. Lion更少的狀態與計算 → 只取正負號。
  6. Muon權重是矩陣,不是一長串數字 → 把整個更新正交化。

文中的動圖都在你的瀏覽器裡即時計算,每一步用的就是文章寫出來的那條公式。按下暫停,可以拖著滑桿一步一步看。

從一條直線開始

假設你在網路上開了一家小店,最近寄出 12 個包裹。重量從 0.5 到 1.5 公斤,運費從 92 元到 150 元不等。

運費看起來大致是「基本費+每公斤加價」,可以寫成一條直線:

y^=wx+b\hat y = w x + b

xx 是重量(公斤),y^\hat y 是預測的運費(以百元為單位),ww 是每公斤加多少,bb 是基本費。我們要從這 12 筆紀錄裡,找出最合適的 ww 和 bb。

先隨便猜一組,每公斤 210 元、基本費 20 元,也就是 w=2.1w = 2.1、b=0.2b = 0.2。這條線太陡了,12 個包裹的預測全都比實際貴,最輕的那個多算了 32 元,最重的多算了 185 元。

怎麼衡量「猜得多差」?把每個包裹的誤差平方,再取平均:

L(w,b)=12n∑i=1n(wxi+b−yi)2L(w,b) = \frac{1}{2n}\sum_{i=1}^{n}\left(w x_i + b - y_i\right)^2

平方讓正負誤差不會互相抵銷,也讓差很多的包裹被罰得更重。前面的 12\frac{1}{2} 只是為了等一下求導數時,把平方帶下來的 2 消掉。

這個 LL 叫做損失函數(loss function)。代入我們猜的那一組,L=0.71L = 0.71。

接下來是整篇最重要的觀念。

每一組 (w,b)(w, b) 都是一條直線,也都對應一個損失值。把 ww 當橫軸、bb 當縱軸,在平面上每一點標出它的損失,就得到一張地形圖。損失越低,地勢越低。找最好的直線,就是在這張地形上找最低點。

每一條直線,都是地形上的一個點左邊是 12 個包裹和目前的直線,右邊是每一組 (w, b) 的損失。在右圖點一下或拖曳,可以自己挑一條線。
0.511.5012重量(公斤)運費(百元)
012-1012w(每公斤)b(基本費)
每公斤 0 元+基本費 120 元L = 0.016

地形圖上一圈一圈的曲線是等高線,同一圈上每一點的損失都相同,越靠近中間的星號,損失越低。星號在 w≈0.59w \approx 0.59、b≈0.61b \approx 0.61,也就是每公斤 59 元、基本費 61 元,這時 L≈0.0005L \approx 0.0005。

注意這張地形的形狀。它是一條斜斜的、又窄又長的山谷。這個形狀會跟著我們走完整篇文章,後面很多方法都在想辦法對付它。

斜率與梯度

站在地形上的某一點,怎麼知道哪邊是下坡?

先簡化一下。把 bb 固定在最佳值,只動 ww,地形就只剩一條曲線。曲線上任一點的切線斜率,就是導數 dLdw\frac{dL}{dw}:

斜率告訴我們,往哪邊是下坡把 b 固定在最佳值,只動 w。橘色線是切線,它的斜率就是導數 dL/dw。
012012w(每公斤)損失 L
w = -0.40dL/dw = -1.08斜率 < 0:下坡在右邊

斜率是正的,代表 ww 變大、損失跟著變大,下坡在左邊;斜率是負的,下坡在右邊;斜率是 0,就到谷底了。往斜率的反方向走,就是往下坡走。

兩個參數都能動的時候,每個參數各有一個偏導數,也就是「只動它、其他不動」時的斜率。對我們的損失函數算一下:

∂L∂w=1n∑i=1n(wxi+b−yi) xi\frac{\partial L}{\partial w} = \frac{1}{n}\sum_{i=1}^{n} (w x_i + b - y_i)\,x_i ∂L∂b=1n∑i=1n(wxi+b−yi)\frac{\partial L}{\partial b} = \frac{1}{n}\sum_{i=1}^{n} (w x_i + b - y_i)

把它們排成一個向量,就是梯度(gradient):

∇L=(∂L∂w, ∂L∂b)\nabla L = \left(\frac{\partial L}{\partial w},\ \frac{\partial L}{\partial b}\right)

這兩個式子讀起來不難。每個包裹的誤差,乘上這個參數對它的影響力,再取平均。bb 對每個包裹的影響都是 1;ww 的影響是包裹的重量 xx,越重的包裹,對 ww 的意見越大。

在起點 (2.1, 0.2)(2.1,\ 0.2),12 個包裹全都被高估,算出來 ∇L≈(1.24, 1.10)\nabla L \approx (1.24,\ 1.10)。兩個分量都是正的,表示 ww 或 bb 再調大,損失都會變大。

梯度垂直於等高線,指向上坡箭頭只畫方向。虛線是通過這一點的等高線;−∇L 是下坡最陡的方向。
012-1012w(每公斤)b(基本費)∇L−∇L
∇L = (1.04, 0.95)‖∇L‖ = 1.41

圖上可以看到梯度的兩個性質:

  1. 它指向上坡最陡的方向,所以 −∇L-\nabla L 是下坡最陡的方向。
  2. 它和通過這一點的等高線垂直。

為什麼?在某一點 θ=(w,b)\theta = (w, b) 附近走一小步 Δ\Delta,損失的變化大約是

L(θ+Δ)≈L(θ)+∇L⋅ΔL(\theta + \Delta) \approx L(\theta) + \nabla L \cdot \Delta

這是一階泰勒展開。點積可以寫成 ∇L⋅Δ=∥∇L∥ ∥Δ∥cos⁡φ\nabla L \cdot \Delta = \lVert\nabla L\rVert\,\lVert\Delta\rVert \cos\varphi,φ\varphi 是梯度和這一步之間的夾角。步長固定時,φ=180∘\varphi = 180^\circ,也就是和梯度反方向走,損失降得最多。沿著等高線走,損失不變,∇L⋅Δ=0\nabla L \cdot \Delta = 0,夾角是 90∘90^\circ,所以梯度和等高線垂直。

BGD:沿著負梯度走

知道下坡的方向,剩下的就簡單了。每次往 −∇L-\nabla L 走一小步,然後重複:

θt+1=θt−η ∇L(θt)\theta_{t+1} = \theta_t - \eta\, \nabla L(\theta_t)

η\eta(eta)是學習率(learning rate),決定一步走多遠。這就是梯度下降法。因為每一步都用全部 12 個包裹來算梯度,所以也叫批次梯度下降(Batch Gradient Descent,BGD)。

這個想法比電腦還早。目前找得到最早的書面紀錄,是 Cauchy 在 1847 年 10 月 18 日法國科學院會議上的三頁短文〈Méthode générale pour la résolution des systèmes d'équations simultanées〉,刊在《Comptes Rendus》第 25 卷第 536 至 538 頁。他要解的是決定天體軌道的聯立方程,做法是把每條方程平方後相加,再沿著負偏導數的方向,讓這個總和一路變小。當時還沒有固定的學習率,Cauchy 給了幾種選法,其中一種是沿著這個方向一直找,找到函數最小的那一點才停。

用 η=0.5\eta = 0.5 走第一步:

θ1=(2.1, 0.2)−0.5×(1.24, 1.10)=(1.48, −0.35)\begin{aligned} \theta_1 &= (2.1,\ 0.2) - 0.5 \times (1.24,\ 1.10) \\ &= (1.48,\ -0.35) \end{aligned}

損失從 0.71 掉到 0.040,一步就少了九成多。

沿著負梯度,一步一步走批次梯度下降,η = 0.5,從「每公斤 210 元+基本費 20 元」出發。
0.511.5012重量(公斤)運費(百元)
012-1012w(每公斤)b(基本費)
每公斤 60 元+基本費 60 元L = 0.0005

第一步很漂亮。接下來呢?

點掉進山谷之後,就沿著谷底慢慢爬。包裹那張圖上的直線早就貼近資料了,之後一百多步都只是在微調,要到第 168 步,才進入離最低點 0.03 以內的範圍。

為什麼這麼慢?把 η\eta 調大一點,會不會好一些?

學習率:一步要走多遠

先回到最簡單的情況,一維的碗 f(u)=12au2f(u) = \frac{1}{2} a u^2。aa 是碗的曲率,也就是二階導數,越大碗越陡。梯度是 aua u,所以每一步:

ut+1=ut−η a ut=(1−ηa) utu_{t+1} = u_t - \eta\, a\, u_t = (1 - \eta a)\, u_t

每走一步,uu 就乘上一次 (1−ηa)(1 - \eta a)。

同一個碗,四種步長f(u) = ½u²,曲率是 1。四組都從 u = −2.4 出發。
η = 0.1:龜速
η = 0.9:很快
η = 1.6:左右擺盪
η = 2.1:發散
飛出畫面

圖裡 a=1a = 1,四組只差在 η\eta:

  • η=0.1\eta = 0.1:每步只縮小 10%,慢慢爬。
  • η=0.9\eta = 0.9:每步只剩 10%,很快到底。
  • η=1.6\eta = 1.6:1−ηa=−0.61 - \eta a = -0.6,每一步都跨到對面,但越跨越近,擺盪著收斂。
  • η=2.1\eta = 2.1:1−ηa=−1.11 - \eta a = -1.1,每一步跨到對面還更遠,越盪越大,發散了。

所以收斂的條件是 ∣1−ηa∣<1|1 - \eta a| < 1,也就是 η<2/a\eta < 2/a。碗越陡,學習率就得越小。

又窄又長的山谷

我們的地形是二維的,麻煩在於它有兩種曲率。

橫切過山谷,地形很陡;順著谷底往前,地形非常平。用線性代數的話說,這是損失的二階導數矩陣(Hessian)的兩個特徵值,在這個例子裡分別是 2.05 和 0.045,相差 46 倍。這個比值叫做條件數(condition number),記作 κ\kappa。

同一個 η\eta 要同時照顧兩個方向。為了不在陡的方向發散,η\eta 必須小於 2/2.05≈0.982/2.05 \approx 0.98;可是在平的方向上,每一步最多只能縮小 0.98×0.045≈4.4%0.98 \times 0.045 \approx 4.4\%,至少要走上幾十步。η\eta 大一點,陡的方向來回彈跳;η\eta 小一點,平的方向走不動。

又窄又長的山谷同樣的包裹、同樣的 η = 0.9,只改變重量的寫法。
-1012-1012wb
η = 0.9第 93 步進入最低點 0.03 以內

η=0.9\eta = 0.9 時,點在陡的方向上來回跳,走成之字形,一邊沿著谷底慢慢前進,第 93 步才到。

這個山谷為什麼是斜的?谷底的方向大約是 (1,−1)(1, -1),也就是 ww 加 1、bb 減 1。對一個 1 公斤的包裹來說,預測運費 w×1+bw \times 1 + b 完全沒變。這 12 個包裹的平均重量剛好是 1 公斤,所以沿著這個方向調整,整體的預測幾乎不受影響,損失也幾乎不變。斜率和截距互相抵銷,就形成了一道斜斜的谷。

點一下圖上的「減掉平均」,把每個包裹的重量都減掉 1 公斤,模型變成 y^=w(x−1)+b′\hat y = w(x - 1) + b'。能畫出來的直線完全一樣,但 ww 和新的截距 b′b' 不再互相牽制,山谷轉正了,條件數降到 10.9,第 46 步就到。再除以標準差,也就是「標準化」,斜率也換成新的 w′w',兩個方向的曲率變得一樣,山谷變成圓碗,條件數是 1,兩步就到了。

這就是訓練前常要把輸入標準化的原因。可是在深度網路裡,參數動輒上億個,每一層的輸入還一直在變,我們沒辦法一一替地形調整形狀。

後面的方法,大致從三個方向下手:

  1. 記住剛才走過的方向,讓來回的彈跳互相抵銷(動量)。
  2. 每個參數用不同的步長(AdaGrad、RMSProp、Adam)。
  3. 估計地形的形狀,或換一把尺來量一步(牛頓法、Shampoo、Muon)。

撞上懸崖

學習率太大會發散。有時候學習率不大,也會被一步甩出去。

撞上懸崖的那一步緩坡在 u = 2.4 撞上一道陡牆。兩邊都用 η = 0.6,右邊把梯度的大小限制在 1 以內。
不裁剪
-2-1012024uL
裁剪到 1
-2-1012024uL

這個地形是一段緩坡接著一道陡牆。點順著緩坡走到牆邊,有一步剛好踩上牆面。牆上的梯度非常大,下一步直接被彈到 u=−5.8u = -5.8,飛出畫面。它花了快十步爬回牆邊,接著又踩上牆面,又被彈出去;40 步裡被彈了三次,其中兩次直接飛出畫面。

真實的 RNN 裡也有這種牆。Pascanu、Mikolov 和 Bengio 在 2013 年分析 RNN 為什麼難訓練時,提出一個假說。梯度爆炸的方向上,曲率通常也很大,損失曲面會形成一道陡牆,一步踩上去,就被甩出原本的山谷。他們在 On the difficulty of training recurrent neural networks 裡用只有一個隱藏單元的 RNN 畫出了這種牆。

解法很直接,梯度太大時就把它縮小。最常見的是按範數裁剪(clip by norm):

g←g⋅min⁡ ⁣(1, c∥g∥)g \leftarrow g \cdot \min\!\left(1,\ \frac{c}{\lVert g \rVert}\right)

梯度的長度超過 cc,就縮到 cc,方向不變。「裁剪到 1」那一格把梯度大小限制在 1,點一直在牆邊小幅來回,沒有飛走。在 PyTorch 裡,這就是 torch.nn.utils.clip_grad_norm_。

cc 要設多少?Pascanu 等人的建議是先觀察一段時間的平均梯度範數,取它的一半到十倍之間,都還能收斂,只是速度會受影響。

SGD 與 MBGD:一次只看幾筆

BGD 每走一步,都要把全部資料看過一遍。12 個包裹無所謂;換成 ImageNet 的 128 萬張訓練圖片,每走一步,就得先讓 128 萬張圖都跑過一次前向和反向傳播。

隨機梯度下降(Stochastic Gradient Descent,SGD)每一步只隨機抽一筆資料,用它的梯度代替全體的梯度:

θt+1=θt−η ∇ℓit(θt)\theta_{t+1} = \theta_t - \eta\, \nabla \ell_{i_t}(\theta_t)

ℓi\ell_i 是第 ii 筆資料自己的損失,iti_t 是第 tt 步抽到的那一筆。

只看一筆,梯度當然不準。但如果每一筆被抽到的機會都一樣,它的期望值剛好就是全體的梯度:

Ei[∇ℓi(θ)]=1n∑i=1n∇ℓi(θ)=∇L(θ)\mathbb{E}_{i}\big[\nabla \ell_i(\theta)\big] = \frac{1}{n}\sum_{i=1}^{n} \nabla \ell_i(\theta) = \nabla L(\theta)

平均來說方向是對的,只是每一步都帶著雜訊。

折衷的做法是每次抽一小批(batch),例如 4 筆,把它們的梯度平均起來。這叫小批次梯度下降(Mini-Batch Gradient Descent,MBGD)。批次越大,雜訊越小;梯度的變異數大致和批次大小成反比。

每一步看 12 筆、4 筆,還是 1 筆三種都用 η = 0.5。左圖是單筆版本目前的直線,圈起來的是它這一步抽到的包裹。
0.511.5012重量(公斤)運費(百元)
012-1012w(每公斤)b(基本費)
BGD(12 筆):已讀 2400 筆 · 第 168 步進入最低點 0.03 以內MBGD(4 筆):已讀 800 筆 · 第 169 步進入最低點 0.03 以內SGD(1 筆):已讀 200 筆 · 第 178 步進入最低點 0.03 以內

三條路線用同樣的 η=0.5\eta = 0.5。BGD 走得最平順;MBGD 一路微微晃動;SGD 抖得最厲害,包裹那張圖上圈起來的,就是它這一步抽到的包裹。

可是看一下讀了多少資料。三者大約都在第 170 步前後進入最低點 0.03 以內,BGD 每步讀 12 筆,到達時已經讀了 2,016 筆;MBGD 讀了 676 筆;SGD 只讀了 178 筆。以讀過的資料量來算,抖得最厲害的那條最省。

學習率要慢慢變小

SGD 有一個 BGD 沒有的麻煩。走到最低點時,全體的梯度是 0,可是每個包裹自己的梯度並不是 0。12 個包裹不可能全都剛好落在同一條直線上,每一筆都還在拉著參數往自己那邊走。抽到哪一筆,就往哪邊偏一下。

固定的學習率停不下來單筆 SGD 直接從最低點出發,畫面放大到最低點周圍 ±0.12。兩邊抽到的包裹順序相同。
固定 η = 0.5
遞減 η = 0.5/(1+t/20)
固定 η = 0.500:近 50 步平均離最低點 4.2/100遞減 η = 0.031:近 50 步平均離最低點 1.5/100

這張圖直接從最低點出發,每次只看一筆。學習率固定時,參數一直在最低點附近打轉,最後 50 步離最低點的平均距離是 0.042;學習率照 ηt=0.5/(1+t/20)\eta_t = 0.5/(1 + t/20) 隨步數變小,打轉的範圍跟著縮小,平均距離降到 0.015。

學習率要怎麼變小才對?太快變小,還沒走到就停了;太慢變小,雜訊一直消不掉。

找最低點,就是找讓 ∇L=0\nabla L = 0 的那一點,也就是解一個方程式的根。Robbins 和 Monro 在 1951 年的〈A Stochastic Approximation Method〉研究的正是這類問題,只是他們每次只能觀測到帶雜訊的結果。後人把他們的步長條件整理成兩條:

∑t=1∞ηt=∞,∑t=1∞ηt2<∞\sum_{t=1}^{\infty} \eta_t = \infty, \qquad \sum_{t=1}^{\infty} \eta_t^2 < \infty

第一條讓總步長夠長,不管起點多遠都走得到;第二條讓雜訊累積的總量有限,最後才停得下來。ηt∝1/t\eta_t \propto 1/t 兩條都滿足,上圖的遞減方式就屬於這一類。

雜訊也有用處

SGD 的雜訊也不全是壞事。

卡在鞍點上f(u, v) = ½u² − ½v² + ¼v⁴,η = 0.2,從 (1.8, 0) 出發。橘色那條在每次的梯度加上大小約 0.0001 的雜訊。
012-101uv鞍點最低點最低點
梯度下降:f = 0.000,‖∇f‖ = 0.000加一點雜訊:f = -0.250,‖∇f‖ = 0.000

這個地形是 f(u,v)=12u2−12v2+14v4f(u, v) = \frac{1}{2}u^2 - \frac{1}{2}v^2 + \frac{1}{4}v^4。原點是一個鞍點,沿著 uu 方向看是谷底,沿著 vv 方向看是山頂,梯度是 0。兩個真正的谷底在 v=±1v = \pm 1。

GD 從 (1.8, 0)(1.8,\ 0) 出發,vv 方向的梯度一開始就是 0,之後也永遠是 0,於是一路滑進鞍點,停在那裡。加上一點點雜訊(標準差只有 0.0001),點走到鞍點附近時被輕輕推離山脊,第 64 步就落進 (0,−1)(0, -1) 的谷底。

在二維的圖上,鞍點看起來像個特例。Dauphin 等人 2014 年的〈Identifying and attacking the saddle point problem in high-dimensional non-convex optimization〉主張,維度越高,鞍點相對於局部極小值的數量就越多,訓練變慢常是因為卡在鞍點附近平坦的高原,而不是掉進壞的局部極小值。

雜訊能幫忙脫困,但理論上要附條件。Ge 等人 2015 年證明,如果每個鞍點都有明確的下坡方向(負曲率),函數也夠平滑,而且雜訊在每個方向都有變異,帶雜訊的 SGD 能在多項式步數內離開鞍點。我們的例子從山脊正上方出發,是故意挑的最壞情況;從隨機的起點出發,GD 幾乎不會剛好停在鞍點上,只是在平坦的高原上可能走得很慢。

SGDM:記住剛才的方向

回到又窄又長的山谷。之字形的問題在於,橫跨山谷的那個方向,梯度每一步都在翻正負號,這一步推向山谷的一側,下一步又推回另一側。沿著谷底的那個方向,梯度雖然小,卻一直指向同一邊。

如果每一步不只看當下的梯度,也參考前幾步的梯度,來回翻轉的部分會互相抵銷,一直指向同一邊的部分會累積起來。

指數移動平均

「參考前幾步」最常用的做法,是指數移動平均(Exponential Moving Average,EMA):

mt=β mt−1+(1−β) gtm_t = \beta\, m_{t-1} + (1 - \beta)\, g_t

新的平均值,是舊平均值乘上 β\beta,再加上新梯度乘上 1−β1 - \beta。β=0.9\beta = 0.9 時,新梯度占一成;十步前的梯度還剩 0.910≈35%0.9^{10} \approx 35\% 的影響力,越舊的越淡。它不必把過去的梯度一個一個存起來,只要記住一個數字。

把之字形平均起來η = 0.9 那條之字形路徑的梯度,拆成橫跨山谷與沿著山谷兩個方向。橘線是 β = 0.9 的移動平均。
橫跨山谷:每一步正負交替
0102030-1.701.7步數
沿著山谷:很小,但方向一致
010203000.06步數
每一步的梯度移動平均

我們把 GD 在山谷裡的梯度,拆成橫跨山谷和沿著山谷兩個分量。橫跨的分量第一步約是 1.7,之後正負交替,EMA 很快就壓到 0 附近;沿著谷底的分量只有約 0.06,但方向始終一致,EMA 穩穩地留了下來。

動量

把這個平均拿來更新參數,就是動量法(momentum)。帶動量的 SGD 常簡稱 SGDM:

vt=β vt−1+gt,θt+1=θt−η vtv_t = \beta\, v_{t-1} + g_t, \qquad \theta_{t+1} = \theta_t - \eta\, v_t

這裡的 vv 少了 (1−β)(1 - \beta) 這個係數,所以它是上面 EMA 的 11−β\frac{1}{1-\beta} 倍。梯度一直指向同一邊時,vv 會累積到 g1−β\frac{g}{1-\beta},β=0.9\beta = 0.9 就是 10 倍。原本在平的方向上走不動的小梯度,就這樣被放大了。

這個比喻來自物理。vv 像是一顆球的速度,梯度是坡度給它的推力,β\beta 決定每一步保留多少速度。

這個想法也比深度學習早得多。Polyak 在 1964 年把它寫成

xn+1=xn−α∇f(xn)+β (xn−xn−1)x^{n+1} = x^n - \alpha \nabla f(x^n) + \beta\,(x^n - x^{n-1})

也就是在梯度那一步之外,再加上「上一步的位移」乘上 β\beta。把上面兩行的 vv 消掉,會得到一模一樣的式子,α\alpha 就是 η\eta。Polyak 自己取名叫重球法(heavy ball),把它看成一個物體在位能場裡運動的離散版本,並建議 β\beta 通常取 0.8 到 0.99。

他還算出了加速的幅度。在條件數為 κ\kappa 的二次函數上,GD 要走的步數大約和 κ\kappa 成正比,重球法只要和 κ\sqrt{\kappa} 成正比。我們的山谷 κ≈46\kappa \approx 46,κ≈6.8\sqrt{\kappa} \approx 6.8。不過這個結果只在二次函數,或極小點附近夠像二次函數的地方成立;Lessard 等人在 2016 年就構造過一個條件數 25 的一維函數,照二次函數的最佳參數跑重球法,會陷入永遠不衰減的振盪。

同樣的 η,加上動量橘色那條頭上的箭頭,是它下一步的位移 −ηv。
012-1012w(每公斤)b(基本費)
梯度下降(η = 0.9):第 93 步進入最低點 0.03 以內動量(η = 0.9,β = 0.7):第 19 步進入最低點 0.03 以內

同樣是 η=0.9\eta = 0.9,GD 第 93 步才到,加上 β=0.7\beta = 0.7 的動量,第 19 步就到了。

仔細看動量那條路線,它一開始並沒有比較乖,反而大幅橫跨山谷好幾次。動量抵銷掉的,是每一步都翻正負號的那種彈跳;球已經累積的速度,仍然要好幾步才停得下來。

β\beta 太大會怎樣?

要記住多少過去動量,η = 0.1,三種 β。梯度不變時,步長最後會累積到 η/(1 − β)。
β = 0.5 · η/(1 − β) = 0.2
β = 0.9 · η/(1 − β) = 1.0
β = 0.99 · η/(1 − β) = 10.0
β = 0.5:200 步後仍未進入最低點 0.03 以內β = 0.9:第 51 步進入最低點 0.03 以內β = 0.99:200 步後仍未進入最低點 0.03 以內

三張圖都用 η=0.1\eta = 0.1。β=0.5\beta = 0.5 記憶太短,幫助有限,200 步內沒走到;β=0.9\beta = 0.9 第 51 步到;β=0.99\beta = 0.99 幾乎沒有摩擦,球在谷底附近一圈一圈繞,200 步內也沒停下來。

NAG:先看一眼再踩

動量反應慢。快到谷底時,球帶著累積的速度衝過頭,要等梯度反過來推好幾步,才轉得回來。

Nesterov 動量(Nesterov Accelerated Gradient,NAG)只改了一個地方。既然這一步反正會沿著速度往前走,那就先走到那裡,看看那邊的坡度,再決定怎麼修正:

vt=β vt−1+∇L(θt−ηβ vt−1)θt+1=θt−η vt\begin{aligned} v_t &= \beta\, v_{t-1} + \nabla L(\theta_t - \eta\beta\, v_{t-1}) \\ \theta_{t+1} &= \theta_t - \eta\, v_t \end{aligned}

唯一的差別是梯度在哪裡算。動量在目前的位置算;NAG 在「照目前速度走一步之後」的前瞻點算。如果前方已經開始上坡,NAG 這一步就提早感覺到,先踩一點剎車。

先往前看,再量坡度藍色在原地量梯度;橘色先照慣性移動 −ηβv,到空心的前瞻點再量。箭頭只畫方向。
012-1012w(每公斤)b(基本費)
動量:第 37 步進入最低點 0.03 以內Nesterov:第 22 步進入最低點 0.03 以內η = 0.5,β = 0.8

空心圈是 NAG 的前瞻點。同樣用 η=0.5\eta = 0.5、β=0.8\beta = 0.8,動量第 37 步到,NAG 第 22 步到。

為什麼在山谷裡特別有效?Sutskever 等人在 2013 年證明,在二次函數上,NAG 等於在每個特徵方向各用一個不同的動量 β(1−ηλ)\beta(1 - \eta\lambda),λ\lambda 是那個方向的曲率。曲率越大的方向,動量越小。代入這張圖的設定,橫跨山谷的方向 λ=2.05\lambda = 2.05,有效動量只剩 0.8×(1−0.5×2.05)≈−0.020.8 \times (1 - 0.5 \times 2.05) \approx -0.02,幾乎沒有衝勁;沿著谷底的方向 λ=0.045\lambda = 0.045,還保有 0.78。容易來回彈跳的方向被收斂,需要加速的方向照樣加速。

這個方法出自 Nesterov 1983 年的論文,原本是凸最佳化的理論結果,保證誤差以 1/k21/k^2 的速度下降。「在前瞻點算梯度」這種寫法,則是 Sutskever、Martens、Dahl 和 Hinton 在〈On the importance of initialization and momentum in deep learning〉裡改寫的。他們讓動量從小慢慢升到 0.99 甚至 0.999,配上仔細設計的初始化,讓 SGD 加動量在深層自編碼器上追平了當時更複雜的二階方法。

AdaGrad:每個參數各走各的

到目前為止,所有參數都共用同一個 η\eta。

這在很多問題上並不合理。AdaGrad 的作者 Duchi、Hazan 和 Singer 舉的是文字資料的例子。常見的詞每一筆資料都會出現,對應的參數一直被更新;罕見的詞偶爾才出現一次,可是它一出現,往往就很有預測力。同一個學習率,對前者可能太大,對後者又太小。

AdaGrad 讓每個參數記住自己過去所有梯度的平方和,再用它的平方根來除:

Gt=Gt−1+gt2θt+1=θt−ηGt+ϵ gt\begin{aligned} G_t &= G_{t-1} + g_t^2 \\ \theta_{t+1} &= \theta_t - \frac{\eta}{\sqrt{G_t} + \epsilon}\, g_t \end{aligned}

這裡的平方、開根號和除法,都是每個參數各算各的。ϵ\epsilon 是一個很小的數,避免除以零。

梯度一直很大的參數,GG 長得快,步子就變小;很少被更新的參數,GG 小,一有梯度就能走一大步。第一步更有意思,G1=g12G_1 = g_1^2,所以每個參數的第一步都是 ±η\pm\eta,和梯度本身多大無關。

AdaGrad:每個座標有自己的學習率η = 0.5。G 是到目前為止所有梯度平方的總和,所以 η/√G 只會變小。第一步,w 和 b 各走剛好 η。
012-1012w(每公斤)b(基本費)
有效學習率
00.250.5η/√Gη = 0.5w:0.392b:0.445
G = (1.624, 1.261)η/√G = (0.392, 0.445)G 有 97% 來自前 5 步

用 η=0.5\eta = 0.5,第一步 ww 和 bb 各走了剛好 0.5。之後兩個參數的有效學習率幾乎就停在 0.39 和 0.45,再也沒動過。GG 有 97% 來自前五步。一開始離最低點遠,梯度大,平方加進去就是一大筆;之後梯度越來越小,再怎麼加也加不了多少。這張圖要到第 203 步才進入 0.03 以內,比 BGD 的 168 步還慢。

GG 只會越加越大,每個參數的有效學習率 η/Gt\eta/\sqrt{G_t} 只會越來越小,而且主要由最早那幾步決定。在凸問題上,這正好是讓它收斂的機制;可是訓練一個深度網路要走上幾十萬步,地形一路在變,學習率往往在還沒走到好地方之前,就已經小到走不動了。

RMSProp 與 AdaDelta:學會忘記

既然麻煩來自「把所有過去的梯度都加起來」,那就只記最近的。

把 AdaGrad 的累加換成指數移動平均,就是 RMSProp:

vt=ρ vt−1+(1−ρ) gt2θt+1=θt−ηvt+ϵ gt\begin{aligned} v_t &= \rho\, v_{t-1} + (1 - \rho)\, g_t^2 \\ \theta_{t+1} &= \theta_t - \frac{\eta}{\sqrt{v_t} + \epsilon}\, g_t \end{aligned}

ρ\rho 通常取 0.9。這裡的 vv 記的是梯度平方的平均,和動量那一節的速度 vv 不是同一個東西。很久以前的大梯度會慢慢被淡忘,有效學習率可以變小,也可以再變大回來。

RMSProp 有個少見的身世,它沒有論文。它出自 Hinton 2012 年在 Coursera 開的〈Neural Networks for Machine Learning〉課程,第 6 講第 5 節(Lecture 6e)的投影片。投影片上寫的就是 0.9 MeanSquare+0.1 g20.9\,\mathit{MeanSquare} + 0.1\,g^2,再用它的平方根去除梯度,並註明這是 Tijmen Tieleman 尚未發表的工作。後來的論文引用它時,就只能引用這份講義。

陡坡之後,是一段很長的緩坡u < 0 的斜率是 1,之後只剩 0.1,谷底在 u ≈ 10。AdaGrad η = 0.5;RMSProp η = 0.1、ρ = 0.9。兩邊都從 u = −3 出發。
各自走到哪裡
-20246810uLAdaGradRMSProp
步長 |Δu|(對數刻度)
060120180240步數|Δu|0.0010.010.11AdaGradRMSProp
AdaGrad u = 3.45RMSProp u = 10.10

這張圖的地形先是一段斜率為 1 的陡坡,接著是斜率只有 0.1 的長緩坡,谷底在 u≈10u \approx 10。兩者都從 u=−3u = -3 出發,AdaGrad 用 η=0.5\eta = 0.5,RMSProp 用 η=0.1\eta = 0.1、ρ=0.9\rho = 0.9。

在陡坡上,兩者的分母都被大梯度撐大。走到緩坡之後,AdaGrad 的 GG 還記著陡坡上的每一步,步長掉到約 0.01;RMSProp 很快忘掉了,分母跟著梯度變小,步長回到約 0.1。到第 100 步,AdaGrad 才走到 u≈1.7u \approx 1.7,RMSProp 已經在 5.1;RMSProp 大約第 150 步就到谷底,AdaGrad 走到第 240 步,也只到 3.45。學習率給得比較大的那個,反而走得比較慢。

同一年,Zeiler 提出的 AdaDelta 也用了同樣的移動平均,還多想了一步。他注意到 SGD 和 AdaGrad 的更新量,單位對不上。梯度的單位是「損失 ÷ 參數」,拿它去更新參數,單位就錯了;如果再用二階導數去除(後面講牛頓法時會再看到),單位才會變回「參數」。AdaDelta 沒有真的去算二階導數,而是把分子的 η\eta 換成「過去更新量」的均方根:

Δθt=−RMS[Δθ]t−1RMS[g]t gt\Delta\theta_t = -\frac{\mathrm{RMS}[\Delta\theta]_{t-1}}{\mathrm{RMS}[g]_t}\, g_t

分子和分母的單位一約,更新量的單位就和參數一致了,連學習率都不用設。

Adam:把兩件事合在一起

到這裡,我們手上有兩個工具。動量用梯度的移動平均,處理方向一直變來變去的問題;RMSProp 用梯度平方的移動平均,替每個參數調整步長。

Kingma 和 Ba 在 2014 年提出的 Adam,就是把兩者放在一起:

mt=β1 mt−1+(1−β1) gtvt=β2 vt−1+(1−β2) gt2m^t=mt1−β1t,v^t=vt1−β2tθt=θt−1−α m^tv^t+ϵ\begin{aligned} m_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t \\ v_t &= \beta_2\, v_{t-1} + (1 - \beta_2)\, g_t^2 \\ \hat m_t &= \frac{m_t}{1 - \beta_1^t}, \qquad \hat v_t = \frac{v_t}{1 - \beta_2^t} \\ \theta_t &= \theta_{t-1} - \alpha\, \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon} \end{aligned}

mm 是梯度的一階動差估計,也就是平均;vv 是二階動差估計,也就是平方的平均。學習率在 Adam 論文裡記作 α\alpha,角色和前面的 η\eta 一樣。論文的預設值是 α=0.001\alpha = 0.001、β1=0.9\beta_1 = 0.9、β2=0.999\beta_2 = 0.999、ϵ=10−8\epsilon = 10^{-8},這組數字到今天仍是 PyTorch 的預設。

前兩行我們都看過了,第三行是新的。

偏差修正

mm 和 vv 都從 0 開始。第一步 m1=0.1 g1m_1 = 0.1\, g_1,只有真實梯度的一成;v1=0.001 g12v_1 = 0.001\, g_1^2,只有千分之一。這兩個估計都被起點的 0 往下拉。

把 mtm_t 展開,假設梯度的期望值一直是 E[g]\mathbb{E}[g],可以算出 E[mt]=(1−β1t) E[g]\mathbb{E}[m_t] = (1 - \beta_1^t)\,\mathbb{E}[g]。所以除以 1−β1t1 - \beta_1^t,就把偏差修回來了;vv 也一樣。

為什麼非修不可?兩個估計的偏差程度不一樣。β2=0.999\beta_2 = 0.999 讓 vv 被拉得比 mm 嚴重得多,不修正的話,分母太小,步子就太大。

Adam 的移動平均從 0 起跑梯度固定為 1,β₁ = 0.9、β₂ = 0.999。虛線是記錄下來的 m、v,實線是除以 1 − βᵗ 之後。時間軸是對數刻度。
m 與 v
110100100000.51tmvm̂ = v̂
步長倍率
110100100001357t未修正 m/√vt = 12 時最高 6.6 倍修正後 m̂/√v̂
mt = 1.000vt = 0.6323未修正 m/√v = 1.26修正後 m̂/√v̂ = 1.00

假設梯度一直是固定的 1。修正過的 m^t/v^t\hat m_t / \sqrt{\hat v_t} 從第一步起就是 1,步長剛好是 α\alpha。不修正的話,第一步是 0.1/0.001≈3.160.1/\sqrt{0.001} \approx 3.16 倍,大約第 12 步衝到 6.6 倍,到第 1,000 步仍有 1.26 倍。Kingma 和 Ba 在變分自編碼器的實驗裡就看到,β2\beta_2 越接近 1,沒有偏差修正的訓練一開始越不穩定。

步長大約就是 α\alpha

修正之後,m^t/v^t\hat m_t / \sqrt{\hat v_t} 大致落在 ±1\pm 1 附近。把整個損失乘上 100,梯度跟著乘上 100,m^\hat m 和 v^\sqrt{\hat v} 一起放大,除了很小的 ϵ\epsilon 之外,更新量幾乎不變。每個參數一步大約走 α\alpha 那麼遠,和梯度本身多大無關。

這是 Adam 好用的主因。SGD 的學習率要配合梯度的尺度調;Adam 的 α\alpha 比較接近「每一步想讓參數動多少」,換一個模型,預設值常常也還能用。

四種更新規則,同一個山谷四組都用 12 個包裹的完整梯度,差別只在更新規則;學習率各自挑了在這裡表現好的值,Adam 用預設的 β₁ = 0.9、β₂ = 0.999。數字是第一次進入最低點 0.03 以內的那一步。
GD · η = 0.9
動量 · η = 0.3, β = 0.9
RMSProp · η = 0.02, ρ = 0.9
Adam · η = 0.2
GD:第 93 步到達動量:第 47 步到達RMSProp:第 130 步到達Adam:第 87 步到達

四個方法在同一個山谷裡,學習率各自調到在這裡表現不錯的值,數字是第一次進入最低點 0.03 以內的步數。四組都用全部 12 個包裹的梯度,所以前兩組是不抽樣的 GD 和帶動量的 GD。GD(η=0.9\eta = 0.9)第 93 步到;動量(η=0.3\eta = 0.3、β=0.9\beta = 0.9)第 47 步;RMSProp(η=0.02\eta = 0.02)第 130 步;Adam(α=0.2\alpha = 0.2)第 87 步。

Adam 並沒有快很多。原因留到後面「把山谷變圓」那一節再說,這和山谷是斜的有關。

Adam 也可以換成 Nesterov 動量。Dozat 在 2016 年把 NAG 的「先看一眼」改寫進 Adam,稱為 Nadam。NAG 先沿著動量走一步再量梯度;Nadam 不另外多算一次梯度,而是在更新時直接用「下一步的動量」β1m^t\beta_1 \hat m_t,再加上這一步的梯度。後來 AlgoPerf(一個比較訓練演算法快慢的公開評測,後面「哪一個最快?」那一節會再介紹)用的基準方法 NAdamW,就是 Nadam 再加上下一節的 AdamW 權重衰減。

Adam 也會出錯

Adam 很快就成了預設選項。但接下來幾年,陸續有人指出它的問題。

會忘記重要的大梯度

Reddi、Kale 和 Kumar 構造了一個很小的例子。參數 xx 只能在 [−1,1][-1, 1] 之間,每三步一個循環,第一步的損失是 CxCx,後兩步是 −x-x。C=3C = 3 時,一輪的總梯度是 3−1−1=1>03 - 1 - 1 = 1 > 0,所以應該把 xx 往 −1-1 推。

Adam 的分母在這裡出了錯。那個罕見的大梯度 3 一出現,vv 立刻變大,這一步的 g/vg/\sqrt{v} 被壓成約 1.05;接下來兩步梯度只有 −1-1,vv 很快又變小,這兩步各被放大成 −0.76-0.76 和 −0.97-0.97。一輪下來,以 αt\alpha_t 為單位,往錯誤方向多走了 0.68。

Adam 走錯方向Reddi 等人的例子:x 限制在 [−1, 1],每三步有一步梯度是 +3,其餘兩步是 −1,所以最低點在 x = −1。β₁ = 0、β₂ = 0.1、α_t = 0.5/√t,兩者都從 x = 1 出發。
0100200300-101tx最低點 x = −1AdamAMSGrad
梯度:每 3 步一次 +3,其餘是 −1
t = 300, gt = -1Adam:x = 1.00,g/√v = -0.97AMSGrad:x = -0.98,g/√v = -0.35

兩者都從 x=1x = 1 出發,學習率是 0.5/t0.5/\sqrt{t}。Adam 每三步就被推回 +1+1,一直停在錯誤的那一端;AMSGrad 第 100 步走到約 −0.40-0.40,第 300 步到 −0.98-0.98。

這裡的 β1=0\beta_1 = 0、β2=1/(1+C2)=0.1\beta_2 = 1/(1 + C^2) = 0.1,是論文為了證明而挑的設定。根源是 Adam 的有效學習率 α/vt\alpha/\sqrt{v_t} 可以變大。最近的梯度一小,過去的大梯度就被忘了。

他們的修正 AMSGrad 只改了一件事,分母改用 vv 的歷史最大值:

v^t=max⁡(v^t−1, vt)\hat v_t = \max(\hat v_{t-1},\ v_t)

有效學習率從此只會變小,不會變大。上面的例子裡,三步都用同一個 v^\hat v,一輪的淨效果變成往正確方向走 0.35。

泛化比較差?

另一個質疑來自 Wilson 等人 2017 年的〈The Marginal Value of Adaptive Gradient Methods in Machine Learning〉。他們構造了一個線性分類問題,SGD 找到的解測試錯誤是 0;AdaGrad、RMSProp、Adam 找到的解卻會把每個新樣本都判成同一類。

在 CIFAR-10 上,他們只調學習率和衰減方式,SGD 的測試錯誤是 7.65%,RMSProp 9.60%,Adam 9.78%。訓練損失降得快,測試成績卻比較差。這篇論文讓不少電腦視覺的研究繼續用 SGD 加動量。

兩年後,Choi 等人用 Wilson 等人公開的程式碼重跑,連動量和 ϵ\epsilon 也一起調,四種方法的測試錯誤幾乎一樣。差距有多少,很大一部分取決於調了哪些超參數。

權重衰減被縮小了

第三個問題最隱蔽,也影響最大。

權重衰減(weight decay)每一步把參數往 0 拉一點,防止參數長得太大。在 SGD 裡,它和 L2 正則化等價。在損失加上 λ2∥θ∥2\frac{\lambda}{2}\lVert\theta\rVert^2,梯度就多了一項 λθ\lambda\theta,效果就是每步把參數縮小一點。

所以早期的 Adam 實作,就把 λθ\lambda\theta 加進梯度裡。可是在 Adam 裡,這一項也會跟著被 v^\sqrt{\hat v} 除掉。梯度一直很大的參數,v^\sqrt{\hat v} 大,衰減就被縮得很小;Loshchilov 和 Hutter 的說法是,過去梯度越大的權重,被正則化得越少。

他們的解法是把衰減拿出來,不經過 Adam 的分母:

θt=θt−1−ηt(α m^tv^t+ϵ+λ θt−1)\theta_t = \theta_{t-1} - \eta_t \left( \alpha\, \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon} + \lambda\, \theta_{t-1} \right)

這就是 AdamW。式子裡的 α\alpha 是學習率;ηt\eta_t 是學習率排程在第 tt 步的倍率,學習率固定時就是 1。

權重衰減放在 Adam 裡面,還是外面兩個權重都從 1 出發,梯度是平均為 0 的雜訊:w₁ 的雜訊大小是 1,w₂ 只有 0.001。α = 0.002、λ = 0.004。把它們拉向 0 的只有正則化。
L2 加進 Adam 的梯度
025050000.51步數ww₁(梯度大)w₂(梯度小)
AdamW(解耦)
025050000.51步數ww₁(梯度大)w₂(梯度小)
L2 加進 Adam 的梯度:w₁ = 0.96,w₂ = 0.28AdamW(解耦):w₁ = 0.13,w₂ = 0.14

兩個權重都從 1 出發,梯度只有雜訊,大小差了一千倍。α=0.002\alpha = 0.002、λ=0.004\lambda = 0.004。L2 加進梯度的版本,梯度大的 w1w_1 幾乎沒被衰減,跑完 500 步還有 0.96;梯度小的 w2w_2 反而每步被拉下約 0.002,第 500 步掉到 0.28。AdamW 對兩個權重一視同仁,每步都乘上 0.996,第 500 步兩個都只剩 0.13 左右。

在 CIFAR-10 的實驗裡,Adam 加 L2 的好結果落在學習率與 λ\lambda 的一條斜線上,調一個就得跟著調另一個;AdamW 的好區域大致和兩軸平行,兩個超參數可以分開調,最好的成績也追上了 SGD。今天訓練 Transformer 和大型語言模型,AdamW 幾乎是預設。

學習率排程

前面說過,SGD 的學習率要慢慢變小。可是要怎麼變小?

從階梯到餘弦

最早最常見的是階梯式,每隔一段時間除以 10。訓練 ResNet-50 的經典配方是 90 個 epoch(把整個訓練集完整看過一遍,叫一個 epoch),在第 30、60、80 個 epoch 各除以 10。它的毛病是要等最後一次除完,才得到好的模型;什麼時候除,也得自己決定。

2016 年的 SGDR 改用餘弦曲線,從最大值平滑地降到最小值:

ηt=ηmin⁡+12(ηmax⁡−ηmin⁡)(1+cos⁡TcurTiπ)\eta_t = \eta_{\min} + \frac{1}{2}\left(\eta_{\max} - \eta_{\min}\right)\left(1 + \cos\frac{T_{\text{cur}}}{T_i}\pi\right)

TcurT_{\text{cur}} 是這一輪已經走了多久,TiT_i 是這一輪的長度。走完一輪,學習率直接跳回最大值,重新開始下一輪,這叫熱重啟(warm restart);下一輪的長度可以乘上 TmultT_{\text{mult}} 越拉越長。提出它的,正是後來寫 AdamW 的 Loshchilov 和 Hutter。

五種學習率排程高度是 η 除以最大值。Step 是 Goyal 等人的 90 epoch 配方;SGDR 用 T₀ = 10、T_mult = 2,共 150 epoch;暖身與 WSD 的暖身都佔前 5%,WSD 在最後 10% 衰減。
Step
100%100%
Cosine
100%100%
SGDR
100%100%
暖身+Cosine
100%100%
WSD
100%100%
Step 0Cosine 0SGDR 0暖身+Cosine 0WSD 0

圖上的五種排程,游標同步移動。SGDR 那一張用 T0=10T_0 = 10、Tmult=2T_{\text{mult}} = 2,在第 10、30、70 個 epoch 重啟。

重啟後來並沒有流行起來。SGDR 自己的實驗裡,CIFAR-10 上 WRN-28-10 最好的單一模型 3.86%,就是來自完全不重啟、只走一輪的餘弦。後來 GPT-3、LLaMA 的訓練設定也都是單一週期的餘弦。留下來的是那條平滑的曲線,代價是又得事先知道總步數;Chinchilla(DeepMind 研究模型大小與訓練資料量怎麼搭配的論文)的實驗發現,餘弦週期如果比實際訓練步數長了 25% 以上,結果就明顯變差。

不想事先決定終點

餘弦排程要先知道總共訓練多久。可是訓練大型語言模型時,常常訓練到一半才決定要不要多訓練一點。

MiniCPM 在 2024 年用了一種三段式排程,稱為 WSD(Warmup-Stable-Decay)。開頭先暖身(下一節會講),之後學習率長時間維持不變,只在最後大約一成的訓練量才降下來。降之前存下的 checkpoint(訓練中途存下來的模型),隨時可以接著繼續訓練。

Defazio 等人在 2024 年走得更遠,乾脆不要排程。Schedule-Free 同時維護三組參數:

yt=(1−β) zt+β xtzt+1=zt−γ ∇f(yt)xt+1=(1−1t+1)xt+1t+1 zt+1\begin{aligned} y_t &= (1-\beta)\, z_t + \beta\, x_t \\ z_{t+1} &= z_t - \gamma\, \nabla f(y_t) \\ x_{t+1} &= \left(1 - \tfrac{1}{t+1}\right) x_t + \tfrac{1}{t+1}\, z_{t+1} \end{aligned}

這裡的 xx、yy、zz 是三組參數,和包裹的重量 xx 無關。zz 是一般的 SGD,步長 γ\gamma 固定;xx 是所有 zz 的平均,也是最後拿來用的模型;梯度則在兩者之間的 yy 計算。對過去的 zz 取平均,效果等於一條終點隨時跟著目前步數移動的線性衰減。

Schedule-Free:三個點、一個平均每次抽 4 個包裹,γ = 0.3、β = 0.9。z 走 SGD 的步伐,x 是到目前為止所有 z 的平均,梯度在 y = 0.1·z + 0.9·x 計算。一開始 x 會落後,因為它還平均著最早那幾個離得很遠的 z。
012-1012w(每公斤)b(基本費)zxy
x(平均):距最低點 0.007z(SGD 步伐):距最低點 0.461y(計算梯度的位置)

每一步抽 4 個包裹,γ=0.3\gamma = 0.3、β=0.9\beta = 0.9。前一百多步,xx 明顯落後 zz,因為它對所有 zz 一視同仁,最早那些離最低點很遠的 zz 也算在裡面;走得越久,xx 越穩。

在 2024 年的 AlgoPerf 訓練演算法競賽裡,Schedule-Free AdamW 拿下不准外部調整超參數的那一組冠軍,平均比基準快約 8%,也是那一組唯一贏過基準的投稿。不過它還是需要暖身,論文的實驗大多把暖身設成總訓練量的 5%,總長度仍然透過暖身進來了。

暖身

現在幾乎每一份訓練設定都會寫,前幾千步的學習率要從很小慢慢升上來。這叫暖身(warmup)。為什麼一開始不能直接用大的學習率?

線性縮放與暖身

暖身最早在 Goyal 等人 2017 年的〈Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour〉被寫成一套配方。他們想把批次從 256 放大到 8,192,用 256 張 GPU 一小時訓練完 ResNet-50。

第一條規則是線性縮放,批次放大 kk 倍,學習率也放大 kk 倍。批次 8,192 的學習率因此是 3.2。可是訓練一開始網路變化得很快,這麼大的學習率直接用上去,模型會被打壞。所以前 5 個 epoch,學習率從原本的 0.1 線性升到 3.2。

不暖身,top-1 錯誤率(第一個猜測就猜錯的比例)是 24.84%;用一段固定的小學習率暖身,反而更差,25.88%;逐步升高的暖身 23.74%,追上批次 256 的 23.60%。批次放到 8,192 之前,錯誤率幾乎不變;16k 開始變差,32k 是 27.55%,64k 是 33.96%。

Adam 為什麼也要暖身

Adam 的步長大約就是 α\alpha,照理說不怕梯度太大。為什麼訓練 Transformer 時,不暖身的 Adam 還是常常一開始就壞掉?

RAdam 的作者 Liu 等人在 2019 年給了一個解釋。訓練剛開始,vv 只看過幾個梯度,用它估計的「梯度有多大」非常不準。第一步更極端,v^1=g12\hat v_1 = g_1^2,自適應學習率 ψ=1/v^1=1/∣g1∣\psi = 1/\sqrt{\hat v_1} = 1/|g_1| 只靠一個樣本估出來,變異數甚至發散。

最初幾步的自適應學習率,很不可靠2,000 次模擬,梯度從 N(0, 1) 抽樣,β₂ = 0.999。色帶是每一步 ψ = 1/√v̂ 的中間 50% 與 90%,線是中位數;▲ 表示至少一次模擬超過 100。兩軸都是對數刻度。
12481632641282560.3110100tψ = 1/√v̂前 4 步:只用動量1/σ = 1▲
90% 的模擬落在 0.93 到 1.1最大值 1.2ρt = 245.1RAdam 修正係數 rₜ = 0.346

圖上是 2,000 次模擬,梯度從標準常態分布抽出,β2=0.999\beta_2 = 0.999。模擬裡,第 1 步的 1/v^1/\sqrt{\hat v} 有 90% 落在 0.50 到 14.4 之間,差了將近三十倍;到第 10 步,已經收斂到 0.73 到 1.6。

RAdam 的做法是估計這個變異數有多大,再乘上一個修正係數 rtr_t,前幾步變異數太大時乾脆不用自適應學習率。β2=0.999\beta_2 = 0.999 時,前 4 步只用動量,之後 rtr_t 從很小慢慢升到 1,效果就像一段內建的暖身。

同一年 10 月,Ma 和 Yarats 指出 rtr_t 只由步數 tt 和 β2\beta_2 決定,和資料無關。所以 RAdam 大致等於一段固定長度的暖身,他們給的經驗法則是 2/(1−β2)2/(1-\beta_2) 步;β2=0.999\beta_2 = 0.999 時就是 2,000 步。他們用 ResNet-50 在 ImageNet 上比,直接用這個長度做線性暖身,和 RAdam 的結果相差不到半個百分點。

批次變大之後:LARS 與 LAMB

Goyal 等人的配方在批次 8,192 以內都很穩,再往上就撐不住了。16k 的錯誤率是 24.79%,32k 是 27.55%,64k 是 33.96%。批次繼續變大,會遇到什麼問題?

一種說法是大批次會找到比較尖銳的谷底。Keskar 等人在 2017 年觀察到,用訓練集 10% 當批次訓練出的模型,谷底比較尖,測試準確率也比較低。這個說法後來被挑戰。Dinh 等人證明,ReLU 網路的尖銳度可以在不改變函數的情況下任意放大;Hoffer 等人則發現,把學習率依批次的平方根放大、訓練步數補足之後,這個落差就消失了。

另一個問題更直接。LARS 的作者 You、Gitman 和 Ginsburg 量了 AlexNet-BN 第一步各層的權重範數和梯度範數。兩者的比值 ∥w∥/∥∇L∥\lVert w\rVert/\lVert\nabla L\rVert,在第一層卷積是 5.76,到第一個全連接層是 1,345,差了兩百多倍。

同一個學習率,各層動的幅度差很多長條是一步更新讓該層改變多少(‖Δw‖/‖w‖,對數刻度)。‖w‖ 與 ‖∇L‖ 取自 LARS 論文 Table 2 的 AlexNet-BN 第 1 次迭代。動畫逐步調高全域學習率 γ;LARS 的信任係數 η = 0.001。
全域學習率(SGD)
10⁻⁵10⁻⁴10⁻³10⁻²10⁻¹110¹更新=權重conv1.w174%fc6.w0.74%
逐層信任比(LARS)
10⁻⁵10⁻⁴10⁻³10⁻²10⁻¹110¹更新=權重conv1.w1.00%fc6.w1.00%
‖w‖/‖∇L‖:conv1.w 5.76、fc6.w 1345全域學習率下,conv1.w 的相對變化是 fc6.w 的 234 倍

同一個全域學習率下,第一層卷積每一步的相對變化,是全連接層的 234 倍。學習率放大到某個程度,第一層的更新就會比權重本身還大,訓練就散了;可是對全連接層來說,這個學習率還小得很。

LARS 替每一層各算一個自己的學習率 λl\lambda^{l},讓更新量和這一層權重的大小成正比:

λl=τ ∥wl∥∥∇L(wl)∥\lambda^{l} = \tau\, \frac{\lVert w^{l}\rVert}{\lVert\nabla L(w^{l})\rVert}

τ\tau 是一個很小的信任係數,論文記作 η\eta、取 0.001,這裡換個字母,免得和學習率搞混。這樣每一層的相對變化都一樣大,不再被最敏感的那一層卡住。AlexNet 在批次 8k 時,不用 LARS、只靠暖身,學習率怎麼調都放不大,top-1 準確率最好是 44.8%;用 LARS 回到 58.2%,接近批次 512 的 58.7%。

LAMB 把同樣的逐層縮放套到 Adam 上。先照 Adam 算出這一層的更新 rr,加上權重衰減 λx\lambda x,再把整個更新的長度換成和這一層權重的長度成正比:

x(l)←x(l)−η ϕ(∥x(l)∥)∥r(l)+λx(l)∥ (r(l)+λx(l))x^{(l)} \leftarrow x^{(l)} - \eta\, \frac{\phi\big(\lVert x^{(l)}\rVert\big)}{\lVert r^{(l)} + \lambda x^{(l)}\rVert}\,\big(r^{(l)} + \lambda x^{(l)}\big)

x(l)x^{(l)} 是第 ll 層的權重,ϕ\phi 是一個把權重範數限制在上下界之間的函數。You 等人在 2019 年用它把 BERT-Large 的預訓練,從 16 顆 TPUv3 上的 81.4 小時,縮短到 1,024 顆 TPUv3 上的 76 分鐘;批次在第一階段是 64k,第二階段是 32k。

故事還有後續。Nado 等人在 2021 年重新調了 Adam,修掉 BERT 開源程式碼裡沒有偏差修正、學習率排程有斷崖這兩個問題,在同樣的批次與步數下,Adam 追上甚至略勝 LAMB;調好的 Nesterov 動量,也在 MLPerf(業界的訓練速度評測)的 ResNet-50 設定下追平了 LARS。

找一個平坦的谷底:SAM

回到 Keskar 等人的那個觀察。尖銳的谷底,真的比較差嗎?

前面所有方法都在回答「怎麼更快走到谷底」。Foret 等人在 2020 年換了一個問題。哪一個谷底比較好?

有兩個谷底,一個深而窄,一個淺而寬。訓練損失上,窄的比較低;可是測試資料和訓練資料總有點不同,參數稍微偏一點,窄谷的損失就急遽升高,寬谷則幾乎不變。

SAM(Sharpness-Aware Minimization)把目標改成「附近最壞的情況」:

min⁡w max⁡∥ϵ∥≤ρ L(w+ϵ)\min_{w}\ \max_{\lVert\epsilon\rVert \le \rho}\ L(w + \epsilon)

這裡的 ww 代表模型的全部參數;ϵ\epsilon 是參數的擾動,和前面避免除以零的 ϵ\epsilon 不同;ρ\rho 是擾動的半徑,和 RMSProp 的 ρ\rho 也無關。在半徑 ρ\rho 以內,找損失最高的那一點,再讓那一點的損失變小。內層的 max 用一階近似,最壞的方向就是梯度方向,ϵ^=ρ ∇L/∥∇L∥\hat\epsilon = \rho\, \nabla L / \lVert\nabla L\rVert。所以每一步先往上坡推 ϵ^\hat\epsilon,在那裡算梯度,再拿這個梯度回到原位置更新。

用 ρ 範圍內最壞的損失來比谷底實線是損失 L,虛線是距離 ρ 以內最壞的損失,也就是 SAM 要壓低的東西。動畫逐漸加大 ρ;每個谷底的箭頭指向它附近最壞的位置。
0123400.511.5L窄谷寬谷
谷底的 L:窄谷 0.33、寬谷 0.58ρ 範圍內最壞:窄谷 1.36、寬谷 0.80這樣比,寬谷勝出

實線是原本的損失,虛線是 ρ\rho 範圍內最壞的損失,也就是 SAM 真正要壓低的東西。ρ=0\rho = 0 時兩條線重疊,窄谷底部 0.33,比寬谷的 0.58 低。ρ\rho 加到 0.1,窄谷附近最壞的損失升到 0.63,寬谷只有 0.60,排序反過來了;ρ=0.45\rho = 0.45 時,差距拉大成 1.36 對 0.80。SAM 改變的是比較谷底的標準。

代價是每一步要算兩次梯度。在 ImageNet 上,ResNet-152 標準訓練最好的 top-1 錯誤率是 20.3%,SAM 是 18.4%;標籤雜訊很重時效果更明顯。後來 Andriushchenko 和 Flammarion 發現,只有在每個小批次上各自做擾動才有效,論文泛化界限描述的全資料版本,幾乎沒有幫助。尖銳度和泛化之間到底是什麼關係,至今仍有爭論。

記憶體不夠:Adafactor 與 GaLore

Adam 每個參數要多存兩個數字,mm 和 vv。參數一多,這兩份狀態就很可觀。

訓練 7B 模型的記憶體(不含前向傳播的中間結果)依 LLaMA-7B 的形狀計算(32 層、d = 4096、FFN 11008、詞彙 32000),全部以 fp32 存放,1 GB = 10⁹ 位元組。Adafactor 不存一階動差;GaLore 只投影注意力與 MLP 矩陣(r = 1024),其餘參數照常用 Adam;梯度一律以完整大小計。
04080120160GBAdamWAdafactorGaLore(r = 1024)107.8 GB53.9 GB72.7 GB
參數梯度優化器狀態優化器狀態:AdamW 53.9 GB、Adafactor 0.011 GB、GaLore 18.8 GB

以 LLaMA-7B 的形狀算,67 億個參數全用 fp32 存,參數本身 27 GB,梯度 27 GB,AdamW 的兩份狀態又是 54 GB,合計約 108 GB,還沒算上前向傳播留下的中間結果(activation)。

只記列和與行和

Adafactor 的作者 Shazeer 和 Stern 看上了 vv。一個 n×mn \times m 的權重矩陣,vv 也是 n×mn \times m。他們只存每一列的和 RR 和每一行的和 CC,需要時再拼回來:

V^=R CΣR\hat V = \frac{R\, C}{\Sigma R}

ΣR\Sigma R 是所有列和再加起來,也就是整個矩陣的總和。這等於用一個秩為 1 的矩陣去近似原本的 vv;秩為 1,意思是每一列都只是同一個向量的倍數。儲存量從 nmnm 降到 n+mn + m。

只留列和與行和,其餘重建回來一個 6×8 的二階動差矩陣 V。Adafactor 只存列和 R = V·1 與行和 C = 1ᵀ·V,用 V̂ = R·C / ΣR 代替 V。
V(完整)RCV̂ = R·C / ΣR(重建)
儲存的數字:48 → 14 個V̂ 的平均相對誤差:21%

6×8 的矩陣原本要存 48 個數字,現在只要 14 個。拼回來的矩陣當然不完全一樣,這個例子的平均相對誤差是 21%,但 vv 只負責決定每個參數的步長大致多大,這種程度的誤差影響有限。在 WMT'14 英德翻譯上,分解前後的 BLEU(翻譯品質的分數,越高越好)是 25.6 對 25.4。

Adafactor 還拿掉了動量,連 mm 都不存,這就出了問題。沒有動量、又沒有暖身時,BLEU 直接掉到 0.1,訓練完全失敗。他們追查發現,β2=0.999\beta_2 = 0.999 時,vv 跟不上梯度的變化,更新量在第 800 步左右衝到正常值的兩倍以上。解法是更新裁剪(update clipping),把整個更新的均方根限制在 1 以內,再讓 β2\beta_2 隨步數慢慢升高。T5 用的就是 Adafactor;PaLM 也用了它,但保留了動量,連分解都拿掉了。

在小空間裡跑 Adam

2024 年的 GaLore 換了一個角度。作者 Zhao 等人注意到,權重矩陣的梯度往往集中在少數幾個方向上,也就是低秩的。那就把梯度先投影到一個小空間,在小空間裡跑 Adam,再投影回去:

Rt=Pt⊤Gt,G~t=α Pt NtR_t = P_t^\top G_t, \qquad \tilde G_t = \alpha\, P_t\, N_t

PtP_t 來自梯度的奇異值分解(把矩陣拆成幾個方向,以及每個方向各自的伸縮量),取最重要的前 rr 個方向;NtN_t 是 Adam 在小矩陣 RtR_t 上算出的更新,α\alpha 是 GaLore 自己的縮放係數。Adam 的狀態只需要存 r×nr \times n,不是 m×nm \times n。每隔 TT 步,重新做一次奇異值分解,換一個子空間。

在小子空間裡跑 Adam,再投影回去一個 6×10 的梯度 G,主要方向會慢慢漂移。每 10 步用 G 的前 2 個左奇異向量重算 P;Adam 的兩個動差只存在 R = PᵀG 上。折線圖是子空間保留了多少 ‖G‖²。
GPR = PᵀGAdam 在這裡更新α·P·N 投影回 6×100%50%100%010203040保留的 ‖G‖² 比例
優化器狀態:完整 Adam 120 個數字,GaLore 52 個(P 加上兩個 r×n 動差)目前保留 99%

和 LoRA(只訓練一對低秩小矩陣的微調方法)不同,GaLore 的權重本身還是滿秩的,受限的只有優化器狀態。在 C4 上預訓練 LLaMA 1B,GaLore 的困惑度(語言模型對下一個 token 有多不確定,越低越好;token 是模型讀文字的基本單位)是 15.64,全秩訓練 15.56,LoRA 19.21。

論文摘要說,8-bit 版本可以在 RTX 4090 這類 24 GB 的消費級 GPU 上預訓練 7B 模型。這是每批只有 256 個 token 時量到的記憶體,約 22 GB;真正跑完的 7B 實驗用的是 64 張 A100。代價是每次換子空間都要做奇異值分解。在 1B 模型上,論文估計它比 8-bit Adam 慢約 17%;7B 模型做一次奇異值分解,LLaMA-Factory 的實測約 10 分鐘,GaLore 團隊後來的 GaLore 2 論文則寫最多 20 分鐘。

把山谷變圓:牛頓法、Shampoo、SOAP、Sophia

回到 Adam 為什麼沒快多少的問題。在同一個山谷裡,GD 第 93 步到,Adam 第 87 步,只快了一點點。

牛頓法

如果知道地形的形狀,就能直接把山谷變圓。牛頓法用 Hessian 的反矩陣修正梯度:

θt+1=θt−H−1∇L(θt)\theta_{t+1} = \theta_t - H^{-1} \nabla L(\theta_t)

在二次函數上,這一步直接走到最低點。換個角度看,乘上 H−1H^{-1} 等於換一套座標,在新座標裡山谷是圓的,梯度直接指向谷底。這種「先把地形變圓再走」的做法,叫做預條件(preconditioning)。

換個座標,把山谷變圓包裹山谷,以最低點為中心。每個座標系裡都跑一次梯度下降(η = 0.9),再變形到下一個:原始座標、每個軸各自依曲率縮放(對角)、用整個矩陣 H^½ 變換。
全矩陣:直直走進去
κ = 1.0原始座標:κ = 45.7對角縮放:κ = 45.6全矩陣:κ = 1.0

這張圖在三種座標之間變形。原始座標的條件數是 45.7。只沿著座標軸各自縮放,也就是對角預條件,條件數變成 45.6,幾乎沒變,因為 Hessian 的兩個對角元素本來就差不多,1.09 和 1。用完整的 Hessian 換座標,條件數才變成 1。

這就是 Adam 在我們的山谷裡沒快多少的原因。Adam、RMSProp、AdaGrad 都只替每個參數各自決定步長,相當於只能沿著座標軸縮放;我們的山谷問題全在「斜」,沿軸縮放救不了。

那為什麼不直接用牛頓法?一個有 nn 個參數的模型,Hessian 是 n×nn \times n。十億個參數,就要存 101810^{18} 個數字,還要求反矩陣。地形不是凸的時候(凸函數只有一個谷,沒有山頂和鞍點),Hessian 可能有負的特徵值,牛頓法會直接往山頂走。

Shampoo 與 SOAP

Shampoo 找到了折衷,作者是 Gupta、Koren 和 Singer。神經網路的參數大多是矩陣,一個 m×nm \times n 的權重矩陣,完整的預條件需要 mn×mnmn \times mn;Shampoo 改用左右兩個小矩陣,分別累積 GG⊤GG^\top 和 G⊤GG^\top G:

Lt=Lt−1+GtGt⊤Rt=Rt−1+Gt⊤GtWt+1=Wt−η Lt−1/4 Gt Rt−1/4\begin{aligned} L_t &= L_{t-1} + G_t G_t^\top \\ R_t &= R_{t-1} + G_t^\top G_t \\ W_{t+1} &= W_t - \eta\, L_t^{-1/4}\, G_t\, R_t^{-1/4} \end{aligned}

Lt−1/4L_t^{-1/4} 是矩陣的 −1/4-1/4 次方,算法是先對 LtL_t 做特徵分解,再把每個特徵值換成它的 −1/4-1/4 次方。1,024×1,024 的一層,完整預條件約有 1.1×10121.1 \times 10^{12} 個元素,Shampoo 只要約 2.1×1062.1 \times 10^{6} 個。Meta 後來的 Distributed Shampoo 加了許多工程改動,在 2024 年的 AlgoPerf 拿下允許外部調整超參數那一組的冠軍,平均比 NAdamW 基準快約 28%,不過八個工作負載中只在兩個最快,ResNet 也沒在時間預算內達標。

Shampoo 每隔一段時間才重算一次矩陣的根,中間預條件整個凍結。SOAP 的作者 Vyas 等人發現,指數取 1/2 的 Shampoo,等價於在 Shampoo 的特徵基底裡跑 Adafactor。SOAP 於是先把梯度轉進 Shampoo 的特徵基底,在那個座標系裡跑 Adam,再把更新轉回原本的座標。基底照樣久久更新一次,二階動差則每一步都更新。在 3.6 億參數的語言模型上,重算頻率從每 1 步放寬到每 100 步,Shampoo 的最終損失從 2.824 升到 2.932,已經接近 AdamW 的 2.943;SOAP 只從 2.820 升到 2.870。

Sophia

Sophia 走對角的路,但看的是 Hessian 的對角線,不是梯度的平方。每 10 步估一次對角 Hessian hh,然後逐座標裁剪:

θt+1=θt−η clip ⁣(mtmax⁡(γht, ϵ), 1)\theta_{t+1} = \theta_t - \eta\, \mathrm{clip}\!\left(\frac{m_t}{\max(\gamma h_t,\ \epsilon)},\ 1\right)

曲率是正的而且夠大,就照牛頓法的比例走;曲率是負的或太小,分母被 ϵ\epsilon 撐住,裁剪讓這一步最多走 η\eta。

曲率變成負的地方f(x) = x⁴/4 − x² + 0.6x + 2,從 f″ < 0 的 x = 0.1 出發。牛頓法往山頂走;Sophia 把 m / max(γh, ε) 裁剪到 [−1, 1]。示範用的設定:β₁ = β₂ = 0.9、每一步用真正的 f″、γ = 1、η = 0.15(論文用 β₁ = 0.96、β₂ = 0.99,每 10 步估一次 Hessian)。
GD(η = 0.1)
f″ < 0
牛頓法
f″ < 0
Sophia 式裁剪
f″ < 0
GD(η = 0.1):x = -1.55牛頓法:x = 0.32Sophia 式裁剪:x = -1.49

這個一維函數在起點附近是負曲率。牛頓法收斂到局部最大值 x=0.316x = 0.316,往山頂去了;Sophia 在負曲率區每步固定走 0.15,往下坡走到谷底附近。最左邊那一格的 GD 只看斜率,也一路往下坡走,停在 −1.55-1.55 附近;它根本沒用到曲率,所以不會被負曲率騙,但步長也不會隨曲率調整。

論文作者 Liu 等人在 GPT-2 上宣稱,達到同樣損失的步數只要 AdamW 的一半。後來的獨立評估都沒看到這麼大的差距。Defazio 在 GitHub 上指出,把 AdamW 的學習率調高之後,1.25 億參數的模型就打平了;2025 年包含 Sophia 三位原作者的〈Fantastic Pretraining Optimizers〉,在 5 億參數以下也沒量到顯著的加速。

只看正負號:Lion

回到記憶體。Adam 要替每個參數存 mm 和 vv 兩份狀態,能不能少存一份?

Lion 是 Google 的 Chen 等人用程式搜尋找到的。他們讓電腦在一個由基本運算組成的程式空間裡演化,篩出來的規則是這樣:

ct=β1 mt−1+(1−β1) gtθt=θt−1−η (sign(ct)+λ θt−1)mt=β2 mt−1+(1−β2) gt\begin{aligned} c_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t \\ \theta_t &= \theta_{t-1} - \eta\,\big(\mathrm{sign}(c_t) + \lambda\, \theta_{t-1}\big) \\ m_t &= \beta_2\, m_{t-1} + (1 - \beta_2)\, g_t \end{aligned}

更新方向只取正負號,所以每個參數每一步都走剛好 η\eta。它只存一份動量 mm,比 Adam 少一份狀態。β1=0.9\beta_1 = 0.9 負責這一步的方向,β2=0.99\beta_2 = 0.99 負責記住長期的動量,兩個角色拆開了。因為每一步的大小固定,Lion 的學習率要比 AdamW 小 3 到 10 倍,權重衰減則大 3 到 10 倍。

Lion 只看正負號兩者都從「每公斤 210 元+基本費 20 元」出發,學習率在 200 步內依 cosine 遞減(峰值:Adam 0.2、Lion 0.05)。Lion 每一步,每個座標都正好移動 ±η。
012-1012w(每公斤)b(基本費)
前 40 步放大
Adam:距最低點 0.022Lion:距最低點 0.023目前學習率:Adam 0.000、Lion 0.0000

Adam 和 Lion 都用餘弦排程走 200 步,最後離最低點都約 0.02。看「前 40 步放大」那一格,一開始兩個梯度分量同號,Lion 每一步在 ww 和 bb 上都走一樣遠,沿著 45° 的斜線前進。

在 JFT 上預訓練的 ViT,Lion 用約三分之一的計算量就追上 AdamW;但在 11 億到 75 億參數的語言模型上,困惑度和 Adafactor 從頭到尾沒有差別。後來的幾份獨立評估,大多量到它和 AdamW 差不多。

換一把尺

sign 這個操作看起來很粗糙,背後有個乾淨的解釋。

「最陡的下降方向」取決於怎麼量長度。我們平常用的長度是 L2 範數,單位圓上讓損失降得最多的方向,就是 −g/∥g∥-g/\lVert g\rVert。如果改用 L∞ 範數,也就是看最大的那個座標,單位「圓」變成一個正方形,最陡的方向就落在角點,正好是 −sign(g)-\mathrm{sign}(g)。

最陡的一步,取決於怎麼量長度在長度不超過 1 的步伐裡,挑讓損失降得最快(⟨g, d⟩ 最小)的那一步。用一般的長度量(圓),答案是 −g/‖g‖;用最大座標來量(正方形),答案永遠是角落 −sign(g)。
L2 範數:圓
g
L∞ 範數:正方形
g
g = (0.94, 0.34)L2:(-0.94, -0.34)L∞:(-1, -1)

Bernstein 和 Newhouse 在 2024 年的〈Old Optimizer, New Norm〉把這個觀點推廣。關掉指數移動平均之後,Adam 就是 L∞ 範數下的最陡下降;Shampoo 拿掉累積之後,剛好是譜範數下的最陡下降。譜範數量的是一個矩陣最多能把向量拉長幾倍,下一節的 Muon 就從這裡出發。

把權重當成矩陣:Muon

除了 Shampoo 這一支,多數方法的步長都是逐座標決定的,等於把參數攤成一長串數字,各自處理。可是神經網路的權重大多是矩陣。

一個權重矩陣的梯度,常常被少數幾個方向主導,奇異值大小懸殊。直接照梯度更新,那幾個方向的變化很大,其他方向幾乎不動。Muon 的做法是把動量矩陣「正交化」。對動量矩陣 MM 做奇異值分解 M=UΣV⊤M = U\Sigma V^\top,把所有奇異值都換成 1,只留下 UV⊤UV^\top。每個方向都動一樣多。

Keller Jordan 從 2024 年 10 月起把 Muon 用在 NanoGPT 的訓練速度競賽,刷新了好幾次紀錄,12 月才整理成部落格文章。它只用在網路中間的二維權重矩陣上,嵌入層、輸出層和那些向量參數仍然用 AdamW。

精確的奇異值分解太貴,Muon 用 Newton–Schulz 迭代近似。先把矩陣除以它的 Frobenius 範數,讓所有奇異值落在 0 到 1 之間,然後重複五次:

X←aX+b (XX⊤)X+c (XX⊤)2XX \leftarrow aX + b\,(XX^\top)X + c\,(XX^\top)^2 X

係數是 (a,b,c)=(3.4445, −4.7750, 2.0315)(a, b, c) = (3.4445,\ -4.7750,\ 2.0315)。

這個多項式會把小的奇異值一路往上推,大的往下拉。

五次 Newton–Schulz 迭代一個 2×2 的更新矩陣,先除以 Frobenius 範數,再迭代 X ← aX + b(XXᵀ)X + c(XXᵀ)²X,(a, b, c) = (3.4445, −4.7750, 2.0315)。左邊是矩陣把單位圓變成什麼形狀,右邊是它的兩個奇異值。
單位圓經過 X 之後
奇異值
五步後約 0.68–1.2(本文計算)00.511.5σ₁σ₂
原始矩陣:σ₁ = 2.05、σ₂ = 0.083σ₁ = 0.940, σ₂ = 0.697

這個 2×2 的矩陣,原本把單位圓壓成一個扁扁的橢圓,奇異值是 2.05 和 0.083。除以範數之後是 0.999 和 0.040。五步之後變成 0.94 和 0.70,橢圓接近圓了,但沒有剛好變成圓。Jordan 在程式註解裡寫明,這組係數只求把奇異值推到大約 0.5 到 1.5 之間,用這點不精確換來更少的迭代步數;本文算出來,五步之後實際落在約 0.68 到 1.2。

Moonshot AI 在 2025 年的〈Muon is Scalable for LLM Training〉把它推到大模型。他們加上了權重衰減,並把每個矩陣的更新乘上 0.2max⁡(r,c)0.2\sqrt{\max(r, c)}(rr、cc 是矩陣的列數和行數),讓更新的均方根固定在 0.2 左右,和 AdamW 的典型大小對齊,這樣就能直接沿用 AdamW 的學習率和權重衰減。在他們的 scaling law 實驗裡,Muon 大約只要 AdamW 52% 的計算量就達到同樣的損失。後來 Moonshot 的 Kimi K2、DeepSeek 的 V4 都在大部分參數上用了 Muon。

哪一個最快?

每一篇新優化器的論文,都會畫一張自己比 AdamW 快的圖。哪些是真的?

AlgoPerf 想用規則回答這個問題。它比的是「在固定硬體上,達到固定目標要多少時間」。總共 8 個工作負載,固定用 8 張 V100,分成兩組,一組允許有限地從外部調整超參數,另一組不准,但時間預算是三倍。2024 年的第一屆,Distributed Shampoo 和 Schedule-Free AdamW 各拿一組冠軍,前面都提過了;在允許外部調參的那一組,同一隊的 Schedule-Free 也拿到第二。

語言模型預訓練這邊,Wen、Hall、Ma 和 Liang 在 2025 年的〈Fantastic Pretraining Optimizers and Where to Find Them〉把 AdamW 和十個新優化器的超參數都仔細調過一輪。他們先發現,只把 GPT-3 配方裡 AdamW 的學習率從 6e-4 調到 8e-3,1.3 億參數的模型上就快了約 2 倍。很多論文宣稱的 2 倍,比的是沒調好的 AdamW。

基準調好之後,Muon、SOAP 這類矩陣型的優化器,在 1.3 億到 5.2 億參數時約快 1.3 到 1.4 倍,到 12 億參數降到約 1.1 倍;Lion、Sophia 這類逐座標的優化器,和 AdamW 差不多。他們也提醒,訓練中途的損失會騙人。Muon 前期常大幅領先,學習率降下來之後,和 AdamW 收在一起。

更大的規模又是另一回事。NVIDIA 在 2026 年 7 月的〈SOAP, Muon, and Beyond〉,用數十億參數、上兆 token 的模型比較,仍然量到 SOAP 和 Muon 勝過 AdamW。他們的基準批次約是每步 2,500 萬個 token,再放大兩三倍,AdamW 就變差,Muon 仍然穩定;原版 SOAP 在大批次下也會出現損失突然飆高的情況,要改成每一步都重新正交化基底的版本才撐得住。兩份結果的模型大小、資料量和批次都不同,可以同時成立。

最後整理一下

從 1847 年 Cauchy 的那三頁開始,梯度下降的核心一直是沿著負梯度走。今天習慣把它寫成這一行:

θt+1=θt−η ∇L(θt)\theta_{t+1} = \theta_t - \eta\, \nabla L(\theta_t)

後來的方法,都在補它某一個地方的不足:

  1. SGD、MBGD:資料太多,每次只看一小批;代價是雜訊,學習率得慢慢變小。
  2. SGDM、NAG:山谷裡來回彈跳,就記住剛才的方向,讓它互相抵銷;NAG 再提早一步剎車。
  3. AdaGrad、RMSProp、Adam:所有參數共用一個步長不合理,就讓每個參數各走各的;RMSProp 學會忘記,Adam 把動量和偏差修正一起放進來。
  4. AMSGrad、AdamW:修補 Adam 會忘記大梯度、權重衰減被縮小的問題。
  5. 餘弦、WSD、Schedule-Free、暖身:學習率怎麼隨時間變化,能不能不必事先知道終點,以及一開始為什麼要慢慢加速。
  6. LARS、LAMB:批次變大以後,各層的步長要各自調整。
  7. SAM:不只找低的谷底,還要找平坦的谷底。
  8. Adafactor、GaLore、Lion:狀態太多、記憶體不夠,就少存一點。
  9. Shampoo、SOAP、Sophia、Muon:估計地形的形狀,或換一把尺來量一步有多長。

如果今天要訓練一個模型,AdamW 加上暖身和餘弦或 WSD 排程,仍然是最穩的起點。模型夠大、權重矩陣夠多,Muon 和 SOAP 值得一試。不管選哪一個,先把學習率調好。

下次看到號稱快兩倍的新優化器,先問一句「AdamW 的學習率,調了嗎?」