---
tags: [nanochat, math, optimizer]
阶段: 02-数学与工程基础
难度: ★★★
created: 2026-10-22
related: "[[Muon优化器]], [[优化算法-梯度下降与Adam]], [[交叉熵与困惑度]]"
---

# 梯度下降与AdamW

## 定义

**梯度下降**（gradient descent, GD）是用负梯度方向作为下降方向的迭代法：

$$
\theta_{t+1}=\theta_t-\eta\,\nabla_\theta\mathcal{L}(\theta_t),
$$

其中 $\theta\in\mathbb{R}^{d}$ 是参数，$\mathcal{L}$ 是损失，$\eta>0$ 是学习率。**随机梯度下降**（SGD）把 $\nabla\mathcal{L}$ 换成在随机小批量 $B_t$ 上算出的梯度 $\mathbf{g}_t$，它是全梯度的无偏估计。

本篇用到的符号与术语：

- $\mathbf{g}_t$：第 $t$ 步在小批量上算出的梯度，$\mathbb{E}[\mathbf{g}_t]=\nabla\mathcal{L}(\theta_t)$。
- $\mathbf{m}_t,\mathbf{v}_t$：Adam 的一阶矩与二阶矩估计，分别逼近 $\mathbb{E}[\mathbf{g}]$ 与 $\mathbb{E}[\mathbf{g}^{2}]$（逐元素）。
- $\beta_1,\beta_2$：一阶与二阶矩的指数衰减率；$\varepsilon$：分母的数值稳定项。
- $\hat{\mathbf{m}}_t,\hat{\mathbf{v}}_t$：偏差修正后的一阶、二阶矩估计。
- $\lambda$：权重衰减系数；$\eta$：学习率；两者相乘 $\eta\lambda$ 才是每步的实际收缩比例。
- **AdamW**：把权重衰减从梯度中解耦出来、直接施加在参数上的 Adam 变体。
- $B$：全局批大小（单位 token）；$D$：训练总 token 数；$C$：模型宽度 `n_embd`。

## 为什么重要

- 优化器决定训练能否收敛，而 nanochat 用了两套更新规则：矩阵参数走 [[Muon优化器]]，词嵌入、解嵌出、标量与门控走 AdamW。两套规则的超参数在同一份配置里联动，理解 AdamW 是读懂另一半的前提。
- AdamW 的自适应缩放使它的有效步长近似等于学习率，因此**学习率、批大小、权重衰减三者的缩放规则**必须成组设计。nanochat 在 `base_train.py` 里用三条公式自动推导它们：`batch_lr_scale`、`dmodel_lr_scale`、`weight_decay_scaled`。这三条公式是「换个 `--depth` 就能训」的实现基础，也是 05 阶段缩放律讨论的入口。
- 融合核 `adamw_step_fused` 是这份代码库里精度处理的典型样本：参数可能是 bf16，但状态与算术全在 fp32，权重衰减、动量、偏差修正、参数更新四步在一个编译图里完成。不读懂它，就解释不了为什么 `wte` 的更新不会因为 bf16 而失真。
- 在全书中的位置：前置是 [[微积分与梯度]]（跨库）与 [[交叉熵与困惑度]] 中的损失梯度；后续被 [[Muon优化器]]、05 阶段的 [[学习率与warmup-warmdown]] 引用。通用推导见 [[优化算法-梯度下降与Adam]]（跨库），本篇只讲 nanochat 的落地、参数分组与三条缩放公式。

## 原理与推导

### 1. 梯度下降、SGD 与小批量

设 $\mathcal{L}$ 的梯度是 $L$-Lipschitz 的。由下降引理（推导见 [[优化算法-梯度下降与Adam]]），取 $\theta_{t+1}=\theta_t-\eta\nabla\mathcal{L}(\theta_t)$ 时

$$
\mathcal{L}(\theta_{t+1})\le\mathcal{L}(\theta_t)-\eta\Big(1-\frac{L\eta}{2}\Big)\|\nabla\mathcal{L}(\theta_t)\|^{2}.
$$

当 $0<\eta<2/L$ 时每步不增，这是步长的稳定性上界。

SGD 用 $\mathbf{g}_t$ 代替全梯度后，下降引理多出一项噪声：

$$
\mathbb{E}\big[\mathcal{L}(\theta_{t+1})\big]\le\mathcal{L}(\theta_t)-\eta\Big(1-\frac{L\eta}{2}\Big)\|\nabla\mathcal{L}\|^{2}+\frac{L\eta^{2}}{2}\mathbb{E}\big[\|\mathbf{g}_t-\nabla\mathcal{L}\|^{2}\big].
$$

若批内样本独立、单样本梯度方差为 $\sigma^{2}$，则 $\mathbb{E}\|\mathbf{g}_t-\nabla\mathcal{L}\|^{2}=\sigma^{2}/B$。因此批大小 $B$ 增大时噪声项按 $1/B$ 下降；当 $\eta$ 大到噪声项与下降项同阶时，继续增大 $B$ 不再带来收益，这是「临界批大小」的来源。

批大小与学习率的经验规则有两条：

$$
\text{线性规则：}\ \eta\propto B,\qquad
\text{平方根规则：}\ \eta\propto\sqrt{B}.
$$

线性规则来自「$k$ 次小批量步 ≈ 一次 $k$ 倍批大小的步」这一近似，成立条件是 $\eta$ 足够小、梯度在 $k$ 步内变化不大（见 Large-batch training, 1812.06162）；平方根规则在 Adam 类自适应方法上更常用，因为逐元素归一化削弱了梯度幅值的影响。nanochat 的选择写在 `base_train.py` 的注释里：AdamW 用平方根缩放，Muon 沿用同一规则（注释明确写了「not studied carefully, assumption」）。

### 2. 动量与 Nesterov

动量把历史梯度做指数平均，抑制小批量噪声：

$$
\mathbf{m}_t=\beta_1\mathbf{m}_{t-1}+(1-\beta_1)\mathbf{g}_t,\qquad
\theta_{t+1}=\theta_t-\eta\,\mathbf{m}_t .
$$

$\beta_1=0.9$ 时等效平均约 $1/(1-\beta_1)=10$ 步的历史。Nesterov 动量的形式是在「前瞻点」上取梯度：

$$
\mathbf{g}^{\text{nes}}_t=\nabla\mathcal{L}\big(\theta_t-\eta\beta_1\mathbf{m}_{t-1}\big)
\approx(1+\beta_1)\mathbf{m}_t-\beta_1\mathbf{m}_{t-1},
$$

最后一步是常见的一阶近似。Muon 的实现使用等价的线性组合 $\mathbf{g}\leftarrow(1-\mu)\mathbf{g}+\mu\,\mathbf{m}$，本篇不展开，细节见 [[Muon优化器]]。

### 3. Adam 的一阶二阶矩与偏差修正

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^{2},
$$

$$
\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}},\qquad
\theta_{t+1}=\theta_t-\eta\,\frac{\hat{\mathbf{m}}_t}{\sqrt{\hat{\mathbf{v}}_t}+\varepsilon}.
$$

这里所有运算逐元素进行。偏差修正的动机可以直接算出来。把递推展开：

$$
\mathbf{m}_t=(1-\beta_1)\sum_{i=1}^{t}\beta_1^{t-i}\mathbf{g}_i .
$$

若梯度在 $t$ 步内近似恒定 $\mathbf{g}_i\approx\mathbf{g}$，则

$$
\mathbf{m}_t=(1-\beta_1^{t})\,\mathbf{g},\qquad
\mathbf{v}_t=(1-\beta_2^{t})\,\mathbf{g}^{2}.
$$

初始化为零使 $\mathbf{m}_t$ 系统性偏小 $(1-\beta_1^{t})$ 倍，除以该因子即得无偏估计 $\hat{\mathbf{m}}_t=\mathbf{g}$。$\beta_1=0.9$ 时 $t=1$ 的偏差是 10 倍，不修正会让前几十步的步长严重不足。

自适应归一化的直接后果是**有效步长与梯度幅值无关**。取恒定梯度 $\mathbf{g}$，有 $\hat{\mathbf{m}}=\mathbf{g}$、$\sqrt{\hat{\mathbf{v}}}=|\mathbf{g}|$，代入得

$$
\eta\,\frac{\mathbf{g}}{|\mathbf{g}|+\varepsilon}\approx\eta\,\mathrm{sign}(\mathbf{g}),
$$

即每个坐标每步移动约 $\eta$。这解释了为什么 Adam 类方法的学习率通常比 SGD 小两个数量级：步长已经由归一化给出，学习率直接等于每步位移。nanochat 里同一训练步内 AdamW 的嵌入学习率（0.2）比 Muon 的矩阵学习率（0.028）大一个数量级，原因是嵌入表的每一行只在对应 token 出现时被更新，命中稀疏，需要更大的位移来补偿。

### 4. AdamW 的解耦权重衰减

两种衰减方式容易混淆。**L2 正则**把惩罚项加进损失：

$$
\tilde{\mathcal{L}}(\theta)=\mathcal{L}(\theta)+\frac{\lambda}{2}\|\theta\|^{2}
\quad\Longrightarrow\quad
\tilde{\mathbf{g}}_t=\mathbf{g}_t+\lambda\theta_t .
$$

在 SGD 下这与「每步按比例收缩参数」等价：$\theta_{t+1}=(1-\eta\lambda)\theta_t-\eta\mathbf{g}_t$。但在 Adam 下，$\lambda\theta_t$ 会进入 $\mathbf{v}_t$ 的估计并被 $1/\sqrt{\hat{\mathbf{v}}}$ 归一化，等效收缩强度变成 $\eta\lambda|\theta|/\sqrt{\hat{\mathbf{v}}}$：梯度小的坐标反而被收缩得更狠。**AdamW** 因此把衰减从梯度中解耦：

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

收缩比例 $\eta\lambda$ 与梯度统计量无关，只与步长和系数有关。这是 nanochat 里 AdamW 与 Muon 都能用同一个 $\lambda$ 语义的原因。

### 5. 学习率、批大小与权重衰减的缩放

**宽度缩放。** `setup_optimizer` 对三组 AdamW 参数（`lm_head`、`wte`、`value_embeds`）乘同一个因子：

$$
s_{C}=\Big(\frac{C}{768}\Big)^{-1/2}=\sqrt{\frac{768}{C}},
$$

即宽度越大学习率越小。768 是 d12 的宽度，也是全部超参数的调参基准模型；注释写明「tuned for 768 dim model」，因此这是经验规则而不是定理。d24 时 $s_{1536}=0.7071$，恰好与批大小因子 $\sqrt{2}$ 相乘为 1，于是 d24 的嵌入学习率回到了 d12 的数值 $0.3$。

**批大小缩放。** 以 d12 的批大小 $B_{\text{ref}}=2^{19}=524{,}288$ 为基准，

$$
\eta=\eta_{\text{ref}}\sqrt{\frac{B}{B_{\text{ref}}}}.
$$

**权重衰减缩放。** nanochat 采用 T_epoch 框架（2405.13698）：定义

$$
T_{\text{epoch}}=\frac{B}{\eta\lambda D},
$$

要求不同规模的训练保持 $T_{\text{epoch}}$ 不变。代入 $\eta=\eta_{\text{ref}}\sqrt{B/B_{\text{ref}}}$：

$$
T_{\text{epoch}}=\frac{\sqrt{B\,B_{\text{ref}}}}{\eta_{\text{ref}}\lambda D}
=\frac{B_{\text{ref}}}{\eta_{\text{ref}}\lambda_{\text{ref}}D_{\text{ref}}}
\ \Longrightarrow\
\lambda=\lambda_{\text{ref}}\sqrt{\frac{B}{B_{\text{ref}}}}\cdot\frac{D_{\text{ref}}}{D}.
$$

这正是 `weight_decay_scaled = args.weight_decay * math.sqrt(total_batch_size / B_REF) * (D_REF / target_tokens)` 一行。$D_{\text{ref}}$ 取 d12 在相同 param:data 比例下的 token 数，因此深度越大、训练 token 越多，衰减系数越小。

### 在 nanochat 中的落地

**参数分组。** `GPT.setup_optimizer` 把全部参数切成 6 个 AdamW 组与若干 Muon 组（Muon 部分见 [[Muon优化器]]）。d24 的 AdamW 组如下。`base_train.py` 传入的 `unembedding_lr`、`embedding_lr`、`scalar_lr` 已经乘过 `batch_lr_scale`，宽度因子在 `setup_optimizer` 内乘，组内倍数在构造 `param_groups` 时乘：

| 组 | 参数量 | 基础 `lr` | 缩放路径 | 生效 `lr`（d24） | `betas` | `eps` | `weight_decay` |
|---|---|---|---|---|---|---|---|
| `lm_head` | 50,331,648 | 0.008 | $\times\sqrt2\times0.7071$ | 0.008 | (0.8, 0.96) | 1e-10 | 0.01 |
| `wte` | 50,331,648 | 0.3 | $\times\sqrt2\times0.7071$ | 0.300 | (0.8, 0.995) | 1e-10 | 0.001 |
| `value_embeds` | 603,979,776 | 0.3 | $\times\sqrt2\times0.7071\times0.5$ | 0.150 | (0.8, 0.995) | 1e-10 | 0.01 |
| `resid_lambdas` | 24 | 0.5 | $\times\sqrt2\times0.01$ | 0.00707 | (0.8, 0.95) | 1e-10 | 0.05 |
| `x0_lambdas` | 24 | 0.5 | $\times\sqrt2$ | 0.7071 | (0.96, 0.95) | 1e-10 | 0.0 |
| `smear_gate` 等 | 26 | 0.2 | 不缩放 | 0.200 | (0.8, 0.95) | 1e-10 | 0.0 |

其中 $\sqrt2$ 即 `batch_lr_scale`，$0.7071$ 即 `dmodel_lr_scale`。三处值得注意：`smear` 组的 `lr=0.2` 是硬编码，既不乘批大小因子也不乘宽度因子；`resid_lambdas` 的倍数 `0.01` 让这 24 个标量以极慢的速度变化；`x0_lambdas` 用 $\beta_1=0.96$，比其余组更平滑。`value_embeds` 的参数量（6.04 亿）是 d24 总参数的 44%，它单独成组以获得 $0.5$ 倍学习率。

**融合核逐行对照。** `nanochat/optim.py` 的 `adamw_step_fused` 与第 3、4 节的公式一一对应：

```text
p32      = p.float(); exp_avg32 = exp_avg.float()
exp_avg_sq32 = exp_avg_sq.float(); grad32 = grad.float()   # 全部升到 fp32
p32.mul_(1 - lr_t * wd_t)                                  # 解耦衰减，先施加
exp_avg32.lerp_(grad32, 1 - beta1_t)                       # m += (1-β1)(g - m)
exp_avg_sq32.lerp_(grad32.square(), 1 - beta2_t)           # v += (1-β2)(g² - v)
bias1 = 1 - beta1_t ** step_t;  bias2 = 1 - beta2_t ** step_t
denom = (exp_avg_sq32 / bias2).sqrt() + eps_t              # sqrt(v̂) + ε
step_size = lr_t / bias1
p32.add_(exp_avg32 / denom, alpha=-step_size)              # θ -= (η/bias1)·m/denom
p.copy_(p32); exp_avg.copy_(exp_avg32); exp_avg_sq.copy_(exp_avg_sq32)
```

四处设计：

1. **`.float()` 在前**。`wte` 与 `value_embeds` 的参数字典在 `init_weights` 里被 cast 成 `COMPUTE_DTYPE`（bf16），若在 bf16 上算 $1-\beta_2=0.005$ 这类标量，会因有效位只有 8 位而损失精度。核内统一转 fp32，最后再 `copy_` 回原 dtype；`copy_` 在参数本来就是 fp32 时是空操作。
2. **`lerp_` 的语义**。`a.lerp_(b, w)` 表示 $a\leftarrow a+w(b-a)$，因此 `lerp_(grad, 1-β1)` 得到 $\mathbf{m}\leftarrow\mathbf{m}+(1-\beta_1)(\mathbf{g}-\mathbf{m})=(1-\beta_1)\mathbf{g}+\beta_1\mathbf{m}$，与递推式一致。写成 `lerp_(grad, beta1)` 会把系数取补，等同于换了 $\beta_1$。
3. **偏差修正的除法位置**。$\sqrt{\mathbf{v}/\text{bias2}}+\varepsilon$ 中 $\varepsilon$ 在开方之后、除法之前加上，且不除以 `bias1`；`step_size` 单独承担 $1/\text{bias1}$。这与 $\hat{\mathbf{m}}/\big(\sqrt{\hat{\mathbf{v}}}+\varepsilon\big)$ 完全一致，与「把 $\varepsilon$ 放进 $\sqrt{\cdot}$ 内」的写法不同。
4. **0-D CPU 张量**。`step_t`、`lr_t`、`beta1_t` 等都以 0 维 CPU 张量传入，`fill_` 后调用。原因是 `torch.compile(fullgraph=True)` 在把 Python 标量作为参数时会为每个新数值重新编译；改用张量后计算图不变，学习率调度不会触发重编译。

**调度器。** `base_train.py` 在每一步先算三个乘子，再写回每个参数组：

```text
lrm            = get_lr_multiplier(step)          # 线性 warmup 40 步，之后常数，最后 warmdown 0.65 线性降到 0.05
muon_momentum  = get_muon_momentum(step)          # 0.85 → 0.97（前 400 步），warmdown 段降到 0.90
muon_weight_decay = get_weight_decay(step)        # λ_scaled·0.5·(1 + cos(π·it/N))
for group in optimizer.param_groups:
    group["lr"] = group["initial_lr"] * lrm
```

`initial_lr` 是在 `setup_optimizer` 之后立刻记录的，已经包含各组在构造时乘上的因子（批大小、宽度与组内倍数）；调度只再做一次线性缩放。权重衰减只写回 `kind == 'muon'` 的组，AdamW 组的 `weight_decay` 保持 `setup_optimizer` 里的常数（0.01、0.001、0.01、0.05、0、0）。

> [!info] 版本说明
> `dev/LOG.md` 的 2026-01-10 条目写「AdamW still has no weight decay and is hardcoded to 0 weight decay」，而当前 master 的 `setup_optimizer` 已给 `lm_head`、`value_embeds` 设 0.01、`wte` 设 0.001、`resid_lambdas` 设 0.05。同一份日志说权重衰减「线性 schedule 到 0」，当前代码是余弦 $\frac{1+\cos(\pi t/N)}{2}$，且默认 `--weight-decay` 为 0.28（日志写作 0.2）。涉及这些数字时以 `nanochat/gpt.py` 与 `scripts/base_train.py` 为准。

**精度与梯度累积。** 训练循环把每个 micro-batch 的损失除以 `grad_accum_steps` 再反向，等价于对整个大批次的平均损失求梯度；fp16 路径额外启用 `GradScaler`，bf16 与 fp32 不需要（bf16 的指数范围与 fp32 相同）。梯度裁剪在 2026-01-08 的实验后被删除，理由是梯度范数从未超过 1.0，裁剪只会引入一次额外的 all-reduce。

## 关键直觉

> [!tip] Adam 把「最速下降」换成了逐坐标的符号步
> 在恒定梯度下 $\hat{\mathbf{m}}/\sqrt{\hat{\mathbf{v}}}\approx\mathrm{sign}(\mathbf{g})$，因此 Adam 每步大致沿梯度的符号移动 $\eta$，与梯度大小无关。这使得它天然适合尺度差异极大的参数（嵌入与标量），也使得「学习率」直接对应「每步位移」而不再对应「沿梯度的比例」。AdamW 的解耦衰减则保证收缩比例 $\eta\lambda$ 不被 $\sqrt{\hat{\mathbf{v}}}$ 扭曲。与严格定义的关系：$\mathrm{sign}$ 近似只在 $\varepsilon\ll|\mathbf{g}|$ 时成立，$\varepsilon=10^{-10}$ 使该近似在 nanochat 的所有参数组上都成立。

## 例子与代码

### 例 1：单参数上的 AdamW 三步

```python
import numpy as np

def adamw_step(p, grad, m, v, t, lr, b1, b2, eps, wd):
    p = p * (1 - lr * wd)                            # 解耦衰减
    m = m + (1 - b1) * (grad - m)                    # 一阶矩
    v = v + (1 - b2) * (grad * grad - v)             # 二阶矩
    m_hat = m / (1 - b1 ** t)                        # 偏差修正
    v_hat = v / (1 - b2 ** t)
    p = p - lr * m_hat / (np.sqrt(v_hat) + eps)
    return p, m, v

p, m, v = 1.0, 0.0, 0.0
for t in (1, 2, 3):
    p, m, v = adamw_step(p, 0.1, m, v, t, 0.1, 0.9, 0.999, 1e-8, 0.01)
    print(f"t={t} p={p:.10f} m={m:.8f} v={v:.3e}")
```

预期输出：

```text
t=1 p=0.8990000100 m=0.01000000 v=1.000e-05
t=2 p=0.7981010200 m=0.01900000 v=1.999e-05
t=3 p=0.6973029290 m=0.02710000 v=2.997e-05
```

第一步的位移是 0.101（其中 0.001 来自衰减、0.1 来自更新），恰好等于 $\eta=0.1$，与第 3 节的「有效步长 ≈ 学习率」一致。若去掉偏差修正，第一步的位移只有约 $0.01$，前几十步都会偏慢。

### 例 2：三条缩放公式在 d12、d20、d24 上的取值

```python
import math

B_REF, RATIO = 2 ** 19, 8
def C_of(depth):
    return -(-depth * 64 // 128) * 128

def scaling(depth):                     # transformer 矩阵 + lm_head 的参数量
    C = C_of(depth)
    n_ve = sum(1 for i in range(depth) if i % 2 == (depth - 1) % 2)
    return depth * 12 * C * C + n_ve * 12 * (C // 128) + C * 32768

D_REF = RATIO * scaling(12)
for depth in (12, 20, 24):
    C = C_of(depth)
    tokens = RATIO * scaling(depth)
    batch = 2 ** round(math.log2(B_REF * (tokens / D_REF) ** 0.383))
    bscale = math.sqrt(batch / B_REF)
    dscale = (C / 768) ** -0.5
    wd = 0.28 * bscale * (D_REF / tokens)
    print(f"d{depth:>2} C={C:>4} batch={batch:>9,} bscale={bscale:.4f} "
          f"dscale={dscale:.4f} wd={wd:.4f} "
          f"matrix_lr={0.02 * bscale:.4f} emb_lr={0.3 * bscale * dscale:.4f}")
```

预期输出：

```text
d12 C= 768 batch=  524,288 bscale=1.0000 dscale=1.0000 wd=0.2800 matrix_lr=0.0200 emb_lr=0.3000
d20 C=1280 batch=1,048,576 bscale=1.4142 dscale=0.7746 wd=0.1002 matrix_lr=0.0283 emb_lr=0.3286
d24 C=1536 batch=1,048,576 bscale=1.4142 dscale=0.7071 wd=0.0597 matrix_lr=0.0283 emb_lr=0.3000
```

三行说明：d12 是基准，所有因子为 1；d20 的批大小翻倍，权重衰减因 $D$ 增大而降到 0.1002；d24 的 $s_C\sqrt2=1$，嵌入学习率回到 0.3，而权重衰减继续降到 0.0597。

## 易错点

> [!warning] 具体、可检验的错误
> - 把 `lerp_(grad, 1 - beta1)` 写成 `lerp_(grad, beta1)`。`lerp_` 的第二个参数是插值权重 $w$，写成 $\beta_1$ 会把 $0.9$ 的历史权重换成 $0.1$，等效于把 $\beta_1$ 改成 $0.1$。
> - 把 $\varepsilon$ 放进 $\sqrt{\cdot}$ 内或让它参与偏差修正。$\sqrt{\mathbf{v}/\text{bias2}}+\varepsilon$ 与 $\sqrt{\mathbf{v}/(\text{bias2}+\varepsilon)}$ 是不同的量；仓库的写法是前者，且 $\varepsilon$ 不除 `bias1`。
> - 让 `step` 从 0 开始。`state['step'] += 1` 在 `fill_` 之前执行，首次更新用 $t=1$；若用 $t=0$，$1-\beta^{0}=0$ 直接除零。
> - 认为 `--weight-decay` 同时控制 AdamW。它只写进 Muon 组；AdamW 的衰减在 `setup_optimizer` 里逐组写死。
> - 把 `dmodel_lr_scale` 当作全局因子。它只乘到 `lm_head`、`wte`、`value_embeds` 三组，Muon 组用的是按形状的 $\sqrt{\max(1,m/n)}$ 规则，见 [[Muon优化器]]。
> - 在调度器里再乘一次 `batch_lr_scale`。`initial_lr` 已经包含它，重复相乘会让学习率偏大 $\sqrt2$ 倍。
> - 在 bf16 参数上直接做标量运算（如 `1 - beta2`）。`adamw_step_fused` 先 `.float()` 正是为了避免这一类精度损失。

## 关联笔记

- 前置：[[微积分与梯度]]（跨库）——梯度、Lipschitz 常数与下降引理的通用推导。
- 前置：[[交叉熵与困惑度]]——AdamW 更新的 $\mathbf{g}$ 就是交叉熵对 logits 的梯度经反向传播得到的结果。
- 后续：[[Muon优化器]]——同一份 `MuonAdamW` 里的另一半，两者共享参数分组与调度器。
- 对照：[[优化算法-梯度下降与Adam]]（跨库）——通用推导与收敛分析，本篇只取结论并展开 nanochat 的实现。
- 对照：[[优化器与学习率]]（跨库）——学习率调度的一般做法，本篇只讲三条自动缩放公式。

## 达标检测

- [ ] 从下降引理写出 SGD 的期望下降不等式，并说明批大小 $B$ 如何进入噪声项。
- [ ] 推导偏差修正：说明为什么 $\mathbb{E}[\mathbf{m}_t]=(1-\beta_1^{t})\mathbf{g}$，以及除以 $(1-\beta_1^{t})$ 后为什么是无偏的。
- [ ] 解释「恒定梯度下 Adam 每步位移约为 $\eta$」的推导，并说明该结论对 $\varepsilon$ 的依赖。
- [ ] 对比 L2 正则与 AdamW 解耦衰减在自适应缩放下的差别，写出两者的更新式。
- [ ] 从 $T_{\text{epoch}}=B/(\eta\lambda D)$ 与 $\eta\propto\sqrt{B}$ 推出 $\lambda$ 的缩放公式。
- [ ] 手算 d24 的 `matrix_lr`、`emb_lr`、`wd`，并与 `base_train.py` 的打印值对照。
- [ ] 指出 `adamw_step_fused` 中四处关键设计（fp32 算术、`lerp_` 方向、$\varepsilon$ 位置、0-D CPU 张量），并说明去掉其一会怎样。

## 参考来源

- Kingma & Ba, *Adam: A Method for Stochastic Optimization*（1412.6980）—— 对应一阶/二阶矩与偏差修正的定义。
- Loshchilov & Hutter, *Decoupled Weight Decay Regularization*（1711.05101）—— 对应 AdamW 的解耦衰减更新式；`nanochat/optim.py` 的注释引用了该编号。
- Karpathy, *nanochat* `nanochat/optim.py`（commit 92d63d4）—— 对应 `adamw_step_fused` 的逐行实现与 fp32 精度处理。
- Karpathy, *nanochat* `scripts/base_train.py`—— 对应 `batch_lr_scale`、`weight_decay_scaled`、`dmodel_lr_scale` 与三条调度器。
- McCandlish et al., *An Empirical Model of Large-Batch Training*（1812.06162）—— 对应批大小与学习率缩放的线性规则及其适用条件。
- Hägele et al., *Scaling Laws for the Learning Rate and Weight Decay*（2405.13698）—— 对应 $T_{\text{epoch}}=B/(\eta\lambda D)$ 恒定的权重衰减缩放。
