数学与优化基础 Math & Optimization

pythonimport numpy as np
# 两条候选：A 短但平均自信度低，B 长且平均更自信
logp_a = np.array([-0.2, -0.3, -0.25])          # 3 token，均值 -0.25
logp_b = np.array([-0.15] * 8)                  # 8 token，均值 -0.15

raw_a, raw_b = logp_a.sum(), logp_b.sum()       # -0.75 vs -1.2
for alpha in (0.0, 0.7, 1.0):
    sa = raw_a / (len(logp_a) ** alpha)
    sb = raw_b / (len(logp_b) ** alpha)
    print(f"alpha={alpha:<3}  A={sa:+.3f}  B={sb:+.3f}  -> 选 {'A' if sa>sb else 'B'}")
# alpha=0（不归一化）总偏好短句 A；alpha=1（平均 logp）B 胜出，更公平
# 实践常用 alpha≈0.7：既校正长度，又保留「长序列信息量更大」的一点优势

2.4 动手练习与自测

概率与统计的题目最容易「以为自己懂了」。以下题目请务必跑出数字再下结论。

1. （梯度验证） 用中心差分验证 ∂L/∂z = p − y，报告最大误差。判据：eps=1e-6 时误差应小于 1e-8；若误差很大，先检查是否忘了 softmax 的数值稳定（减 max）。
2. （PPL 换算） 给定交叉熵 1.2 nats、平均每 token 4 字节，算 PPL 与 bits-per-byte。判据：PPL≈3.32、bpb≈0.415。再验证 CE = H(y) + KL(y‖p) 对软标签成立。
3. （样本量规划） 你希望以 95% 置信分辨 ±2pp 的差异，算所需评测集大小。判据：约 2401 条；若只测 200 条，只能分辨 ±6pp 量级。
4. （配对检验） 用同一批输入跑两个模型，对差值做 bootstrap；对比「独立两样本」检验的 p 值。判据：配对检验的功效更高、置信区间更窄，因为消除了输入难度带来的方差。
5. （长度归一化） 构造两条不等长候选，报告 α=0 / 0.7 / 1.0 下 best-of-n 的胜者。判据：α=0 系统性偏好短句；α 增大后更长、更自信的候选胜出。
6. （Gibbs 不等式） 证明 KL(p‖q) ≥ 0 且等号当且仅当 p=q。提示：用 −log x ≥ 1−x。这是交叉熵下界与「困惑度不可能低于数据熵」的根源。

3. 微积分与最优化：让模型学会

3.1 梯度、链式法则与反向传播

反向传播不是新知识，就是链式法则 + 动态规划：从损失往回走，复用已经算过的中间梯度。理解这一点后，你就会明白为什么 PyTorch 要建计算图、为什么 detach() 会切断梯度、为什么显存会被激活值占满。

python# 手写一个两层网络的前向 + 反向，彻底看清 autograd 在做什么
import numpy as np
rng = np.random.default_rng(42)

X, Y = rng.normal(size=(64, 8)), rng.normal(size=(64, 4))
W1, W2 = rng.normal(size=(8, 16)) * 0.1, rng.normal(size=(16, 4)) * 0.1

for step in range(200):
    # ---- forward ----
    h_pre = X @ W1
    h = np.maximum(h_pre, 0)               # ReLU
    logits = h @ W2
    logits -= logits.max(1, keepdims=True)
    p = np.exp(logits); p /= p.sum(1, keepdims=True)
    loss = -np.log(p[np.arange(64), Y.argmax(1)]).mean()

    # ---- backward ----
    dlogits = p.copy()
    dlogits[np.arange(64), Y.argmax(1)] -= 1
    dlogits /= 64                          # ∂L/∂z = p - y，正是上面推的结论
    dW2 = h.T @ dlogits
    dh = dlogits @ W2.T
    dh_pre = dh * (h_pre > 0)              # ReLU 的导数：大于 0 处为 1
    dW1 = X.T @ dh_pre

    # ---- SGD 更新 ----
    for W, dW in ((W1, dW1), (W2, dW2)):
        W -= 0.5 * dW

自动微分有两种模式。前向模式沿计算图「同方向」走，每遍算一个输入方向的方向导数，适合「输入维度 ≪ 输出维度」（如物理仿真）；反向模式从输出往回走一遍，同时得到所有参数对损失的梯度，适合「参数 ≫ 输出」（神经网络，损失是标量、参数上亿）。这就是为什么深度学习全是反向模式——前向模式对亿级参数要跑上亿遍，不可承受。

工程上验证一个手写反向是否正确的黄金标准是梯度检查：在若干坐标上做中心差分，与解析梯度比对。数值梯度正确但慢（每个参数要两次前向），解析梯度快但易写错，两者互为对照。下面抽查两层网络里 W1 的几个元素。

pythonimport numpy as np
rng = np.random.default_rng(0)
X = rng.normal(size=(8, 4)); yidx = rng.integers(0, 3, size=8)
W1 = rng.normal(size=(4, 6)) * 0.3
W2 = rng.normal(size=(6, 3)) * 0.3

def loss(W1, W2):
    h = np.maximum(X @ W1, 0)
    z = h @ W2
    z = z - z.max(1, keepdims=True)
    p = np.exp(z); p /= p.sum(1, keepdims=True)
    return float(-np.log(p[np.arange(8), yidx]).mean())

# ---- 解析梯度（复用手推结论）----
h_pre = X @ W1; h = np.maximum(h_pre, 0)
z = h @ W2; z = z - z.max(1, keepdims=True)
p = np.exp(z); p /= p.sum(1, keepdims=True)
dz = p.copy(); dz[np.arange(8), yidx] -= 1; dz /= 8      # ∂L/∂z = (p − y)/N
dW2 = h.T @ dz
dW1 = X.T @ ((dz @ W2.T) * (h_pre > 0))

# ---- 数值梯度（抽查 3 个元素）----
eps = 1e-6
for i, j in [(0,0), (2,3), (3,5)]:
    Wp = W1.copy(); Wp[i,j] += eps
    Wm = W1.copy(); Wm[i,j] -= eps
    num = (loss(Wp, W2) - loss(Wm, W2)) / (2*eps)
    print(f"W1[{i},{j}] analytic={dW1[i,j]:+.6f} numeric={num:+.6f} diff={abs(dW1[i,j]-num):.2e}")
# 每个抽查点的 diff 都 < 1e-6：手写反向与数值梯度一致，可以放心训练

pythonimport torch
# detach() 与 no_grad()：精确控制「哪一段参与梯度」
x = torch.randn(4, requires_grad=True)
y = x * 2                      # y.requires_grad = True
z = y.detach() * 3             # z 的图从 y 处被切断，反向不会流回 x
print(z.requires_grad)         # False

with torch.no_grad():          # 整段不建图、不存激活，省显存
    pred = model(x)            # 推理 / 评估指标计算应包在这里

# 为什么激活值占显存：反向需要前向的中间结果（如 ReLU 的 mask、归一化的均值）
# batch=32, seq=2048, hidden=8192, fp16 → 单层激活约 32*2048*8192*2 ≈ 1 GB
# 几十层叠加 + 优化器状态，就是单卡放不下大模型的原因（进而需要 ZeRO/张量并行）

3.2 优化器演进：SGD → AdamW → Muon

2026 年一个值得注意的变化是：Muon 优化器正在取代 AdamW 成为前沿实验室的新默认（Kimi、GLM、DeepSeek-V4 等都已采用或验证）。理解这条演进线，比记住某个优化器的公式更有价值。

Adam 的完整更新（这是你必须能默写的）：对参数 θ，记梯度 g_t=∇L(θ_t)，一阶矩 m_t=β₁m_{t−1}+(1−β₁)g_t，二阶矩 v_t=β₂v_{t−1}+(1−β₂)g_t⊙g_t，偏差校正 m̂_t=m_t/(1−β₁ᵗ)、v̂_t=v_t/(1−β₂ᵗ)，最终 θ_t=θ_{t−1}−η·m̂_t/(√v̂_t+ε)。ε（常 1e-8）防止除零，在小梯度方向起「数值保险丝」作用；β₁≈0.9、β₂≈0.999 是多年实证甜点。

pythonimport numpy as np
rng = np.random.default_rng(0)
params = [rng.normal(size=(8,4))*0.1, rng.normal(size=(4,))*0.1]
grads  = [rng.normal(size=p.shape) for p in params]
m = [np.zeros_like(p) for p in params]
v = [np.zeros_like(p) for p in params]
beta1, beta2, eps = 0.9, 0.999, 1e-8
lr, wd, t = 3e-4, 0.01, 0

for t in range(1, 101):
    for i, (p, g) in enumerate(zip(params, grads)):
        m[i] = beta1*m[i] + (1-beta1)*g
        v[i] = beta2*v[i] + (1-beta2)*(g*g)
        mhat = m[i] / (1 - beta1**t)            # 偏差校正
        vhat = v[i] / (1 - beta2**t)
        # AdamW：权重衰减作用在参数本身，与梯度缩放解耦
        p -= lr * (mhat / (np.sqrt(vhat) + eps) + wd * p)

# 全局范数梯度裁剪：防止长序列 / 大 loss 导致梯度爆炸
total_norm = np.sqrt(sum(np.sum(g*g) for g in grads))
clip = 1.0
if total_norm > clip:
    grads = [g * (clip / total_norm) for g in grads]
print("step done, total_norm=", round(float(total_norm), 4))

AdamW 与 Adam 的关键区别在权重衰减位置：Adam 把 L2 正则项加进梯度 g+λθ，而自适应缩放 1/√v̂ 会同时缩小正则的等效强度，使衰减随参数尺度变化、不可控；AdamW 直接 θ −= η·(m̂/√v̂ + λθ)，衰减与梯度缩放解耦，正则效果稳定——这是 2026 年几乎所有大模型训练的默认。梯度裁剪用全局范数：ĝ = g·min(1, c/‖g‖₂)，c 常取 1.0，是长序列训练防爆炸的保险丝。FP8 训练（DeepSeek-V4 等前沿集群标配）下梯度以 8-bit 存，动态缩放因子（如 MXFP4→FP8 的逐级缩放）必须与裁剪、Muon 的正交化协同，否则低精度会把小奇异值方向的更新直接量化成零。

Muon 的一次更新可以拆成三步：① 用动量缓冲累积历史梯度（mu≈0.95）；② 用 Newton–Schulz 正交化把缓冲矩阵的奇异值拉平；③ 乘一个 RMS 缩放因子，使更新量的均方根与 AdamW 的更新量相当（否则换成 Muon 后学习率要重调）。实践中是混合优化：只对 2D 权重矩阵用 Muon，embedding、LayerNorm 增益与 bias 仍用 AdamW——因为它们不适合「按矩阵做谱约束」。下面是可运行的一次更新：

pythonimport numpy as np
rng = np.random.default_rng(0)
G = rng.normal(size=(64, 32))             # 某一层权重的梯度矩阵

def newtonschulz(G, steps=5):
    a, b, c = 3.4445, -4.7750, 2.0315
    X = G / (np.linalg.norm(G) + 1e-7)    # 归一到谱范数 <= 1
    for _ in range(steps):
        A = X @ X.T
        X = a*X + (b*A + c*(A @ A)) @ X
    return X

mu = 0.95
buf = (1 - mu) * G                        # 单步动量（真实训练会跨步累积）
O = newtonschulz(buf)                     # 正交化：各方向尺度均衡
lr = 0.02
update = 0.2 * lr * np.sqrt(O.size) * O   # RMS 缩放，对齐 AdamW 的更新量级
print("update RMS =", round(float(np.sqrt((update**2).mean())), 5))
S = np.linalg.svd(O, compute_uv=False)
print("正交化后奇异值 max/min =", round(float(S.max() / S.min()), 3))   # ≈ 1
# 结论：正交化让更新不再被少数大奇异值垄断；Muon 与 AdamW 混用是 2026 主流配置

3.3 学习率、批大小与缩放律

学习率与批大小不是两个独立旋钮，而是被缩放律绑在一起的。当把批大小 b 增大 k 倍，若线性缩放规则（linear scaling rule）成立，学习率也应乘 k，这样每步「看到的样本量」等效。但线性缩放只在临界批大小（critical batch size）B_crit 以内近似成立；超过后，梯度噪声被 averaging 掉，继续加 batch 的收益按 1/√b 衰减，单纯放大学习率只会不稳。

梯度噪声尺度（gradient noise scale） χ ≈ ‖g‖² / ‖∇g·g‖² 决定了 B_crit ≈ χ·(某曲率因子)，大语言模型常见量级在数千到数万。换句话说，在 B_crit 内，「加 batch」几乎免费加速；超过后，「加样本」不如「加步数」。Warmup 占总步数的经验比例是 1–3%（如 100k 步里 2000 步预热），让 Adam 的二阶矩先收敛、让 embedding 等冷启动参数先稳定。余弦退火让 lr 从峰值平滑降到 min_ratio·η（常 0.1）；WSD（warmup-stable-decay）则先恒定再在最后一段快速衰减，利于「训练中途切数据 / 切阶段」且不丢已学知识，是 2026 年长程预训练（如 Qwen3 的continued pretrain）更受欢迎的调度。

pythonimport math

def lr_at(step, base_lr=3e-4, warmup=2000, total=100_000, min_ratio=0.1,
          schedule='cosine'):
    if step < warmup:
        return base_lr * step / warmup
    prog = (step - warmup) / max(1, total - warmup)
    if schedule == 'cosine':
        return base_lr * (min_ratio + (1-min_ratio)*0.5*(1+math.cos(math.pi*prog)))
    if schedule == 'wsd':
        # 前 90% 恒定，后 10% 线性衰减到 min_ratio*base
        if prog < 0.9: return base_lr
        p2 = (prog-0.9)/0.1
        return base_lr*(min_ratio + (1-min_ratio)*(1-p2))
    return base_lr*min_ratio

# 临界批大小：超过后有效加速 ≈ sqrt(b) 而非 b
B_crit = 2**14
for b in (512, 2048, 8192, 32768):
    eff = (b/B_crit)**0.5 if b > B_crit else 1.0
    print(f"batch={b:6d}  有效加速≈{min(1.0, b/B_crit)*eff + (b>B_crit)*0:.2f}×")

缩放律不只告诉你「怎么加 batch」，更告诉你「加算力还能不能赢」。Chinchilla 之后的经验形式是 L(C) ≈ E + a·C^{−b}（C 为训练算力，E 是不可约损失）。把已知的几点在 log-log 空间拟合，就能外推预测更大训练的开销——这是「训练前先估预算」的标准动作：

pythonimport numpy as np
C = np.array([1e18, 3e18, 1e19, 3e19, 1e20])     # 训练 FLOPs
L = np.array([2.60, 2.42, 2.24, 2.10, 1.98])     # 观测到的 loss

E = 1.69                                          # 不可约损失下界（示例）
b_hat, log_a = np.polyfit(np.log(C), np.log(L - E), 1)
a_hat = np.exp(log_a)
print(f"拟合: L ≈ {E:.2f} + {a_hat:.3f} / C^{abs(b_hat):.3f}")
print("预测 :", np.round(E + a_hat * C**(-b_hat), 3))
print("实测 :", L)
# 指数约 0.05–0.10：算力每翻 10 倍，loss 只降零点零几
# → 2026 年「纯粹堆算力」边际收益递减，破局靠架构（MoE）、数据质量与后训练

3.4 动手练习与自测

本组题目直接对应里程碑 M5 的交付物：手写反向 + 优化器 + 调度。做完你就能读懂 AdamW / Muon 的每一行。

1. （梯度检查） 对两层 MLP 手写反向，用中心差分抽查 3 个权重元素。判据：diff < 1e-6；若某元素差很大，优先怀疑 ReLU 的 mask 用错（应基于 h_pre>0 而非 h>0）。
2. （AdamW 偏差校正） 关掉 (1−β^t) 校正，观察前 10 步参数更新是否偏小。判据：不校正时前几步更新约为校正后的 (1−β₁ᵗ) 倍（t=1 时约 0.1 倍），这正是「冷启动估计偏低」的量化体现。
3. （Muon vs AdamW） 在同一玩具二次型上分别用两种优化器跑 200 步，画 loss 曲线。判据：Muon 应在高条件数问题上更快；但换成 embedding 这类非方阵且谱结构杂乱的参数，AdamW 更稳。
4. （临界批大小） 固定总样本数，把 batch 从 512 增到 32768，记录达到同一 loss 的步数与墙钟时间。判据：超过 B_crit 后墙钟时间不再线性下降，出现「加 batch 不加速」的拐点。
5. （调度对比） 实现 cosine 与 WSD 两种调度，在同一训练上对比末段 loss。判据：WSD 在 stable 段可任意截断续训，末段快速衰减能追平 cosine，但更便于换数据。
6. （权重衰减范围） 把 wd 从 0 调到 0.1，观察验证 loss。判据：wd 过大（0.1）会欠拟合，过小（0）会过拟合；0.01 常是甜点，但应随模型规模微调。

4. 强化学习数学基础（后训练的前置知识）

4.1 MDP、策略梯度与优势函数

2026 年，强化学习已经从「小众方向」变成「基础模型与有用产品之间的那一层」。阶段 6（后训练）与阶段 7（推理模型）会大量用到这里的符号，所以这里必须打牢。好消息是：你不需要学深度强化学习那一整套环境仿真，只需要掌握语言模型场景下的 RL。

策略梯度定理的思路（务必理解推导，而不是只记结论）：我们要最大化期望回报 J(θ)=E_{τ∼π_θ}[R(τ)]。对 θ 求导，利用 ∇π_θ(a|s)=π_θ(a|s)·∇log π_θ(a|s)（似然比技巧 / REINFORCE 核心），可以把期望里的梯度提出来，得到 ∇J(θ)=E[ Σ_t ∇log π_θ(a_t|s_t) · G_t ]。再减掉一个基线 b(s_t)（不引入偏差但降低方差），得到 ∇J(θ)=E[ Σ_t ∇log π_θ(a_t|s_t) · (G_t − b(s_t)) ]——括号里就是优势。好结果提高其概率，坏结果降低其概率，这就是 RLHF 全部故事的开头。

pythonimport numpy as np
# GAE: A_t = Σ_{l=0}^{∞} (γλ)^l δ_{t+l},  δ_t = r_t + γV(s_{t+1}) − V(s_t)
#   λ=0 → 只用一步 TD 残差（低方差、高偏差）
#   λ=1 → 蒙特卡洛回报（高方差、低偏差），二者之间的偏差-方差旋钮
def compute_gae(rewards, values, gamma=1.0, lam=0.95):
    adv = np.zeros_like(rewards, dtype=float)
    gae = 0.0
    for t in reversed(range(len(rewards))):
        nxt = values[t+1] if t+1 < len(values) else 0.0
        delta = rewards[t] + gamma*nxt - values[t]
        gae = delta + gamma*lam*gae
        adv[t] = gae
    return adv

rewards = np.array([0.0, 0.0, 0.0, 1.0])     # 只在最后一步给奖励
values  = np.array([0.5, 0.6, 0.7, 0.8, 0.0])
for lam in (0.0, 0.5, 0.95, 1.0):
    print(f"λ={lam:<4} A={np.round(compute_gae(rewards, values, lam=lam),3)}")
# λ 越大，优势越「看长远」，方差越大但偏差越小

GRPO 把「基线」从「学一个价值网络」换成了「同一 prompt 采样一组答案、用组内统计量当基线」。这就是它省掉 Critic 的全部秘诀：A_i = (r_i − mean(r)) / (std(r) + ε)。分母的标准化让不同 prompt 之间的优势可比，是 GRPO 稳定的关键。它有个前提假设——同组答案「可比较」，一旦轨迹长短差异巨大（Agentic 场景），这个假设就崩了。

pythonimport numpy as np
# GRPO 组内相对优势：同一 prompt 采样 G 个答案，用组统计量做基线
def grpo_advantage(rewards, eps=1e-4):
    r = np.asarray(rewards, dtype=float)
    return (r - r.mean()) / (r.std() + eps)

# 情形 1：组内区分度高（一半对一半错）—— 信号强
print(np.round(grpo_advantage([1, 1, 0, 0, 1]), 3))

# 情形 2：全对或全错 —— 组内均值 = 全体，优势全为 0，这步白算
print(np.round(grpo_advantage([1, 1, 1, 1]), 3))     # [0. 0. 0. 0.]
print(np.round(grpo_advantage([0, 0, 0, 0]), 3))     # [0. 0. 0. 0.]

# → 这正是 DAPO 引入「动态采样」的动机：丢弃全对/全错的组，不浪费算力
#   同时 clip 掉优势的极端值（如 |A| 截断到 5）以防梯度爆炸

4.2 从 PPO 到 GRPO：一条必读的算法脉络

下面这条脉络是 2026 年面试的高频考点，也是阶段 6 与阶段 7 的骨架。理解「每一步在修什么问题」，比记住公式重要。

DPO 的目标函数值得单独推导一遍，因为它是「RL → 分类」的最漂亮的一次重参数化。它把「奖励模型 + PPO」合并成一个离线分类损失：L_DPO = −log σ( β·[log(π_θ(y_w|x)/π_ref(y_w|x)) − log(π_θ(y_l|x)/π_ref(y_l|x))] )，其中 y_w 是偏好（更优）回答、y_l 是被拒回答。直觉：让「好回答相对参考模型的提升」超过「坏回答相对参考模型的提升」。β（0.1–0.5）控制偏离参考模型的强度。

pythonimport numpy as np
def sigmoid(x): return 1 / (1 + np.exp(-x))

def dpo_loss(logp_w, logp_l, ref_w, ref_l, beta=0.1):
    # logp_*: 当前策略对回答的对数概率；ref_*: 参考模型的对数概率
    margin = beta * ((logp_w - ref_w) - (logp_l - ref_l))
    loss = -np.log(sigmoid(margin))
    # 隐式奖励：r(x,y) = beta * log(pi/pi_ref)，DPO 不训练显式奖励模型
    return loss, beta * (logp_w - ref_w), beta * (logp_l - ref_l)

loss, r_w, r_l = dpo_loss(-3.0, -4.5, -3.2, -4.0, beta=0.1)
print(f"loss={loss:.4f}  implicit_rw={r_w:+.3f}  implicit_rl={r_l:+.3f}")
# 好回答相对参考提升 (+0.2)、坏回答下降 (−0.5)，margin>0，loss 很小
# 注意：DPO 是离线的，不探索——这是它轻量但也「封顶」的根本原因

4.3 重要性采样与 clip 的数学

PPO 之所以能「稳定地反复用同一批旧数据更新多轮」，靠的是重要性采样比值 r_t(θ)=π_θ(a_t|s_t)/π_old(a_t|s_t)，它把「用旧策略采的样本」校正成「对新策略的期望」。对单步，校正后的目标 E[r_t(θ)·A_t] 在 r=1 处对 θ 取梯度恰好等于原策略梯度（这是重要性采样恒等式 E_{old}[ (π/π_old)·f ] = E_π[f] 的直接推论）。

pythonimport numpy as np
# 重要性比值 r_t(θ) = π_θ / π_old，PPO clip 目标
logp_new = np.array([-1.2, -0.8, -2.0])
logp_old = np.array([-1.1, -0.9, -1.9])
ratio = np.exp(logp_new - logp_old)            # r = exp(logπ_new - logπ_old)
adv = np.array([0.5, -0.3, 1.2])
eps = 0.2
surr1 = ratio * adv
surr2 = np.clip(ratio, 1-eps, 1+eps) * adv
ppo_loss = -np.minimum(surr1, surr2).mean()    # 取裁后较小（悲观）目标
print("ratio =", np.round(ratio,3), "  loss =", round(float(ppo_loss),4))

# KL 惩罚的三种估计（用于 RLHF 的信任域软约束）
def kl_estimates(p_new, p_old):
    log_r = np.log(p_new + 1e-12) - np.log(p_old + 1e-12)
    k1 = (p_new - p_old) * log_r                       # 一阶（未归一近似）
    k2 = p_old * log_r                                 # 二阶 Schur 近似，最常用
    k3 = p_old * ((p_new-p_old)**2) / (2*p_old**2)     # 三阶，更稳
    return k1.mean(), k2.mean(), k3.mean()

为什么 clip 能保证信任域：当优势 A_t>0（这个动作好于平均），我们本想沿 r 增大方向推，但目标被截到 (1+ε)A，超过就不再给奖励，于是策略不会「一步冲太远」；当 A_t<0，截到 (1−ε)A，回退也被限制。这等价于在每步给策略更新加了一个隐式信任域，避免 PPO 早期「一脚踩空就崩」。KL 惩罚是更软的同类约束：k1（一阶，近似最粗糙）、k2（二阶 Schur 近似，实践中最常用）、k3（三阶，数值更稳）。token 级 vs 序列级比值是 2025 年 GRPO 家族的关键分歧：标准 PPO/GRPO 用 r_t = π_θ(token)/π_old(token) 逐 token 比，长序列上比值乘积噪声大、易崩；GSPO 改用在整条序列上求几何/算术平均的 r_seq，对长轨迹与 MoE（专家路由使 token 级概率跳变）显著更稳。

pythonimport numpy as np
rng = np.random.default_rng(0)
# 一条长序列：token 级对数概率比 —— 连乘导致比值漂移、方差爆炸
T = 512
dlogp = rng.normal(0, 0.02, size=T)          # 每个 token 的 log(pi_new/pi_old)
r_token = np.exp(dlogp)                       # token 级比值，均值 ≈ 1
r_seq_arith = r_token.mean()                  # 序列级：算术平均
r_seq_geom  = np.exp(dlogp.mean())            # 序列级：几何平均（GSPO 变体）

print("token 比值 std =", round(float(r_token.std()), 4))
print("序列级(算术) =", round(float(r_seq_arith), 4),
      " 序列级(几何) =", round(float(r_seq_geom), 4))

# off-policy 漂移：随更新轮次加大偏离，token 级比值的方差急剧上升
for shift in (0.0, 0.01, 0.05, 0.1):
    d = rng.normal(shift, 0.02, size=T)
    prod = np.exp(d.sum())                    # 整条序列的比 (连乘)
    print(f"shift={shift:<5}  token级std={np.exp(d).std():.4f}  序列边长比={prod:.3e}")
# 序列边长比指数级漂移 → token 级 clip 在长序列上失效，这正是 GSPO 改序列级的动机

4.4 动手练习与自测

这一组题目是阶段 6（后训练）与阶段 7（推理模型）的预演。全部可用 numpy 实现，不依赖任何 RL 环境。

1. （GAE 的 λ） 用同一组 reward 与 value，分别取 λ=0 / 0.5 / 0.95 / 1，报告优势序列。判据：λ=0 只用一步 TD 残差（方差最小、偏差最大）；λ=1 退化为蒙特卡洛回报；λ 越大优势越「看长远」。
2. （组内优势） 对奖励 [1,1,0,0,1] 与 [1,1,1,1] 分别算 GRPO 优势。判据：前者非零且和为 0；后者全为 0（该步不产生梯度），说明为什么需要动态采样丢弃无效题。
3. （DPO 目标） 手写 DPO loss 并计算隐式奖励 β·log(π/π_ref)。判据：当「好回答提升 > 坏回答提升」时 margin>0、loss 趋近 0；β 越大对参考模型的偏离越快。
4. （clip 生效边界） 构造 ratio=0.5/1.0/1.5、优势 A=+1 与 −1 的组合，手算 min(rA, clip(r,1±ε)A)。判据：A=+1 时 ratio>1.2 被截断；A=−1 时 ratio<0.8 被截断——这就是信任域的具体形状。
5. （序列级比值） 在长度 512 的序列上对比 token 级与序列级比值的方差，并把 off-policy 偏移 shift 从 0 加到 0.1。判据：token 级方差随 shift 迅速上升，整条序列的连乘比值指数级漂移（可达 1e3 以上），而序列级比值稳定在 1 附近。
6. （KL 估计） 用 k1 / k2 / k3 三种估计同一个 KL，比较与真值的偏差。判据：k2（Schur 近似）在中小偏离下最接近真值、方差最低，这是 RLHF 里默认用 k2 的原因。

项目里程碑

阶段练习项目

常见误区

• 追求「数学系式完备」而卡在证明上，几个月碰不到模型。应该边用边补。
• 只背公式不理解动机，遇到论文里的新变体就完全看不懂。
• 学了深度强化学习那一整套（DQN / A3C / 环境仿真）却不知道 LLM 的 RL 只用策略梯度部分，白花时间。
• 把 SVD、KL 散度、交叉熵当三个孤立知识点背下来，不知道它们在后训练里是一套东西。
• 用单次评测的均值差下结论，不做显著性判断——这是 A/B 实验最常见的错误。
• 以为 T=0 是「确定性最强」的玄学，没意识到它数学上就是 softmax 在 T→0 退化为 argmax（贪心）。
• 混淆 Adam 的 L2 正则与 AdamW 的解耦权重衰减，在框架里同时开两者导致双重正则、训练不稳。
• 把权重衰减套到 LayerNorm 增益和 bias 上，忽略「只对 2D 权重衰减」的惯例，引发不稳定。
• 用线性缩放规则把学习率随批大小一起放大，却没意识到超过临界批大小后收益按 1/√b 衰减，反而训飞。
• 在 PPO / GRPO 里用新模型重新前向得到的 logp 去减旧 logp 算比值，引入不可见偏差；比值必须基于同一批采样数据。
• 在长序列上直接用 token 级重要性比值做 off-policy 校正，没意识到连乘漂移会让方差爆炸，应改用序列级比值或加 KL 早停。
• FP8 / 低精度训练时把 Adam 的二阶矩也压成低精度累积，导致下溢把小奇异值方向量化成零，更新被悄悄抹掉。

面试高频问题速答

推导交叉熵损失对 logits 的梯度。

设 p = softmax(z)，softmax 的雅可比为 ∂p_i/∂z_j = p_i(δ_ij − p_j)。对 L = −log p_y，有 ∂L/∂z_j = −(1/p_y)·p_y(δ_yj − p_j) = p_j − δ_yj，即 ∂L/∂z = p − y。这个结果说明分类任务的梯度就是「预测分布减真实分布」，解释了收敛快的原因，也是阶段 4 策略梯度与 DPO 损失的同一套结构。

KL 散度为什么不对称？什么时候用哪个方向？

KL(p‖q) ≠ KL(q‖p)。KL(p‖q)（前向）会惩罚「p 有概率而 q 为 0」，倾向于覆盖所有模式（mass-covering），是最大似然的方向；KL(q‖p)（反向）倾向于只拟合一个模式（mode-seeking），用于变分推理与某些蒸馏目标。RLHF 里对参考模型方向的 KL 惩罚需按具体论文确认符号。

Adam 和 AdamW 的区别是什么？

Adam 把 L2 正则项加进梯度，自适应缩放会同时缩小正则的等效强度，使权重衰减随参数尺度变化、不可控。AdamW 把权重衰减从梯度中解耦，直接作用于参数更新 θ −= η·(m̂/√v̂ + λθ)，正则效果稳定。亚当的偏差校正 (1−βᵗ) 解决冷启动估计偏低的问题，这是现在几乎所有大模型训练的默认。

为什么 GRPO 可以不设 Critic？

因为它用「同一 prompt 采样一组答案」的组内奖励统计量来估计基线：优势 ≈ (r − 组内均值) / 组内标准差，组均值起到了 baseline 的作用，从而免去价值网络 V(s)。代价是需要多次采样提高 rollout 成本，且在长程、不等长子轨迹场景假设会失效——这正是 2026 年长程 Agentic 训练回归 Critic 的原因。

LoRA 为什么有效？用线性代数的语言解释。

微调时的权重更新 ΔW 谱衰减很快，近似低秩：ΔW ≈ BA，A∈R^{r×d_in}、B∈R^{d_out×r}，r 远小于 d。可训练参数量从 d_in·d_out 降到 r(d_in+d_out)。B 零初始化、A 高斯初始化使训练起点 ΔW=0，模型从原能力平滑长出；推理前 W_new = W + (α/r)BA 可写回主干，不增加任何延迟。

学习率和批大小怎么一起调？什么是临界批大小？

在临界批大小 B_crit 内用 linear scaling（批 ×k，lr ×k），超过后收益按 1/√b 衰减，应改 sqrt scaling 或停止放大 lr。B_crit 由梯度噪声尺度决定，大语言模型常在数千到数万。warmup 占总步数 1–3% 让 Adam 二阶矩与冷启动参数先稳定；WSD 比纯余弦更利于断点续训换数据。

PPO 的 clip 为什么能保证信任域？

clip 把目标取 min(rA, clip(r,1±ε)A)：当 A>0 时上行被截到 (1+ε)A，A<0 时下行被截到 (1−ε)A，等价于每步给策略更新加隐式信任域，避免一步冲太远。再叠加 KL 惩罚（k2 Schur 近似最常用）做软约束。比值必须基于同一批采样数据，且 off-policy 校正只在比值不过大时有效，否则要加 KL 早停或改用序列级比值（GSPO）。

2026 年 Muon 优化器为什么受关注？

Muon 对梯度矩阵做正交化（Newton-Schulz 迭代近似谱范数约束），使各方向更新尺度均衡，避免被少数大奇异值主导，超大模型训练更稳更快，已被 Kimi / GLM / DeepSeek-V4 等采用或验证。它与 LoRA 的谱衰减直觉一脉相承，也是为什么「谱与条件数」在 2026 年不再是纯理论——它们直接影响你能不能把模型训稳。

学习资源