scratch2modern
第一章 · 训练

1.06 优化器

这一节手写 6 个优化器:SGD 到 Muon
结果Muon 1.163 最好,Adam 1.176,SGD 1.319 最差

前面几节一直在想办法让训练跑得更快,可参数到底怎么更新,用的始终是 microgpt 自带的 Adam,我们没问过为什么是它。反向传播算出来的梯度,只告诉我们往哪个方向改参数,loss 下降得最快。每一步走多远、不同的参数要不要区别对待、以前的梯度要不要用上,这些都由优化器决定。这一节我们手写 6 个优化器,看看它们差在哪里。

1.10 1.15 1.20 1.25 1.30 1.35 SGD 1.319 Momentum 1.217 Adam 1.176 AdamW 1.183 Lion 1.226 Muon 1.163 验证集 bpb,越低越好(点是 3 个种子的均值,横线是范围)

6 个优化器各自用最合适的学习率,训练同样的 4096 步。Muon 最好,SGD 最差,中间差了 0.16。

先交代一个变化:从这一节开始,基础设置换成 bpe1024、模型宽度 48,一共 13.8 万个参数。这是 1.05 最后那组实验的结论,参数量相同时这个组合最好。其余和 1.05 一样:TinyStories,上下文 256,batch 16,训练 4096 步,学习率从初始值线性降到 0。每个优化器单独一个文件,接口都一样:给它参数和学习率,每一步调用一次 step。

下面按时间顺序讲这 6 个,每一个都在解决前一个留下的问题。代码只放每一步更新的那几行(完整文件在 GitHub),每个都先写出数学,再看代码。

1SGD沿着梯度往下走

最直接的想法:梯度指向 loss 上升最快的方向,那就往反方向走一小步。

\[\theta \leftarrow \theta - \eta\, g_t\]

\(\theta\) 是参数,\(g_t\) 是第 \(t\) 步的梯度,\(\eta\) 是学习率。SGD 里的"随机"(stochastic),是说 \(g_t\) 不是在全部数据上算的,而是在一个 batch 上算的,带着噪声。写成代码就一行:

for p in params:
    p -= lr * p.grad

问题在于,所有参数共用一个 \(\eta\)。想象 loss 是一条狭长的山谷,横着很陡,顺着谷底很平。\(\eta\) 要照顾最陡的方向,不然横着会越跳越高,直接发散;可这样一来,平缓的方向就走得很慢。

起点 +最低点 SGD:在两壁之间来回跳,沿谷底走得很慢 momentum:震荡抵消,沿谷底越走越快

示意:同一条山谷,都走 30 步。SGD 的学习率已经快到发散的边缘了,离最低点还是很远。

我们的实验里正是这样:SGD 的学习率越大越好,一直到 2;再加到 2.83,第 12 步就发散了。

2Momentum让方向攒起来

不直接用当前的梯度,而是把梯度一步步攒起来,攒下来的量叫动量 \(m\):

\[m \leftarrow \beta\, m + g_t, \qquad \theta \leftarrow \theta - \eta\, m\]

每一步先把之前攒的乘上 \(\beta\)(我们用 0.9),再加上这一步的梯度,然后沿着 \(m\) 走。像一个球滚下山:来回震荡的方向上,\(g_t\) 正负交替,加起来互相抵消;一直朝着同一个方向的谷底,\(g_t\) 不断叠加,越滚越快。如果梯度一直是 \(g\),\(m\) 最终会停在

\[m = \beta m + g \;\Rightarrow\; m = \frac{g}{1-\beta}\]

也就是 \(\beta = 0.9\) 时,步长被放大 10 倍。

for p, buf in zip(params, bufs):
    buf.mul_(beta).add_(p.grad)  # 新:先把攒下的乘 0.9,再加上这一步的梯度
    p -= lr * buf                # 新:用动量代替梯度

实验里 momentum 最好的学习率是 0.707,乘上 10 倍,等效步长约 7,是 SGD 发散边界的好几倍。震荡被抵消掉了,所以敢迈大步,bpb 从 1.319 降到 1.217。

剩下的问题是,不同参数的梯度大小可以差好几个数量级。比如一个很少出现的 token,它的 embedding 只有在 batch 里出现时才有梯度。全局只有一个 \(\eta\),对梯度大的参数刚好,对梯度小的就太小了。

3Adam每个参数有自己的步长

Adam 给每个参数记两样东西,再用它们来更新:

\[\begin{aligned} m &\leftarrow \beta_1 m + (1-\beta_1)\, g_t \\ v &\leftarrow \beta_2 v + (1-\beta_2)\, g_t^2 \\ \hat m &= \frac{m}{1-\beta_1^t}, \qquad \hat v = \frac{v}{1-\beta_2^t} \\ \theta &\leftarrow \theta - \eta\, \frac{\hat m}{\sqrt{\hat v} + \epsilon} \end{aligned}\]

一行一行看:

  1. \(m\) 是梯度的滑动平均,告诉我们往哪走,和 momentum 一样,只是多乘了 \(1-\beta_1\),变成了平均而不是累加。
  2. \(v\) 是梯度平方的滑动平均,告诉我们这个参数的梯度一般有多大。
  3. \(m\) 和 \(v\) 都从 0 开始,前几步会严重偏小,除以 \(1-\beta^t\) 正好修正回来。\(t\) 大了以后这一项趋近于 1,就不起作用了。
  4. 更新时用 \(\hat m\) 除以 \(\sqrt{\hat v}\),每个参数都用自己梯度的大小去归一化,\(\epsilon\) 只是防止除以 0。梯度大的,步子不会太大;梯度小的,步子也不会太小,每个参数每步大约都走 \(\eta\) 这么远。

\(\beta_1 = 0.85,\ \beta_2 = 0.99\),沿用 microgpt 的设置。

t += 1
for p, m, v in zip(params, ms, vs):
    m.mul_(beta1).add_((1 - beta1) * p.grad)       # 梯度的平均:往哪走
    v.mul_(beta2).add_((1 - beta2) * p.grad ** 2)  # 梯度平方的平均:梯度一般有多大
    m_hat = m / (1 - beta1 ** t)                   # m 和 v 从 0 开始,前几步偏小,修正回来
    v_hat = v / (1 - beta2 ** t)
    p -= lr * m_hat / (v_hat ** 0.5 + eps)         # 用自己梯度的大小归一化

实验里 Adam 最好的学习率是 0.01,bpb 1.176。代价是每个参数要多存 \(m\) 和 \(v\) 两份,优化器的状态是参数量的 2 倍。

4AdamW把 weight decay 单独拿出来

weight decay 是每一步把所有参数按比例往 0 拉一点,防止参数无限变大。最自然的做法是在 loss 里加一项参数的平方和:

\[\mathcal{L}\;\to\;\mathcal{L} + \frac{\lambda}{2}\lVert\theta\rVert^2\]

它的梯度是 \(\lambda\theta\),加进 \(g_t\) 就行。在 SGD 里这样做完全没问题。但在 Adam 里,加进去的 \(\lambda\theta\) 也会和梯度一起被 \(\sqrt{\hat v}\) 除掉,结果梯度大的参数反而被拉得少,这不是我们想要的。AdamW 的修正很简单,weight decay 不经过梯度,单独减掉:

\[\theta \leftarrow \theta - \eta\lambda\,\theta - \eta\, \frac{\hat m}{\sqrt{\hat v} + \epsilon}\]

多出来的就是 \(-\eta\lambda\theta\) 这一项,其余和 Adam 完全一样。我们取 \(\lambda = 0.1\)。

for p, m, v in zip(params, ms, vs):
    p.mul_(1 - lr * weight_decay)  # 新:和 Adam 唯一的区别,不经过梯度,直接往 0 拉一点
    ...                            # 其余和 Adam 完全一样

实验里 AdamW 比 Adam 略差,1.183 对 1.176,差距比换种子带来的波动还大。我们的模型小、训练短,还处在学不够的阶段,用不着把参数往回拉。

5Lion只看方向,不看大小

Lion 是 Google 在 2023 年用程序自动搜索出来的。它把 Adam 的思路推到了头:Adam 用 \(\hat m/\sqrt{\hat v}\) 来归一化,Lion 干脆只取符号:

\[\begin{aligned} \theta &\leftarrow \theta - \eta\cdot \mathrm{sign}\big(\beta_1 m + (1-\beta_1)\, g_t\big) \\ m &\leftarrow \beta_2 m + (1-\beta_2)\, g_t \end{aligned}\]

\(\mathrm{sign}\) 只看正负,正的变成 1,负的变成 −1,所以每个参数每一步都恰好走 \(\pm\eta\)。注意两行用的 \(\beta\) 不一样:更新方向用 \(\beta_1 = 0.9\) 混合,动量本身用 \(\beta_2 = 0.99\) 更新。好处是只要一份状态 \(m\),显存是 Adam 的一半。

for p, m in zip(params, ms):
    p -= lr * (beta1 * m + (1 - beta1) * p.grad).sign()  # 只取符号:每步都走 ±lr
    m.mul_(beta2).add_((1 - beta2) * p.grad)             # 只有一份状态

每个参数每步都走满,更新的幅度比 Adam 大,学习率就要小很多。我们最好的学习率是 0.00125,正好是 Adam 的 1/8,bpb 1.226。它也完全丢掉了梯度大小的信息:哪怕某个参数的梯度只是噪声,也要走满一步。

6Muon把权重当作矩阵来更新

前面 5 个都把参数看成一堆独立的数,各更新各的。但 Transformer 里大部分参数是矩阵,它的作用是把一个向量变成另一个向量。Muon(Keller Jordan,2024)从这个角度出发。它的观察是:用 Adam 这类优化器训练时,矩阵的更新往往集中在少数几个方向上,其余方向几乎不动。

任何矩阵都可以拆成三个矩阵相乘,这叫奇异值分解:

\[M = U \Sigma V^\top\]

\(U\) 和 \(V\) 的每一列是一个方向,\(\Sigma\) 是对角矩阵,对角线上的奇异值 \(\sigma_i\) 表示每个方向被放大了多少。Muon 把动量矩阵 \(M\) 的奇异值全都换成 1,方向保留,但每个方向的幅度一样,原来被压住的方向也能学起来。这叫正交化:

\[\mathrm{orth}(M) = U V^\top, \qquad \theta \leftarrow \theta - \eta \cdot \sqrt{\max\!\Big(1, \frac{\text{行数}}{\text{列数}}\Big)} \cdot \mathrm{orth}(M)\]

\(M\) 是动量,和 momentum 一样攒(\(\beta = 0.95\)),实际代码里拿去正交化的是 \(g_t + \beta m\),这叫 Nesterov 动量,相当于往前多看一步。根号那一项让高矩阵和宽矩阵的更新幅度一致。

奇异值分解算起来很慢,Muon 用 Newton–Schulz 迭代来近似,只用矩阵乘法。先把 \(M\) 缩小到所有奇异值都不超过 1,记作 \(X\),然后反复做:

\[X \leftarrow aX + b\,(XX^\top)X + c\,(XX^\top)^2X, \qquad (a,b,c) = (3.4445,\ -4.7750,\ 2.0315)\]

这一步对每个奇异值做的事是一样的:\(\sigma \leftarrow a\sigma + b\sigma^3 + c\sigma^5\)。这组系数让 \(\sigma\) 每迭代一次就往 1 推一大步,5 次就差不多了,只是不精确等于 1,我们实测落在 0.68 到 1.13 之间。

def orthogonalize(G, steps=5):
    # Newton–Schulz 迭代:把 G 的奇异值都推向 1,近似得到 U Vᵀ
    a, b, c = 3.4445, -4.7750, 2.0315
    X = G / (G.norm() + 1e-7)  # 先缩小,让所有奇异值都不超过 1
    for _ in range(steps):
        A = X @ X.T
        X = a * X + (b * A + c * A @ A) @ X
    return X

for p, buf in zip(matrices, bufs):  # 只管 Transformer 内部的矩阵
    buf.mul_(beta).add_(p.grad)
    g = p.grad + beta * buf         # 和 momentum 一样攒动量(Nesterov 写法)
    scale = max(1, p.shape[0] / p.shape[1]) ** 0.5  # 让高矩阵和宽矩阵的更新幅度一致
    p -= lr * scale * orthogonalize(g)
adam.step()                         # 其余参数还是交给 Adam

Muon 只用在 Transformer 内部的矩阵上,也就是 q、k、v、o 和 MLP。embedding 是查表,norm 的权重不是矩阵,lm_head 原作者发现用 Adam 更好,这些都还交给 Adam。在我们的模型里,Muon 只管 2.8 万个参数,占 20%。

怎么比也要想一想。不同优化器合适的学习率能差上千倍,SGD 是 2,Lion 是 0.00125,用同一个学习率去比,比的其实是学习率。所以每个优化器单独扫一遍学习率,相邻两点差 2 倍,取各自最好的那个;如果最好的点紧挨着发散的点,就在中间再补一个。然后在最好的学习率上再换 2 个随机种子,一共跑 3 次。有的优化器之间只差 0.01,和换种子带来的波动是同一个量级,不看波动就分不出谁真的更好。

运行结果

结果分成两档。Muon、Adam、AdamW 是一档,彼此相差不到 0.02;momentum、Lion、SGD 是另一档,比前一档差 0.03 到 0.16。前三名的排名是可信的:Muon 比 Adam 好 0.013,Adam 比 AdamW 好 0.008,都比各自换种子的波动(0.002 到 0.005)大。momentum 和 Lion 只差 0.009,比 Lion 自己换种子的波动(0.013)还小,算打平。

SGD 1.2 1.4 1.6 1.8 0.125 16 Momentum 0.0156 2 Adam 0.00125 0.16 AdamW 1.2 1.4 1.6 1.8 0.00125 0.16 Lion 0.000156 0.02 Muon 0.0025 0.32 横轴:学习率(对数坐标,相邻两点差 2 倍);纵轴:验证集 bpb;大点是最佳学习率;× 是发散

扫描图上差别更明显。SGD 和 momentum 的学习率越大越好,最好的点紧贴着发散的点,看不到谷底,它们就是被最陡的方向卡住了。Adam 和 Muon 在很宽的范围里都不发散,谷底也平缓,这就是常说的"好调"。Muon 的谷底最宽,0.01 到 0.04 的结果都在最佳值的 0.02 以内。

Lion 有点特别。学习率 0.0025 和 0.00177 都不是一开始就发散,而是分别训练到第 776 步和第 3403 步才崩。一个可能的原因是我们没有加 weight decay(原论文是加的),参数每步都走满一步,慢慢变大,直到不稳定。这只是推测。

Adam Muon 1.15 1.20 1.25 1.30 1.35 1.40 0 1024 2048 3072 4096 步数 1.15 1.20 1.25 1.30 1.35 1.40 0 10 20 30 40 训练时间(秒)

Adam 和 Muon 各自在最佳学习率下的验证集 bpb,纵轴只画了 1.40 以下的部分。左边按步数,右边按训练时间。

按步数算,Muon 最好。但它每一步多花 21% 的时间,4096 步要 40 秒,Adam 只要 33 秒。原因还是 1.04 讲过的:矩阵只有 48×48,5 次迭代几乎不花计算,时间都花在多出来的几十次 kernel 启动上。

按时间看,到 Adam 跑完的 33 秒,Muon 的学习率还没降完,bpb 1.18,比 Adam 还差一点。要公平地按时间比,得让 Muon 在 33 秒内就把学习率降完,这里没有做。

Muon 生成的故事:

Once upon a time, there was a little girl named Lily. She had a very pretty. She had a new friend, a little girl named Lily.

最后补充一点:这些结论放到大模型上还成立吗?大体是一致的。SGD 基本不用来训练 Transformer;AdamW 是大模型预训练的默认选择,LLaMA、Chinchilla、DeepSeek-V3 用的都是它;Muon 正在被前沿模型采用,Kimi K2、GLM-4.5、DeepSeek-V4 都换成了它。

不一致的地方,主要来自规模。weight decay 在我们这里有害,但大模型要训练很久,不加的话权重会越来越大,超出 bf16 这类低精度数能精确表示的范围,所以是必需的。Muon 的额外开销在我们这里有 21%,到了大模型里,矩阵大了,额外的计算不到 1%。至于 Muon 到底能快多少,Moonshot 报告约 2 倍;Wen et al. (2025) 把 AdamW 认真调好以后再比,只有 1.1 到 1.4 倍,而且模型越大越少。这也说明了,比较优化器时,每个都要各自调好学习率,不然比的就是学习率。