爆款方案 · 第 03 期 / 共 30 期
反向传播:
一次前向,为什么必须把整条路都记下来
上一期算出 4.61 这个数。这一期讲它怎么变成 70 亿个「你该往哪改、改多少」------ 以及为什么教科书里的数值微分,在真实模型上要跑 22.7 天。
热度 ★★★★★门槛 中15 秒投流版 + 75 秒正片版抖音 / 视频号 / 小红书 / B站
7B 模型,一次反向传播 0.42 毫秒 ,拿到全部 70 亿个梯度。
同样的事换成数值微分:22.7 天。慢 46 亿倍。------主钩子。同一个目标、两种做法、一个天上一个地下。3 秒内完成量级冲击,不需要任何前置知识。
第 1 章 · 选题判断
为什么第 3 期是它
第 02 期结尾留了个问题没答:交叉熵算出 4.61 这个数,可模型有 70 亿个参数,每一个都要知道「我该往哪改、改多少」。一个标量,怎么变成 70 亿个方向?
答案就是反向传播。它做的事听起来平淡:把链式法则在图上一层层倒着走。但它的计算成本结构 才是真正惊人的地方 ------ 不管你有一百个参数还是七千亿个,求全部梯度,只需要一次前向 + 一次反向,也就是大约 3 倍前向的算力。这个性质不是工程优化,是反向模式自动微分的数学结论。
0.42 ms
一次反传拿到 70 亿个梯度
(按 1e14 FLOP/s 估)
22.7 天
同样的梯度用数值微分
2.69×
梯度检查点省下的激活显存
(本机实测)
它还有个容易被忽略的身份:反向传播不是「深度学习发明的算法」。反向模式自动微分 1970 年就由 Linnainmaa 写进硕士论文,Werbos 1974 年把它用在神经网络上,Rumelhart、Hinton、Williams 1986 年那篇 Nature 才让它流行起来。搞清楚这条脉络,「反向传播」这四个字就不会再被当成玄学。
这一期还是后面所有期的地基:04 期 的 Adam 更新的是这里算出来的梯度;18 期 混合精度会在这里静默下溢(本期实测:0.5 连乘 25 层,fp16 的梯度直接变 0);20 期 的 ZeRO 与 21 期 FlashAttention 的重算策略,本质都是在处理本节要讲的这笔「显存账」。
第 2 章 · 算法内核
口播背后必须站得住的东西
下面每一条都是上镜稿的「证据层」。凡标「实测」的,都是本机跑出来的数;凡标「估算」的,都写清了假设。
2.1定义:它只做一件事 ------ 向量-雅可比积
设一个节点 y = f(x),已知上游传回来的 ȳ = ∂L/∂y(和 y 同形),那么要往下传的就是:
x̄ = ȳ · Jf(x) ,其中 Jf = ∂y/∂x这一步叫 VJP(vector-Jacobian product)。反向传播 = 沿逆拓扑序,每个节点做一次 VJP
关键在于:它从不显式构造雅可比矩阵 。一个 4096×4096 的线性层,雅可比是 1677 万个元素;而 VJP 只做两次矩阵乘法,输出和输入同形。这是「反向模式能用在 70 亿参数上」的根本原因 ------ 空间和时间都只和图规模成正比,与参数量无关。
cost(反向) ≈ 2 × cost(前向) memory(反向) = O(前向中间量)「2 倍」是矩阵乘主导网络的常用经验值,与算子构成有关;本期实测的小网络上 1 次前向+1 次反向 ≈ 1.7 倍前向耗时
2.2为什么必须「存」:局部导数依赖当时的输入
这一节是整期最值钱的部分,因为它解释了显存账单的来源 。反向时每个节点要算局部导数,而这个导数往往依赖于前向时的输入值或输出值:
| 算子 | 反传时需要什么 | 于是前向必须留下 |
|---|---|---|
relu(z) |
导数 1z\>0 | 一个布尔 mask(可以压成 1 bit) |
tanh(z) |
导数 1−tanh²(z) | 输出本身即可,不必存输入 |
softmax(z) |
J = diag(q) − qqᵀ | 输出 q(第 02 期那个 q) |
x @ W |
∂/∂x = ȳWᵀ,∂/∂W = xᵀȳ | 两个输入都要 |
LayerNorm(x) |
依赖均值与方差 | 统计量,或输入 x |
注意力 softmax(QKᵀ)V |
依赖注意力矩阵 | n×n 的注意力矩阵 ← 这就是 FlashAttention 要重算它的原因 |
看最后一行:一个 4096 长度、32 头的注意力层,注意力矩阵就是 32×4096×4096 ≈ 5.4 亿个元素。整条前向如果都存下来,就是「层数 × 这个数」。所以「必须存」不是实现细节,它是 Transformer 训练显存的第一大来源,也是第 21 期 FlashAttention(不存、重算)、第 20 期 ZeRO(把这些切到别的卡上)要解决的问题。
2.3扇出必须累加:最贵的那个「不报错的 bug」
如果某个值在图里被用了两次,它就有两条下游路径。总梯度是两条路径各自贡献之和 ------ 因为多元链式法则本来就是求和,不是取其一。
前向:算一步,就把这一步的输入留在显存里t = tanh(x) s = t × x L = sx1.50t0.9051s1.3577L1.3577tanh× x=x 还被 s 直接乘了一次 ------ 一个值,两条出边反向:从 ∂L/∂L = 1 出发,每退一步乘一个局部导数∂L/∂x = 1.1762∂L/∂t = 1.5000∂L/∂s = 1.00∂L/∂L = 1× x = 0.9051× (1−t²)这一路贡献 ∂s/∂x · ∂L/∂s = t = 0.9051两条路在 x 上相加:0.2711 + 0.9051 = 1.1762
图 1 L = x·tanh(x) 在 x = 1.5 处的前向与反向。上半部分是前向:t = tanh(x)、s = t·x、L = s,绿色是各节点的值,全部要留在显存里。下半部分是反向:从 ∂L/∂L = 1 出发,每退一步只乘一个局部导数。注意 x 有两条出边 (进 tanh、直接进乘法),所以 ∂L/∂x 收到两份贡献:0.2711 + 0.9051 = 1.1762。
与中心差分对拍:数值解 1.96e+20,误差 9.1e-11。
一个实现细节值得单独说:几乎所有自动微分框架里,梯度的累积都是 p.g = p.g + vjp(...)。把加号写成等号,程序不会报错、loss 曲线看起来也正常下降,只是这个参数收到的梯度永远缺一块。这是我在 review 别人的手写反传时最常发现的错误。
实测:漏掉一支梯度,误差有多大
取 y = Σ sin(x·w)·(x² + x),x 在表达式里出现 3 次 。
正确写法(三支相加)与中心差分对比:最大误差 5.2e-10。
错误写法(只留最后一支,覆盖前面的):逐元素最大相对误差 73% ------ 已经和真值完全不是一个量级,但这段代码不会抛任何异常。
2.4数值微分的地板:为什么它只能做「体检」,不能做训练
数值微分用 (f(x+h) − f(x−h)) / 2h 逼近。它有两项误差在互相拉扯:
误差 ≈ (h²/6)·|f‴| + (ε·|f|)/h → 最优 h ≈ ε1/3,最小误差 ≈ ε2/3ε 是浮点机器精度:fp64 ≈ 2.2e−16,fp32 ≈ 1.2e−7
第一项是截断误差 :h 越大,用割线代替切线越不准,按 h² 涨。第二项是舍入误差:h 越小,两个几乎相等的数相减,有效位被吃光,按 1/h 涨。两者相交处就是精度天花板。
1e-141e-121e-101e-81e-61e-41e-21e01e21e-121e-101e-81e-61e-41e-21e0扰动步长 h(对数轴)与解析梯度的误差最优点 h = 1e−5误差 5.1e−12 ------ 这就是天花板h 太大:截断误差 ∝ h²h 太小:舍入误差 ∝ 1/h实测:中心差分vs 解析梯度灰虚线 = 理论渐近线(+2 / −1)
图 2 实测:二层 MLP 的交叉熵损失,对其中一个参数做中心差分,与解析梯度(也就是反向传播算出来的值)比较。横轴是扰动步长 h(对数),纵轴是误差(对数)。
左侧陡降段斜率 +2(截断误差 ∝ h²),右侧回升段斜率 −1(舍入误差 ∝ 1/h),中间触底于 h ≈ 1e-05、误差 5.1e-12。**这就是数值微分的物理极限:fp64 下最好也只能到 1e−11 量级。**虚线是两条理论渐近线。
| 步长 h | 实测误差 | 诊断 |
|---|---|---|
| 1e−1 | 8.0e−04 | h 太大:曲线被切线的二次项吃掉 |
| 1e−2 | 8.0e−06 | 仍偏大 |
| 1e−4 | 8.0e−10 | 即将触底 |
| 1e−5 | 5.1e−12 | 最优点(理论 ε1/3≈6e−6) |
| 1e−8 | 6.0e−09 | h 太小:两个几乎相等的数相减 |
| 1e−12 | 7.6e−05 | 完全被舍入噪声淹没 |
三个直接推论,都是实践里会踩的:
- **梯度检查的容差不能设成 1e−12。**先转 fp64、用中心差分、容差取 1e−4 ~ 1e−6(相对值),否则你的 CI 会随机红。
- **fp32 根本做不了梯度检查。**ε2/3 ≈ 2.4e−5,也就是说误差本身就有 1e−5 量级 ------ 你分不清是代码错了 0.1% 还是浮点噪声。
- **它慢得和参数量成正比。**每个参数要 2 次前向。本期小网络 57 个参数,实测数值微分 2.93 ms,而一次前向+反向只要 0.049 ms,实测差 60 倍。把这个比例套到 70 亿参数上就是开头的 22.7 天。
2.5三种求导,只有一种能用在 70 亿参数上
| 方式 | 一次传播得到什么 | 拿到全梯度要几次 | 能不能用于训练 |
|---|---|---|---|
| 数值微分 | 一个方向的近似导数 | 2 × 参数量(140 亿) | 不能。慢、且精度只有 1e−11 量级 |
| 符号微分 | 一个导数表达式 | 1 | 不能。表达式随图规模膨胀,且无法处理控制流 / 数据依赖的图 |
| 前向模式 AD | 一个输入方向的 JVP | 参数量(70 亿) | 不能。方向数 = 输入维数 |
| 反向模式 AD | 一个输出方向的 VJP | 输出维数 = 1 | 能。这就是反向传播 |
这张表的关键在最后两行:前向模式和后向模式是同一个数学对象的两面 ,成本分别是「输入维数」和「输出维数」次图遍历。神经网络恰好是「输入几亿维、输出一维」的极端形状,所以反向模式赢了 9 个数量级。这不是工程技巧,是问题结构决定的。
顺带解释一个日常疑惑:loss.backward() 不带参数,是因为 loss 是标量,∂L/∂L 只能是 1。如果你对一个向量调用 backward(),框架就必须让你传 grad_output ------ 它在问「你要对哪个输出方向求导」。
2.6显存账单:激活值不是最大的,但只有它能省
以 7B 模型、32 层、d=4096、序列 2048、bf16 混合精度 + Adam 为例。激活值按每层每 token 需要留下的张量逐个累加(不含可重算的注意力矩阵):
| 每层每 token 要留的张量 | 元素数 | bf16 占用 |
|---|---|---|
| attn 输入(残差流) | 4,096 | 8.0 KB |
| q / k / v 投影 | 12,288 | 24.0 KB |
| attn 输出投影输入 | 4,096 | 8.0 KB |
| mlp 归一化输入 | 4,096 | 8.0 KB |
| gate / up 投影 | 22,016 | 43.0 KB |
| SiLU 激活输出 | 11,008 | 21.5 KB |
| down 投影输入 | 11,008 | 21.5 KB |
| 合计 | 68608 | 134.0 KB |
| 项目 | 占用 | 随 batch 变化? | 能省吗 |
|---|---|---|---|
| 参数(bf16) | 13.0 GB | 否 | 只能量化 / 切分 |
| 梯度(bf16) | 13.0 GB | 否 | 只能切分 |
| fp32 主权重 | 26.1 GB | 否 | 不能,精度兜底 |
| Adam 一阶 m | 26.1 GB | 否 | 不能 |
| Adam 二阶 v | 26.1 GB | 否 | 不能 |
| 训练状态小计 | 104.3 GB | 否 | --- |
| 激活值(1 条 2048 token) | 8.4 GB | 是,线性 | 能,靠重算 |
| 激活值(batch = 8) | 67.0 GB | --- | --- |
| 合计(batch = 8) | 171.3 GB | --- | --- |
三个结论,可以直接当结论用:
- batch = 1 就已经 112.7 GB,一张 80G 的卡放不下。所以「显存不够就减 batch」在 7B 全量训练上根本减不下去。
- 激活值占 39%(batch=8) ,不是最大的那一项 ------ 但它是唯一可以靠多算一遍换回来的。其他五项是必须常驻的状态。
- 这也是为什么「训 7B 要 8 张 80G 卡」这句话是对的,但原因不是模型太大,而是优化器状态 + 激活值这两笔账。
口径说明(避免被专业观众挑)
① 上表是核算(按张量字节数逐项累加),不是采样测量;② 未计入注意力 n×n 矩阵 ------ 现代实现默认重算或用 FlashAttention 融合,不会物化它;③ 未计入通信 buffer、临时 workspace、碎片,实际峰值会更高;④ Adam 状态按 4+4 字节、主权重按 4 字节计,若用 8-bit 优化器(如 bitsandbytes)可再砍一半以上。
2.7梯度检查点:用算力换显存,最优在 √L
既然激活值可以重算,那就别全存。每 k 层只在段的入口 存一个检查点,反向时进入这一段再重算一遍前向。
显存从 O(L) 变成 L/k + k(存 k 个段的入口 + 重算一段的中间量),对 k 求极小得 k = √L,此时显存 ≈ 2√L;代价是每个 batch 多算 (1 − 1/k) 次前向。
02468101210.816.322.342.052.082.3106.32011.040每隔 k 层存一个检查点(k=1 就是全存)峰值显存 MBk = 8:只有 4.0 MB比全存省 2.69 倍理论最优k = √L = 6.3代价+29% 算力k 两端都会退化到全存
图 3 实测:40 层 × 512 维 × batch 64 的网络,用 tracemalloc 记录每次运行的峰值 内存分配(单位 MB)。k=1 是全存基线 10.8 MB;k=8 降到 4.0 MB,省 2.69 倍;k 继续增大反而回升 ------ 因为最后要重算的整段本身也要占内存。两端都退化回全存,最优点确实落在 √L ≈ 6.3 附近。
| k(每 k 层存一个) | 峰值显存 | 省了多少 | 额外算力(按 FLOP 计) |
|---|---|---|---|
| 1 | 10.8 | 1.00× | +0% |
| 2 | 6.3 | 1.72× | +17% |
| 4 | 2.3 | 2.53× | +25% |
| 5 | 2.0 | 2.69× | +27% |
| 8 | 2.0 | 2.69× | +29% |
| 10 | 2.3 | 2.53× | +30% |
| 20 | 6.3 | 1.72× | +32% |
| 40 | 11.0 | 0.98× | +32% |
两个必须说清楚的点:
- 梯度值完全不变。 实测 k=8 与全存的梯度总和之差
0.0e+00------ 重算只是重做前向,数学上一模一样。 - **额外算力是 +29%,不是零。**口播里说「用算力换显存」,很多内容会说成「几乎免费」,这不准确。反向=2 单位、前向=1 单位时,k=8 的总成本从 3 单位变成 3.875 单位。GPU 上这个比例会因为访存/计算重叠而偏离,但量级是对的。
顺带一提上界:Chen 等人 2016 年的 sublinear memory 方案把重算做成递归的,能把显存压到 O(√n) 且常数更小;而 FlashAttention 走的是另一条路 ------ 不存注意力矩阵,反向时只重算一小块(正好是第 21 期的主题)。
2.8最阴的一个坑:fp16 下梯度会变成 0,而不是变小
反向传播是一串连乘。乘积一旦小于浮点能表示的最小值,得到的不是「很小的数」,而是精确的 0。而梯度为 0 的参数,从此再也不更新。
| 精度 | 最小正规数 | 0.5 连乘降到 0 的层数 | 1.5 连乘溢出 |
|---|---|---|---|
| fp16 | 6.10e-05 | 第 25 层 | 第 28 层(max 65504) |
| fp32 | 1.18e−38 | 第 150 层 | 第 193 层 |
这就是 loss scaling 存在的唯一理由:把 loss 先乘一个常数(比如 2¹²)再反传,整个梯度链被同比例抬起,避开下溢区;更新参数前再除回去。bf16 因为指数位和 fp32 一样宽(8 位),几乎没有这个问题 ------ 它的代价在尾数只有 8 位(约 3 位十进制有效数字),所以需要 fp32 主权重兜底。两个格式的病完全不同,别混为一谈。
这条为什么值得单独讲
因为它的失败模式是静默的:不报错、不 NaN、loss 照常下降,只是某一部分参数永远学不动。这跟 4.3 的「加号写成等号」是同一类 bug ------ 都会让训练「看起来还行,其实少了一半」。视频里讲这种坑,比讲公式更容易被专业观众记住。
2.9可运行的最小实现:43 行的一个自动微分引擎
import numpy as np
class T:
# 反向模式自动微分:每个节点记住「父节点 + 局部 VJP」
def __init__(self, v, parents=()):
self.v = np.asarray(v, dtype=np.float64) # 前向值:必须留着
self.g = np.zeros_like(self.v) # 梯度:扇出时累加
self.parents = list(parents) # [(父节点, 局部反传)]
def __add__(self, o):
o = o if isinstance(o, T) else T(o)
return T(self.v + o.v, [(self, lambda g: g), (o, lambda g: g)])
def __mul__(self, o):
o = o if isinstance(o, T) else T(o)
# 局部导数 = 对方的值 -> 所以前向一定要把两个输入都存下来
return T(self.v * o.v, [(self, lambda g, o=o: g * o.v),
(o, lambda g, s=self: g * s.v)])
def __matmul__(self, o):
return T(self.v @ o.v, [(self, lambda g, o=o: g @ o.v.T),
(o, lambda g, s=self: s.v.T @ g)])
def tanh(a):
t = np.tanh(a.v)
return T(t, [(a, lambda g: g * (1.0 - t * t))]) # 用输出重算,不必存输入
def relu(a):
m = a.v > 0
return T(a.v * m, [(a, lambda g: g * m)])
def backward(root):
order, seen = [], set()
def topo(t): # 拓扑排序:父在前,子在后
if id(t) in seen:
return
seen.add(id(t))
for p, _ in t.parents:
topo(p)
order.append(t)
topo(root)
root.g = np.ones_like(root.v) # dL/dL = 1(这就是 backward() 不用传参的原因)
for t in reversed(order): # 逆拓扑序 = 反向
for p, vjp in t.parents:
p.g = p.g + vjp(t.g) # 必须是 +=,不是 =
# ---- 性质 1:扇出必须累加 ----
x = T(1.5)
y = tanh(x) * x
backward(y)
assert abs(y.v - 1.3577) < 1e-4
assert abs(x.g - 1.1762) < 1e-4, x.g # 0.2711 + 0.9051
# ---- 性质 2:与中心差分对拍(relu + 两层矩阵乘)----
rng = np.random.default_rng(0)
X = T(rng.normal(size=(4, 5)))
W1 = T(rng.normal(scale=.5, size=(5, 6)))
W2 = T(rng.normal(scale=.5, size=(6, 1)))
def loss_value(): # 参数变了就重建一次图,用于数值微分
h = relu(X @ W1)
out = h @ W2
return float((out * out).v.mean())
h = relu(X @ W1); out = h @ W2
backward((out * out) * T(1.0 / 4.0)) # 损失 = (1/4)·Σout²,故 dL/dout = out/2
def numgrad(node, idx, eps=1e-6):
old = node.v[idx]; node.v[idx] = old + eps; lp = loss_value()
node.v[idx] = old - eps; lm = loss_value(); node.v[idx] = old
return (lp - lm) / (2 * eps)
e = max(abs(numgrad(W2, (i, 0)) - W2.g[i, 0]) for i in range(6))
assert e < 1e-6, e # 实测 3.9e-12
print("ok", y.v, x.g, e)
这 43 行里,四件事全都对上了前面的结论:self.v 就是那笔显存账 (为了算局部导数必须留);p.g = p.g + ... 就是扇出累加 ;root.g = 1 就是 backward() 不带参的原因 ;逆拓扑序就是保证「上游的梯度先算完,才能往下游传」。
一个实现细节:tanh 的 VJP 用的是闭包里的 t(输出),不是输入 ------ 这就是 4.2 那张表里「用输出重算,不必存输入」的例子。真实的框架(PyTorch 的 save_for_backward)就是让每个算子自己声明「我反传时需要留什么」,而不是无脑全存。
2.10性质小结(可直接当结论用)
- **成本与参数量无关。**一次前向 + 一次反向 ≈ 3 倍前向算力,拿到全部梯度。这是「深度学习能训练」的计算基础。
- **代价是内存,不是时间。**反向需要的局部导数依赖前向值,所以必须留 ------ 这就是激活值显存的来源,也是 checkpoint / FlashAttention / ZeRO 的动机。
- **扇出处必须累加。**多元链式法则是求和。写成覆盖不报错,静默错。
- **它算的是精确值。**自动微分没有近似(只有浮点舍入),这与数值微分的 1e−11 地板有本质区别 ------ 所以梯度检查只是「体检工具」,不是训练手段。
- **只对「少输出」高效。**输出一维时是 1 次遍历,输入一维时是 1 次遍历 ------ 神经网络正好是前者。
- **它不负责更新参数。**反向传播只产出梯度;拿梯度怎么走是优化器的事(下一期)。把它叫「反向传播算法」时,别把它当成优化算法。
- **精度会静默吃掉梯度。**fp16 下 0.5 连乘 25 层即为 0,必须配 loss scaling。
第 3 章 · 30 期排期
不重复清单(按调用频次从高到低)
按「大模型里被用到的频次 × 理解依赖关系」排定。前面的讲不透,后面会变成名词堆砌。每天一期,不回头重复。
| 期号 | 算法 / 机制 | 类别 | 爆点方向 |
|---|---|---|---|
| 01 | Scaled Dot-Product Attention ✓ | 注意力 | 1000 字 = 100 万次计算 |
| 02 | Softmax 与交叉熵损失 ✓ | 目标函数 | 自信地答错,罚 6.6 倍 |
| 03 | 反向传播与自动微分(本期) | 训练 | 0.42 毫秒 vs 22.7 天 |
| 04 | SGD → Momentum → Adam → AdamW | 优化 | 为什么 Adam 会「记仇」 |
| 05 | LayerNorm / RMSNorm | 归一化 | 去掉均值那一项,省了多少算力 |
| 06 | 残差连接 | 结构 | 没有它,100 层网络根本训不动 |
| 07 | 位置编码:正弦 → 可学习 → RoPE | 位置 | AI 为什么会「数不清第几个字」 |
| 08 | 多头注意力:MHA / MQA / GQA | 注意力 | 把 32 个头砍到 8 个,效果几乎不掉 |
| 09 | KV Cache 与增量解码 | 推理 | 聊到第 50 轮,显存怎么爆的 |
| 10 | 因果掩码与自回归生成 | 解码 | 训练能并行、推理必须串行的根因 |
| 11 | 解码策略:贪心 / Beam / Top-k / Top-p / 温度 | 解码 | 同一个问题两次答案不同的真相 |
| 12 | BPE 与 SentencePiece 分词 | 预处理 | AI 数不清「strawberry 有几个 r」 |
| 13 | 词嵌入与分布假设 | 表示 | 为什么「国王 − 男人 + 女人 ≈ 女王」 |
| 14 | 前馈网络与 SwiGLU 门控 | 结构 | 大模型 2/3 的参数其实在这里 |
| 15 | 正则化:Dropout / 权重衰减 / 早停 | 训练 | 为什么大模型反而不怕过拟合 |
| 16 | 参数初始化:Xavier / He | 训练 | 初始化错了,再好的模型也训不起来 |
| 17 | 学习率调度:Warmup + Cosine | 训练 | 为什么前 2000 步要「慢慢加速」 |
| 18 | 混合精度训练与梯度裁剪 | 工程 | bf16 和 fp16,差的不是一个字母 |
| 19 | 数据并行与 AllReduce | 分布式 | 一千张卡,梯度怎么对齐 |
| 20 | ZeRO / 张量并行 / 流水线并行 | 分布式 | 一个模型装不进一张卡怎么办 |
| 21 | FlashAttention:分块 + online softmax | 加速 | 不改数学,只改访存,快 3 倍 |
| 22 | 稀疏注意力与滑动窗口 | 注意力 | 只看邻居 512 个词够不够 |
| 23 | 线性注意力与 Mamba(状态空间模型) | 注意力 | 把 n² 干掉之后还剩什么 |
| 24 | MoE 混合专家与路由负载均衡 | 结构 | 671B 参数,每次只激活 37B |
| 25 | 对比学习与 InfoNCE | 表示 | Embedding 模型凭什么判断「像」 |
| 26 | 向量检索:HNSW / IVF-PQ | 检索 | 十亿条向量里,毫秒级找最近邻 |
| 27 | BM25 与混合检索 | 检索 | RAG 里为什么还要留一个「老算法」 |
| 28 | 量化:INT8 / GPTQ / AWQ | 压缩 | 把 16 位压到 4 位,精度只掉一点 |
| 29 | 知识蒸馏与 KL 散度 | 压缩 | 小学生怎么学会教授的解题直觉 |
| 30 | RLHF:PPO 与 DPO | 对齐 | 「有用、诚实、无害」是算出来的 |
备选池(主线写完或需要换题时顺延):投机解码 Speculative Decoding、约束解码 / JSON Mode、前缀树缓存 RadixAttention、课程学习、长上下文外推、视觉编码器中的卷积与 Patch Embedding。
第 03 期 · 反向传播与自动微分(Backpropagation & Automatic Differentiation)
参考:Linnainmaa, The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors , 1970;Werbos, Beyond Regression , 1974;Rumelhart, Hinton & Williams, Learning representations by back-propagating errors , Nature 1986;Griewank & Walther, Evaluating Derivatives ;Baydin et al., Automatic Differentiation in Machine Learning: a Survey , JMLR 2018;Chen et al., Training Deep Nets with Sublinear Memory Cost , 2016;Micikevicius et al., Mixed Precision Training , ICLR 2018。
文中所有「实测」数字由 NumPy 在本机跑出(种子固定,脚本可复现):手写反传 vs 中心差分最大差 1.8e-10;数值微分误差曲线为 fp64 下 27 个步长的实测;检查点显存由 tracemalloc 记录峰值分配(40 层 × 512 维 × batch 64)。「7B 模型的 0.42 ms / 22.7 天」是按 3×2·N·T 与 2N×2·N·T FLOP 在 1e14 FLOP/s 下的估算 ,非本机实测;显存表为逐项核算 ,非采样。
作者:小算 · 高级算法工程师