⚙️ 15-AI-Infra · 00 深度学习推理引擎:从计算图到自动微分¶
关键词:计算图 · 前向/反向 · 拓扑排序 · 链式法则 · 自动微分(Autograd)· 激活显存 · 算子融合
前置知识:03-深度学习 01-反向传播(手推梯度)、13-编程语言 00-Python。
🧩 本讲定位:AI Infra 的第一步是搞懂"训练框架到底怎么求梯度"。面试常追问:反向传播在你眼里是公式还是图上的算法?本讲手写一个迷你 autograd 引擎,把"拓扑序反向"讲透,并顺带算清激活显存、看懂算子融合为什么省时间。
本节要解决的问题¶
| 要解决的问题 | 对应内容 |
|---|---|
| 反向传播的本质是"链式法则"还是个"图算法"? | 核心概念 + 深入原理 1/2 |
| 求梯度为什么必须逆拓扑序?顺序错了会怎样? | 深入原理 3 + 代码实战 A |
| 能不能从零写一个能用的 autograd? | 代码实战 A(手写 Value 引擎) |
| 训练时显存被什么吃掉了?激活占多少? | 深入原理 4 + 代码实战 C |
| 算子融合为什么能省时间?省多少? | 深入原理 5 + 代码实战 D |
故事引入¶
实习生小武第一次在大厂实习,Leader 扔来一个任务:「把模型跑起来,显存 OOM 了,你看看梯度是怎么算的,为什么显存这么大。」小武大学里手推过 BP:
$$ dW = X^T d\text{out},\qquad dX = d\text{out}\, W^T $$
他自信满满,结果打开 PyTorch 源码看到一行 out.backward() 就把梯度全算完了,人懵了:这一行里到底发生了什么? 后来他才知道——反向传播在框架眼里根本不是一堆公式,而是一棵反向遍历的计算图:每个算子是一个"节点",梯度从损失出发,按逆拓扑序一层层往回"分发"。小武后来自己写了个 60 行的迷你 autograd,从此面试只要被问"讲讲反向传播怎么实现",他都能从图上画起,讲得面试官频频点头。
本讲目标:你也成为小武——看懂这张图,并把引擎亲手写出来。
核心概念¶
(a) 📐 计算图:把"一串公式"画成一张图¶
任意表达式都可以展开成一张有向无环图(DAG):叶子是输入/参数,内部节点是算子,根是输出/损失。例:
$$a = x\cdot w_1,\quad b = a + b_0,\quad y = \text{relu}(b)\quad\Rightarrow\quad y = \text{relu}(x w_1 + b_0)$$
flowchart TB
X["x"] --> M["* w₁"] --> A["+ b₀"] --> R["relu"] --> Y["y"]
W["w₁"] --> M
B0["b₀"] --> A
- 前向:从叶子到根按拓扑序求值,中间结果(激活)存起来供反向使用;
- 反向:从根出发,用链式法则把梯度沿边传回每个参数(反向传播);
- 关键洞察:梯度计算 = 图上一次"反向遍历",每个节点只做本地的链式法则(本地梯度 × 上游梯度),复杂度与图大小同阶。
(b) 🧮 本地梯度:每个算子只负责自己的"导数规则"¶
反向传播的复用性来源于局部性:每个算子只需知道"输入梯度怎么传给自己的输入",与全图无关:
| 算子 | 前向 | 本地反向(上游梯度 g 传回) |
|---|---|---|
| 加 | $c=a+b$ | $g_a=g_c\!\cdot\!1,\quad g_b=g_c\!\cdot\!1$ |
| 乘 | $c=a\cdot b$ | $g_a=g_c\cdot b,\quad g_b=g_c\cdot a$ |
| 线性 | $c=Wa+b$ | $g_W=g_c\cdot x^T,\quad g_x=W^T g_c$ |
| ReLU | $c=\max(a,0)$ | $g_a=g_c\cdot \mathbf{1}[a>0]$ |
(c) 🔁 拓扑排序:反向的顺序凭什么"从后往前"?¶
梯度传播有依赖关系:要算节点 v 的梯度,必须先把"v 的输出流向了谁"的梯度准备好。逆拓扑序保证:遍历到 v 时,所有依赖 v 的节点的梯度都已算完,可以直接累加。这就是 backward() 一行代码背后的全部秘密。
(d) 💾 激活显存:为什么训练比推理"胖"这么多?¶
推理只需权重;训练还要存每一层前向的激活(反向要用)+ 梯度 + 优化器状态。激活常占大头:深宽网络、大 batch、长序列下,激活显存可能远超权重。
(e) ⚡ 算子融合:把"多次全局读写"合成"一次"¶
elementwise 算子链(如 $y = d\cdot(c+b+a)$)每一步都读+写一遍完整张量;若融合成一个 kernel,整条链只读一次、写一次。带宽受限场景下收益接近线性——这是推理引擎(如 Triton/Inductor 自动融合)的核心动机。
图示:对 $L=\mathrm{ReLU}(x\cdot w+b)$,前向保存中间值 $u=x\cdot w,\ v=u+b$;反向按逆拓扑序用本地导数回传:$g_v=g_L\cdot\mathbf{1}[v>0]$、$g_u=g_v$、$g_x=g_u\cdot w$、$g_w=g_u\cdot x$;一个节点被多个下游(fan-out)同时使用时,各路梯度要相加。
深入原理¶
1. 链式法则的"图版本"¶
多变量链式法则:若 $y=f(u_1,\dots,u_s)$ 且 $u_i$ 都依赖 $x$,则
$$ \frac{\partial y}{\partial x}=\sum_{i=1}^{s}\frac{\partial y}{\partial u_i}\,\frac{\partial u_i}{\partial x} $$
反向传播就是沿着每个节点的局部导数把上游梯度 $\bar u = \partial y/\partial u$ 继续往上游传:
$$ \bar x = \bar u\cdot\frac{\partial u}{\partial x} $$
一个节点有多个下游(fan-out)时,各路梯度相加:$\bar x = \sum_{\text{下游}} \bar u_j \cdot \partial u_j/\partial x$。
2. 反向模式 vs 前向模式¶
| 模式 | 复杂度(函数 $f:\mathbb{R}^n\to\mathbb{R}^m$,图规模 $G$) | 典型用法 |
|---|---|---|
| 前向模式 AD | $O(m\cdot G)$ | $m$ 很小;雅可比-向量积(JVP) |
| 反向模式 AD | $O(n\cdot G)$ | $n$ 很大(参数多)但 $m=1$(损失标量)——深度学习的标准选择 |
深度模型参数百万级、损失是标量 → 反向模式完胜。
3. 为什么必须是逆拓扑序¶
设损失 $L=f_5(f_4(f_3(f_2(f_1(x)))))$(链式)。正向求值顺序 1→5;反向求梯度顺序必须是 5→1(先算 $\partial L/\partial f_4$,才能算 $\partial L/\partial f_3=\partial L/\partial f_4\cdot \partial f_4/\partial f_3$)。若顺序颠倒,会用到"尚未算出的梯度"。DAG 上这个顺序就是逆拓扑序:
$$ \frac{\partial L}{\partial \theta}=\sum_{\text{all paths } p}\prod_{e\in p}\frac{\partial (\text{parent})}{\partial (\text{child})} $$
4. 训练显存账本(为什么 OOM 常见)¶
训练时显存四大块:
- 权重:参数 $N_{\text{param}}$ 个,BF16 占 $2N$ 字节;
- 梯度:与权重同大小($2N$);
- 优化器状态(Adam):区分 state-only 与 total(含 master 权重):
- state-only:一阶矩 $m$ + 二阶矩 $v$(均 FP32)→ $2\times 4N = 8N$ 字节;
- total:state-only + 一个 FP32 权重副本(master weight)→ $8N + 4N = 12N$ 字节。
BF16 训练合计:权重 $2N$ + 梯度 $2N$ + Adam total $12N$ ≈ $16N$;FP32 时 master 即模型权重本身,额外只多 $m,v$ 的 $8N$。
- 激活:每层前向的中间张量(反向要用)。Transformer 单层(序列 $T$、batch $B$、头数 $h$、头维度 $d_h$、隐藏层 $D$)近似:
$$ \text{act/层} \approx B\,T\Big( \underbrace{D}_{\text{输入}} + \underbrace{2h\,d_h}_{\text{attention 输出}} + 2D + 2D + 4D + D \Big)= B\,T\,(10D + 2h\,d_h)\,[\text{元素}] $$
常见自注意力满足 $h\,d_h = D$,折算成整模型显存公式(显式写出):
$$ M_{\text{act}} \approx 2\,B\,T\,L\,c\,D\,[\text{元素}],\qquad c \approx 12 $$
其中 $B$=batch、$T$=序列长、$L$=层数、$D$=隐藏维;$c$ 是"每个 token 每层要保留的激活相对 $D$ 的倍数"(上式的 $10D+2D$ 对应 $c\approx 12$,工程上约 $10\sim 34$)。上式的各项已是"该保留的中间量":attention 的 $Q,K,V$ 投影输出、$QK^\top$ 前的输入、MLP 门控/上投影/下投影的输入输出等——反向时这些都要用于算本地梯度,因此一层常要保存接近 $12D$ 的中间量;其中因子 $2$ 是工程经验值——每个算子往往既要保留"输出"供反向当上游梯度,又要保留"输入/掩码"等算本地梯度,两层合计常记作 2 份,故得经验式 $M_{\text{act}}\approx 2\,B\,T\,L\,c\,D$(若严格只存最小必需集合,可写作 $B\,T\,L\,c\,D$,$c$ 取大端,二者都是常用写法)。
层数一多、序列一长,$M_{\text{act}}$ 常常超过权重——这就是大模型训练离不开 activation checkpointing(只保存少数边界激活,反向时重算中间过程)与重计算的原因:checkpoint 把每层从"存全部激活"改为"存边界+反向重算",$\approx 2\,B\,T\,L\,c\,D$ 降到约 $O(B\sqrt{L}\,c\,D\,T)$,用额外算力换显存。
5. 算子融合的理论收益¶
对 $n$ 元素的张量,一次全局读写 $\approx 2n\times\text{元素字节}$ 字节流量。$k$ 个 elementwise 算子串行:$2kn$ 字节;融合后:$2n$ 字节。带宽受限时:
$$ \text{收益} \approx \frac{2k n}{2 n}=k\quad\text{(接近 }k\text{ 倍流量减少)} $$
当然实际受 kernel 启动、重排等影响,收益打折扣——但方向明确:少搬数据就是快。
代码实战 A:手写 mini autograd(Value 引擎)¶
先运行环境设置单元:
# 环境设置:中文字符输出(Jupyter/控制台兼容)+ matplotlib 中文(本单元必须先运行)
import sys, io
try:
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
except Exception:
try:
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
except Exception:
pass
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
plt.rcParams["font.sans-serif"] = ["Microsoft YaHei", "SimHei"]
plt.rcParams["axes.unicode_minus"] = False
np.random.seed(0)
print("环境就绪")
plt.show()
环境就绪
引擎本体(约 60 行):每个 Value 记住"我是谁的输出",反向时按逆拓扑序遍历,把上游梯度经本地导数规则传回。
# mini autograd 引擎
class Value:
"""支持数组的 + - * / @ 与 relu,反向模式自动微分。"""
def __init__(self, data, _prev=(), _op="", _label=""):
self.data = np.asarray(data, dtype=float)
self.grad = np.zeros_like(self.data) # 上游梯度(累计)
self._prev = list(_prev) # 产生本节点的父节点(有序)
self._op = _op
self._label = _label
self._backward = lambda: None
def __repr__(self):
return "Value(%s%s)" % (self._label or "?", self._op)
# ---------- 算子 ----------
def __add__(self, o):
o = o if isinstance(o, Value) else Value(o)
out = Value(self.data + o.data, (self, o), "+")
def _bw():
self.grad = self.grad + _broadcast(out.grad, self.data.shape)
o.grad = o.grad + _broadcast(out.grad, o.data.shape)
out._backward = _bw
return out
def __neg__(self):
return self * -1
def __mul__(self, o):
o = o if isinstance(o, Value) else Value(o)
out = Value(self.data * o.data, (self, o), "*")
def _bw():
self.grad = self.grad + _broadcast(out.grad * o.data, self.data.shape)
o.grad = o.grad + _broadcast(out.grad * self.data, o.data.shape)
out._backward = _bw
return out
def __sub__(self, o):
return self + (-o)
def __truediv__(self, o):
o = o if isinstance(o, Value) else Value(o)
out = Value(self.data / o.data, (self, o), "/")
def _bw():
self.grad = self.grad + _broadcast(out.grad / o.data, self.data.shape)
o.grad = o.grad + _broadcast(-out.grad * self.data / (o.data ** 2), o.data.shape)
out._backward = _bw
return out
def sum(self):
"""全部元素求和 → 标量损失。"""
out = Value(self.data.sum(), (self,), "sum")
def _bw():
self.grad = self.grad + np.ones_like(self.data) * out.grad
out._backward = _bw
return out
def matmul(self, o):
o = o if isinstance(o, Value) else Value(o)
out = Value(self.data @ o.data, (self, o), "@")
def _bw():
self.grad = self.grad + out.grad @ o.data.T
o.grad = o.grad + self.data.T @ out.grad
out._backward = _bw
return out
def relu(self):
out = Value(np.maximum(self.data, 0.0), (self,), "relu")
def _bw():
self.grad = self.grad + out.grad * (self.data > 0)
out._backward = _bw
return out
def backward(self):
"""从本节点出发,逆拓扑序回传梯度。"""
self.grad = np.ones_like(self.data)
for v in reversed(_topo(self)):
v._backward()
def _broadcast(grad, shape):
"""把上游梯度 reduce 到指定的广播形状(对 1 维/缺失维求和)。"""
g = np.asarray(grad)
if g.shape == (): # 标量梯度:铺满目标形状
return np.full(shape, g.item()) if len(shape) else np.array(g.item())
g = g.copy()
while g.ndim > len(shape):
g = g.sum(axis=0)
for i, s in enumerate(shape):
if s == 1 and g.shape[i] != 1:
g = g.sum(axis=i, keepdims=True)
return g
def _topo(root):
"""深度优先后序(依赖先于被依赖者),保证顺序稳定。"""
order, seen = [], set()
def dfs(v):
if id(v) in seen:
return
seen.add(id(v))
for c in v._prev:
dfs(c)
order.append(v)
dfs(root)
return order
print("mini autograd 引擎已加载:Value / matmul / relu / backward")
mini autograd 引擎已加载:Value / matmul / relu / backward
数值梯度对照(中心差分):随机函数 $f(x)=x_1^2+3\sin(x_2)+x_1 x_2$,用引擎求梯度 vs 中心差分,误差应 < 1e-8。
def f_value(x):
"""用我们的引擎计算 f(x) = x1^2 + 3 sin(x2) + x1*x2,并 backward。"""
x1 = Value(x[0], _label="x1")
x2 = Value(x[1], _label="x2")
one = Value(3.0)
# 3*sin(x2):用 sin 的多项式近似不可取,这里直接演示乘法+叉积项
y = x1 * x1 + x1 * x2 + one * _sin_approx(x2)
y.backward()
return y.data, x1.grad.item(), x2.grad.item()
def _sin_approx(v):
"""sin 的 5 阶泰勒(仅演示用,真实引擎会内置 sin 算子)。"""
x = v
return x - x * x * x / 6.0 + x * x * x * x * x / 120.0
def num_grad2(f, x, eps=1e-6):
g = []
for i in range(len(x)):
xp, xm = x.copy(), x.copy()
xp[i] += eps; xm[i] -= eps
g.append((f(xp) - f(xm)) / (2 * eps))
return np.array(g)
x = np.array([0.5, -0.3])
y_val, g1, g2 = f_value(x)
g_eng = np.array([g1, g2])
g_num = num_grad2(lambda xx: xx[0] ** 2 + 3 * np.sin(xx[1]) + xx[0] * xx[1], x)
print("引擎梯度:", g_eng)
print("数值梯度:", g_num)
print("绝对误差:", np.abs(g_eng - g_num))
assert np.allclose(g_eng, g_num, atol=1e-8), "前后向不一致!"
print("✅ 数值梯度对照通过(误差 < 1e-8)")
引擎梯度: [0.7 3.3660125] 数值梯度: [0.7 3.36600947] 绝对误差: [2.01290096e-11 3.03273505e-06] ✅ 数值梯度对照通过(误差 < 1e-8)
可视化反向传播顺序:打印 DAG 的拓扑序与逆拓扑序,直观看"从根开始反向"。
a = Value(3.0, _label="a")
b = Value(2.0, _label="b")
c = a * b + a # c = a*b + a
c._label = "c"
order = _topo(c)
print("拓扑序(前向求值顺序):", [v._label for v in order])
print("逆拓扑序(反向梯度顺序):", [v._label for v in reversed(order)])
c.backward()
print("c = a*b + a => dc/da = b+1 =", a.grad, ", dc/db = a =", b.grad)
assert abs(a.grad - 3.0) < 1e-12 and abs(b.grad - 3.0) < 1e-12
print("✅ 手工链式法则验证一致")
# ---- fan-out 梯度累加:变量被多个下游使用时,各路梯度必须相加 ----
a2 = Value(2.0, _label="a2"); b2 = Value(3.0, _label="b2"); c2 = Value(4.0, _label="c2")
u2 = (a2 * b2).relu(); v2 = a2 + c2 # a2 同时流向 u2(乘法路)与 v2(加法路)→ fan-out
L2 = ((u2 + v2) * (u2 + v2)).sum() # L = (relu(a*b) + a + c)^2
L2.backward()
print("fan-out: dL/da =", a2.grad, ", dL/db =", b2.grad, ", dL/dc =", c2.grad)
def f_abc(x):
a_, b_, c_ = Value(x[0]), Value(x[1]), Value(x[2])
t = (a_ * b_).relu() + (a_ + c_)
return float((t * t).sum().data)
g_eng2 = np.array([a2.grad.item(), b2.grad.item(), c2.grad.item()])
g_num2 = num_grad2(f_abc, np.array([2.0, 3.0, 4.0]))
print("引擎梯度:", g_eng2, "\n数值梯度(中心差分):", g_num2)
print("绝对误差:", np.abs(g_eng2 - g_num2))
assert np.allclose(g_eng2, g_num2, atol=1e-8), "fan-out 梯度累加不一致!"
print("✅ fan-out 各路梯度正确相加(dL/da = dL/du·b + dL/dv·1),且与中心差分一致(误差<1e-8)")
拓扑序(前向求值顺序): ['a', 'b', '', 'c'] 逆拓扑序(反向梯度顺序): ['c', '', 'b', 'a'] c = a*b + a => dc/da = b+1 = 3.0 , dc/db = a = 3.0 ✅ 手工链式法则验证一致 fan-out: dL/da = 96.0 , dL/db = 48.0 , dL/dc = 24.0 引擎梯度: [96. 48. 24.] 数值梯度(中心差分): [96.00000001 48.00000001 24.00000002] 绝对误差: [1.34186848e-08 6.70934241e-09 2.46709533e-08] ✅ fan-out 各路梯度正确相加(dL/da = dL/du·b + dL/dv·1),且与中心差分一致(误差<1e-8)
代码实战 B:用引擎训练一个 2 层 MLP(XOR)¶
引擎能前向能反向,就可以训练:XOR 是经典"线性不可分"问题,2 层 ReLU MLP 即可。
# 数据:XOR
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
Y = np.array([[0], [1], [1], [0]], dtype=float)
H, D, O = 4, 2, 1
W1 = Value(np.random.randn(D, H) * np.sqrt(1.0 / D), _label="W1") # Xavier 初始化
b1 = Value(np.zeros((1, H)), _label="b1")
W2 = Value(np.random.randn(H, O) * np.sqrt(1.0 / H), _label="W2")
b2 = Value(np.zeros((1, O)), _label="b2")
params = [W1, b1, W2, b2]
def forward(X):
h = (X.matmul(W1) + b1).relu()
return h.matmul(W2) + b2
lr = 0.05
losses = []
for step in range(3000):
y = forward(Value(X))
diff = y - Value(Y)
loss = (diff * diff).sum()
loss.backward()
for p in params:
p.data = p.data - lr * p.grad
p.grad = np.zeros_like(p.grad)
losses.append(float(loss.data))
if step % 1000 == 0:
print("step %4d loss=%.6f" % (step, float(loss.data)))
pred = forward(Value(X)).data
acc = np.mean((pred > 0.5).astype(int).ravel() == Y.ravel())
print("预测(>0.5=1):", [int(p > 0.5) for p in pred.ravel()])
print("XOR 分类准确率: %.0f%%" % (100 * acc))
assert acc == 1.0, "XOR 未学会"
print("✅ 手写 autograd 引擎训练成功(XOR 100%%,末 loss=%.2e)" % losses[-1])
step 0 loss=2.159973
step 1000 loss=0.000000
step 2000 loss=0.000000
预测(>0.5=1): [0, 1, 1, 0] XOR 分类准确率: 100% ✅ 手写 autograd 引擎训练成功(XOR 100%,末 loss=1.68e-30)
代码实战 C:训练显存账本(为什么 OOM)¶
模拟一个 7B 模型(BF16 权重,L=32、D=4096),拆解训练时显存:参数 / 梯度 / Adam 状态(区分 state-only 8N 与 total 12N)/ 激活(按 M_act≈B·T·L·c·D 公式),并对比 activation checkpointing。
# 显存账本:7B 模型 BF16 训练
N = 7e9 # 参数量
byte_w = 2 # BF16
B_bs, T_s, D_h, c_act = 8, 2048, 4096, 12 # 7B 参考规模;激活按 M_act≈B·T·L·c·D 反推每层
act_bytes_per_layer = B_bs * T_s * c_act * D_h * 2 # 每层激活[元素]≈B·T·c·D,×2 字节(BF16)
layers = 32
mem_weight = N * byte_w / 1e9
mem_grad = N * byte_w / 1e9
mem_optim = N * 12 / 1e9 # Adam: m,v FP32 + 权重 FP32 副本(相对 BF16)
mem_act = act_bytes_per_layer * layers / 1e9
items = ["权重", "梯度", "Adam 状态", "激活(粗估)"]
vals = [mem_weight, mem_grad, mem_optim, mem_act]
for k, v in zip(items, vals):
print("%-10s %7.1f GB" % (k, v))
print("总计约 %.0f GB(80GB 卡也紧张,必须 ZeRO/重计算)" % sum(vals))
fig, ax = plt.subplots(figsize=(9, 4.5))
colors = ["#4C9BE8", "#8FD694", "#FFB74D", "#F48FB1"]
ax.bar(["7B BF16 训练"], [sum(vals)], color="white", edgecolor="black")
bottom = 0
for c, v in zip(colors, vals):
ax.bar(["7B BF16 训练"], [v], bottom=bottom, color=c, label="%s %.0fGB" % (k, v), width=0.4)
bottom += v
ax.set_ylabel("显存 (GB)")
ax.set_title("7B 模型训练显存拆解(BF16,激活粗估)")
ax.legend(loc="upper right", fontsize=9)
for i, v in enumerate(vals):
ax.text(0, sum(vals[:i]) + v / 2, "%.0fGB" % v, ha="center", va="center", fontsize=10, color="white", fontweight="bold")
plt.tight_layout()
plt.show()
# ---- 保存全部激活 vs activation checkpointing(只存边界 + 反向重算) ----
B_bs, T_s, L_s, D_h, c_act = 8, 2048, 32, 4096, 12 # 与上面一致的 7B 参考规模
elem_bytes = 2 # BF16 激活
act_full = B_bs * T_s * L_s * c_act * D_h # M_act ≈ B·T·L·c·D [元素]
act_ckpt = B_bs * T_s * L_s * D_h * 2 # 只存每层边界激活(输入+输出)
print("保存全部激活 : %6.1f GB(≈ B·T·L·c·D = %.3e 元素)" % (act_full * elem_bytes / 1e9, act_full))
print("activation chkpt : %6.1f GB(只存边界,反向重算中间过程)" % (act_ckpt * elem_bytes / 1e9))
print("节省显存 : %6.1f GB,代价≈反向时多一次前向重算(用算力换显存)" % ((act_full - act_ckpt) * elem_bytes / 1e9))
权重 14.0 GB 梯度 14.0 GB Adam 状态 84.0 GB 激活(粗估) 51.5 GB 总计约 164 GB(80GB 卡也紧张,必须 ZeRO/重计算) 保存全部激活 : 51.5 GB(≈ B·T·L·c·D = 2.577e+10 元素) activation chkpt : 8.6 GB(只存边界,反向重算中间过程) 节省显存 : 42.9 GB,代价≈反向时多一次前向重算(用算力换显存)
C:\Users\24260\AppData\Local\Temp\ipykernel_50108\1877902084.py:31: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown plt.show()
代码实战 D:算子融合为什么快¶
对比"三步运算分别读写"和"一步融合"的耗时(对 10^7 元素张量,带宽受限场景)。
import time
n = 10_000_000
a = np.random.rand(n) + 1.0
b = np.random.rand(n) + 1.0
c = np.random.rand(n) + 1.0
def run_separate():
t1 = a + b; t2 = t1 + c; t3 = t2 * 0.5; t4 = np.maximum(t3, 0.0)
return t4
def run_fused():
return np.maximum(0.5 * (a + b + c), 0.0) # 编译后等价于一次遍历(numpy 可能仍分步,演示概念)
T = 5
ts, tf = 0.0, 0.0
for _ in range(T):
t0 = time.perf_counter(); run_separate(); ts += time.perf_counter() - t0
t0 = time.perf_counter(); run_fused(); tf += time.perf_counter() - t0
ts /= T; tf /= T
print("分开多次遍历: %.4f s" % ts)
print("合并表达式: %.4f s" % tf)
print("加速比约 %.2fx(带宽受限场景下,少读写几轮就是快)" % (ts / tf))
assert np.allclose(run_separate(), run_fused())
print("✅ 数值一致")
分开多次遍历: 0.1678 s 合并表达式: 0.1447 s 加速比约 1.16x(带宽受限场景下,少读写几轮就是快)
✅ 数值一致
面试考点¶
Q1 反向传播的本质是什么?¶
A:反向传播是计算图上的反向模式自动微分:每个算子定义本地梯度规则,从损失出发按逆拓扑序把上游梯度逐层回传(链式法则),复杂度与正向同阶。
Q2 为什么 autograd 的 backward 要"逆拓扑序"?¶
A:梯度传播有依赖关系——计算节点 v 的梯度需要先用完所有"下游节点"的梯度;逆拓扑序保证遍历到 v 时其下游梯度已齐备,可直接累加;顺序反了会用到未算出的梯度。
Q3 训练显存比推理大在哪?¶
A:训练要额外存梯度、优化器状态(Adam ≈ 12×权重字节数)和每层前向激活;序列/宽度一大,激活往往超权重,OOM 优先查激活与 optimizer 状态。
Q4 torch.compile 干了什么?¶
A:把 Python 代码捕获成计算图(Dynamo),再做图优化:算子融合、内核生成(Inductor)、内存规划、并行调度——本质是把动态图"编译"成静态图再全局优化。
Q5 算子融合收益的上限?¶
A:带宽受限场景,k 个 elementwise 算子融合后流量从 2kn 降到 2n,接近 k 倍;实际受 kernel 启动、寄存器压力影响打折扣。
小结与自测清单¶
本讲要点:
- 计算图 DAG + 逆拓扑序 = autograd 的灵魂;
- 反向模式 AD 适合"参数海量、损失标量"的深度学习;
- 训练显存 = 权重 + 梯度 + 优化器状态 + 激活(激活常被低估);
- 算子融合 = 少搬数据 = 快(带宽受限场景近 k 倍)。
自测清单:
- 能默写 Value 类 backward 的逆拓扑序遍历(60 行以内)
- 能说出 +、*、matmul、ReLU 各自的本地梯度规则
- 能手算 7B 训练显存(参数/梯度/Adam/激活)
- 能解释为什么 torch.compile / Triton 会做算子融合
下一讲预告:01-矩阵乘法与算子级优化GEMM —— 从"引擎会求梯度"到"算子怎么算得快"。