1.06 优化器
前面几节一直在想办法让训练跑得更快,可参数到底怎么更新,用的始终是 microgpt 自带的 Adam,我们没问过为什么是它。反向传播算出来的梯度,只告诉我们往哪个方向改参数,loss 下降得最快。每一步走多远、不同的参数要不要区别对待、以前的梯度要不要用上,这些都由优化器决定。这一节我们手写 6 个优化器,看看它们差在哪里。
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\) 是参数,\(g_t\) 是第 \(t\) 步的梯度,\(\eta\) 是学习率。SGD 里的"随机"(stochastic),是说 \(g_t\) 不是在全部数据上算的,而是在一个 batch 上算的,带着噪声。写成代码就一行:
for p in params:
p -= lr * p.grad
问题在于,所有参数共用一个 \(\eta\)。想象 loss 是一条狭长的山谷,横着很陡,顺着谷底很平。\(\eta\) 要照顾最陡的方向,不然横着会越跳越高,直接发散;可这样一来,平缓的方向就走得很慢。
示意:同一条山谷,都走 30 步。SGD 的学习率已经快到发散的边缘了,离最低点还是很远。
我们的实验里正是这样:SGD 的学习率越大越好,一直到 2;再加到 2.83,第 12 步就发散了。
2Momentum让方向攒起来
不直接用当前的梯度,而是把梯度一步步攒起来,攒下来的量叫动量 \(m\):
每一步先把之前攒的乘上 \(\beta\)(我们用 0.9),再加上这一步的梯度,然后沿着 \(m\) 走。像一个球滚下山:来回震荡的方向上,\(g_t\) 正负交替,加起来互相抵消;一直朝着同一个方向的谷底,\(g_t\) 不断叠加,越滚越快。如果梯度一直是 \(g\),\(m\) 最终会停在
也就是 \(\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 给每个参数记两样东西,再用它们来更新:
一行一行看:
- \(m\) 是梯度的滑动平均,告诉我们往哪走,和 momentum 一样,只是多乘了 \(1-\beta_1\),变成了平均而不是累加。
- \(v\) 是梯度平方的滑动平均,告诉我们这个参数的梯度一般有多大。
- \(m\) 和 \(v\) 都从 0 开始,前几步会严重偏小,除以 \(1-\beta^t\) 正好修正回来。\(t\) 大了以后这一项趋近于 1,就不起作用了。
- 更新时用 \(\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 里加一项参数的平方和:
它的梯度是 \(\lambda\theta\),加进 \(g_t\) 就行。在 SGD 里这样做完全没问题。但在 Adam 里,加进去的 \(\lambda\theta\) 也会和梯度一起被 \(\sqrt{\hat v}\) 除掉,结果梯度大的参数反而被拉得少,这不是我们想要的。AdamW 的修正很简单,weight decay 不经过梯度,单独减掉:
多出来的就是 \(-\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 干脆只取符号:
\(\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 这类优化器训练时,矩阵的更新往往集中在少数几个方向上,其余方向几乎不动。
任何矩阵都可以拆成三个矩阵相乘,这叫奇异值分解:
\(U\) 和 \(V\) 的每一列是一个方向,\(\Sigma\) 是对角矩阵,对角线上的奇异值 \(\sigma_i\) 表示每个方向被放大了多少。Muon 把动量矩阵 \(M\) 的奇异值全都换成 1,方向保留,但每个方向的幅度一样,原来被压住的方向也能学起来。这叫正交化:
\(M\) 是动量,和 momentum 一样攒(\(\beta = 0.95\)),实际代码里拿去正交化的是 \(g_t + \beta m\),这叫 Nesterov 动量,相当于往前多看一步。根号那一项让高矩阵和宽矩阵的更新幅度一致。
奇异值分解算起来很慢,Muon 用 Newton–Schulz 迭代来近似,只用矩阵乘法。先把 \(M\) 缩小到所有奇异值都不超过 1,记作 \(X\),然后反复做:
这一步对每个奇异值做的事是一样的:\(\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 和 momentum 的学习率越大越好,最好的点紧贴着发散的点,看不到谷底,它们就是被最陡的方向卡住了。Adam 和 Muon 在很宽的范围里都不发散,谷底也平缓,这就是常说的"好调"。Muon 的谷底最宽,0.01 到 0.04 的结果都在最佳值的 0.02 以内。
Lion 有点特别。学习率 0.0025 和 0.00177 都不是一开始就发散,而是分别训练到第 776 步和第 3403 步才崩。一个可能的原因是我们没有加 weight decay(原论文是加的),参数每步都走满一步,慢慢变大,直到不稳定。这只是推测。
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 生成的故事:
最后补充一点:这些结论放到大模型上还成立吗?大体是一致的。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 倍,而且模型越大越少。这也说明了,比较优化器时,每个都要各自调好学习率,不然比的就是学习率。