---
tags: [AI, 深度学习, 优化器]
阶段: 04-深度学习核心
难度: ★★★
created: 2026-10-18
related: "[[优化算法-梯度下降与Adam]], [[损失函数]], [[反向传播详解]], [[正则化与调参]]"
---

# 优化器与学习率

## 定义

**优化器**（optimizer）是给定梯度序列 $\{\mathbf{g}_t\}$ 与超参数后，把参数从初值 $\theta_0$ 迭代到 $\theta_T$ 的确定性更新规则；**学习率**（learning rate）是每步更新沿给定方向的尺度系数。

逐项定义本篇使用的符号：

- $\theta_t\in\mathbb{R}^{P}$：第 $t$ 步的参数向量，$P$ 为参数个数；$\theta_{t,i}$ 为其第 $i$ 个坐标。
- $\mathbf{g}_t=\nabla_\theta L(\theta_t)\in\mathbb{R}^{P}$：第 $t$ 步的梯度；小批量训练时为批内梯度的平均。
- $\eta>0$ 或 $\eta_t$：学习率；带下标时表示随步数变化的调度值。
- $\mathbf{m}_t,\mathbf{v}_t\in\mathbb{R}^{P}$：Adam 的一阶矩与二阶矩估计；$\mathbf{s}_t$ 为 RMSProp 的二阶矩估计；$\mathbf{G}_t$ 为 AdaGrad 的累积平方梯度。
- $\beta$：Momentum 的动量系数；$\beta_1,\beta_2$：Adam 的两个指数衰减率；$\rho$：RMSProp 的衰减率。
- $\epsilon>0$：数值稳定项，防止除以零并控制小梯度坐标的行为。
- $\lambda\ge0$：权重衰减系数；$\Omega(\theta)=\frac12\|\theta\|_2^2$ 为 L2 正则项。
- $B$：批大小；$N$：训练样本数；$T$：总步数；$T_w$：warmup 步数。
- $c>0$：梯度裁剪阈值；$\|\mathbf{g}\|_2$：梯度的全局 $L_2$ 范数。
- $\mathbf{u}_t$：第 $t$ 步的更新方向；$P_t$：预条件矩阵（preconditioner）。

术语：

- 预条件（preconditioning）：用正定矩阵 $P_t$ 左乘梯度，改变各坐标的更新尺度。
- 一阶矩（first moment）：梯度的指数移动平均，估计梯度的均值。
- 二阶矩（second moment）：梯度平方的指数移动平均，估计梯度的均方值。
- 偏差修正（bias correction）：除以 $1-\beta^{t}$，消除零初始化造成的矩估计偏小。
- 权重衰减（weight decay）：每步按固定比例收缩参数；解耦权重衰减指收缩项不进入梯度与矩估计。
- 学习率调度（learning rate schedule）：把 $\eta$ 设为步数 $t$ 的确定性函数。
- 梯度裁剪（gradient clipping）：按范数或逐元素限制梯度大小。
- 参数组（parameter group）：在同一个优化器中为不同参数子集设置不同学习率或权重衰减。

## 为什么重要

- 梯度只给出局部下降方向，优化器决定沿该方向走多远、以什么坐标尺度走。目标函数的条件数较大时，固定步长的梯度下降在曲率大的方向振荡、在曲率小的方向进展缓慢，收敛步数与条件数成正比；动量与逐坐标自适应分别从时间维与坐标维修正这一问题。
- 深度网络的参数梯度量级差异可达数个数量级。嵌入矩阵、LayerNorm 增益与偏置的梯度尺度不同，单一学习率会让一部分参数更新过快、另一部分几乎不更新；Adam 的逐坐标归一化使每步位移近似为 $\eta$，降低了这种尺度差异的影响。
- 学习率是训练中最敏感的超参数。步长超过稳定性上界时损失发散；步长过小时收敛步数按条件数增长。warmup、余弦退火与批量缩放规则共同决定训练早期能否稳定启动、后期能否压到较低的噪声下界。
- 大模型训练依赖若干工程约定：AdamW 的解耦权重衰减、$\beta_2=0.95$、梯度裁剪、混合精度与参数分组。这些约定的作用都可以从更新式推出，不理解更新式就只能照搬超参数。
- 在全书中的位置：前置为 [[优化算法-梯度下降与Adam]]（收敛性、$2/L$ 上界、条件数与遗憾界）与 [[反向传播详解]]（梯度的产生）；本篇消费 [[损失函数]] 给出的梯度尺度，后续被 [[正则化与调参]]、[[PyTorch实战入门]]、[[分布式训练与部署]] 与 [[预训练-微调-对齐pipeline]] 引用。
- 对应能力目标：懂原理对应「写出每种优化器的更新式并解释每一项」；能复现对应「在同一网络上复现四种优化器的收敛差异」；会评估对应「根据梯度范数、损失曲线与批量大小判断学习率是否合适」。

## 原理与推导

### 1. 统一形式：预条件梯度下降

把大多数一阶方法写成

$$\theta_{t+1}=\theta_t-\eta_t\,P_t^{-1}\mathbf{g}_t$$

其中 $P_t$ 为对称正定矩阵。选择不同的 $P_t$ 得到不同方法：

| 方法 | $P_t$ | 每坐标有效步长 |
|---|---|---|
| SGD | $\mathbf{I}$ | $\eta g_{t,i}$ |
| AdaGrad | $\operatorname{diag}(\sqrt{G_{t,i}}+\epsilon)$ | $\eta g_{t,i}/(\sqrt{G_{t,i}}+\epsilon)$ |
| RMSProp | $\operatorname{diag}(\sqrt{s_{t,i}}+\epsilon)$ | $\eta g_{t,i}/(\sqrt{s_{t,i}}+\epsilon)$ |
| Adam | $\operatorname{diag}(\sqrt{\hat v_{t,i}}+\epsilon)$ | $\eta \hat m_{t,i}/(\sqrt{\hat v_{t,i}}+\epsilon)$ |

Momentum 不在这张表里：它不是在坐标维上缩放，而是在时间维上对梯度做低通滤波。优化器可以按两个独立维度分类：

- 时间维：是否对历史梯度做累积或指数平均。SGD 只用当前梯度；Momentum 与 Adam 使用历史。
- 坐标维：是否为每个坐标设置不同的尺度。SGD 与 Momentum 对所有坐标使用同一系数；AdaGrad、RMSProp、Adam 逐坐标缩放。

需要明确 Adam 不是二阶方法。它用梯度平方的滑动平均近似每个坐标的梯度均方值，而不是 Hessian 的对角元。它处理的是梯度尺度差异，不是曲率各向异性；对条件数很大的二次型，Adam 的收敛仍受特征方向耦合影响，只是每坐标的步长被归一化。

### 2. SGD 与梯度噪声

小批量 SGD 的更新为

$$\mathbf{g}_t=\frac{1}{B}\sum_{i\in\mathcal{B}_t}\nabla_\theta\ell_i(\theta_t),\qquad
\theta_{t+1}=\theta_t-\eta\mathbf{g}_t$$

若批从训练集中均匀有放回抽取，则 $\mathbb{E}[\mathbf{g}_t]=\nabla_\theta L(\theta_t)$，即随机梯度是无偏估计。设单样本梯度的协方差为 $\sigma^{2}\mathbf{I}$，则

$$\operatorname{Var}(\mathbf{g}_t)=\frac{\sigma^{2}}{B}\mathbf{I}$$

批量增大 $B$ 倍，梯度标准差降为 $1/\sqrt{B}$。

噪声下界。取二次目标 $f(\theta)=\frac12\lambda\theta^{2}$，随机梯度 $g_t=\lambda\theta_t+\xi_t$，$\mathbb{E}[\xi_t]=0$、$\operatorname{Var}(\xi_t)=\sigma^{2}$。迭代为

$$\theta_{t+1}=(1-\eta\lambda)\theta_t-\eta\xi_t$$

设稳态方差为 $V$，由 $\theta_t$ 与 $\xi_t$ 独立得

$$V=(1-\eta\lambda)^{2}V+\eta^{2}\sigma^{2}
\quad\Longrightarrow\quad
V=\frac{\eta^{2}\sigma^{2}}{1-(1-\eta\lambda)^{2}}
=\frac{\eta\sigma^{2}}{2\lambda-\eta\lambda^{2}}$$

当 $\eta\lambda\ll1$ 时 $V\approx\eta\sigma^{2}/(2\lambda)$，参数的标准差为 $\sqrt{\eta\sigma^{2}/(2\lambda)}$。因此固定步长的 SGD 不会收敛到驻点，而是在其邻域内以正比于 $\sqrt{\eta}$ 的幅度波动；把学习率减半只能把最终标准差降到 $1/\sqrt{2}$，收敛步数却翻倍。这一权衡是学习率衰减的理论依据，相关收敛分析见 [[优化算法-梯度下降与Adam]]。

关于噪声与泛化的关系，可以陈述的机制是：噪声使参数在极小值附近持续扰动，扰动的协方差由 $\eta$、批大小与局部曲率共同决定；小批量训练因此不会精确停在某个尖锐解上。将该效应直接解释为「小批量一定泛化更好」则不成立，因为它与显式正则、数据增广、训练步数和数据分布耦合，需要控制变量实验才能归因。

### 3. Momentum 与 Nesterov

PyTorch 形式的 Momentum 维护未归一化的速度：

$$\mathbf{v}_{t+1}=\beta\mathbf{v}_t+\mathbf{g}_t,\qquad
\theta_{t+1}=\theta_t-\eta\mathbf{v}_{t+1},\qquad 0\le\beta<1$$

展开递推得

$$\mathbf{v}_{t+1}=\sum_{i=1}^{t}\beta^{t-i}\mathbf{g}_i$$

历史梯度的权重按 $\beta$ 的幂次衰减，有效记忆长度约为 $1/(1-\beta)$；$\beta=0.9$ 时约为 $10$ 步。若梯度恒为 $\mathbf{g}$，则 $\mathbf{v}_t\to\mathbf{g}/(1-\beta)$，稳态位移为 $\eta\mathbf{g}/(1-\beta)$，等效学习率被放大 $1/(1-\beta)$ 倍。

有些实现使用归一化形式

$$\mathbf{v}_{t+1}=\beta\mathbf{v}_t+(1-\beta)\mathbf{g}_t$$

此时稳态 $\mathbf{v}\to\mathbf{g}$，位移为 $\eta\mathbf{g}$，与 SGD 同尺度。两种形式只差常数因子 $(1-\beta)$，但阅读代码或论文时必须确认采用哪一种，否则会把等效学习率差 $10$ 倍的设置当成相同设置。

Momentum 在二次型上的稳定条件。对 $f(\theta)=\frac12\lambda\theta^{2}$，令 $v_{t+1}=\beta v_t+\lambda\theta_t$，$\theta_{t+1}=\theta_t-\eta v_{t+1}$，写成矩阵形式：

$$\begin{bmatrix}\theta_{t+1}\\ v_{t+1}\end{bmatrix}
=\begin{bmatrix}1-\eta\lambda&-\eta\beta\\ \lambda&\beta\end{bmatrix}
\begin{bmatrix}\theta_t\\ v_t\end{bmatrix}$$

特征多项式为

$$r^{2}-(1+\beta-\eta\lambda)r+\beta=0$$

两根均在单位圆内的条件为 $\beta<1$ 与

$$\eta\lambda<2(1+\beta)$$

$\beta=0.9$ 时上界为 $3.8$，而 SGD 的上界为 $2$。动量扩大了可用步长范围，原因是对高曲率方向的振荡分量做了时间平均：当 $1-\eta\lambda<0$ 时，SGD 在该方向交替变号，动量把相邻两步的相反分量部分抵消。

Nesterov 加速梯度把梯度取在外推点上：

$$\mathbf{v}_{t+1}=\beta\mathbf{v}_t+\nabla_\theta L\big(\theta_t-\eta\beta\mathbf{v}_t\big),\qquad
\theta_{t+1}=\theta_t-\eta\mathbf{v}_{t+1}$$

与 Momentum 的差别只在梯度求值位置：先按当前动量向前试探 $\eta\beta\mathbf{v}_t$，再在该点计算梯度。若试探点已越过极小值，该点的梯度方向反转，修正项抵消一部分动量，因此过冲小于 Momentum。对凸且 $L$-smooth 的目标，Nesterov 的收敛率为 $O(1/t^{2})$，梯度下降为 $O(1/t)$；深度学习中两者表现通常接近，差异取决于局部结构。

PyTorch 的 `SGD(momentum=..., nesterov=True)` 采用另一种写法：先算 $\mathbf{v}\leftarrow\beta\mathbf{v}+\mathbf{g}$，再用 $\mathbf{g}+\beta\mathbf{v}$ 作为更新方向。它与上式在连续时间极限下一致，但在离散步长较大时数值不同；对照实现时应以框架文档为准，不能把两种写法逐行等同。

### 4. AdaGrad

AdaGrad 按坐标累积历史梯度平方：

$$\mathbf{G}_t=\mathbf{G}_{t-1}+\mathbf{g}_t\odot\mathbf{g}_t,\qquad
\theta_{t+1}=\theta_t-\frac{\eta}{\sqrt{\mathbf{G}_t}+\epsilon}\odot\mathbf{g}_t$$

其中 $\odot$ 为逐元素乘，$\mathbf{G}_0=\mathbf{0}$，平方根与除法均逐元素进行。由于 $\mathbf{G}_{t,i}$ 包含 $g_{t,i}^{2}$，有 $\sqrt{\mathbf{G}_{t,i}}\ge|g_{t,i}|$，故单坐标位移满足

$$|\Delta\theta_{t,i}|=\frac{\eta|g_{t,i}|}{\sqrt{G_{t,i}}+\epsilon}\le\eta$$

梯度长期较大的坐标获得较小的有效步长，梯度稀疏的坐标获得较大的有效步长。对凸问题，AdaGrad 的遗憾界为 $O(\sqrt{T})$，这是它最初的理论依据。

其缺陷来自单调性。若某坐标的梯度恒为 $c$，则 $G_{t,i}=c^{2}t$，有效学习率为 $\eta/(c\sqrt{t})$，随步数单调衰减到零；训练后期该坐标几乎停止更新。深度网络的非平稳性使这一问题更严重：早期的大梯度会永久压低后续所有更新的步长。$\epsilon$ 只能在 $G$ 很小时起作用，无法逆转 $\sqrt{t}$ 的衰减。AdaGrad 因此主要用于梯度稀疏且统计平稳的问题，例如稀疏特征上的线性模型。

### 5. RMSProp

RMSProp 用指数移动平均替代单调累积：

$$\mathbf{s}_t=\rho\,\mathbf{s}_{t-1}+(1-\rho)\,\mathbf{g}_t\odot\mathbf{g}_t,\qquad
\theta_{t+1}=\theta_t-\frac{\eta}{\sqrt{\mathbf{s}_t}+\epsilon}\odot\mathbf{g}_t$$

其中 $\rho\in[0,1)$ 为衰减率，常用 $0.9$ 或 $0.99$。展开得

$$\mathbf{s}_t=(1-\rho)\sum_{i=1}^{t}\rho^{t-i}\mathbf{g}_i\odot\mathbf{g}_i$$

它近似为近期梯度平方的均值，记忆长度约为 $1/(1-\rho)$。与 AdaGrad 的差别是遗忘：旧梯度的影响按 $\rho$ 的幂次衰减，有效步长随局部梯度尺度变化，而不随训练时长单调下降。

$\mathbf{s}_t$ 的期望比真实二阶矩小 $1-\rho^{t}$ 倍（零初始化造成的偏差），RMSProp 通常不做修正；前几步分母偏小，步长偏大。$\epsilon$ 与 warmup 共同限制这一早期阶段。若梯度平稳且 $|g_{t,i}|\approx c$，则 $\sqrt{s_{t,i}}\to c$，更新约为 $\eta\,\mathrm{sign}(g_{t,i})$，每坐标位移约为 $\eta$，与梯度尺度无关。

### 6. Adam：矩估计、偏差修正与 $\epsilon$

Adam 同时维护一阶矩与二阶矩：

$$\mathbf{m}_t=\beta_1\mathbf{m}_{t-1}+(1-\beta_1)\mathbf{g}_t,\qquad
\mathbf{v}_t=\beta_2\mathbf{v}_{t-1}+(1-\beta_2)\mathbf{g}_t\odot\mathbf{g}_t$$

初值 $\mathbf{m}_0=\mathbf{v}_0=\mathbf{0}$，默认 $\beta_1=0.9$、$\beta_2=0.999$、$\epsilon=10^{-8}$。展开得

$$\mathbf{m}_t=(1-\beta_1)\sum_{i=1}^{t}\beta_1^{t-i}\mathbf{g}_i,\qquad
\mathbf{v}_t=(1-\beta_2)\sum_{i=1}^{t}\beta_2^{t-i}\mathbf{g}_i\odot\mathbf{g}_i$$

偏差修正的推导。设各步梯度的期望相同，$\mathbb{E}[\mathbf{g}_i]=\boldsymbol{\mu}$，则

$$\mathbb{E}[\mathbf{m}_t]=(1-\beta_1)\sum_{i=1}^{t}\beta_1^{t-i}\boldsymbol{\mu}
=(1-\beta_1)\frac{1-\beta_1^{t}}{1-\beta_1}\boldsymbol{\mu}
=(1-\beta_1^{t})\boldsymbol{\mu}$$

同理，若 $\mathbb{E}[\mathbf{g}_i\odot\mathbf{g}_i]=\boldsymbol{\nu}$，则 $\mathbb{E}[\mathbf{v}_t]=(1-\beta_2^{t})\boldsymbol{\nu}$。零初始化使两个矩估计都偏小，且偏差因子随 $t$ 变化；除以该因子得到

$$\hat{\mathbf{m}}_t=\frac{\mathbf{m}_t}{1-\beta_1^{t}},\qquad
\hat{\mathbf{v}}_t=\frac{\mathbf{v}_t}{1-\beta_2^{t}}$$

于是 $\mathbb{E}[\hat{\mathbf{m}}_t]=\boldsymbol{\mu}$、$\mathbb{E}[\hat{\mathbf{v}}_t]=\boldsymbol{\nu}$。参数更新为

$$\theta_{t+1}=\theta_t-\eta\frac{\hat{\mathbf{m}}_t}{\sqrt{\hat{\mathbf{v}}_t}+\epsilon}$$

三点限定：

1. 修正只对「梯度同分布」的期望成立。若梯度均值随步数变化，$\mathbb{E}[\mathbf{m}_t]$ 是历史均值的加权平均，修正项只消除零初始化偏差，不消除非平稳性带来的滞后。
2. 第一步的更新约为 $\eta\,\mathrm{sign}(\mathbf{g}_1)$。由 $\hat{\mathbf{m}}_1=\mathbf{g}_1$、$\hat{\mathbf{v}}_1=\mathbf{g}_1^{2}$ 得 $\hat m_{1,i}/\sqrt{\hat v_{1,i}}=\mathrm{sign}(g_{1,i})$，每坐标位移约为 $\eta$，与梯度大小无关。初始化较差或首批梯度的坐标尺度差异很大时，这一步可能过大。
3. $\hat m_{t,i}/\sqrt{\hat v_{t,i}}$ 的绝对值近似不超过 $1$。当 $\beta_1=\beta_2$ 时，由柯西–施瓦茨不等式可得 $m_{t,i}^{2}\le v_{t,i}$，故比值不超过 $1$；$\beta_1\ne\beta_2$ 时该界只是近似。实际更新幅度因此以 $\eta$ 为尺度，这也是 Adam 对梯度整体缩放不敏感的原因。

$\epsilon$ 的作用有三层：

- 防止 $\hat v_{t,i}=0$ 时除以零，例如某坐标的梯度恒为零。
- 控制小梯度坐标的行为。当 $\sqrt{\hat v_{t,i}}\ll\epsilon$ 时，更新约为 $\eta\hat m_{t,i}/\epsilon$，$\epsilon$ 越大，这类坐标的步长越小；当 $\sqrt{\hat v_{t,i}}\gg\epsilon$ 时，$\epsilon$ 可忽略。
- 影响数值范围。float16 下 $\hat v$ 可能下溢或上溢，$\epsilon$ 过小会导致除零或 inf；bf16 的指数范围与 float32 相同，但尾数位少，矩估计仍建议保存在 float32。PyTorch 默认将 $\epsilon$ 加在偏差修正后的 $\sqrt{\hat v}$ 上，与原文一致；把 $\epsilon$ 放进根号内（$\sqrt{\hat v+\epsilon}$）是另一种实现，二者只在 $\hat v$ 与 $\epsilon$ 同量级时产生可见差异。

$\beta_2$ 的选择决定二阶矩的记忆长度。$0.999$ 对应约 $1000$ 步，适合平稳梯度；大语言模型训练中梯度统计随课程与数据分布快速变化，常取 $0.95$（约 $20$ 步）以加快适应。该取值不是理论最优，而是稳定性与响应速度的折中。

### 7. AdamW：解耦权重衰减

L2 正则把目标改为 $L(\theta)+\frac{\lambda}{2}\|\theta\|_2^{2}$，梯度变为 $\mathbf{g}_t+\lambda\theta_t$。该梯度进入 Adam 的矩估计，参数更新为

$$\theta_{t+1}=\theta_t-\eta\frac{\hat{\mathbf{m}}_t}{\sqrt{\hat{\mathbf{v}}_t}+\epsilon}$$

其中 $\hat{\mathbf{m}}_t$ 已包含正则项的贡献。若参数变化缓慢，衰减项对分子的贡献约为 $\lambda\theta_t$，每步的相对收缩约为

$$\frac{\eta\lambda}{\sqrt{\hat v_{t,i}}+\epsilon}$$

它逐坐标不同：$\hat v_{t,i}$ 大的坐标收缩弱，$\hat v_{t,i}$ 小的坐标收缩强，且该比值在 $\hat v_{t,i}\to0$ 时无上界。正则强度因此依赖梯度统计量，失去了「每步按固定比例收缩」的含义。

AdamW 把衰减从梯度中分离：

$$\theta_{t+1}=(1-\eta\lambda)\theta_t-\eta\frac{\hat{\mathbf{m}}_t}{\sqrt{\hat{\mathbf{v}}_t}+\epsilon}$$

衰减项只由 $\eta\lambda$ 决定，与 $\hat{\mathbf{v}}_t$ 无关。当 $\eta\lambda<1$ 时，每步把参数乘以 $1-\eta\lambda$。

一个具体对照。取 $\theta_i=1$、$\eta=0.01$、$\lambda=0.1$：

- 坐标 A 的 $\sqrt{\hat v}=1$。L2 版本每步衰减约 $0.01\times0.1/1=0.001$；AdamW 也是 $0.001$。
- 坐标 B 的 $\sqrt{\hat v}=0.01$。L2 版本每步衰减约 $0.01\times0.1/0.01=0.1$，是坐标 A 的 $100$ 倍；AdamW 仍为 $0.001$。

L2 与解耦衰减仅在 $\sqrt{\hat v_t}$ 对所有坐标与所有步都相同的退化情形下等价。一般情形下二者给出不同轨迹；PyTorch 的 `Adam(weight_decay=...)` 实现的是 L2（把 $\lambda\theta$ 加到梯度），`AdamW(weight_decay=...)` 才是解耦版本。

衰减的累积效果可以精确写出。忽略高阶项，

$$\prod_{t=1}^{T}(1-\eta_t\lambda)\approx\exp\left(-\lambda\sum_{t=1}^{T}\eta_t\right)$$

若 $\eta=10^{-4}$、$T=10^{5}$、$\lambda=0.1$，则 $\lambda\sum\eta_t=1$，总收缩为 $e^{-1}\approx0.368$。换成余弦调度时 $\sum\eta_t$ 约为峰值乘以步数的一半，同样的 $\lambda$ 只收缩约 $e^{-0.5}\approx0.607$。这说明学习率调度会改变权重衰减的有效强度；改变调度后必须重新调整 $\lambda$，不能把 $\lambda$ 当作与调度无关的常数。

参数分组是 AdamW 的标准用法：偏置、LayerNorm 或 RMSNorm 的增益、以及部分归一化参数通常不施加衰减，因为对它们做收缩会破坏平移或尺度自由度；线性层与注意力投影矩阵施加衰减。各组可以共享矩估计的超参数，但使用不同的 $\lambda$ 与学习率。

### 8. 学习率调度

**分段常数衰减**（step decay）每经过 $s$ 步把学习率乘以 $\gamma$：

$$\eta_t=\eta_0\,\gamma^{\lfloor t/s\rfloor},\qquad 0<\gamma<1$$

多段版本在预设的里程碑处各乘一次 $\gamma$。指数衰减为 $\eta_t=\eta_0\gamma^{t}$。两者的共同问题是超参数需要人工设定：step 的曲线在里程碑处不连续，指数衰减则缺少明确的终止点，且衰减过快会过早冻结参数。

**余弦退火**在 warmup 之后把学习率从峰值平滑降到下限：

$$\eta_t=\eta_{\min}+\frac12(\eta_{\max}-\eta_{\min})
\left(1+\cos\left(\pi\frac{t-T_w}{T-T_w}\right)\right),\qquad T_w\le t\le T$$

余弦曲线在两端导数为零：$t=T_w$ 与 $t=T$ 处学习率变化率为零，训练末期步长平缓下降，避免突然减小造成的损失反弹。$\eta_{\min}$ 通常取峰值的 $1\%$ 到 $10\%$，或直接取零。

**线性 warmup** 在前 $T_w$ 步把学习率从接近零线性升至峰值：

$$\eta_t=\eta_{\max}\frac{t+1}{T_w},\qquad t<T_w$$

warmup 的必要性可以从三个机制说明：

1. Adam 的二阶矩在最初几步只由少量梯度平方构成，估计方差大。$t=1$ 时 $\hat v_1=g_1^{2}$，更新为 $\eta\,\mathrm{sign}(g_1)$，每坐标位移都是满额 $\eta$；若某些坐标的初始梯度异常大或异常小，逐坐标归一化会把这种异常转化为固定的满额位移。warmup 用较小的 $\eta_t$ 限制这一阶段的总位移。
2. 归一化层与残差网络的激活统计量在训练初期尚未稳定；大步长会改变各层输入分布，使后续批次的梯度统计继续漂移。较小的早期步长让统计量先稳定。
3. 大批量训练中，虽然梯度估计的方差小，但初始点附近的曲率可能很大；warmup 相当于逐步增大信赖域，避免第一步就跨出局部二次近似有效的区域。

**逆平方根调度**（inverse square root）由 Transformer 原文采用：

$$\eta_t=d_{\text{model}}^{-0.5}\min\left(t^{-0.5},\ t\,T_w^{-1.5}\right)$$

其中 $d_{\text{model}}$ 为模型宽度。$t<T_w$ 时学习率随 $t$ 线性上升，之后按 $t^{-0.5}$ 衰减。**OneCycle** 先 warmup 到峰值，再余弦下降到低于初始值的下限，常用于固定计算预算的短训练。

| 调度 | 公式 | 曲线形状 | 适用场景 |
|---|---|---|---|
| Step | $\eta_0\gamma^{\lfloor t/s\rfloor}$ | 分段下降 | CNN 分类，里程碑已知 |
| Exponential | $\eta_0\gamma^{t}$ | 指数下降 | 简单基线 |
| Cosine | $\eta_{\min}+\frac12(\eta_{\max}-\eta_{\min})(1+\cos\pi p)$ | 平滑下降，两端导数为零 | 大模型预训练、微调 |
| Linear | $\eta_0(1-t/T)$ | 线性下降 | 短程微调 |
| Inverse sqrt | $d^{-0.5}\min(t^{-0.5},tT_w^{-1.5})$ | 先升后按 $t^{-0.5}$ 降 | Transformer 原版 |
| OneCycle | 先升后余弦至下限 | 单峰 | 固定预算训练 |

PyTorch 的调度器有调用顺序约束：先 `optimizer.step()`，再 `scheduler.step()`。若顺序颠倒，调度器会在参数更新前推进，第一次更新使用第二个学习率值，等于跳过初始值；PyTorch 从 1.1 起会对该顺序发出警告。使用梯度累积时，每个优化器步只调用一次 `scheduler.step()`，不能在每个 micro-batch 调用。

### 9. 批大小与学习率缩放

批量 $B$ 同时影响梯度噪声与每 epoch 的步数。两种常用缩放规则对应两个不同的不变量。

线性缩放要求每个 epoch 的总位移不变。一个 epoch 有 $N/B$ 步，每步位移约 $\eta\mathbf{g}$，总位移约 $\eta\mathbf{g}N/B$；令其与 $B$ 无关，得

$$\eta\propto B$$

平方根缩放要求单步由噪声引起的位移不变。噪声标准差为 $\sigma/\sqrt{B}$，单步噪声位移约 $\eta\sigma/\sqrt{B}$；令其与 $B$ 无关，得

$$\eta\propto\sqrt{B}$$

两者不是竞争关系，而是控制不同的量：线性缩放保持信号位移，平方根缩放保持噪声位移。小批量、训练步数充足时线性缩放常用；批量很大、噪声相对信号已很小时，继续线性增大学习率会破坏稳定性，此时平方根缩放或保持学习率不变更合适。批量超过某一临界值后，梯度噪声的下降不再带来等比例的收敛加速，继续增大批量只减少并行步数，不减少总计算量；该临界值依赖模型、数据与优化器，需通过实验确定。

从基准 $B_0=32$、$\eta_0=0.1$ 出发：

| $B$ | 线性 $\eta$ | 平方根 $\eta$ |
|---|---|---|
| $32$ | $0.1$ | $0.1$ |
| $128$ | $0.4$ | $0.2$ |
| $512$ | $1.6$ | $0.4$ |
| $2048$ | $6.4$ | $0.8$ |

改变批量后还需同步调整 warmup 步数与权重衰减。若总训练 epoch 不变，步数按 $B$ 反比减少，warmup 的步数也应减少以保持相同的 epoch 比例；权重衰减的总次数减少，$\sum\eta_t$ 改变，有效衰减强度随之改变。梯度累积把 $A$ 个 micro-batch 的梯度相加，等效批量为 $B_{\text{micro}}A$；损失若按每个 micro-batch 求平均后再求和，需要除以 $A$ 才能得到等效平均梯度。分布式数据并行（DDP）对各设备的梯度求平均，全局批量为单卡批量乘设备数再乘累积步数。

### 10. 梯度裁剪

全局范数裁剪为

$$\mathbf{g}\leftarrow\mathbf{g}\cdot\min\left(1,\frac{c}{\|\mathbf{g}\|_2}\right)$$

当梯度范数超过 $c$ 时，整体缩放到范数 $c$；否则不变。该操作保持方向，只改变长度。逐元素裁剪为

$$g_i\leftarrow\mathrm{clip}(g_i,-c,c)$$

它不保持方向，梯度各分量被独立截断，通常不用于模型梯度更新；差分隐私训练中的逐样本裁剪针对单个样本的梯度范数，也不是逐元素裁剪。

裁剪的作用有三点：

1. 限制单步位移。对 SGD，$\|\Delta\theta\|=\eta\|\mathbf{g}\|\le\eta c$；一个异常批次不能产生远超正常步长的更新。
2. 防止数值溢出。float16 的动态范围窄，梯度范数突然增大可能使平方或矩估计溢出为 inf，随后出现 NaN；裁剪把范数压回可表示范围。
3. 降低重尾噪声的影响。语言模型的梯度范数分布有明显重尾，少数批次的范数可达中位数的数十倍；裁剪使这些批次对参数的影响有上界。

裁剪对 Adam 的作用需要单独分析。若某一步的梯度被全局缩放因子 $s<1$，且矩估计中的历史梯度也按相同比例缩放，则 $\mathbf{m}$ 缩放 $s$、$\sqrt{\mathbf{v}}$ 缩放 $s$，比值 $\hat{\mathbf{m}}/\sqrt{\hat{\mathbf{v}}}$ 不变，更新几乎不变（$\epsilon$ 项除外）。实际上历史中只有部分梯度被裁剪，因此更新会变化，但变化幅度远小于 SGD。对 Adam 而言，裁剪的主要收益是防止溢出与限制异常批次对矩估计的污染，而不是直接限制步长；对 SGD 与 AdaGrad，裁剪才直接限制步长。这一区别常被忽略。

阈值 $c$ 的常用起点为 $1.0$（大语言模型）或 $5.0$（CNN）。应监控裁剪前后范数的比值与触发比例：若大多数步都触发裁剪，说明学习率或初始化有问题，裁剪掩盖了真正的原因；若从不触发，阈值形同虚设。裁剪应在损失缩放反缩放之后、优化器更新之前执行。

### 11. 工程细节

参数分组。一个优化器可以接收多个参数组，每组独立的 `lr`、`weight_decay`、`betas`：

```python
# 假设 model 已定义
decay, no_decay = [], []
for name, p in model.named_parameters():
    if not p.requires_grad:
        continue
    if p.ndim < 2 or name.endswith(".bias"):
        no_decay.append(p)
    else:
        decay.append(p)
groups = [{"params": decay, "weight_decay": 0.1},
          {"params": no_decay, "weight_decay": 0.0}]
```

判据是参数是否参与尺度或平移自由度：矩阵乘法的权重参与尺度变换，适合衰减；偏置与归一化增益不适合。嵌入矩阵通常施加衰减，但是否衰减取决于任务与词表规模，需通过消融确认。

混合精度。常见做法是前向与反向使用 bfloat16 或 float16 的 autocast，参数主副本与优化器状态保持 float32。float16 需要损失缩放（loss scaling）以避免梯度下溢；bfloat16 的指数范围与 float32 相同，通常不需要缩放，但尾数位少，矩估计的舍入误差更大，$\epsilon$ 与 $\beta_2$ 需相应调整。若把参数本身转为低精度，Adam 的 $\hat v$ 可能下溢，表现为某些坐标停止更新。

检查点与恢复。优化器状态包含每步的矩估计与步数计数 $t$；调度器状态包含当前步数或 epoch。恢复训练时必须同时加载模型、优化器与调度器状态，否则偏差修正从 $t=1$ 重新开始，学习率也从调度起点重新计算，二者都会造成损失跳变。仅加载模型参数而重建优化器，是最常见的恢复错误。

融合算子。PyTorch 的 `foreach=True` 把参数组的更新合并为批量算子，`fused=True` 在 CUDA 上进一步融合，减少 kernel 启动开销。融合实现与逐参数实现在浮点舍入上不完全相同，长训练中可能产生可见差异；对可复现性要求高的实验应固定实现与确定性选项。FSDP 或 ZeRO 把优化器状态分片到各设备，更新式不变，但状态的分片与聚合顺序会影响数值。

### 12. 方法对比

| 方法 | 维护状态 | 更新式 | 主要超参 | 每步代价 | 特点 |
|---|---|---|---|---|---|
| SGD | 无 | $\theta\leftarrow\theta-\eta g$ | $\eta$ | $O(P)$ | 噪声下界 $\propto\sqrt{\eta}$，稳定上界 $\eta\lambda<2$ |
| Momentum | $\mathbf{v}$ | $\mathbf{v}\leftarrow\beta\mathbf{v}+g$，$\theta\leftarrow\theta-\eta\mathbf{v}$ | $\eta,\beta$ | $O(P)$ | 时间平滑，稳定上界 $\eta\lambda<2(1+\beta)$ |
| Nesterov | $\mathbf{v}$ | 梯度取在 $\theta-\eta\beta\mathbf{v}$ | $\eta,\beta$ | $O(P)$ | 过冲修正，凸情形 $O(1/t^{2})$ |
| AdaGrad | $\mathbf{G}$ | $\theta\leftarrow\theta-\eta g/(\sqrt{\mathbf{G}}+\epsilon)$ | $\eta$ | $O(P)$ | 坐标自适应，学习率单调衰减 |
| RMSProp | $\mathbf{s}$ | $\mathbf{s}\leftarrow\rho\mathbf{s}+(1-\rho)g^{2}$ | $\eta,\rho$ | $O(P)$ | 非平稳适应，无单调衰减 |
| Adam | $\mathbf{m},\mathbf{v}$ | 偏差修正后逐坐标归一化 | $\eta,\beta_1,\beta_2,\epsilon$ | $O(P)$ | 尺度不敏感，需 warmup |
| AdamW | $\mathbf{m},\mathbf{v}$ | Adam 更新加解耦衰减 | 同上，另有 $\lambda$ | $O(P)$ | 衰减与梯度统计解耦 |

## 关键直觉

> [!tip] 机制性直觉
> 优化器可以看作两个正交操作的组合：时间维上对梯度做指数平均（Momentum 与 Adam 的一阶矩），坐标维上除以梯度均方值的平方根（AdaGrad、RMSProp、Adam 的二阶矩）。前者抑制来回振荡、放大持续一致的方向；后者把每个坐标的步长归一到约 $\eta$，使梯度尺度不同的参数获得相近的位移。AdamW 的权重衰减则是一个与梯度无关的乘性收缩，每步把参数乘以 $1-\eta\lambda$，其累积效果为 $\exp(-\lambda\sum_t\eta_t)$，因此衰减强度由学习率的积分决定，而不是由步数单独决定。上述表述对应第 1 节的预条件形式、第 6 节的两条矩递推与第 7 节的更新式；它不意味着 Adam 是二阶方法，因为二阶矩估计的是梯度均方值而非曲率。

## 例子与代码

### 实验设置

在同一个三层网络上比较四种优化器。数据由

$$y=\sin(2x)+0.3x+\varepsilon,\qquad \varepsilon\sim\mathcal{N}(0,0.1^{2})$$

生成 $256$ 个样本，前 $200$ 个用于训练，后 $56$ 个用于验证。网络为 $1\to32\to32\to1$，隐藏层使用 tanh，输出层线性，损失为 MSE。全批量训练 $600$ 步，不丢弃、不打乱。四种优化器从完全相同的参数初值出发，数据与初值均由 NumPy 固定种子生成后拷入 PyTorch，保证比较只改变优化器。

```python
import numpy as np
import torch
import torch.nn as nn

# 数据与初值用 NumPy 固定，四种优化器共享同一组数值
rng = np.random.default_rng(42)
x = rng.normal(size=(256, 1))
y = np.sin(2 * x) + 0.3 * x + rng.normal(0, 0.1, size=(256, 1))
Xtr, Ytr = torch.from_numpy(x[:200]), torch.from_numpy(y[:200])
Xva, Yva = torch.from_numpy(x[200:]), torch.from_numpy(y[200:])

r = np.random.default_rng(7)
W1 = r.normal(0.0, 1.0, size=(1, 32))
W2 = r.normal(0.0, 1 / np.sqrt(32), size=(32, 32))
W3 = r.normal(0.0, 1 / np.sqrt(32), size=(32, 1))

def make_model():
    model = nn.Sequential(
        nn.Linear(1, 32), nn.Tanh(),
        nn.Linear(32, 32), nn.Tanh(),
        nn.Linear(32, 1),
    ).double()                                   # float64 便于与数值推导逐位对照
    with torch.no_grad():
        model[0].weight.copy_(torch.from_numpy(W1.T))
        model[2].weight.copy_(torch.from_numpy(W2.T))
        model[4].weight.copy_(torch.from_numpy(W3.T))
        for m in model:
            if isinstance(m, nn.Linear):
                m.bias.zero_()
    return model

def train(opt_fn, steps=600):
    model = make_model()
    opt = opt_fn(model.parameters())
    hist = []
    for _ in range(steps):
        loss = ((model(Xtr) - Ytr) ** 2).mean()
        opt.zero_grad()                          # 清空上一步的梯度，否则会累加
        loss.backward()
        opt.step()
        hist.append(loss.item())
    with torch.no_grad():
        val = ((model(Xva) - Yva) ** 2).mean().item()
    return hist, val

configs = {
    "SGD":      lambda p: torch.optim.SGD(p, lr=0.1),
    "Momentum": lambda p: torch.optim.SGD(p, lr=0.02, momentum=0.9),
    "Adam":     lambda p: torch.optim.Adam(p, lr=0.01),
    "AdamW":    lambda p: torch.optim.AdamW(p, lr=0.01, weight_decay=0.1),
}

for name, fn in configs.items():
    h, val = train(fn)
    step = next((i + 1 for i, v in enumerate(h) if v < 0.03), -1)
    print(f"{name:9s} final={h[-1]:.6f} val={val:.6f} steps<0.03={step} "
          f"@100={h[99]:.6f} @400={h[399]:.6f}")
```

预期输出：

```text
SGD       final=0.028441 val=0.032158 steps<0.03=199 @100=0.035520 @400=0.027568
Momentum  final=0.015817 val=0.019387 steps<0.03=113 @100=0.031411 @400=0.018016
Adam      final=0.011408 val=0.011771 steps<0.03=86 @100=0.026564 @400=0.012811
AdamW     final=0.011620 val=0.012275 steps<0.03=87 @100=0.026983 @400=0.012899
```

结果解释：

- Adam 最快。它的逐坐标归一化使每步位移约为 $\eta=0.01$，在梯度尺度较小的方向上不会被压缩；第 $86$ 步即低于 $0.03$。
- Momentum 次之。$\eta=0.02$、$\beta=0.9$ 的稳态等效步长为 $0.02/(1-0.9)=0.2$，大于 SGD 的 $0.1$，但动量需要若干步积累速度，前期慢于 Adam。
- SGD 在第 $199$ 步首次低于 $0.03$，随后在 $0.028$ 附近波动，最终值 $0.028441$ 反而略高于阈值。这是第 2 节推导的噪声下界：固定学习率的 SGD 不会停在一个点上，而是在极小值邻域内持续扰动；Adam 的更新由一阶矩与二阶矩之比决定，在极小值附近梯度方向反复变化时该比值减小，波动幅度因此更低。
- AdamW 与 Adam 的轨迹接近，但训练损失与验证损失都略高。$600$ 步、$\eta=0.01$、$\lambda=0.1$ 的累积衰减为

$$\exp\left(-0.1\times0.01\times600\right)=e^{-0.6}\approx0.549$$

即参数被整体收缩到无衰减轨迹的约 $55\%$。该目标是一维平滑函数，训练集只有 $200$ 个样本，收缩没有带来泛化收益，因此验证损失略升。这个结果说明权重衰减不是无条件有益，其强度应与模型容量、数据量与任务噪声匹配。

三处实现细节：

- `make_model()` 每次重建网络并重新拷入同一组 NumPy 初值。若在同一个模型上依次训练四种优化器，后面的实验会继承前面的参数，比较失效。
- `opt.zero_grad()` 必须在 `loss.backward()` 之前调用。漏掉它会使梯度跨步累加，等效学习率随步数增长，Adam 的矩估计也会被污染。
- `.double()` 把参数与输入转为 float64。float32 下四种优化器的损失差异仍在，但末位数值会变化，无法与上表逐位对照。

### Adam 对梯度整体缩放的近似不变性

```python
import numpy as np

def adam_1d(scale, steps=20, lr=0.1, b1=0.9, b2=0.999, eps=1e-8):
    # 目标 f(theta)=0.5*theta^2，梯度为 scale*theta
    theta, m, v = 1.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = scale * theta
        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 -= lr * m_hat / (np.sqrt(v_hat) + eps)
    return theta

for scale in (1e-3, 1.0, 1e3):
    print(scale, f"{adam_1d(scale):.10f}")
```

预期输出：

```text
0.001 -0.2711512913
1.0 -0.2711540941
1000.0 -0.2711540969
```

梯度乘以 $10^{3}$ 或 $10^{-3}$ 后，$20$ 步后的参数几乎不变（差异在 $10^{-6}$ 量级，来自 $\epsilon$）。原因是 $\mathbf{m}$ 与 $\sqrt{\mathbf{v}}$ 同比例缩放，比值不变；$\epsilon$ 破坏了严格的尺度不变性，梯度越小时 $\epsilon$ 的相对影响越大。SGD 在同一实验下会得到完全不同的轨迹：步长与梯度成正比，缩放 $10^{3}$ 倍会使更新放大 $10^{3}$ 倍并可能发散。这正是 Adam 在超参数迁移与混合精度下更宽容的原因，也是它需要 $\epsilon$ 与 warmup 的原因。

### warmup 与余弦退火的学习率轨迹

```python
import math

def lr_at(t, total=1000, warmup=100, peak=1e-3, floor=1e-5):
    if t < warmup:
        return peak * (t + 1) / warmup           # 线性 warmup
    p = (t - warmup) / (total - warmup)
    return floor + 0.5 * (peak - floor) * (1 + math.cos(math.pi * p))

for t in (0, 50, 99, 100, 250, 500, 750, 1000):
    print(t, f"{lr_at(t):.8f}")
```

预期输出：

```text
0 0.00001000
50 0.00051000
99 0.00100000
100 0.00100000
250 0.00093368
500 0.00059096
750 0.00018682
1000 0.00001000
```

$t=0$ 时学习率为峰值的 $1/100$，$t=99$ 时达到峰值；余弦段从峰值开始，$t=250$ 时只下降到峰值的 $93.4\%$，$t=750$ 时降至 $18.7\%$，末端回到下限。该轨迹的积分 $\sum_t\eta_t\approx0.5055$（$1001$ 个点），约为「全程保持峰值」的一半。若两种轨迹使用相同的 $\lambda=0.1$，权重衰减的总收缩分别为 $e^{-0.0506}\approx0.951$ 与 $e^{-0.1001}\approx0.905$；余弦调度实际上把有效正则强度减半。改变调度而不改变 $\lambda$，会同时改变优化与正则。

## 易错点

> [!warning] 常见错误
> - 学习率调度器的调用顺序错误或恢复训练时状态不全。PyTorch 要求在 `optimizer.step()` 之后调用 `scheduler.step()`，顺序颠倒会跳过第一个学习率值且不报错；恢复训练时优化器的 `step` 计数与矩估计、调度器的步数都必须加载，否则偏差修正从 $t=1$ 重新开始，学习率也回到调度起点，损失会出现跳变。使用梯度累积时每个优化器步只调用一次调度器，不能在每个 micro-batch 调用。
> - 把 `torch.optim.Adam(weight_decay=...)` 当作 AdamW。前者把 $\lambda\theta$ 加到梯度，衰减进入矩估计后按 $\sqrt{\hat v}$ 逐坐标缩放；后者的收缩固定为 $\eta\lambda$。两者只有在 $\sqrt{\hat v}$ 为常数时才等价。
> - 梯度累积时未缩放损失。把 $A$ 个 micro-batch 的平均损失直接相加，梯度是正确值的 $A$ 倍；应在反向传播前除以 $A$，或对各 micro-batch 的损失取平均。Adam 对整体缩放不敏感，但权重衰减、$\epsilon$ 与梯度裁剪的阈值会因此改变。
> - 认为梯度裁剪能修复 Adam 的异常更新。全局范数裁剪保持方向，而 Adam 的归一化更新对整体缩放近似不变，裁剪主要防止溢出与矩估计污染；对 SGD 才直接限制步长。若裁剪频繁触发，应先检查学习率与初始化。
> - 在改变批量时只按线性规则放大学习率。线性缩放只在小批量区间成立；批量超过临界值后应改用平方根缩放或保持学习率，并同步调整 warmup 与权重衰减，否则会损失稳定性或浪费计算。
> - 对偏置与归一化增益施加权重衰减。对这些参数收缩会破坏平移与尺度自由度，通常应放入 `weight_decay=0` 的参数组；是否衰减嵌入矩阵需通过消融确认。

## 关联笔记

- 前置：[[优化算法-梯度下降与Adam]] —— 梯度下降的收敛条件、$2/L$ 上界、条件数与遗憾界在此建立；本篇不再重复证明，只引用其结论并补充实现层面的更新式。
- 前置：[[反向传播详解]] —— 本篇消费该篇产出的梯度；梯度消失、梯度爆炸与梯度裁剪的动机在该篇的连乘分析中已经出现。
- 前置：[[损失函数]] —— 损失的梯度尺度决定学习率与裁剪阈值；交叉熵的 $\mathbf{p}-\mathbf{y}$ 与 MSE 的 $2(f-y)$ 相差常数与批大小因子，直接比较两者的学习率没有意义。
- 后续：[[正则化与调参]] —— 权重衰减、Dropout、归一化与早停共同控制泛化；本篇给出解耦衰减的更新式，该篇讨论其与 L2、数据增广的组合。
- 后续：[[预训练-微调-对齐pipeline]] —— 大模型预训练的 AdamW、warmup、余弦调度、梯度裁剪与 $\beta_2=0.95$ 等约定在此汇总；[[分布式训练与部署]] 进一步讨论大批量与优化器状态分片。

## 达标检测

- [ ] 写出 Momentum 的两种等价形式（含与不含 $1-\beta$ 因子），说明稳态等效学习率分别是多少，并推导二次型上的稳定条件 $\eta\lambda<2(1+\beta)$。
- [ ] 从 $m_t$、$v_t$ 的展开式推导偏差修正，说明只修正一阶矩或完全不修正时，前几步的更新会怎样偏离。
- [ ] 写出 Adam 与 AdamW 的更新式，构造一个两坐标例子说明 L2 衰减强度为何依赖 $\sqrt{\hat v}$；取 $\eta=10^{-4}$、$\lambda=0.1$、$T=10^{5}$ 计算常数学习率下的总衰减，并说明余弦调度使 $\sum_t\eta_t$ 减半后衰减如何变化。
- [ ] 用 $t=1$ 时 $\hat v_1=g_1^{2}$ 说明 Adam 首步位移约为 $\eta\,\mathrm{sign}(g_1)$，并解释 warmup 为何能限制这一阶段。
- [ ] 在同一网络上运行四种优化器，报告最终训练损失、验证损失与达到阈值步数，并解释 SGD 的噪声下界与 AdamW 的衰减效果。
- [ ] 说明全局范数裁剪对 SGD 与 Adam 的不同作用，并给出一个裁剪频繁触发时应检查的超参数。

## 参考来源

- Kingma & Ba, *Adam: A Method for Stochastic Optimization*, arXiv:1412.6980 —— 对应本篇第 6 节的矩估计、偏差修正、$\epsilon$ 位置与默认超参数。
- d2l.ai《动手学深度学习》，优化算法章 —— 对应 SGD、Momentum、AdaGrad、RMSProp、Adam 的更新式、学习率调度与批量缩放的实现。
- PyTorch 官方文档，`torch.optim.SGD`、`torch.optim.Adam`、`torch.optim.AdamW`、`torch.optim.lr_scheduler` —— 对应动量与 Nesterov 的实现形式、L2 与解耦衰减的区别、调度器调用顺序。
- Goodfellow, Bengio, Courville, *Deep Learning*, 2016, 第 8 章 —— 对应优化算法的动机、动量与自适应方法的讨论，以及训练中的梯度裁剪与学习率选择。
- Vaswani et al., "Attention Is All You Need", arXiv:1706.03762 —— 对应逆平方根学习率调度与 warmup 的原始形式。
