优化器 / LR Schedule 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. 为什么不止用裸 SGD：真实 loss 地形病态（Hessian 条件数 $\kappa=\lambda_{\max}/\lambda_{\min}$ 极大），裸梯度下降在陡方向来回震荡、在缓方向爬不动。两味药：动量（沿一致方向累积、震荡相消）+ 逐参数自适应步长（对角预条件，拉平各坐标曲率失配）。优化器谱系就是"SGD → +动量 → +自适应 → Adam（两者都要）"。
2. SGD / Momentum / Nesterov：裸 SGD $\theta_t=\theta_{t-1}-\eta g_t$；heavy-ball 动量 $v_t=\mu v_{t-1}+g_t,\ \theta_t=\theta_{t-1}-\eta v_t$（抑制震荡、加速一致方向）；Nesterov 在前瞻点 $\theta-\eta\mu v$ 求梯度（look-ahead，纠过冲）。动量 $\approx$ 梯度的指数加权平均，窗口 $\sim 1/(1-\mu)$。
3. AdaGrad → RMSProp → Adam：AdaGrad 逐坐标步长 $\propto 1/\sqrt{\sum g^2}$（累加全部历史 → 只要梯度不会永远为 0（$\Sigma g^2\to\infty$，长训练几乎必然满足），LR 就单调趋于 0，长训练"学不动"）；RMSProp 把累加和换成 EMA（修好单调衰减）；Adam = RMSProp 的二阶 EMA + 一阶动量 + 偏差修正。
4. Adam 偏差修正：$m,v$ 从 0 起步早期有偏（偏向 0），除以 $1-\beta^t$ 去偏。因 $\beta_2$（0.999）比 $\beta_1$（0.9）更接近 1，$v$ 偏得更重 → 不修正时早期步长偏大（默认 $\beta$ 下首步 $\approx\frac{1-\beta_1}{\sqrt{1-\beta_2}}=3.16$ 倍 $\eta$），修正后首步回到 $\eta$。注意 $\epsilon$ 在根号外（PyTorch）。
5. AdamW 解耦权重衰减：Adam 的 L2 正则 $\ne$ 权重衰减。L2 把 $\lambda\theta$ 加进梯度 → 经 $1/\sqrt{\hat v}$ 缩放 → 历史梯度大的参数被衰减得更少（解耦被破坏）。AdamW（Loshchilov & Hutter）解耦：Adam 步之外直接从权重减 $\eta\lambda\theta$。这是现代默认；裸 SGD（无 momentum）下两者等价、Adam 下不等价（带动量的 SGD 若用耦合 L2，衰减项经动量缓冲跨步累积，与解耦的 SGDW 不再严格等价）。
6. 前沿优化器：Muon（把 2D 权重的动量经牛顿-舒尔茨迭代正交化，仅隐藏 2D 层，Kimi-K2 在用）、Lion（符号动量，单状态 → Adam 一半显存）、Shampoo（Kronecker 因子化的全矩阵预条件）、SOAP（在 Shampoo 特征基里跑 Adam）、Adafactor（因子化二阶矩 → 亚线性显存）、LAMB（逐层自适应，超大 batch）、Sophia（轻量二阶，对角 Hessian）。
7. LR schedule：warmup（早期 $\hat v$ 方差大 + 大 batch/Post-LN 不稳 → 线性拉起）；cosine（平滑降到 ~0，+ warm restart，需预定总步数）；inverse-sqrt / Noam（原始 Transformer 调度）；WSD（warmup-stable-decay，恒定段 + 末段短衰减 → 不用预定总步数、支持续训与中途 checkpoint）；one-cycle（super-convergence）。
8. 权重衰减 + LR-batch 缩放 + no-decay 组：wd 做正则（近来也有"wd $\approx$ 有效 LR 控制器"的视角）；线性缩放规则（batch ×$k$ → LR ×$k$，SGD；Adam 常用 $\sqrt k$）；LayerNorm/RMSNorm gain、bias、embedding 不加 wd（分 decay/no-decay 两组）。
9. 梯度裁剪 + LLM 超参：按全局范数裁（保方向）vs 按值裁（改方向），防梯度爆炸/loss spike；LLM 预训练默认 $\beta_2=\mathbf{0.95}$（不是 0.999，长记忆对尖峰太迟钝）、$\beta_1=0.9$、$\epsilon=\text{1e-8}$、wd $=0.1$、grad-clip $=1.0$。

§1 为什么需要 SGD 之外的优化器

裸随机梯度下降（SGD）的根本困境，是真实 loss 地形几乎总是"病态"的。 把损失在一个极小点附近二阶展开，曲率由 Hessian $H$ 描述；定义条件数 $\kappa=\lambda_{\max}/\lambda_{\min}$（$H$ 的最大与最小特征值之比）。$\kappa$ 大意味着不同方向的曲率差异巨大——某些方向陡峭如峡谷壁、某些方向平缓如谷底。对一个二次型，梯度下降的收敛速率约为 $\big(\tfrac{\kappa-1}{\kappa+1}\big)$，$\kappa$ 越大越慢。

直觉上，裸 SGD 在病态谷里会来回震荡：固定一个全局 $\eta$，为了不在陡方向（大 $\lambda$）发散，$\eta$ 必须取得很小（$\eta\lt 2/\lambda_{\max}$）；但这个小 $\eta$ 在缓方向（小 $\lambda$）上又爬得极慢。结果是在峡谷壁之间锯齿形（zig-zag）反复横跳，真正想前进的谷底方向却几乎不动。深网络的 loss 地形动辄 $\kappa\sim 10^4$ 以上，裸 SGD 因此既慢又不稳。

两味互补的药，正好对应优化器谱系的两条轴：

• 动量（momentum）：累积历史梯度的速度。震荡方向上梯度反复反号、在速度里相互抵消；一致方向上梯度同号、在速度里累积加速。等价于把更新方向做了平滑，把 GD 的收敛常数从 $\kappa$ 改善到 $\sqrt\kappa$ 量级（$\tfrac{\sqrt\kappa-1}{\sqrt\kappa+1}$）。注意：$\kappa\to\sqrt\kappa$ 是强凸二次型上精调 heavy-ball/Nesterov 的经典加速结论；真实深网含随机梯度噪声、非凸、曲率含时，它是直觉而非保证。
• 逐参数自适应步长（adaptive / per-parameter LR）：给每个坐标按它自己的梯度历史单独缩放步长——梯度一直很大的坐标用小步、一直很小的用大步。这相当于一个对角预条件子，把各坐标的有效曲率拉平，直接缓解 $\kappa$ 大的病。

谱系一句话：SGD（只用一阶梯度）→ + 动量（加一阶 EMA）→ + 自适应（加二阶矩 EMA）→ Adam = 动量 + 自适应 + 偏差修正。后面 §2–§5 沿这条线走，§6 是前沿（矩阵预条件 / 符号 / 省显存），§7–§9 是配套的 LR 调度、权重衰减、裁剪。

§2 SGD / Momentum / Nesterov

2.1　裸 SGD 与 heavy-ball 动量

裸 SGD 每步只看当前 mini-batch 梯度 $g_t$：

$$\theta_t = \theta_{t-1} - \eta\, g_t.$$

heavy-ball 动量（Polyak, 1964）引入一个速度缓冲 $v$，让更新带"惯性"：

$$\boxed{\;v_t = \mu\, v_{t-1} + g_t, \qquad \theta_t = \theta_{t-1} - \eta\, v_t\;}\qquad (\mu\ \text{典型 }0.9).$$

（这是 PyTorch SGD(momentum=μ) 的形式：$v$ 初始为 0，首步 $v_1=g_1$，无 $(1-\mu)$ damping。）为什么有用：

• 震荡方向（陡壁）：相邻步梯度反复反号，在 $v_t=\mu v_{t-1}+g_t$ 的指数加权和里部分相消 → 横跳被压住。
• 一致方向（谷底）：相邻步梯度同号、持续累积 → 速度变大、加速前进。

2.2　Nesterov 加速梯度（NAG）

heavy-ball 在当前点 $\theta_{t-1}$ 求梯度。Nesterov accelerated gradient 改成在"动量将把你带去的"前瞻点求梯度：

$$v_t = \mu\, v_{t-1} + g\big(\theta_{t-1} - \eta\mu\, v_{t-1}\big), \qquad \theta_t = \theta_{t-1} - \eta\, v_t.$$

直觉："先看一眼动量要把我推到哪，再在那个点算梯度"——若前方要过冲，前瞻梯度会提前给出修正，所以 NAG 在凸问题上有更好的收敛常数。Sutskever et al.（ICML 2013）实证：精心设计的（Nesterov 式）动量对训练深网络至关重要，好的动量 + 初始化能让深网在没有自适应优化器时也训得起来。

2.3　动量 ≈ 梯度的指数加权平均

把递推展开（设 $v_0=0$）：

$$v_t = \sum_{i=1}^{t} \mu^{\,t-i}\, g_i.$$

这是历史梯度的几何（指数）加权和——越近的梯度权重越大，越远的按 $\mu^{t-i}$ 衰减。等效平均窗口约 $1/(1-\mu)$（$\mu=0.9$ → 约 10 步，$\mu=0.99$ → 约 100 步）。所以动量在做一件朴素的事：把含噪的瞬时梯度平均成一个更平滑、更可信的下降方向，顺带把一致趋势放大、把噪声/震荡抹掉。

§3 AdaGrad → RMSProp → Adam（自适应谱系）

3.1　AdaGrad：逐坐标自适应，但会"学到死"

AdaGrad（Duchi, Hazan & Singer, JMLR 2011）给每个坐标一个独立的、随历史梯度自适应的步长。维护逐坐标的累加平方和 $G_t$：

$$G_t = G_{t-1} + g_t^2 \ (\text{逐元素}), \qquad \theta_t = \theta_{t-1} - \frac{\eta}{\sqrt{G_t}+\epsilon}\odot g_t.$$

效果：梯度一直很大的坐标 $G$ 大 → 步长小；稀疏/罕见特征 $G$ 小 → 步长大。在凸优化、稀疏特征（NLP 早期、推荐）上很有效。致命缺陷：$G_t$ 是单调递增的累加和，分母 $\sqrt{G_t}$ 只增不减 → 有效学习率单调非增；只要 $\Sigma g_t^2\to\infty$（梯度不会恒为 0，长训练几乎必然满足），LR 就趋于 0。在深网络的长训练里，跑着跑着步长就缩到几乎为 0，学不动了（学习过早停滞）。

3.2　RMSProp：把累加和换成 EMA

RMSProp（Hinton, Coursera Neural Networks for ML, Lecture 6e, 2012，未正式发表）一针见血：问题出在"累加全部历史"。把累加和换成指数移动平均，让旧梯度被遗忘：

$$E[g^2]_t = \rho\, E[g^2]_{t-1} + (1-\rho)\, g_t^2, \qquad \theta_t = \theta_{t-1} - \frac{\eta}{\sqrt{E[g^2]_t}+\epsilon}\odot g_t.$$

EMA 的分母不再无界增长（它跟踪的是"最近的"梯度平方尺度），于是有效 LR 不会衰减到 0——AdaGrad 的死结被解开。这就是 Adam 二阶矩项的直接前身。

3.3　Adam = RMSProp + 动量 + 偏差修正

Adam（Kingma & Ba, 2014）把两条轴合一：RMSProp 的二阶矩 EMA（自适应步长）+ heavy-ball 的一阶矩 EMA（动量）+ 一个关键的偏差修正（§4）。一句话记忆：

$$\textbf{Adam} = \underbrace{\text{RMSProp}}_{\text{二阶矩 EMA}} + \underbrace{\text{momentum}}_{\text{一阶矩 EMA}} + \underbrace{\text{bias correction}}_{\text{去早期偏差}}.$$

§4 Adam 深入

4.1　完整更新式

$$m_t = \beta_1 m_{t-1} + (1-\beta_1)\, g_t \qquad (\text{一阶矩 / 动量, EMA}),$$

$$v_t = \beta_2 v_{t-1} + (1-\beta_2)\, g_t^2 \qquad (\text{二阶矩 / 自适应, EMA}),$$

$$\hat m_t = \frac{m_t}{1-\beta_1^{\,t}}, \qquad \hat v_t = \frac{v_t}{1-\beta_2^{\,t}} \qquad (\textbf{偏差修正}),$$

$$\boxed{\;\theta_t = \theta_{t-1} - \eta\,\frac{\hat m_t}{\sqrt{\hat v_t}+\epsilon}\;}\qquad (\epsilon\ \text{在根号外，PyTorch}).$$

默认 $\beta_1=0.9,\ \beta_2=0.999,\ \epsilon=10^{-8}$。$m_0=v_0=0$。

4.2　为什么需要偏差修正

$m,v$ 都从 0 初始化。早期它们是对真实矩的有偏估计——偏向 0，且 $\beta$ 越接近 1 偏得越久。对平稳梯度取期望：$\mathbb{E}[m_t]=(1-\beta_1^t)\,\mathbb{E}[g]$，所以 $\hat m_t=m_t/(1-\beta_1^t)$ 恰好去偏；$\hat v_t$ 同理。

关键、也是高频被深问的一点：不修正时，早期等效步长不是偏小，而是偏大。 看第一步（$t=1$）：

$$\frac{m_1}{\sqrt{v_1}} = \frac{(1-\beta_1)\,g_1}{\sqrt{(1-\beta_2)}\,\lvert g_1\rvert} = \frac{1-\beta_1}{\sqrt{1-\beta_2}}\,\mathrm{sign}(g_1).$$

代入默认值：$\frac{1-0.9}{\sqrt{1-0.999}}=\frac{0.1}{0.0316}\approx 3.16$。也就是说不修正的首步约为目标 $\eta$ 的 3.16 倍——因为 $v$（$\beta_2$ 更接近 1）被压向 0 比 $m$ 更狠，分母 $\sqrt{v}$ 太小，反而把步长放大了。偏差修正把 $\hat m_1=g_1,\ \hat v_1=g_1^2$ 还原，使首步回到 $\eta\cdot\dfrac{g_1}{\lvert g_1\rvert+\epsilon}\approx\eta\cdot\mathrm{sign}(g_1)$（严格式含 $\epsilon$：$\eta\lvert g_1\rvert/(\lvert g_1\rvert+\epsilon)<\eta$，仅当 $\lvert g_1\rvert\gg\epsilon$ 时才近似等于 $\eta$，训练中梯度量级通常 $\gg 10^{-8}$ 故此近似基本成立）。（§A 的 [d] 会数值印证这个 3.16。）

§5 AdamW（最高频的一节）

5.1　Adam 的 L2 正则 $\ne$ 权重衰减

经典 L2 正则的做法：在损失里加 $\frac{\lambda}{2}\lVert\theta\rVert^2$，等价于给梯度加一项 $\lambda\theta$：

$$g_t' = g_t + \lambda\,\theta_{t-1}.$$

对裸 SGD，这恰好就是权重衰减：$\theta_t=\theta_{t-1}-\eta(g_t+\lambda\theta_{t-1})=(1-\eta\lambda)\theta_{t-1}-\eta g_t$——每步把权重按 $(1-\eta\lambda)$ 收缩。但对 Adam，灾难发生了：这个 $\lambda\theta$ 被塞进 $g'$，于是它要一起进 $m,v$，最终被 $1/(\sqrt{\hat v}+\epsilon)$ 缩放：

$$\theta_t = \theta_{t-1} - \eta\,\frac{\widehat{m'_t}}{\sqrt{\hat v_t}+\epsilon},\qquad m'\ \text{含 }\lambda\theta\ \text{的贡献}.$$

后果：历史梯度大的参数（$\hat v$ 大）拿到的有效衰减反而更小，历史梯度小的参数被衰减更多——衰减强度被 $\hat v$ 扭曲，和"对所有权重施加均匀收缩"的正则本意完全脱节。这就是"L2 与 weight decay 在自适应优化器下不再等价"。

5.2　AdamW：解耦权重衰减

AdamW（Loshchilov & Hutter, Decoupled Weight Decay Regularization, 1711.05101）的修法极简——把权重衰减从梯度里拿出来，绕过自适应分母，直接作用在权重上：

$$\boxed{\;\theta_t = \theta_{t-1} - \eta\Big(\frac{\hat m_t}{\sqrt{\hat v_t}+\epsilon} + \lambda\,\theta_{t-1}\Big)\;}$$

即先按原始梯度 $g$（不含 $\lambda\theta$）算 Adam 步，再单独减一个 $\eta\lambda\theta_{t-1}$。等价写法 $\theta_t=(1-\eta\lambda)\theta_{t-1}-\eta\,\hat m_t/(\sqrt{\hat v_t}+\epsilon)$——一个干净的、与 $\hat v$ 无关的均匀收缩（PyTorch AdamW 即把衰减乘上 lr）。

为什么通常更好（更可控）：解耦后所有参数受到同样的相对收缩 $\lambda$，正则强度不再被各参数的梯度历史扭曲，更符合"控制权重范数"的本意；Loshchilov & Hutter 实证 AdamW 在多任务上往往稳定优于 Adam+L2，且 LR 与 wd 的最优值更容易解耦调参（不必绝对化成"所有任务都更泛化"，但它是更可控、更常用的默认）。为何裸 SGD 下两者重合：裸 SGD 既没有 $1/\sqrt{\hat v}$ 这层自适应缩放，也没有动量缓冲对 $\lambda\theta$ 的跨步累积，$\lambda\theta$ 加进梯度后被原样使用，恰好就是均匀收缩；一旦引入自适应分母（Adam）或动量缓冲（SGD+momentum，对应 SGDW vs 耦合 L2+momentum 的区别），加梯度（L2）和直接收缩（decay）就分道扬镳。

§6 前沿优化器

每个只记一个核心 idea即可——面试报得出"它改了 Adam 的哪一块"就够。

6.1　Muon：把动量正交化

Muon（Keller Jordan, 2024 技术博客）针对2D 权重矩阵：先按动量算出更新矩阵 $M$，再用几次 Newton-Schulz 迭代把它正交化成 $O\approx\mathrm{NewtonSchulz}(M)$（数学上逼近 $M=U\Sigma V^\top$ 的 $UV^\top$，即最近的半正交矩阵，用迭代代替昂贵的 SVD），用 $O$ 去更新权重。直觉：正交化让更新在所有奇异方向上同等用力、不被少数大奇异值主导 → 更新更均衡、有效学习更快。只用于隐藏层的 2D 矩阵；embedding、输出头、norm gain、bias 这些仍走 AdamW（正交化对它们无意义）。Moonshot 的 Kimi-K2 用 Muon 训练；可扩展性见 Muon is Scalable for LLM Training（2502.16982）。

6.2　Lion：符号动量，单状态

Lion（Chen et al., Symbolic Discovery of Optimization Algorithms, 2302.06675）由符号程序搜索自动发现。更新取动量的符号：$u_t=\mathrm{sign}(\beta_1 m_{t-1}+(1-\beta_1)g_t)$，$\theta_t=\theta_{t-1}-\eta(u_t+\lambda\theta_{t-1})$，再更新动量 $m_t=\beta_2 m_{t-1}+(1-\beta_2)g_t$。只存 1 个状态（动量） → 优化器显存是 Adam（要存 $m,v$ 两个）的一半。sign 让每个坐标走等幅步长；通常配更小的 LR、更大的 wd。

6.3　Shampoo / SOAP：全矩阵预条件

• Shampoo（Gupta, Koren & Singer, 1802.09568）：超越 Adam 的对角预条件，做全矩阵 / Kronecker 因子化预条件。对一个权重矩阵维护左、右预条件子 $L=\sum GG^\top$、$R=\sum G^\top G$，用 $L^{-1/4} G\, R^{-1/4}$ 更新——以 Kronecker 积近似全矩阵 AdaGrad，捕捉坐标间耦合。收敛更快但每步贵（要算矩阵的逆根）。
• SOAP（Vyas et al., 2409.11321）：在 Shampoo 的（缓变）特征基里跑 Adam——把梯度旋到 Shampoo 预条件子的特征空间、在那里做标准 Adam，再旋回来。它把 Shampoo 与 Adam/Adafactor 联系起来，更稳、超参更少。

6.4　Adafactor / LAMB / Sophia

• Adafactor（Shazeer & Stern, 1804.04235）：把二阶矩矩阵 $v\in\mathbb{R}^{m\times n}$ 因子化成行、列两个向量（秩-1 重构 $v\approx rc^\top$）→ 显存从 $O(mn)$ 降到 $O(m+n)$（亚线性）。T5 用它在有限显存上训大模型。
• LAMB（You et al., 1904.00962）：在 Adam 更新方向上再做逐层自适应——按每层的 $\lVert\theta\rVert/\lVert\text{update}\rVert$（trust ratio）缩放（LARS 的 Adam 版）。让超大 batch 训练稳定（76 分钟训 BERT）。
• Sophia（Liu et al., 2305.14342）：轻量二阶。用对角 Hessian 估计（Gauss-Newton-Bartlett 或 Hutchinson）做预条件 + 对更新裁剪，每 $k$ 步才更新一次 Hessian → 比 AdamW 更快收敛，二阶开销摊薄。

§7 学习率调度

7.1　Warmup：为什么开头要慢

warmup 在训练最初的几百~几千步把 LR 从 0（或很小）线性拉到峰值，再交给后续衰减。动机有二：

1. Adam 早期方差大：$\hat v$ 在前几步只用了极少样本估计，即使偏差修正保证 $\mathbb{E}[\hat v_t]$ 无偏（§4.2），单次实现的 $\hat v_t$ 仍是高方差估计——个别 step 上 $\hat v_t$ 可能远小于真实二阶矩，使 $\hat m/\sqrt{\hat v}$ 剧烈抖动、偶尔炸出偏大的有效步长（RAdam, Liu et al. 2019 的核心动机）。这与 §4.2 讨论的"未修正首步系统性偏大 3.16×"是两回事——后者是标准 Adam 已用偏差修正精确抵消的确定性偏差，并非早期不稳的真正来源。先用小 LR 让 $m,v$ 的统计"热身"到可靠，再放大步长。
2. 大 batch / Post-LN 不稳：mean-reduce 下批梯度是无偏估计（$\mathbb{E}[g_B]=\mathbb{E}[g]$），batch 增大只降方差（$\mathrm{Var}\propto 1/B$），并不放大梯度尺度本身；真正的不稳来自大 batch 配合线性缩放规则用了更大的 LR（§8.2），而初期权重远未收敛、变化快，大 LR 更易发散；此外 Post-LN Transformer 顶层梯度天然偏大（见 normalization 篇 §5）——两者叠加，一上来就大 LR 容易发散。warmup 压住早期不稳。

7.2　Cosine 退火（+ warm restart）

cosine（Loshchilov & Hutter, SGDR, 1608.03983）把 LR 从峰值平滑余弦衰减到 $\sim\eta_{\min}$：

$$\eta_t = \eta_{\min} + \tfrac12(\eta_{\max}-\eta_{\min})\Big(1+\cos\big(\pi\, t/T\big)\Big).$$

早期大 LR 快速探索、后期小 LR 精细收敛（噪声小、易落入更平的极小）。SGDR 还加 warm restart：周期性把 LR 拉回峰值，帮助跳出局部解。代价：必须预先确定总步数 $T$（$\cos$ 要知道终点）——这正是 WSD 想解决的痛点。

7.3　Inverse-sqrt / Noam（原始 Transformer 调度）

原始 Transformer（Vaswani et al., 1706.03762）用的调度，先线性 warmup 再 $1/\sqrt t$ 衰减：

$$\eta_t = d_{\text{model}}^{-1/2}\cdot\min\!\Big(t^{-1/2},\ t\cdot t_{\text{warmup}}^{-3/2}\Big).$$

$t\lt t_{\text{warmup}}$ 时取后项（线性上升），之后取前项（按 $t^{-1/2}$ 下降）。无需预定总步数，是早期机器翻译/语言模型的标配。

7.4　WSD：Warmup-Stable-Decay

WSD（MiniCPM, Hu et al., 2404.06395）把调度切成三段：warmup → 长时间恒定（stable，峰值 LR）→ 末段短促 decay。最大卖点：不用预先 commit 总步数——恒定段可以无限延长，想停的时候才接一段短 decay（loss 在 decay 段会陡降到一个好水平）。好处：

• 支持持续训练 / 中途加数据（恒定段随时续）；
• 每做一次 decay 就得到一个可用的 checkpoint，不必为每个目标步数各训一条余弦；
• 便于在固定算力下探索"训多久"，而不是一次性赌死 $T$。

7.5　One-cycle / super-convergence

one-cycle（Smith, Super-Convergence, 1708.07120）：整个训练就一个周期——LR 先升到一个很大的峰值再降到远低于初值，动量则反向同步循环（LR 高时动量低）。在某些设置下能"超收敛"（用很大的 LR 极快训完）。它和 cosine、WSD 一样是"先升后降"的家族，区别在单周期 + 超大峰值 LR。

🎯 选调度的一句话 固定预算、追极致质量 → cosine（但要预定步数）；不确定要训多久 / 要续训 / 要中途出 checkpoint → WSD；经典 Transformer 复现 → Noam；想用超大 LR 极速训 → one-cycle。所有这些前面都应接 warmup。

§8 权重衰减 + LR-batch 缩放 + no-decay 组

8.1　权重衰减做什么（含一个现代视角）

经典视角：权重衰减是正则——每步把权重朝 0 收缩，限制权重范数、压模型复杂度、抗过拟合。现代视角（对网络中尺度不变的那部分权重而言）：紧接归一化层、且不经残差直连等其他缩放敏感路径的权重矩阵 $W$（例如 Pre-LN block 里紧跟 LayerNorm/RMSNorm 的线性层权重）具有尺度不变性——把 $W$ 乘个正常数，归一化后输出不变；这部分权重的"绝对大小"本身不直接影响函数，于是 wd 的真正作用更像是在调有效学习率 / 控制权重范数的平衡点——wd 越大、权重范数越小、等效梯度步长相对越大。注意：这一论证不适用于残差分支上的权重、norm 层自身的 $\gamma/\beta$、bias、输出头等——它们的尺度会直接影响网络输出，不满足尺度不变性。这是近年训练动力学研究里的重要观察（把 wd 当"有效 LR 旋钮"而非单纯正则，但仅对满足尺度不变性的那部分权重成立）。

8.2　LR 随 batch size 缩放

大 batch 训练里，LR 必须跟着 batch 调，否则白白浪费算力或不稳：

• 线性缩放规则（Goyal et al., 1706.02677）：batch ×$k$ → LR ×$k$（用于大 batch SGD），并配 warmup。直觉：mini-batch 均值梯度的方差 $\propto 1/B$，把 batch 放大 $k$ 倍后噪声降低，可以放心把步长也放大 $k$ 倍以保持"每个样本贡献的有效更新"大致不变。
• Adam 的 $\sqrt k$ 缩放：Adam 的更新近似被 $\sqrt{\hat v}$ 归一化（接近符号化），经验上对 batch 用平方根缩放（LR ×$\sqrt k$）更稳，而非线性。
• 相关地，LARS（You et al., 1708.03888）/ LAMB（§6.4）用逐层 trust ratio 实现超大 batch 下的自适应缩放。

8.3　no-decay 参数组

不是所有参数都该加权重衰减。 标准实践把参数分成两组：

• 加 wd：各线性层 / 卷积的权重矩阵。
• 不加 wd（no-decay）：LayerNorm/RMSNorm 的 gain $\gamma$、所有 bias、（通常）embedding。

原因：这些是尺度 / 平移参数，把它们朝 0 收缩会直接损害表示——把 LN 的 gain 压向 0 等于抹掉该层激活的尺度；bias 本就不该被正则（它只管平移）。GPT/LLaMA 等代码库都显式构造 decay / no-decay 两个 param group。

§9 梯度裁剪 + LLM 超参细节

9.1　梯度裁剪：全局范数 vs 按值

训练里偶发的梯度爆炸 / loss 尖峰（尤其 RNN、长序列、大 LR）会一步把权重带飞甚至 NaN。梯度裁剪（Pascanu, Mikolov & Bengio, 1211.5063）给梯度设一个闸：

• 按全局范数裁（clip by global norm，最常用）：把所有参数的梯度拼成一个大向量，算其 $\lVert g\rVert_2$；若超过阈值 $c$，整体缩放 $g\leftarrow g\cdot c/\lVert g\rVert_2$。保持方向、只压幅度。
• 按值裁（clip by value）：逐分量 clamp 到 $[-v, v]$。会改变梯度方向（不同分量被不同程度截断），一般不如全局范数。

为什么稳：偶发的超大梯度被钳到阈值内，单步更新幅度有界 → 不会因一个坏 batch 把训练带崩。LLM 预训练几乎都用 global-norm clip，阈值 1.0。

9.2　LLM 训练的 Adam 超参默认

LLM 预训练的 Adam/AdamW 配方和"教科书默认"有几处关键不同：

§10 选优化器 + 显存账

10.1　优化器状态的显存

混合精度训练里，每个可训练参数的显存大致是：bf16 权重 2 B + bf16 梯度 2 B + fp32 master 4 B + 优化器状态。优化器状态正是各方法的分水岭：

• SGD+momentum：1 个状态（动量 $v$）。
• Adam / AdamW：2 个状态（$m, v$），fp32 下 $=8$ B/param——这往往是大头，是"省显存"动机的来源。
• Lion：1 个状态（动量）→ Adam 的一半。
• Adafactor：因子化 $v$ → 亚线性，近似只剩"参数级"开销。

由此催生的省显存路线：

• 8-bit Adam（Dettmers et al., 2110.02861）：把 $m,v$ 分块量化到 8-bit 存储（用时反量化），优化器状态显存降到约 $1/4$，质量几乎无损。
• Adafactor：因子化二阶矩，亚线性显存（T5）。
• Lion：少存一个状态，直接减半。

10.2　什么时候用哪个

🎯 "用哪个优化器"决策树

• Transformer / LLM 微调或预训练：AdamW（安全默认，$\beta_2=0.95$、wd 0.1、grad-clip 1.0、配 warmup+cosine/WSD）。
• 经典视觉（ResNet 等）：SGD+momentum 常泛化更好、且省显存——CV 里仍有大量 SOTA 用它。
• 想要额外训练加速 / 大规模：Muon（2D 隐藏层）、Shampoo/SOAP（全矩阵预条件，肯花每步算力）。
• 显存受限：8-bit Adam / Adafactor / Lion。
• 超大 batch：LAMB / LARS（逐层 trust ratio）。

§11 工程对比 + 常见误区

11.1　优化器对比表

11.2　常见误区（footguns）

§12 25 高频面试题

按难度分三档，点开看答案要点 + 易踩坑。L2/L3 是顶级 lab 深水区（AdamW 解耦、偏差修正方向、$\beta_2$ 选择、缩放规则、Muon/Shampoo/Lion/Sophia 等）。

L1必会题

L2进阶题

L3高级题

§A 附录：sanity check

本 tutorial 的从零实现应满足以下关键不变量（可写一段纯 PyTorch、CPU 几秒的脚本验证）：

1. [a] 从零 SGD+momentum == torch.optim.SGD：用 $v_t=\mu v_{t-1}+g_t,\ \theta\mathrel{-}=\eta v_t$（PyTorch 约定：$v$ 初值 0、无 damping），跑几步后两者逐元素在浮点误差内相等（atol≈1e-5）。
2. [b] 从零 Adam == torch.optim.Adam：$\hat m=m/(1-\beta_1^t),\ \hat v=v/(1-\beta_2^t),\ \theta\mathrel{-}=\eta\hat m/(\sqrt{\hat v}+\epsilon)$（$\epsilon$ 根号外）应与 PyTorch 逐元素一致。
3. [c] AdamW $\ne$ Adam+L2，且从零解耦衰减 == torch.optim.AdamW：相同 weight_decay=λ 下，torch.optim.AdamW（解耦）与 torch.optim.Adam(weight_decay=λ)（L2）产生不同更新（$\lVert\Delta\rVert\gt 0$）；从零"先 Adam 步、再减 $\eta\lambda\theta$"的解耦实现应与 AdamW 一致。这是 §5 的核心。
4. [d] 偏差修正使首步近似回到 $\eta$（当 $|g_1|\gg\epsilon$ 时；严格式为 $\eta|g_1|/(|g_1|+\epsilon)<\eta$）：$t=1$ 不修正的等效步长 $\approx 3.16\eta$（$=\frac{1-\beta_1}{\sqrt{1-\beta_2}}$，因 $v$ 被 $\beta_2$ 压向 0 比 $m$ 更狠 → 分母太小 → 步长偏大），修正后近似回到 $\eta$（同样需要 $|g_1|\gg\epsilon$）。验证 corrected/uncorrected 比 $=\frac{\sqrt{1-\beta_2}}{1-\beta_1}\approx 0.316$。
5. [e] cosine-with-warmup 调度形状：$\eta(0)\approx 0$、在 warmup 边界处取到峰值 $\eta_{\max}$、末端衰减到 $\sim\eta_{\min}$，且 warmup 之后单调不增。
6. [f] 动量加速病态二次：在条件数 $\kappa$ 大的二次型上、用稳定边界内的小 $\eta$ 跑 $N$ 步，GD+momentum 的最终 loss 显著低于裸 GD（动量在缓方向累积加速）。

下面是几段示意代码（CPU 可跑、Chinese 注释、含形状/数值注释；演示其中几条不变量，完整 6 条 [a]–[f] 见下方独立脚本）。

[a]/[b] SGD+momentum 与 Adam 从零实现，并与 torch.optim 对齐：

import torch

def sgd_momentum_from_scratch(params, grads, lr=0.1, mu=0.9, steps=5):
    """heavy-ball: v = mu*v + g; theta -= lr*v。v 初值 0（首步 v=g），对齐 PyTorch SGD。"""
    theta = params.clone()                      # [d] 参数
    v = torch.zeros_like(theta)                 # [d] 动量缓冲
    for t in range(steps):
        g = grads[t]                            # [d] 第 t 步梯度（这里用固定序列便于对齐）
        v = mu * v + g                          # 速度 = 动量*旧速度 + 当前梯度
        theta = theta - lr * v                  # 沿速度方向更新
    return theta

def adam_from_scratch(grads, theta0, lr=0.1, b1=0.9, b2=0.999, eps=1e-8, steps=5):
    """m,v 的 EMA + 偏差修正 + eps 在根号外，逐元素对齐 PyTorch Adam。"""
    theta = theta0.clone()
    m = torch.zeros_like(theta)                 # 一阶矩 [d]
    v = torch.zeros_like(theta)                 # 二阶矩 [d]
    for t in range(1, steps + 1):
        g = grads[t - 1]                        # [d]
        m = b1 * m + (1 - b1) * g               # 动量 EMA
        v = b2 * v + (1 - b2) * g * g           # 平方梯度 EMA
        m_hat = m / (1 - b1 ** t)               # 偏差修正（去早期偏向 0）
        v_hat = v / (1 - b2 ** t)
        theta = theta - lr * m_hat / (v_hat.sqrt() + eps)   # eps 在根号外
    return theta

# 与 torch.optim 对齐（同一固定梯度序列喂给两边）：
torch.manual_seed(0)
d, steps = 8, 5
theta0 = torch.randn(d)
grads = [torch.randn(d) for _ in range(steps)]   # 固定梯度序列，保证可比

# --- SGD ---
p = theta0.clone().requires_grad_(True)
opt = torch.optim.SGD([p], lr=0.1, momentum=0.9)
for t in range(steps):
    opt.zero_grad(); p.grad = grads[t].clone(); opt.step()
ref_sgd = p.detach()
mine_sgd = sgd_momentum_from_scratch(theta0, grads, lr=0.1, mu=0.9, steps=steps)
assert torch.allclose(mine_sgd, ref_sgd, atol=1e-6)    # 从零 == torch.optim.SGD

[d] 偏差修正：不修正首步偏大（默认 $\beta$ 下 $\approx 3.16\eta$），修正后 $=\eta$：

import torch

b1, b2, eps = 0.9, 0.999, 1e-8
g1 = torch.tensor([2.0])                          # 任意非零首步梯度
m1 = (1 - b1) * g1                                # 未修正一阶矩
v1 = (1 - b2) * g1 * g1                           # 未修正二阶矩
uncorrected = (m1 / (v1.sqrt() + eps)).item()     # 不修正的等效步长 / lr
corrected = ((m1 / (1 - b1)) / ((v1 / (1 - b2)).sqrt() + eps)).item()  # 修正后
ratio = (1 - b1) / (1 - b2) ** 0.5                # = 3.162...，理论首步放大倍数
# 不变量：uncorrected ≈ ratio ≈ 3.16（偏大），corrected ≈ 1.0（= lr 量级）
assert abs(uncorrected - ratio) < 1e-3
assert abs(corrected - 1.0) < 1e-3

[c] AdamW（解耦衰减）$\ne$ Adam+L2（耦合），从零解耦 == torch.optim.AdamW：

import torch

def adamw_decoupled_from_scratch(grads, theta0, lr=0.1, b1=0.9, b2=0.999,
                                 eps=1e-8, wd=0.05, steps=5):
    """解耦：先按原始梯度 g 做 Adam 步，再直接减 lr*wd*theta（不过自适应分母）。"""
    theta = theta0.clone()
    m = torch.zeros_like(theta); v = torch.zeros_like(theta)
    for t in range(1, steps + 1):
        g = grads[t - 1]                          # 不含 wd 的原始梯度
        m = b1 * m + (1 - b1) * g
        v = b2 * v + (1 - b2) * g * g
        m_hat = m / (1 - b1 ** t); v_hat = v / (1 - b2 ** t)
        theta = theta - lr * (m_hat / (v_hat.sqrt() + eps) + wd * theta)  # 解耦衰减
    return theta

torch.manual_seed(0)
d, steps, wd = 8, 5, 0.05
theta0 = torch.randn(d)
grads = [torch.randn(d) for _ in range(steps)]

# torch.optim.AdamW（解耦） vs torch.optim.Adam(weight_decay=)（L2/耦合）
def run(opt_cls, **kw):
    p = theta0.clone().requires_grad_(True)
    opt = opt_cls([p], lr=0.1, betas=(0.9, 0.999), eps=1e-8, weight_decay=wd, **kw)
    for t in range(steps):
        opt.zero_grad(); p.grad = grads[t].clone(); opt.step()
    return p.detach()

ref_adamw = run(torch.optim.AdamW)
ref_adam_l2 = run(torch.optim.Adam)
assert (ref_adamw - ref_adam_l2).norm() > 1e-4         # AdamW != Adam+L2（相同 wd 下不同）
mine = adamw_decoupled_from_scratch(grads, theta0, wd=wd, steps=steps)
assert torch.allclose(mine, ref_adamw, atol=1e-6)      # 从零解耦 == torch.optim.AdamW

[e] cosine-with-warmup 调度（检查首/峰/末三点 + 单调）：

import math

def cosine_warmup_lr(step, warmup, total, lr_max, lr_min=0.0):
    """线性 warmup 到 lr_max，再余弦衰减到 lr_min。需预定总步数 total。"""
    if step < warmup:
        return lr_max * step / warmup                       # 线性上升（step=0 -> ~0）
    progress = (step - warmup) / (total - warmup)           # 0 -> 1
    return lr_min + 0.5 * (lr_max - lr_min) * (1 + math.cos(math.pi * progress))

warmup, total, lr_max = 100, 1000, 1.0
lrs = [cosine_warmup_lr(t, warmup, total, lr_max) for t in range(total + 1)]
assert lrs[0] < 1e-9                                        # 起点 ~0
assert abs(lrs[warmup] - lr_max) < 1e-9                     # warmup 边界处取峰值
assert lrs[-1] < 1e-6                                       # 末端衰减到 ~lr_min(=0)
assert all(lrs[i] >= lrs[i + 1] - 1e-12 for i in range(warmup, total))  # warmup 后单调不增

完整可跑脚本见 code/optimizer_lr_schedule.py（纯 PyTorch、CPU 几秒、6 个 assert 覆盖 [a]–[f]）。运行 python code/optimizer_lr_schedule.py 的真实输出：

[a] SGD+momentum from scratch vs torch.optim.SGD: max|Δ| = 1.19e-07  OK
[b] Adam from scratch vs torch.optim.Adam: max|Δ| = 1.19e-07  OK
[c] AdamW vs Adam+L2 (same wd=0.1): max|Δ| = 2.13e-01 (DIFFER, decoupled≠coupled); from-scratch decoupled vs AdamW = 2.16e-07 (MATCH)  OK
[d] bias correction at step 1: corrected/uncorrected = 0.316 (= √(1-β2)/(1-β1) ≈ 0.316); without it the under-estimated v̂ makes the first step ~3.2× too large  OK
[e] cosine+warmup lr: t=0 -> 0.000, t=warmup -> 1.000 (peak), t=end -> 0.000 (min); linear warmup midpoint -> 0.500  OK
[f] ill-conditioned quadratic (κ=20) after 100 steps: GD loss = 4.04e-02  vs  GD+momentum loss = 1.46e-05  (momentum lower)  OK

all optimizer / LR-schedule sanity checks passed ✓

📚 参考文献

• Adam — Kingma & Ba, Adam: A Method for Stochastic Optimization, arXiv 1412.6980 (2014), ICLR 2015.
• AdamW (Decoupled Weight Decay) — Loshchilov & Hutter, Decoupled Weight Decay Regularization, arXiv 1711.05101 (2017), ICLR 2019.
• AdaGrad — Duchi, Hazan & Singer, Adaptive Subgradient Methods for Online Learning and Stochastic Optimization, JMLR 12 (2011)（无 arXiv id，按 JMLR 出处引用）.
• RMSProp — Hinton, Neural Networks for Machine Learning, Coursera Lecture 6e (2012)（课程讲义，无正式论文 / arXiv id）.
• Nesterov accelerated gradient — Nesterov, A method of solving a convex programming problem with convergence rate $O(1/k^2)$, Soviet Math. Doklady 27 (1983)（无 arXiv id）.
• Momentum for deep nets — Sutskever, Martens, Dahl & Hinton, On the importance of initialization and momentum in deep learning, ICML 2013（PMLR proceedings；无独立 arXiv id，按会议出处引用）.
• AMSGrad (Adam 收敛性) — Reddi, Kale & Kumar, On the Convergence of Adam and Beyond, arXiv 1904.09237 (2019), ICLR 2018.
• SGDR / cosine annealing — Loshchilov & Hutter, SGDR: Stochastic Gradient Descent with Warm Restarts, arXiv 1608.03983 (2016), ICLR 2017.
• Transformer / Noam schedule — Vaswani et al., Attention Is All You Need, arXiv 1706.03762 (2017), NeurIPS 2017.
• Linear scaling rule — Goyal et al., Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour, arXiv 1706.02677 (2017).
• LARS — You, Gitman & Ginsburg, Large Batch Training of Convolutional Networks, arXiv 1708.03888 (2017).
• LAMB — You et al., Large Batch Optimization for Deep Learning: Training BERT in 76 minutes, arXiv 1904.00962 (2019), ICLR 2020.
• Lion — Chen et al., Symbolic Discovery of Optimization Algorithms, arXiv 2302.06675 (2023), NeurIPS 2023.
• Shampoo — Gupta, Koren & Singer, Shampoo: Preconditioned Stochastic Tensor Optimization, arXiv 1802.09568 (2018), ICML 2018.
• SOAP — Vyas et al., SOAP: Improving and Stabilizing Shampoo using Adam, arXiv 2409.11321 (2024).
• Adafactor — Shazeer & Stern, Adafactor: Adaptive Learning Rates with Sublinear Memory Cost, arXiv 1804.04235 (2018), ICML 2018.
• Sophia — Liu et al., Sophia: A Scalable Stochastic Second-order Optimizer for Language Model Pre-training, arXiv 2305.14342 (2023), ICLR 2024.
• One-cycle / Super-Convergence — Smith & Topin, Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates, arXiv 1708.07120 (2017).
• WSD / MiniCPM — Hu et al., MiniCPM: Unveiling the Potential of Small Language Models with Scalable Training Strategies, arXiv 2404.06395 (2024), COLM 2024.
• 8-bit Adam — Dettmers et al., 8-bit Optimizers via Block-wise Quantization, arXiv 2110.02861 (2021), ICLR 2022.
• Gradient clipping — Pascanu, Mikolov & Bengio, On the difficulty of training Recurrent Neural Networks, arXiv 1211.5063 (2012), ICML 2013.
• Muon (scaling) — Liu et al. (Moonshot AI), Muon is Scalable for LLM Training, arXiv 2502.16982 (2025).
• Muon (原始 writeup) — Keller Jordan et al., Muon: An optimizer for the hidden layers of neural networks, 2024 技术博客（无独立 arXiv 论文，按博客 writeup 引用）.