w wyl123ly 的博客
MD

梯度下降与AdamW

21 KB 2026.10.22 原文件

梯度下降与AdamW

定义

梯度下降(gradient descent, GD)是用负梯度方向作为下降方向的迭代法:

其中 是参数, 是损失, 是学习率。随机梯度下降(SGD)把 换成在随机小批量 上算出的梯度 ,它是全梯度的无偏估计。

本篇用到的符号与术语:

  • :第 步在小批量上算出的梯度,。
  • :Adam 的一阶矩与二阶矩估计,分别逼近 与 (逐元素)。
  • :一阶与二阶矩的指数衰减率;:分母的数值稳定项。
  • :偏差修正后的一阶、二阶矩估计。
  • :权重衰减系数;:学习率;两者相乘 才是每步的实际收缩比例。
  • AdamW:把权重衰减从梯度中解耦出来、直接施加在参数上的 Adam 变体。
  • :全局批大小(单位 token);:训练总 token 数;:模型宽度 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 与小批量

设 的梯度是 -Lipschitz 的。由下降引理(推导见 优化算法-梯度下降与Adam),取 时

当 时每步不增,这是步长的稳定性上界。

SGD 用 代替全梯度后,下降引理多出一项噪声:

若批内样本独立、单样本梯度方差为 ,则 。因此批大小 增大时噪声项按 下降;当 大到噪声项与下降项同阶时,继续增大 不再带来收益,这是「临界批大小」的来源。

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

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

2. 动量与 Nesterov

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

时等效平均约 步的历史。Nesterov 动量的形式是在「前瞻点」上取梯度:

最后一步是常见的一阶近似。Muon 的实现使用等价的线性组合 ,本篇不展开,细节见 Muon优化器。

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

Adam 的更新为

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

若梯度在 步内近似恒定 ,则

初始化为零使 系统性偏小 倍,除以该因子即得无偏估计 。 时 的偏差是 10 倍,不修正会让前几十步的步长严重不足。

自适应归一化的直接后果是有效步长与梯度幅值无关。取恒定梯度 ,有 、,代入得

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

4. AdamW 的解耦权重衰减

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

在 SGD 下这与「每步按比例收缩参数」等价:。但在 Adam 下, 会进入 的估计并被 归一化,等效收缩强度变成 :梯度小的坐标反而被收缩得更狠。AdamW 因此把衰减从梯度中解耦:

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

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

宽度缩放。 setup_optimizer 对三组 AdamW 参数(lm_head、wte、value_embeds)乘同一个因子:

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

批大小缩放。 以 d12 的批大小 为基准,

权重衰减缩放。 nanochat 采用 T_epoch 框架(2405.13698):定义

要求不同规模的训练保持 不变。代入 :

这正是 weight_decay_scaled = args.weight_decay math.sqrt(total_batch_size / B_REF) (D_REF / target_tokens) 一行。 取 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)betasepsweight_decay
lm_head50,331,6480.0080.008(0.8, 0.96)1e-100.01
wte50,331,6480.30.300(0.8, 0.995)1e-100.001
value_embeds603,979,7760.30.150(0.8, 0.995)1e-100.01
resid_lambdas240.50.00707(0.8, 0.95)1e-100.05
x0_lambdas240.50.7071(0.96, 0.95)1e-100.0
smear_gate 等260.2不缩放0.200(0.8, 0.95)1e-100.0

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

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

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 上算 这类标量,会因有效位只有 8 位而损失精度。核内统一转 fp32,最后再 copy_ 回原 dtype;copy_ 在参数本来就是 fp32 时是空操作。
  2. lerp_ 的语义。a.lerp_(b, w) 表示 ,因此 lerp_(grad, 1-β1) 得到 ,与递推式一致。写成 lerp_(grad, beta1) 会把系数取补,等同于换了 。
  3. 偏差修正的除法位置。 中 在开方之后、除法之前加上,且不除以 bias1;step_size 单独承担 。这与 完全一致,与「把 放进 内」的写法不同。
  4. 0-D CPU 张量。step_t、lr_t、beta1_t 等都以 0 维 CPU 张量传入,fill_ 后调用。原因是 torch.compile(fullgraph=True) 在把 Python 标量作为参数时会为每个新数值重新编译;改用张量后计算图不变,学习率调度不会触发重编译。

调度器。 base_train.py 在每一步先算三个乘子,再写回每个参数组:

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)。

版本说明

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」,当前代码是余弦 ,且默认 --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。

关键直觉

Adam 把「最速下降」换成了逐坐标的符号步

在恒定梯度下 ,因此 Adam 每步大致沿梯度的符号移动 ,与梯度大小无关。这使得它天然适合尺度差异极大的参数(嵌入与标量),也使得「学习率」直接对应「每步位移」而不再对应「沿梯度的比例」。AdamW 的解耦衰减则保证收缩比例 不被 扭曲。与严格定义的关系: 近似只在 时成立, 使该近似在 nanochat 的所有参数组上都成立。

例子与代码

例 1:单参数上的 AdamW 三步

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}")

预期输出:

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 来自更新),恰好等于 ,与第 3 节的「有效步长 ≈ 学习率」一致。若去掉偏差修正,第一步的位移只有约 ,前几十步都会偏慢。

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

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}")

预期输出:

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 的批大小翻倍,权重衰减因 增大而降到 0.1002;d24 的 ,嵌入学习率回到 0.3,而权重衰减继续降到 0.0597。

易错点

具体、可检验的错误

- 把 lerp_(grad, 1 - beta1) 写成 lerp_(grad, beta1)。lerp_ 的第二个参数是插值权重 ,写成 会把 的历史权重换成 ,等效于把 改成 。

- 把 放进 内或让它参与偏差修正。 与 是不同的量;仓库的写法是前者,且 不除 bias1。

- 让 step 从 0 开始。state['step'] += 1 在 fill_ 之前执行,首次更新用 ;若用 , 直接除零。

- 认为 --weight-decay 同时控制 AdamW。它只写进 Muon 组;AdamW 的衰减在 setup_optimizer 里逐组写死。

- 把 dmodel_lr_scale 当作全局因子。它只乘到 lm_head、wte、value_embeds 三组,Muon 组用的是按形状的 规则,见 Muon优化器。

- 在调度器里再乘一次 batch_lr_scale。initial_lr 已经包含它,重复相乘会让学习率偏大 倍。

- 在 bf16 参数上直接做标量运算(如 1 - beta2)。adamw_step_fused 先 .float() 正是为了避免这一类精度损失。

关联笔记

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

达标检测

  • [ ] 从下降引理写出 SGD 的期望下降不等式,并说明批大小 如何进入噪声项。
  • [ ] 推导偏差修正:说明为什么 ,以及除以 后为什么是无偏的。
  • [ ] 解释「恒定梯度下 Adam 每步位移约为 」的推导,并说明该结论对 的依赖。
  • [ ] 对比 L2 正则与 AdamW 解耦衰减在自适应缩放下的差别,写出两者的更新式。
  • [ ] 从 与 推出 的缩放公式。
  • [ ] 手算 d24 的 matrix_lr、emb_lr、wd,并与 base_train.py 的打印值对照。
  • [ ] 指出 adamw_step_fused 中四处关键设计(fp32 算术、lerp_ 方向、 位置、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)—— 对应 恒定的权重衰减缩放。