返回博客
一般文章

图解梯度下降法

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超大批量时各层 ‖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 步内按余弦递减(峰值: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 的学习率,调了吗?」