打开一份 PyTorch 的训练代码,循环里几乎都有这两行:
loss.backward()
optimizer.step()
backward() 算出每个参数该往哪个方向改,step() 真正动手去改。这篇要讲的,就是 step() 里面那几行。
方向都已经算好了,照着走不就行了?听起来没什么好讲的。可是光是「这一步怎么走」,从 SGD、Momentum、AdaGrad、Adam、AdamW 一路到 Lion、Muon,就长出了一整个家族。每个新方法出现,几乎都是因为前一个方法在某种地形上走不好。
我们从最基础的地方开始,用一条直线和十二个包裹。先把「梯度」画出来,再让它走过狭长的山谷、随机的噪声、悬崖和鞍点,看每个方法补上了前一个方法的哪个缺口。
出发前,先看一眼整条路线。每一行是一个方法,后面写的是它要补的缺口:
基本款
- BGD起点:每一步都看完全部数据。
- SGD · MBGD每步看完全部数据太慢 → 抽一条或一小批。
- SGDM之字形与噪声 → 累积速度。
- NAG动量冲过头 → 在前方的位置算梯度。
每个参数各自的步长
- AdaGrad所有参数共用一个学习率 → 按累积梯度各自缩放。
- RMSProp · AdaDeltaAdaGrad 的学习率只降不升 → 改用会遗忘的移动平均。
- Adam · Nadam合并动量与各自的步长,并修正从零起步的偏差。
修补 Adam
- AMSGradAdam 可能收敛到错的地方 → 让 v 不再变小。
- AdamWL2 正则化在 Adam 里被除掉 → 把权重衰减拆出来。
- Warmup · Cosine · SGDR · RAdam · Schedule-Free学习率要怎么变?Adam 为何要预热?→ 调度、修正方差,或干脆不调度。
规模与几何
- LARS · LAMB超大批量时各层 ‖w‖/‖g‖ 差很多 → 逐层信任比。
- Adafactor · GaLore优化器状态吃掉显存 → 分解它,或放进低秩子空间。
- SAM低损失却落在窄谷 → 比较 ρ 范围内最坏的损失。
- Shampoo · SOAP · Sophia对角缩放救不了斜的山谷 → 矩阵预条件,或曲率加裁剪。
- Lion更少的状态与计算 → 只取正负号。
- Muon权重是矩阵,不是一长串数字 → 把整个更新正交化。
文中的动图都在你的浏览器里实时计算,每一步用的就是文章写出来的那条公式。按下暂停,可以拖着滑块一步一步看。
从一条直线开始
假设你在网上开了一家小店,最近寄出 12 个包裹。重量从 0.5 到 1.5 公斤,运费从 92 元到 150 元不等。
运费看起来大致是「基本费+每公斤加价」,可以写成一条直线:
是重量(公斤), 是预测的运费(以百元为单位), 是每公斤加多少, 是基本费。我们要从这 12 条记录里,找出最合适的 和 。
先随便猜一组,每公斤 210 元、基本费 20 元,也就是 、。这条线太陡了,12 个包裹的预测全都比实际贵,最轻的那个多算了 32 元,最重的多算了 185 元。
怎么衡量「猜得有多差」?把每个包裹的误差平方,再取平均:
平方让正负误差不会互相抵消,也让差很多的包裹被罚得更重。前面的 只是为了等一下求导时,把平方带下来的 2 消掉。
这个 叫做损失函数(loss function)。代入我们猜的那一组,。
接下来是整篇最重要的概念。
每一组 都是一条直线,也都对应一个损失值。把 当横轴、 当纵轴,在平面上每一点标出它的损失,就得到一张地形图。损失越低,地势越低。找最好的直线,就是在这张地形上找最低点。
地形图上一圈一圈的曲线是等高线,同一圈上每一点的损失都相同,越靠近中间的星号,损失越低。星号在 、,也就是每公斤 59 元、基本费 61 元,这时 。
注意这张地形的形状。它是一条斜斜的、又窄又长的山谷。这个形状会跟着我们走完整篇文章,后面很多方法都在想办法对付它。
斜率与梯度
站在地形上的某一点,怎么知道哪边是下坡?
先简化一下。把 固定在最优值,只动 ,地形就只剩一条曲线。曲线上任一点的切线斜率,就是导数 :
斜率是正的,说明 变大、损失跟着变大,下坡在左边;斜率是负的,下坡在右边;斜率是 0,就到谷底了。往斜率的反方向走,就是往下坡走。
两个参数都能动的时候,每个参数各有一个偏导数,也就是「只动它、其他不动」时的斜率。对我们的损失函数算一下:
把它们排成一个向量,就是梯度(gradient):
这两个式子读起来不难。每个包裹的误差,乘上这个参数对它的影响力,再取平均。 对每个包裹的影响都是 1; 的影响是包裹的重量 ,越重的包裹,对 的意见越大。
在起点 ,12 个包裹全都被高估,算出来 。两个分量都是正的,表示 或 再调大,损失都会变大。
图上可以看到梯度的两个性质:
- 它指向上坡最陡的方向,所以 是下坡最陡的方向。
- 它和通过这一点的等高线垂直。
为什么?在某一点 附近走一小步 ,损失的变化大约是
这是一阶泰勒展开。点积可以写成 , 是梯度和这一步之间的夹角。步长固定时,,也就是和梯度反方向走,损失降得最多。沿着等高线走,损失不变,,夹角是 ,所以梯度和等高线垂直。
BGD:沿着负梯度走
知道下坡的方向,剩下的就简单了。每次往 走一小步,然后重复:
(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.71 掉到 0.040,一步就少了九成多。
第一步很漂亮。接下来呢?
点掉进山谷之后,就沿着谷底慢慢爬。包裹那张图上的直线早就贴近数据了,之后一百多步都只是在微调,要到第 168 步,才进入离最低点 0.03 以内的范围。
为什么这么慢?把 调大一点,会不会好一些?
学习率:一步要走多远
先回到最简单的情况,一维的碗 。 是碗的曲率,也就是二阶导数,越大碗越陡。梯度是 ,所以每一步:
每走一步, 就乘上一次 。
图里 ,四组只差在 :
- :每步只缩小 10%,慢慢爬。
- :每步只剩 10%,很快到底。
- :,每一步都跨到对面,但越跨越近,来回摆动着收敛。
- :,每一步跨到对面还更远,越摆越大,发散了。
所以收敛的条件是 ,也就是 。碗越陡,学习率就得越小。
又窄又长的山谷
我们的地形是二维的,麻烦在于它有两种曲率。
横切过山谷,地形很陡;顺着谷底往前,地形非常平。用线性代数的话说,这是损失的二阶导数矩阵(Hessian)的两个特征值,在这个例子里分别是 2.05 和 0.045,相差 46 倍。这个比值叫做条件数(condition number),记作 。
同一个 要同时照顾两个方向。为了不在陡的方向发散, 必须小于 ;可是在平的方向上,每一步最多只能缩小 ,至少要走上几十步。 大一点,陡的方向来回弹跳; 小一点,平的方向走不动。
时,点在陡的方向上来回跳,走成之字形,一边沿着谷底慢慢前进,第 93 步才到。
这个山谷为什么是斜的?谷底的方向大约是 ,也就是 加 1、 减 1。对一个 1 公斤的包裹来说,预测运费 完全没变。这 12 个包裹的平均重量刚好是 1 公斤,所以沿着这个方向调整,整体的预测几乎不受影响,损失也几乎不变。斜率和截距互相抵消,就形成了一道斜斜的谷。
点一下图上的「减掉平均」,把每个包裹的重量都减掉 1 公斤,模型变成 。能画出来的直线完全一样,但 和新的截距 不再互相牵制,山谷转正了,条件数降到 10.9,第 46 步就到。再除以标准差,也就是「标准化」,斜率也换成新的 ,两个方向的曲率变得一样,山谷变成圆碗,条件数是 1,两步就到了。
这就是训练前常要把输入标准化的原因。可是在深度网络里,参数动辄上亿个,每一层的输入还一直在变,我们没办法一一替地形调整形状。
后面的方法,大致从三个方向下手:
- 记住刚才走过的方向,让来回的弹跳互相抵消(动量)。
- 每个参数用不同的步长(AdaGrad、RMSProp、Adam)。
- 估计地形的形状,或换一把尺来量一步(牛顿法、Shampoo、Muon)。
撞上悬崖
学习率太大会发散。有时候学习率不大,也会被一步甩出去。
这个地形是一段缓坡接着一道陡墙。点顺着缓坡走到墙边,有一步刚好踩上墙面。墙上的梯度非常大,下一步直接被弹到 ,飞出画面。它花了快十步爬回墙边,接着又踩上墙面,又被弹出去;40 步里被弹了三次,其中两次直接飞出画面。
真实的 RNN 里也有这种墙。Pascanu、Mikolov 和 Bengio 在 2013 年分析 RNN 为什么难训练时,提出了一个假说。梯度爆炸的方向上,曲率通常也很大,损失曲面会形成一道陡墙,一步踩上去,就被甩出原本的山谷。他们在 On the difficulty of training recurrent neural networks 里用只有一个隐藏单元的 RNN 画出了这种墙。
解法很直接,梯度太大时就把它缩小。最常见的是按范数裁剪(clip by norm):
梯度的长度超过 ,就缩到 ,方向不变。「裁剪到 1」那张图把梯度大小限制在 1,点一直在墙边小幅来回,没有飞走。在 PyTorch 里,这就是 torch.nn.utils.clip_grad_norm_。
要设多少?Pascanu 等人的建议是先观察一段时间的平均梯度范数,取它的一半到十倍之间,都还能收敛,只是速度会受影响。
SGD 与 MBGD:一次只看几条数据
BGD 每走一步,都要把全部数据看过一遍。12 个包裹无所谓;换成 ImageNet 的 128 万张训练图片,每走一步,就得先让 128 万张图都跑过一次前向和反向传播。
随机梯度下降(Stochastic Gradient Descent,SGD)每一步只随机抽一条数据,用它的梯度代替全体的梯度:
是第 条数据自己的损失, 是第 步抽到的那一条。
只看一条,梯度当然不准。但如果每一条被抽到的机会都一样,它的期望值刚好就是全体的梯度:
平均来说方向是对的,只是每一步都带着噪声。
折中的做法是每次抽一小批(batch),例如 4 条,把它们的梯度平均起来。这叫小批量梯度下降(Mini-Batch Gradient Descent,MBGD)。批量越大,噪声越小;梯度的方差大致和批量大小成反比。
三条路线用同样的 。BGD 走得最平顺;MBGD 一路微微晃动;SGD 抖得最厉害,包裹那张图上圈起来的,就是它这一步抽到的包裹。
可是看一下读了多少数据。三者大约都在第 170 步前后进入最低点 0.03 以内,BGD 每步读 12 条,到达时已经读了 2,016 条;MBGD 读了 676 条;SGD 只读了 178 条。按读过的数据量来算,抖得最厉害的那条路线最省。
学习率要慢慢变小
SGD 有一个 BGD 没有的麻烦。走到最低点时,全体的梯度是 0,可是每个包裹自己的梯度并不是 0。12 个包裹不可能全都刚好落在同一条直线上,每一个都还在拉着参数往自己那边走。抽到哪一个,就往哪边偏一下。
这张图直接从最低点出发,每次只看一条。学习率固定时,参数一直在最低点附近打转,最后 50 步离最低点的平均距离是 0.042;学习率照 随步数变小,打转的范围跟着缩小,平均距离降到 0.015。
学习率要怎么变小才对?太快变小,还没走到就停了;太慢变小,噪声一直消不掉。
找最低点,就是找让 的那一点,也就是解一个方程的根。Robbins 和 Monro 在 1951 年的〈A Stochastic Approximation Method〉研究的正是这类问题,只是他们每次只能观测到带噪声的结果。后人把他们的步长条件整理成两条:
第一条让总步长够长,不管起点多远都走得到;第二条让噪声累积的总量有限,最后才停得下来。 两条都满足,上图的递减方式就属于这一类。
噪声也有用处
SGD 的噪声也不全是坏事。
这个地形是 。原点是一个鞍点,沿着 方向看是谷底,沿着 方向看是山顶,梯度是 0。两个真正的谷底在 。
GD 从 出发, 方向的梯度一开始就是 0,之后也永远是 0,于是一路滑进鞍点,停在那里。加上一点点噪声(标准差只有 0.0001),点走到鞍点附近时被轻轻推离山脊,第 64 步就落进 的谷底。
在二维的图上,鞍点看起来像个特例。Dauphin 等人 2014 年的〈Identifying and attacking the saddle point problem in high-dimensional non-convex optimization〉主张,维度越高,鞍点相对于局部极小值的数量就越多,训练变慢常是因为卡在鞍点附近平坦的高原,而不是掉进坏的局部极小值。
噪声能帮忙脱困,但理论上要附带条件。Ge 等人 2015 年证明,如果每个鞍点都有明确的下坡方向(负曲率),函数也足够光滑,而且噪声在每个方向都有方差,带噪声的 SGD 能在多项式步数内离开鞍点。我们的例子从山脊正上方出发,是故意挑的最坏情况;从随机的起点出发,GD 几乎不会刚好停在鞍点上,只是在平坦的高原上可能走得很慢。
SGDM:记住刚才的方向
回到又窄又长的山谷。之字形的问题在于,横跨山谷的那个方向,梯度每一步都在翻转正负号,这一步推向山谷的一侧,下一步又推回另一侧。沿着谷底的那个方向,梯度虽然小,却一直指向同一边。
如果每一步不只看当前的梯度,也参考前几步的梯度,来回翻转的部分会互相抵消,一直指向同一边的部分会累积起来。
指数移动平均
「参考前几步」最常用的做法,是指数移动平均(Exponential Moving Average,EMA):
新的平均值,是旧平均值乘上 ,再加上新梯度乘上 。 时,新梯度占一成;十步前的梯度还剩 的影响力,越旧的越淡。它不必把过去的梯度一个一个存起来,只要记住一个数字。
我们把 GD 在山谷里的梯度,拆成横跨山谷和沿着山谷两个分量。横跨的分量第一步约是 1.7,之后正负交替,EMA 很快就压到 0 附近;沿着谷底的分量只有约 0.06,但方向始终一致,EMA 稳稳地留了下来。
动量
把这个平均拿来更新参数,就是动量法(momentum)。带动量的 SGD 常简称 SGDM:
这里的 少了 这个系数,所以它是上面 EMA 的 倍。梯度一直指向同一边时, 会累积到 , 就是 10 倍。原本在平的方向上走不动的小梯度,就这样被放大了。
这个比喻来自物理。 像是一颗球的速度,梯度是坡度给它的推力, 决定每一步保留多少速度。
这个想法也比深度学习早得多。Polyak 在 1964 年把它写成
也就是在梯度那一步之外,再加上「上一步的位移」乘上 。把上面两行的 消掉,会得到一模一样的式子, 就是 。Polyak 自己取名叫重球法(heavy ball),把它看成一个物体在势能场里运动的离散版本,并建议 通常取 0.8 到 0.99。
他还算出了加速的幅度。在条件数为 的二次函数上,GD 要走的步数大约和 成正比,重球法只要和 成正比。我们的山谷 ,。不过这个结果只在二次函数,或极小点附近足够像二次函数的地方成立;Lessard 等人在 2016 年就构造过一个条件数 25 的一维函数,照二次函数的最优参数跑重球法,会陷入永远不衰减的振荡。
同样是 ,GD 第 93 步才到,加上 的动量,第 19 步就到了。
仔细看动量那条路线,它一开始并没有更老实,反而大幅横跨山谷好几次。动量抵消掉的,是每一步都翻正负号的那种弹跳;球已经累积的速度,仍然要好几步才停得下来。
太大会怎样?
三张图都用 。 记忆太短,帮助有限,200 步内没走到; 第 51 步到; 几乎没有摩擦,球在谷底附近一圈一圈绕,200 步内也没停下来。
NAG:先看一眼再踩
动量反应慢。快到谷底时,球带着累积的速度冲过头,要等梯度反过来推好几步,才转得回来。
Nesterov 动量(Nesterov Accelerated Gradient,NAG)只改了一个地方。既然这一步反正会沿着速度往前走,那就先走到那里,看看那边的坡度,再决定怎么修正:
唯一的差别是梯度在哪里算。动量在当前位置算;NAG 在「照当前速度走一步之后」的前瞻点算。如果前方已经开始上坡,NAG 这一步就提早感觉到,先踩一点刹车。
空心圈是 NAG 的前瞻点。同样用 、,动量第 37 步到,NAG 第 22 步到。
为什么在山谷里特别有效?Sutskever 等人在 2013 年证明,在二次函数上,NAG 等于在每个特征方向各用一个不同的动量 , 是那个方向的曲率。曲率越大的方向,动量越小。代入这张图的设置,横跨山谷的方向 ,有效动量只剩 ,几乎没有冲劲;沿着谷底的方向 ,还保有 0.78。容易来回弹跳的方向被压住,需要加速的方向照样加速。
这个方法出自 Nesterov 1983 年的论文,原本是凸优化的理论结果,保证误差以 的速度下降。「在前瞻点算梯度」这种写法,则是 Sutskever、Martens、Dahl 和 Hinton 在〈On the importance of initialization and momentum in deep learning〉里改写的。他们让动量从小慢慢升到 0.99 甚至 0.999,配上精心设计的初始化,让 SGD 加动量在深层自编码器上追平了当时更复杂的二阶方法。
AdaGrad:每个参数各走各的
到目前为止,所有参数都共用同一个 。
这在很多问题上并不合理。AdaGrad 的作者 Duchi、Hazan 和 Singer 举的是文本数据的例子。常见的词每一条数据里都会出现,对应的参数一直被更新;罕见的词偶尔才出现一次,可是它一出现,往往就很有预测力。同一个学习率,对前者可能太大,对后者又太小。
AdaGrad 让每个参数记住自己过去所有梯度的平方和,再用它的平方根来除:
这里的平方、开根号和除法,都是每个参数各算各的。 是一个很小的数,避免除以零。
梯度一直很大的参数, 长得快,步子就变小;很少被更新的参数, 小,一有梯度就能走一大步。第一步更有意思,,所以每个参数的第一步都是 ,和梯度本身多大无关。
用 ,第一步 和 各走了刚好 0.5。之后两个参数的有效学习率几乎就停在 0.39 和 0.45,再也没动过。 有 97% 来自前五步。一开始离最低点远,梯度大,平方一加进去就很大;之后梯度越来越小,再怎么加也加不了多少。这张图要到第 203 步才进入 0.03 以内,比 BGD 的 168 步还慢。
只会越加越大,每个参数的有效学习率 只会越来越小,而且主要由最早那几步决定。在凸问题上,这正好是让它收敛的机制;可是训练一个深度网络要走上几十万步,地形一路在变,学习率往往在还没走到好地方之前,就已经小到走不动了。
RMSProp 与 AdaDelta:学会忘记
既然麻烦来自「把所有过去的梯度都加起来」,那就只记最近的。
把 AdaGrad 的累加换成指数移动平均,就是 RMSProp:
通常取 0.9。这里的 记的是梯度平方的平均,和动量那一节的速度 不是同一个东西。很久以前的大梯度会慢慢被淡忘,有效学习率可以变小,也可以再变大回来。
RMSProp 的出身很少见,它没有论文。它出自 Hinton 2012 年在 Coursera 开的〈Neural Networks for Machine Learning〉课程,第 6 讲第 5 节(Lecture 6e)的幻灯片。幻灯片上写的就是 ,再用它的平方根去除梯度,并注明这是 Tijmen Tieleman 尚未发表的工作。后来的论文引用它时,就只能引用这份讲义。
这张图的地形先是一段斜率为 1 的陡坡,接着是斜率只有 0.1 的长缓坡,谷底在 。两者都从 出发,AdaGrad 用 ,RMSProp 用 、。
在陡坡上,两者的分母都被大梯度撑大。走到缓坡之后,AdaGrad 的 还记着陡坡上的每一步,步长掉到约 0.01;RMSProp 很快忘掉了,分母跟着梯度变小,步长回到约 0.1。到第 100 步,AdaGrad 才走到 ,RMSProp 已经在 5.1;RMSProp 大约第 150 步就到谷底,AdaGrad 走到第 240 步,也只到 3.45。学习率给得比较大的那个,反而走得比较慢。
同一年,Zeiler 提出的 AdaDelta 也用了同样的移动平均,还多想了一步。他注意到 SGD 和 AdaGrad 的更新量,单位对不上。梯度的单位是「损失 ÷ 参数」,拿它去更新参数,单位就错了;如果再用二阶导数去除(后面讲牛顿法时会再看到),单位才会变回「参数」。AdaDelta 没有真的去算二阶导数,而是把分子的 换成「过去更新量」的均方根:
分子和分母的单位一约,更新量的单位就和参数一致了,连学习率都不用设。
Adam:把两件事合在一起
到这里,我们手上有两个工具。动量用梯度的移动平均,处理方向一直变来变去的问题;RMSProp 用梯度平方的移动平均,替每个参数调整步长。
Kingma 和 Ba 在 2014 年提出的 Adam,就是把两者放在一起:
是梯度的一阶矩估计,也就是平均; 是二阶矩估计,也就是平方的平均。学习率在 Adam 论文里记作 ,角色和前面的 一样。论文的默认值是 、、、,这组数字到今天仍是 PyTorch 的默认值。
前两行我们都看过了,第三行是新的。
偏差修正
和 都从 0 开始。第一步 ,只有真实梯度的一成;,只有千分之一。这两个估计都被起点的 0 往下拉。
把 展开,假设梯度的期望值一直是 ,可以算出 。所以除以 ,就把偏差修回来了; 也一样。
为什么非修不可?两个估计的偏差程度不一样。 让 被拉得比 严重得多,不修正的话,分母太小,步子就太大。
假设梯度一直是固定的 1。修正过的 从第一步起就是 1,步长刚好是 。不修正的话,第一步是 倍,大约第 12 步冲到 6.6 倍,到第 1,000 步仍有 1.26 倍。Kingma 和 Ba 在变分自编码器的实验里就看到, 越接近 1,没有偏差修正的训练一开始越不稳定。
步长大约就是
修正之后, 大致落在 附近。把整个损失乘上 100,梯度跟着乘上 100, 和 一起放大,除了很小的 之外,更新量几乎不变。每个参数一步大约走 那么远,和梯度本身多大无关。
这是 Adam 好用的主要原因。SGD 的学习率要配合梯度的尺度调;Adam 的 比较接近「每一步想让参数动多少」,换一个模型,默认值常常也还能用。
四个方法在同一个山谷里,学习率各自调到在这里表现不错的值,数字是第一次进入最低点 0.03 以内的步数。四组都用全部 12 个包裹的梯度,所以前两组是不抽样的 GD 和带动量的 GD。GD()第 93 步到;动量(、)第 47 步;RMSProp()第 130 步;Adam()第 87 步。
Adam 并没有快很多。原因留到后面「把山谷变圆」那一节再说,这和山谷是斜的有关。
Adam 也可以换成 Nesterov 动量。Dozat 在 2016 年把 NAG 的「先看一眼」改写进 Adam,称为 Nadam。NAG 先沿着动量走一步再量梯度;Nadam 不另外多算一次梯度,而是在更新时直接用「下一步的动量」,再加上这一步的梯度。后来 AlgoPerf(一个比较训练算法快慢的公开评测,后面「哪一个最快?」那一节会再介绍)用的基线方法 NAdamW,就是 Nadam 再加上下一节的 AdamW 权重衰减。
Adam 也会出错
Adam 很快就成了默认选项。但接下来几年,陆续有人指出它的问题。
会忘记重要的大梯度
Reddi、Kale 和 Kumar 构造了一个很小的例子。参数 只能在 之间,每三步一个循环,第一步的损失是 ,后两步是 。 时,一轮的总梯度是 ,所以应该把 往 推。
Adam 的分母在这里出了错。那个罕见的大梯度 3 一出现, 立刻变大,这一步的 被压成约 1.05;接下来两步梯度只有 , 很快又变小,这两步各被放大成 和 。一轮下来,以 为单位,往错误方向多走了 0.68。
两者都从 出发,学习率是 。Adam 每三步就被推回 ,一直停在错误的那一端;AMSGrad 第 100 步走到约 ,第 300 步到 。
这里的 、,是论文为了证明而挑的设置。根源是 Adam 的有效学习率 可以变大。最近的梯度一小,过去的大梯度就被忘了。
他们的修正 AMSGrad 只改了一件事,分母改用 的历史最大值:
有效学习率从此只会变小,不会变大。上面的例子里,三步都用同一个 ,一轮的净效果变成往正确方向走 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 等人公开的代码重跑,连动量和 也一起调,四种方法的测试错误率几乎一样。差距有多少,很大一部分取决于调了哪些超参数。
权重衰减被缩小了
第三个问题最隐蔽,影响也最大。
权重衰减(weight decay)每一步把参数往 0 拉一点,防止参数长得太大。在 SGD 里,它和 L2 正则化等价。在损失加上 ,梯度就多了一项 ,效果就是每步把参数缩小一点。
所以早期的 Adam 实现,就把 加进梯度里。可是在 Adam 里,这一项也会跟着被 除掉。梯度一直很大的参数, 大,衰减就被缩得很小;Loshchilov 和 Hutter 的说法是,过去梯度越大的权重,被正则化得越少。
他们的解法是把衰减拿出来,不经过 Adam 的分母:
这就是 AdamW。式子里的 是学习率; 是学习率调度在第 步的倍率,学习率固定时就是 1。
两个权重都从 1 出发,梯度只有噪声,大小差了一千倍。、。L2 加进梯度的版本,梯度大的 几乎没被衰减,跑完 500 步还有 0.96;梯度小的 反而每步被拉下约 0.002,第 500 步掉到 0.28。AdamW 对两个权重一视同仁,每步都乘上 0.996,第 500 步两个都只剩 0.13 左右。
在 CIFAR-10 的实验里,Adam 加 L2 的好结果落在学习率与 的一条斜线上,调一个就得跟着调另一个;AdamW 的好区域大致和两轴平行,两个超参数可以分开调,最好的成绩也追上了 SGD。今天训练 Transformer 和大语言模型,AdamW 几乎是默认选择。
学习率调度
前面说过,SGD 的学习率要慢慢变小。可是要怎么变小?
从阶梯到余弦
最早最常见的是阶梯式,每隔一段时间除以 10。训练 ResNet-50 的经典配方是 90 个 epoch(把整个训练集完整看过一遍,叫一个 epoch),在第 30、60、80 个 epoch 各除以 10。它的毛病是要等最后一次除完,才得到好的模型;什么时候除,也得自己决定。
2016 年的 SGDR 改用余弦曲线,从最大值平滑地降到最小值:
是这一轮已经走了多久, 是这一轮的长度。走完一轮,学习率直接跳回最大值,重新开始下一轮,这叫热重启(warm restart);下一轮的长度可以乘上 ,越拉越长。提出它的,正是后来写 AdamW 的 Loshchilov 和 Hutter。
图上的五种调度,游标同步移动。SGDR 那一张用 、,在第 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 同时维护三组参数:
这里的 、、 是三组参数,和包裹的重量 无关。 是普通的 SGD,步长 固定; 是所有 的平均,也是最后拿来用的模型;梯度则在两者之间的 计算。对过去的 取平均,效果等于一条终点随时跟着当前步数移动的线性衰减。
每一步抽 4 个包裹,、。前一百多步, 明显落后 ,因为它对所有 一视同仁,最早那些离最低点很远的 也算在里面;走得越久, 越稳。
在 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。
第一条规则是线性缩放,批量放大 倍,学习率也放大 倍。批量 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 的步长大约就是 ,照理说不怕梯度太大。为什么训练 Transformer 时,不预热的 Adam 还是常常一开始就坏掉?
RAdam 的作者 Liu 等人在 2019 年给了一个解释。训练刚开始, 只看过几个梯度,用它估计的「梯度有多大」非常不准。第一步更极端,,自适应学习率 只靠一个样本估出来,方差甚至发散。
图上是 2,000 次模拟,梯度从标准正态分布抽出,。模拟里,第 1 步的 有 90% 落在 0.50 到 14.4 之间,差了将近三十倍;到第 10 步,已经收敛到 0.73 到 1.6。
RAdam 的做法是估计这个方差有多大,再乘上一个修正系数 ,前几步方差太大时干脆不用自适应学习率。 时,前 4 步只用动量,之后 从很小慢慢升到 1,效果就像一段内置的预热。
同一年 10 月,Ma 和 Yarats 指出 只由步数 和 决定,和数据无关。所以 RAdam 大致等于一段固定长度的预热,他们给的经验法则是 步; 时就是 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 第一步各层的权重范数和梯度范数。两者的比值 ,在第一层卷积是 5.76,到第一个全连接层是 1,345,差了两百多倍。
同一个全局学习率下,第一层卷积每一步的相对变化,是全连接层的 234 倍。学习率放大到某个程度,第一层的更新就会比权重本身还大,训练就发散了;可是对全连接层来说,这个学习率还小得很。
LARS 替每一层各算一个自己的学习率 ,让更新量和这一层权重的大小成正比:
是一个很小的信任系数,论文记作 、取 0.001,这里换个字母,免得和学习率搞混。这样每一层的相对变化都一样大,不再被最敏感的那一层卡住。AlexNet 在批量 8k 时,不用 LARS、只靠预热,学习率怎么调都放不大,top-1 准确率最好是 44.8%;用 LARS 回到 58.2%,接近批量 512 的 58.7%。
LAMB 把同样的逐层缩放套到 Adam 上。先照 Adam 算出这一层的更新 ,加上权重衰减 ,再把整个更新的长度换成和这一层权重的长度成正比:
是第 层的权重, 是一个把权重范数限制在上下界之间的函数。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)把目标改成「附近最坏的情况」:
这里的 代表模型的全部参数; 是参数的扰动,和前面避免除以零的 不同; 是扰动的半径,和 RMSProp 的 也无关。在半径 以内,找损失最高的那一点,再让那一点的损失变小。内层的 max 用一阶近似,最坏的方向就是梯度方向,。所以每一步先往上坡推 ,在那里算梯度,再拿这个梯度回到原位置更新。
实线是原本的损失,虚线是 范围内最坏的损失,也就是 SAM 真正要压低的东西。 时两条线重叠,窄谷底部 0.33,比宽谷的 0.58 低。 加到 0.1,窄谷附近最坏的损失升到 0.63,宽谷只有 0.60,排序反过来了; 时,差距拉大成 1.36 对 0.80。SAM 改变的是比较谷底的标准。
代价是每一步要算两次梯度。在 ImageNet 上,ResNet-152 标准训练最好的 top-1 错误率是 20.3%,SAM 是 18.4%;标签噪声很重时效果更明显。后来 Andriushchenko 和 Flammarion 发现,只有在每个小批量上各自做扰动才有效,论文泛化界描述的全数据版本,几乎没有帮助。尖锐度和泛化之间到底是什么关系,至今仍有争论。
显存不够:Adafactor 与 GaLore
Adam 每个参数要多存两个数字, 和 。参数一多,这两份状态就很可观。
按 LLaMA-7B 的形状算,67 亿个参数全用 fp32 存,参数本身 27 GB,梯度 27 GB,AdamW 的两份状态又是 54 GB,合计约 108 GB,还没算上前向传播留下的中间结果(activation)。
只记行和与列和
Adafactor 的作者 Shazeer 和 Stern 看上了 。一个 的权重矩阵, 也是 。他们只存每一行的和 和每一列的和 ,需要时再拼回来:
是所有行和再加起来,也就是整个矩阵的总和。这等于用一个秩为 1 的矩阵去近似原本的 ;秩为 1,意思是每一行都只是同一个向量的倍数。存储量从 降到 。
6×8 的矩阵原本要存 48 个数字,现在只要 14 个。拼回来的矩阵当然不完全一样,这个例子的平均相对误差是 21%,但 只负责决定每个参数的步长大致多大,这种程度的误差影响有限。在 WMT'14 英德翻译上,分解前后的 BLEU(翻译质量的分数,越高越好)是 25.6 对 25.4。
Adafactor 还拿掉了动量,连 都不存,这就出了问题。没有动量、又没有预热时,BLEU 直接掉到 0.1,训练完全失败。他们追查发现, 时, 跟不上梯度的变化,更新量在第 800 步左右冲到正常值的两倍以上。解法是更新裁剪(update clipping),把整个更新的均方根限制在 1 以内,再让 随步数慢慢升高。T5 用的就是 Adafactor;PaLM 也用了它,但保留了动量,连分解都拿掉了。
在小空间里跑 Adam
2024 年的 GaLore 换了一个角度。作者 Zhao 等人注意到,权重矩阵的梯度往往集中在少数几个方向上,也就是低秩的。那就把梯度先投影到一个小空间,在小空间里跑 Adam,再投影回去:
来自梯度的奇异值分解(把矩阵拆成几个方向,以及每个方向各自的伸缩量),取最重要的前 个方向; 是 Adam 在小矩阵 上算出的更新, 是 GaLore 自己的缩放系数。Adam 的状态只需要存 ,而不是 。每隔 步,重新做一次奇异值分解,换一个子空间。
和 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 的逆矩阵修正梯度:
在二次函数上,这一步直接走到最低点。换个角度看,乘上 等于换一套坐标,在新坐标里山谷是圆的,梯度直接指向谷底。这种「先把地形变圆再走」的做法,叫做预条件(preconditioning)。
这张图在三种坐标之间变形。原始坐标的条件数是 45.7。只沿着坐标轴各自缩放,也就是对角预条件,条件数变成 45.6,几乎没变,因为 Hessian 的两个对角元素本来就差不多,1.09 和 1。用完整的 Hessian 换坐标,条件数才变成 1。
这就是 Adam 在我们的山谷里没快多少的原因。Adam、RMSProp、AdaGrad 都只替每个参数各自决定步长,相当于只能沿着坐标轴缩放;我们的山谷问题全在「斜」,沿轴缩放救不了。
那为什么不直接用牛顿法?一个有 个参数的模型,Hessian 是 。十亿个参数,就要存 个数字,还要求逆矩阵。地形不是凸的时候(凸函数只有一个谷,没有山顶和鞍点),Hessian 可能有负的特征值,牛顿法会直接往山顶走。
Shampoo 与 SOAP
Shampoo 找到了折中,作者是 Gupta、Koren 和 Singer。神经网络的参数大多是矩阵,一个 的权重矩阵,完整的预条件需要 ;Shampoo 改用左右两个小矩阵,分别累积 和 :
是矩阵的 次方,算法是先对 做特征分解,再把每个特征值换成它的 次方。1,024×1,024 的一层,完整预条件约有 个元素,Shampoo 只要约 个。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 ,然后逐坐标裁剪:
曲率是正的而且足够大,就照牛顿法的比例走;曲率是负的或太小,分母被 撑住,裁剪让这一步最多走 。
这个一维函数在起点附近是负曲率。牛顿法收敛到局部极大值 ,往山顶去了;Sophia 在负曲率区每步固定走 0.15,往下坡走到谷底附近。最左边那张图里的 GD 只看斜率,也一路往下坡走,停在 附近;它根本没用到曲率,所以不会被负曲率骗,但步长也不会随曲率调整。
论文作者 Liu 等人在 GPT-2 上宣称,达到同样损失的步数只要 AdamW 的一半。后来的独立评估都没看到这么大的差距。Defazio 在 GitHub 上指出,把 AdamW 的学习率调高之后,1.25 亿参数的模型就打平了;2025 年包含 Sophia 三位原作者的〈Fantastic Pretraining Optimizers〉,在 5 亿参数以下也没测到显著的加速。
只看正负号:Lion
回到显存。Adam 要替每个参数存 和 两份状态,能不能少存一份?
Lion 是 Google 的 Chen 等人用程序搜索找到的。他们让计算机在一个由基本运算组成的程序空间里进化,筛出来的规则是这样:
更新方向只取正负号,所以每个参数每一步都走刚好 。它只存一份动量 ,比 Adam 少一份状态。 负责这一步的方向, 负责记住长期的动量,两个角色拆开了。因为每一步的大小固定,Lion 的学习率要比 AdamW 小 3 到 10 倍,权重衰减则大 3 到 10 倍。
Adam 和 Lion 都用余弦调度走 200 步,最后离最低点都约 0.02。看「前 40 步放大」那张图,一开始两个梯度分量同号,Lion 每一步在 和 上都走一样远,沿着 45° 的斜线前进。
在 JFT 上预训练的 ViT,Lion 用约三分之一的计算量就追上 AdamW;但在 11 亿到 75 亿参数的语言模型上,困惑度和 Adafactor 从头到尾没有差别。后来的几份独立评估,大多测到它和 AdamW 差不多。
换一把尺
sign 这个操作看起来很粗糙,背后有个干净的解释。
「最陡的下降方向」取决于怎么量长度。我们平常用的长度是 L2 范数,单位圆上让损失降得最多的方向,就是 。如果改用 L∞ 范数,也就是看最大的那个坐标,单位「圆」变成一个正方形,最陡的方向就落在角点,正好是 。
Bernstein 和 Newhouse 在 2024 年的〈Old Optimizer, New Norm〉把这个观点推广。关掉指数移动平均之后,Adam 就是 L∞ 范数下的最陡下降;Shampoo 拿掉累积之后,刚好是谱范数下的最陡下降。谱范数量的是一个矩阵最多能把向量拉长几倍,下一节的 Muon 就从这里出发。
把权重当成矩阵:Muon
除了 Shampoo 这一支,多数方法的步长都是逐坐标决定的,等于把参数摊成一长串数字,各自处理。可是神经网络的权重大多是矩阵。
一个权重矩阵的梯度,常常被少数几个方向主导,奇异值大小悬殊。直接照梯度更新,那几个方向的变化很大,其他方向几乎不动。Muon 的做法是把动量矩阵「正交化」。对动量矩阵 做奇异值分解 ,把所有奇异值都换成 1,只留下 。每个方向都动一样多。
Keller Jordan 从 2024 年 10 月起把 Muon 用在 NanoGPT 的训练速度竞赛,刷新了好几次纪录,12 月才整理成博客文章。它只用在网络中间的二维权重矩阵上,嵌入层、输出层和那些向量参数仍然用 AdamW。
精确的奇异值分解太贵,Muon 用 Newton–Schulz 迭代近似。先把矩阵除以它的 Frobenius 范数,让所有奇异值落在 0 到 1 之间,然后重复五次:
系数是 。
这个多项式会把小的奇异值一路往上推,大的往下拉。
这个 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.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 的那三页开始,梯度下降的核心一直是沿着负梯度走。今天习惯把它写成这一行:
后来的方法,都在补它某一个地方的不足:
- SGD、MBGD:数据太多,每次只看一小批;代价是噪声,学习率得慢慢变小。
- SGDM、NAG:山谷里来回弹跳,就记住刚才的方向,让它互相抵消;NAG 再提早一步刹车。
- AdaGrad、RMSProp、Adam:所有参数共用一个步长不合理,就让每个参数各走各的;RMSProp 学会忘记,Adam 把动量和偏差修正一起放进来。
- AMSGrad、AdamW:修补 Adam 会忘记大梯度、权重衰减被缩小的问题。
- 余弦、WSD、Schedule-Free、预热:学习率怎么随时间变化,能不能不必事先知道终点,以及一开始为什么要慢慢加速。
- LARS、LAMB:批量变大以后,各层的步长要各自调整。
- SAM:不只找低的谷底,还要找平坦的谷底。
- Adafactor、GaLore、Lion:状态太多、显存不够,就少存一点。
- Shampoo、SOAP、Sophia、Muon:估计地形的形状,或换一把尺来量一步有多长。
如果今天要训练一个模型,AdamW 加上预热和余弦或 WSD 调度,仍然是最稳的起点。模型够大、权重矩阵够多,Muon 和 SOAP 值得一试。不管选哪一个,先把学习率调好。
下次看到号称快两倍的新优化器,先问一句「AdamW 的学习率,调了吗?」
