优化器

梯度下降告诉你该往哪个方向走。它对走多远、走多快只字不提。SGD 是一个指南针。Adam 是带路况数据的 GPS。

类型： Build 语言： Python 前置要求： 第 03.05 课（损失函数） 预计时间： ~75 分钟

学习目标

用 Python 从零实现 SGD、带动量的 SGD、Adam 和 AdamW 优化器
解释 Adam 的偏差修正如何补偿训练初期那些初始化为零的矩估计
演示为什么在同一个任务上，AdamW 比带 L2 正则化的 Adam 泛化得更好
为 transformer、CNN、GAN 和微调选对优化器和默认超参数

问题背景

你算出了梯度。你知道第 4721 号权重应该减小 0.003 来降低损失。但 0.003 是什么单位？以什么缩放？还有，第 1 步和第 1000 步应该走同样的幅度吗？

普通梯度下降在每一步对每个参数都施加同样的学习率：w = w - lr * gradient。这造成三个问题，让训练神经网络在实践中很痛苦。

第一，振荡。损失曲面很少是个平滑的碗。它更像一条又长又窄的山谷。梯度指向横穿山谷的方向（陡的方向），而不是沿着山谷的方向（缓的方向）。梯度下降在那个窄维度上来回弹跳，却只在有用的那个方向上挪一点点。你见过这个：损失先快速下降然后停滞，不是因为模型收敛了，而是因为它在振荡。

第二，对所有参数用一个学习率是错的。有些权重需要大更新（它们还在早期、欠拟合的阶段）。另一些需要极小的更新（它们已经接近最优值）。一个对前者有效的学习率会毁掉后者，反之亦然。

第三，鞍点。在高维里，损失曲面有大片梯度接近零的平坦区域。普通 SGD 以梯度的速度爬过这些区域，而那速度实际上为零。模型看起来卡住了。它没卡住——它在一个平坦区域里，另一边有可用的下坡。但 SGD 没有机制推过去。

Adam 一并解决了这三个问题。它对每个参数维护两个滑动平均——梯度均值（动量，处理振荡）和梯度平方的均值（自适应速率，处理不同尺度）。再加上对前几步的偏差修正，它给了你一个用默认超参数就能搞定 80% 问题的优化器。本课从零把它搭出来，让你确切理解它在另外 20% 上何时、为何失败。

核心概念

随机梯度下降（SGD）

最简单的优化器。在一个 mini-batch 上算梯度，往反方向走一步。

w = w - lr * gradient

"随机"指的是你用数据的一个随机子集（mini-batch）来估计梯度，而不是整个数据集。这种噪声其实有用——它帮你逃离尖锐的局部极小值。但噪声也导致振荡。

学习率是唯一的旋钮。太高：损失发散。太低：训练慢到天荒地老。最优值取决于架构、数据、批大小和当前训练阶段。对现代网络上的普通 SGD，典型值在 0.01 到 0.1 之间。但即便在一次训练里，理想的学习率也在变。

动量

球滚下坡的类比被用滥了，但确实准确。你不再只按梯度走一步，而是维护一个累积了过去梯度的速度。

m_t = beta * m_{t-1} + gradient
w = w - lr * m_t

Beta（通常 0.9）控制保留多少历史。beta = 0.9 时，动量大致是最近 10 个梯度的平均（1 / (1 - 0.9) = 10）。

它为什么能修复振荡：指向同一方向的梯度会累积。来回翻转方向的梯度会抵消。在那条窄山谷里，"横穿"分量每步都翻号，被抑制掉了；"沿着"分量保持一致，被放大了。结果就是在有用方向上平滑加速。

真实数字：单用 SGD 在一个病态损失曲面上可能要 10000 步。带动量的 SGD（beta=0.9）在同一个问题上通常 3000-5000 步。这个加速不是边际改善。

RMSProp

第一个真正管用的逐参数自适应学习率方法。Hinton 在一次 Coursera 讲座里提出（从未正式发表）。

s_t = beta * s_{t-1} + (1 - beta) * gradient^2
w = w - lr * gradient / (sqrt(s_t) + epsilon)

s_t 追踪梯度平方的滑动平均。梯度一直很大的参数会被一个大数除（更小的有效学习率）。梯度很小的参数会被一个小数除（更大的有效学习率）。

这解决了"对所有参数用一个学习率"的问题。一个已经在拿大更新的权重多半接近它的目标了——给它慢下来。一个一直在拿极小更新的权重可能训练不足——给它加速。

Epsilon（通常 1e-8）防止某个参数还没更新过时除以零。

Adam：动量 + RMSProp

Adam 把两个想法合起来。它对每个参数维护两个指数滑动平均：

m_t = beta1 * m_{t-1} + (1 - beta1) * gradient        (first moment: mean)
v_t = beta2 * v_{t-1} + (1 - beta2) * gradient^2       (second moment: variance)

偏差修正是大多数讲解会跳过的关键细节。在第 1 步，m_1 = (1 - beta1) * gradient。beta1 = 0.9 时，那是 0.1 * gradient——小了十倍。滑动平均还没热起来。偏差修正补偿了这一点：

m_hat = m_t / (1 - beta1^t)
v_hat = v_t / (1 - beta2^t)

第 1 步、beta1 = 0.9 时：m_hat = m_1 / (1 - 0.9) = m_1 / 0.1 = 实际梯度。第 100 步时：(1 - 0.9^100) 约等于 1.0，所以修正消失了。偏差修正对前 ~10 步重要，~50 步之后就无关紧要了。

更新：

w = w - lr * m_hat / (sqrt(v_hat) + epsilon)

Adam 默认值：lr = 0.001，beta1 = 0.9，beta2 = 0.999，epsilon = 1e-8。这些默认值适用于 80% 的问题。它们不灵时，先改 lr。然后是 beta2。几乎永远别改 beta1 或 epsilon。

AdamW：正确做权重衰减

L2 正则化往损失里加 lambda * w^2。在普通 SGD 里，这等价于权重衰减（每步从权重里减 lambda * w）。在 Adam 里，这个等价关系断了。

Loshchilov & Hutter 的洞见是：当你往损失里加 L2、然后 Adam 处理梯度时，自适应学习率把正则化项也缩放了。梯度方差大的参数得到的正则化更少，方差小的得到的更多。这不是你想要的——你想要的是不管梯度统计如何、都施加均匀的正则化。

AdamW 通过在 Adam 更新之后直接对权重施加权重衰减来修复这一点：

w = w - lr * m_hat / (sqrt(v_hat) + epsilon) - lr * lambda * w

权重衰减项（lr * lambda * w）不被 Adam 的自适应因子缩放。每个参数都得到同样比例的收缩。

这看起来像个小细节。它不是。在几乎每个任务上，AdamW 都比 Adam + L2 正则化收敛到更好的解。它是 PyTorch 里训练 transformer、扩散模型和大多数现代架构的默认优化器。BERT、GPT、LLaMA、Stable Diffusion——全是用 AdamW 训出来的。

学习率：最重要的超参数

mermaid

graph TD
    LR["学习率"] --> TooHigh["太高 (lr > 0.01)"]
    LR --> JustRight["恰到好处"]
    LR --> TooLow["太低 (lr < 0.00001)"]

    TooHigh --> Diverge["损失爆炸<br/>权重变 NaN<br/>训练崩溃"]
    JustRight --> Converge["损失稳步下降<br/>到达好的极小值<br/>泛化良好"]
    TooLow --> Stall["损失下降极慢<br/>卡在次优极小值<br/>浪费算力"]

    JustRight --> Schedule["通常需要调度"]
    Schedule --> Warmup["热身：从 0 爬到最大值<br/>训练前 1-10%"]
    Schedule --> Decay["衰减：随时间减小<br/>余弦或线性"]

如果你只调一个超参数，调学习率。学习率改变 10 倍，比你要做的任何架构决策都更重要。常见默认值：

SGD：lr = 0.01 到 0.1
Adam/AdamW：lr = 1e-4 到 3e-4
微调预训练模型：lr = 1e-5 到 5e-5
学习率热身（warmup）：在前 1-10% 的步数里线性爬升

优化器对比

mermaid

flowchart LR
    subgraph "优化路径"
        SGD_P["SGD<br/>横穿山谷振荡<br/>慢但找到平坦极小值"]
        Mom_P["SGD + 动量<br/>路径更平滑<br/>比 SGD 快 3 倍"]
        Adam_P["Adam<br/>逐参数自适应<br/>收敛快"]
        AdamW_P["AdamW<br/>Adam + 正确的衰减<br/>泛化最好"]
    end
    SGD_P --> Mom_P --> Adam_P --> AdamW_P

每个优化器何时胜出

mermaid

flowchart TD
    Task["你在训练什么？"] --> Type{"模型类型？"}

    Type -->|"Transformer / LLM"| AdamW["AdamW<br/>lr=1e-4, wd=0.01-0.1"]
    Type -->|"CNN / ResNet"| SGD_M["SGD + 动量<br/>lr=0.1, momentum=0.9"]
    Type -->|"GAN"| Adam2["Adam<br/>lr=2e-4, beta1=0.5"]
    Type -->|"微调"| AdamW2["AdamW<br/>lr=2e-5, wd=0.01"]
    Type -->|"还不确定"| Default["先用 AdamW<br/>lr=3e-4, wd=0.01"]

figure

optimizer-trajectory

动手构建

第 1 步：普通 SGD

python

class SGD:
    def __init__(self, lr=0.01):
        self.lr = lr

    def step(self, params, grads):
        for i in range(len(params)):
            params[i] -= self.lr * grads[i]

第 2 步：带动量的 SGD

python

class SGDMomentum:
    def __init__(self, lr=0.01, beta=0.9):
        self.lr = lr
        self.beta = beta
        self.velocities = None

    def step(self, params, grads):
        if self.velocities is None:
            self.velocities = [0.0] * len(params)
        for i in range(len(params)):
            self.velocities[i] = self.beta * self.velocities[i] + grads[i]
            params[i] -= self.lr * self.velocities[i]

第 3 步：Adam

python

import math

class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.epsilon = epsilon
        self.m = None
        self.v = None
        self.t = 0

    def step(self, params, grads):
        if self.m is None:
            self.m = [0.0] * len(params)
            self.v = [0.0] * len(params)

        self.t += 1

        for i in range(len(params)):
            self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * grads[i]
            self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * grads[i] ** 2

            m_hat = self.m[i] / (1 - self.beta1 ** self.t)
            v_hat = self.v[i] / (1 - self.beta2 ** self.t)

            params[i] -= self.lr * m_hat / (math.sqrt(v_hat) + self.epsilon)

第 4 步：AdamW

python

class AdamW:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8, weight_decay=0.01):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.epsilon = epsilon
        self.weight_decay = weight_decay
        self.m = None
        self.v = None
        self.t = 0

    def step(self, params, grads):
        if self.m is None:
            self.m = [0.0] * len(params)
            self.v = [0.0] * len(params)

        self.t += 1

        for i in range(len(params)):
            self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * grads[i]
            self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * grads[i] ** 2

            m_hat = self.m[i] / (1 - self.beta1 ** self.t)
            v_hat = self.v[i] / (1 - self.beta2 ** self.t)

            params[i] -= self.lr * m_hat / (math.sqrt(v_hat) + self.epsilon)
            params[i] -= self.lr * self.weight_decay * params[i]

第 5 步：训练对比

用全部四个优化器，在第 05 课的圆形数据集上训练同一个两层网络。对比收敛情况。

python

import random

def sigmoid(x):
    x = max(-500, min(500, x))
    return 1.0 / (1.0 + math.exp(-x))

def make_circle_data(n=200, seed=42):
    random.seed(seed)
    data = []
    for _ in range(n):
        x = random.uniform(-2, 2)
        y = random.uniform(-2, 2)
        label = 1.0 if x * x + y * y < 1.5 else 0.0
        data.append(([x, y], label))
    return data

class OptimizerTestNetwork:
    def __init__(self, optimizer, hidden_size=8):
        random.seed(0)
        self.hidden_size = hidden_size
        self.optimizer = optimizer

        self.w1 = [[random.gauss(0, 0.5) for _ in range(2)] for _ in range(hidden_size)]
        self.b1 = [0.0] * hidden_size
        self.w2 = [random.gauss(0, 0.5) for _ in range(hidden_size)]
        self.b2 = 0.0

    def get_params(self):
        params = []
        for row in self.w1:
            params.extend(row)
        params.extend(self.b1)
        params.extend(self.w2)
        params.append(self.b2)
        return params

    def set_params(self, params):
        idx = 0
        for i in range(self.hidden_size):
            for j in range(2):
                self.w1[i][j] = params[idx]
                idx += 1
        for i in range(self.hidden_size):
            self.b1[i] = params[idx]
            idx += 1
        for i in range(self.hidden_size):
            self.w2[i] = params[idx]
            idx += 1
        self.b2 = params[idx]

    def forward(self, x):
        self.x = x
        self.z1 = []
        self.h = []
        for i in range(self.hidden_size):
            z = self.w1[i][0] * x[0] + self.w1[i][1] * x[1] + self.b1[i]
            self.z1.append(z)
            self.h.append(max(0.0, z))

        self.z2 = sum(self.w2[i] * self.h[i] for i in range(self.hidden_size)) + self.b2
        self.out = sigmoid(self.z2)
        return self.out

    def compute_grads(self, target):
        eps = 1e-15
        p = max(eps, min(1 - eps, self.out))
        d_loss = -(target / p) + (1 - target) / (1 - p)
        d_sigmoid = self.out * (1 - self.out)
        d_out = d_loss * d_sigmoid

        grads = [0.0] * (self.hidden_size * 2 + self.hidden_size + self.hidden_size + 1)
        idx = 0
        for i in range(self.hidden_size):
            d_relu = 1.0 if self.z1[i] > 0 else 0.0
            d_h = d_out * self.w2[i] * d_relu
            grads[idx] = d_h * self.x[0]
            grads[idx + 1] = d_h * self.x[1]
            idx += 2

        for i in range(self.hidden_size):
            d_relu = 1.0 if self.z1[i] > 0 else 0.0
            grads[idx] = d_out * self.w2[i] * d_relu
            idx += 1

        for i in range(self.hidden_size):
            grads[idx] = d_out * self.h[i]
            idx += 1

        grads[idx] = d_out
        return grads

    def train(self, data, epochs=300):
        losses = []
        for epoch in range(epochs):
            total_loss = 0.0
            correct = 0
            for x, y in data:
                pred = self.forward(x)
                grads = self.compute_grads(y)
                params = self.get_params()
                self.optimizer.step(params, grads)
                self.set_params(params)

                eps = 1e-15
                p = max(eps, min(1 - eps, pred))
                total_loss += -(y * math.log(p) + (1 - y) * math.log(1 - p))
                if (pred >= 0.5) == (y >= 0.5):
                    correct += 1
            avg_loss = total_loss / len(data)
            accuracy = correct / len(data) * 100
            losses.append((avg_loss, accuracy))
            if epoch % 75 == 0 or epoch == epochs - 1:
                print(f"    Epoch {epoch:3d}: loss={avg_loss:.4f}, accuracy={accuracy:.1f}%")
        return losses

实际使用

PyTorch 的优化器负责处理参数组、梯度裁剪和学习率调度：

python

import torch
import torch.optim as optim

model = torch.nn.Sequential(
    torch.nn.Linear(784, 256),
    torch.nn.ReLU(),
    torch.nn.Linear(256, 10),
)

optimizer = optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.01)

scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

for epoch in range(100):
    optimizer.zero_grad()
    output = model(torch.randn(32, 784))
    loss = torch.nn.functional.cross_entropy(output, torch.randint(0, 10, (32,)))
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
    optimizer.step()
    scheduler.step()

套路永远是：zero_grad、forward、loss、backward、（clip）、step、（schedule）。把这个顺序记牢。搞错它（比如在 optimizer.step() 之前调 scheduler.step()）是一个常见的微妙 bug 来源。

对 CNN，很多从业者仍然偏爱 SGD + 动量（lr=0.1，momentum=0.9，weight_decay=1e-4）配一个 step 或余弦调度。SGD 找到更平坦的极小值，往往泛化得更好。对 transformer 和 LLM，AdamW 配 warmup + 余弦衰减是通用默认选项。没有量化过的理由就别跟共识对着干。

拿去用

本课产出：

outputs/prompt-optimizer-selector.md —— 一个决策提示词，为任何架构选对优化器和学习率

练习

实现 Nesterov 动量，在"前瞻"位置（w - lr * beta * v）而不是当前位置算梯度。在圆形数据集上和标准动量对比收敛情况。
实现一个学习率热身调度：在前 10% 的训练步里从 0 线性爬到 max_lr，然后余弦衰减到 0。用 Adam + warmup 对比 Adam 不带 warmup 训练。测量在圆形数据集上达到 90% 准确率分别要多少 epoch。
在 Adam 训练时追踪每个参数的有效学习率。有效率是 lr * m_hat / (sqrt(v_hat) + eps)。画出第 10、50、200 步后有效率的分布。所有参数都在以同样的速度更新吗？
实现梯度裁剪（按全局范数裁剪）。把最大梯度范数设为 1.0。用一个高学习率（Adam 的 lr=0.01）分别在裁剪和不裁剪下训练。在 10 个随机种子上数有多少次运行发散（损失变成 NaN）。
在一个权重很大的网络上对比 Adam 和 AdamW。把所有权重初始化为 [-5, 5] 里的随机值（比正常大得多）。用 weight_decay=0.1 训练 200 个 epoch。把两个优化器训练过程中权重的 L2 范数画出来。AdamW 应该表现出更快的权重收缩。

关键术语

术语	大家怎么说	实际是什么
学习率（Learning rate）	"步长"	施加在梯度更新上的标量乘数；训练里影响最大的单个超参数
SGD	"基础梯度下降"	随机梯度下降：在一个 mini-batch 上算梯度，用 w 减去 lr * gradient 来更新权重
动量（Momentum）	"滚球类比"	过去梯度的指数滑动平均；抑制振荡、加速一致的方向
RMSProp	"自适应学习率"	把每个参数的梯度除以它近期梯度的滑动 RMS；拉平各参数的学习率
Adam	"默认优化器"	把动量（一阶矩）和 RMSProp（二阶矩）结合，并对初始几步做偏差修正
AdamW	"正确版的 Adam"	带解耦权重衰减的 Adam；直接对权重施加正则化，而不是通过梯度
偏差修正（Bias correction）	"给滑动平均热身"	除以 (1 - beta^t)，补偿 Adam 矩估计的零初始化
权重衰减（Weight decay）	"收缩权重"	每步从权重值里减去一小部分；一个惩罚大权重的正则化手段
学习率调度（Learning rate schedule）	"随时间改 lr"	一个在训练中调整学习率的函数；warmup + 余弦衰减是现代默认选项
梯度裁剪（Gradient clipping）	"给梯度范数封顶"	当梯度向量范数超过阈值时把它缩小；防止梯度爆炸式的更新

Claude 认证课程

lessons

00-certification-strategy

01-claude-product-and-model-landscape

02-model-selection-and-token-economics

03-prompting-and-task-decomposition

04-context-knowledge-memory-and-caching

05-output-evaluation-and-validation

06-governance-safety-and-responsible-use

07-workflow-design-and-human-handoffs

08-messages-api-and-application-lifecycle

09-structured-output-and-defensive-parsing

10-tool-use-and-agentic-loops

11-mcp-server-design-and-integration

12-claude-agent-sdk-and-hooks

13-application-security-and-secrets

14-evals-testing-debugging-and-observability

15-claude-code-for-development-teams

16-multi-agent-orchestration-and-delegation

17-agent-sdk-sessions-subagents-and-context

18-tool-contracts-errors-and-progressive-discovery

19-claude-code-memory-rules-skills-and-ci

20-reliable-extraction-batch-and-reviewers

21-long-context-reliability-provenance-and-escalation

22-business-discovery-requirements-and-slas

23-end-to-end-architecture-and-value-tradeoffs

24-rag-retrieval-and-data-pipelines

25-integration-protocols-identity-and-least-privilege

26-production-observability-latency-and-cost

27-enterprise-governance-compliance-and-hitl

28-stakeholder-communication-adrs-and-lifecycle

29-associate-workflow-capstone

30-developer-application-capstone

31-architect-foundations-scenario-capstone

32-architect-professional-system-capstone

references

research

阶段 0：环境与工具

01-dev-environment

outputs

04-apis-and-keys

outputs

05-jupyter-notebooks

outputs

09-data-management

outputs

12-debugging-and-profiling

outputs

阶段 1：数学基础

01-linear-algebra-intuition

outputs

02-vectors-matrices-operations

outputs

03-matrix-transformations

outputs

04-calculus-for-ml

outputs

05-chain-rule-and-autodiff

outputs

06-probability-and-distributions

outputs

07-bayes-theorem

outputs

08-optimization

outputs

09-information-theory

outputs

10-dimensionality-reduction

outputs

11-singular-value-decomposition

outputs

12-tensor-operations

outputs

13-numerical-stability

outputs

14-norms-and-distances

outputs

15-statistics-for-ml

outputs

16-sampling-methods