PyTorch自动求导背后到底发生了什么

可视化演示

计算图机制：一张会“自我销毁”的配方单

烘焙工坊的墙上贴着一张不断生长的配方流水单。师父把面粉和糖倒进搅拌盆，流水单上立刻多一行“面粉、糖 → 面糊”；把面糊送进烤箱，又多一行“面糊 → 蛋糕胚”。每次运算，流水单就长一截，把“谁变成了谁”记得清清楚楚。这张不断生长的流水单，就是 autograd 的计算图（Computational Graph）。

在 PyTorch 里，计算图是记录张量运算关系的有向无环图（DAG）。图的节点是张量（食材），边是运算产生的依赖关系。因为 PyTorch 采用动态建图——代码跑一行，图就长一节——所以你在 if、for 里写的任何控制流都会被如实记进图里，灵活得像师父随手调整配方。这也是 PyTorch 与“先建图后执行”的静态图框架最大的区别。

每次对张量做运算时，PyTorch 会检查输入是否 requires_grad=True：如果要追溯，它就创建一个记录运算类型的节点，并给输出张量挂上 grad_fn 属性——相当于配方单上那行“本食材由什么加工而来”的小字。前向传播结束、调用 backward() 时，autograd 从输出节点出发，沿 grad_fn 反向遍历整张图，一路把梯度传回叶子节点。有个关键细节：一次 backward() 后图会被自动释放，省内存，但也意味着不做设置就不能连续两次 backward()——除非你留下 retain_graph=True 这张“存根”。

把计算图看成一串嵌套的加工函数，正向传播就是一路套下去；反向传播则像沿着这串加工记录倒着查账。一张动态生长、用完即焚的配方单，就是 autograd 记账的起点。

---

Tensor 追踪：给食材贴上溯源标签

工坊里不是所有食材都要被追责。这包“现成奶油霜”是外面买来的，它的配方不属于工坊，出了问题怪不到工坊头上；而自己打发的淡奶油就不同，每一克糖都要被记录。在 PyTorch 里，“要不要记这一笔”由 requires_grad 开关决定。

张量创建时可以设置 requires_grad=True，表示“请追踪我的所有运算，将来要算我的梯度”。这相当于给食材贴上溯源标签。反向传播只把梯度算给贴了标签的张量。默认情况下，只有叶子节点（leaf tensor）——即用户直接创建的、没参与过任何运算的张量——会被单独要求追踪；由运算产生的新张量，是否追溯由输入决定。更妙的是 requires_grad 有传播性：只要输入中有一个需要梯度，输出张量就自动变成“需要追踪”。就像一道菜里只要用了需要追责的食材，整道菜都要被记账。

用 is_leaf 可以查询一个张量是不是叶子。普通张量的 grad 属性默认是 None；只有在 requires_grad=True 且参与反向传播后，grad 才会被填上梯度。非叶子节点默认不保存梯度（省内存），除非用 retain_grad() 显式保留。师父心里清楚：只有“买进来的原料”才值得长期记台账，中间产物用完即丢。

---

反向传播：从蛋糕倒推调料配比

蛋糕被评委打了 4.2 分的低分，师父要改进配方。他不会把整个蛋糕扔进垃圾桶重来，而是从分数倒推：蛋糕太甜 → 裱花的糖霜出了问题 → 糖霜里的糖放多了。每一步只问一件事：“这一步的变化，按什么比例影响下一步？”把这些比例一路乘起来，就得到每个原料该负多少责任——这就是反向传播（backpropagation）。

反向传播的数学底座是链式法则。假设损失 $L$ 先算到中间量 $y$，$y$ 再由输入 $x$ 算出，那么 $L$ 对 $x$ 的导数等于两段导数的乘积。autograd 干的活，就是把这条规则自动套用到计算图的每条边上：从输出节点开始，按拓扑序的逆序，把上游梯度乘上每步局部导数，一层层传回叶子。

调用 backward() 触发整个旅程。对标量损失直接 loss.backward()；如果损失不是标量，需要显式传入一个与输出同形状的“上游梯度”权重。梯度在图中沿边流动时遵循“多路径相加”原则：如果一个张量被两条路径影响，它的梯度是两条路径梯度之和。这保证了梯度在 DAG 上的守恒，也解释了为什么“分叉再汇合”的模型结构会影响梯度分布。

---

梯度管理：攒批评意见也是一门学问

师父试做分批次进行：星期一做 4 个蛋糕，把评委意见记在小本本上；星期二再做 4 个，继续把意见累加进同一页；一周攒齐 100 条意见，才统一调一次配方。这在训练里叫梯度累加（gradient accumulation）。但小本本如果一直不擦，下一轮的批评会记在旧账上，配方周周错上加错——所以每轮结束必须清零账本。

PyTorch 中张量的 grad 是累加的：连续多次调用 backward()，梯度会不断往上加。这本质是特性：小数据集上可以模拟大 batch，或者用梯度累积省显存。但代价是，如果训练循环里忘了 optimizer.zero_grad()，第二次 backward() 的梯度就叠在第一次上面，参数更新被“两次梯度之和”误导，表现为 loss 震荡、不收敛。

标准训练循环四步是：zero_grad()（清空旧账）→ forward()（做蛋糕）→ loss.backward()（记批评）→ optimizer.step()（改配方）。此外还有两个记忆点：backward(retain_graph=True) 表示“查完账先别撕流水单”，方便在同一张图上再次反向传播，在梯度累加和复杂模型调试中很常用，代价是内存上升；默认“用完即焚”则是内存优化——图不保留，中间节点梯度也不保留。

---

推理模式：不需要追溯的“快速出餐”

周一的品鉴会来了很多客人，师父连做 50 个蛋糕摆上柜台，客人们只在意好不好吃，没人关心配方怎么调——这时候再记账就是纯粹浪费纸笔。于是师父宣布：“本时段免记账。”这就是 no_grad 模式：出餐速度拉满，厨余账本干干净净。

模型训练完进入推理或评估阶段，只需要前向传播输出预测，不需要反向传播更新参数。用 torch.no_grad() 包住推理代码，会全局关闭计算图构建和 requires_grad 传递，省内存又加速。注意它与 requires_grad=False 不同：后者只是某一块食材不贴标签，而 no_grad 是整个厨房临时进入“免记账”状态。

另一个常用工具是 tensor.detach()：它返回一个与原来共享数据但 requires_grad=False 的新张量，相当于“复印一份配方，但复印件上不写原料来源”。这适合把某一步的输出摘出来另作他用，比如写日志、画曲线、拼接特征，避免错误梯度。注意 detach 让张量从当前图分离，原图那部分依然存在。

---

自定义算子：发明新工具，还得配说明书

工坊总用超市买的模具，但师父心血来潮，自己 3D 打印了一个异形裱花嘴——这就是自定义算子。新工具用起来很爽，但问题来了：账房先生（autograd）不认识这个新工具，不知道“过这个裱花嘴，责任该怎么分摊”。所以师父必须为它单独写一份“说明书”：正向时食材怎么变成成品，反向时不满意度怎么按比例退给每个原料。

PyTorch 允许继承 torch.autograd.Function 来自定义带梯度计算的操作。你需要实现两个静态方法：forward(ctx, *inputs) 定义正向运算；backward(ctx, *grad_output) 定义反向传播时要返回的梯度。ctx 像师徒间的小纸条——正向时把中间结果用 ctx.save_for_backward() 存下来，反向时拿出来算梯度。这就是 autograd 对自定义算子的要求：你不但要会做蛋糕，还要说清楚怎么倒查。

调用自定义算子时用 Function.apply()，它会负责建立计算图节点、管理上下文。假设自定义算子 $y = f(x)$，反向时传入的 grad_output 是上游梯度 $\bar{y}$，backward 要返回 $\bar{x} = \bar{y} \cdot f'(x)$。对多输入算子，backward 要返回与输入同样数量的梯度张量；不需要梯度的输入返回 None 即可。很多底层算子（如矩阵乘法、卷积）内部都有高效的手写 backward：通用 autograd 图能拼装，但手工展开永远性能更高。

---

AI 应用场景

Python 演示

class Value:    """A tiny tensor that supports autograd."""     def __init__(self, data, _children=(), _op=''):        self.data = data        self.grad = 0.0        self._prev = set(_children)        self._op = _op        self._backward = lambda: None     def __add__(self, other):        other = other if isinstance(other, Value) else Value(other)        out = Value(self.data + other.data, (self,), '+')        def _add_backward():            self.grad += 1.0 * out.grad            other.grad += 1.0 * out.grad        out._backward = _add_backward        return out     def __mul__(self, other):        other = other if isinstance(other, Value) else Value(other)        out = Value(self.data * other.data, (self,), '*')        def _mul_backward():            self.grad += other.data * out.grad            other.grad += self.data * out.grad        out._backward = _mul_backward        return out     def relu(self):        out = Value(max(self.data, 0.0), (self,), 'relu')        def _relu_backward():            self.grad += (1.0 if self.data > 0 else 0.0) * out.grad        out._backward = _relu_backward        return out     def backward(self):        topo, visited = [], set()         def build_topo(v):            if v not in visited:                visited.add(v)                for child in v._prev:                    build_topo(child)                topo.append(v)         build_topo(self)        self.grad = 1.0        for node in reversed(topo):            node._backward()  def train_one_step():    x = Value(2.0)   # input feature    w = Value(3.0)   # weight    b = Value(1.0)   # bias    out = (x * w + b).relu()    out.backward()    print("out=%.2f grad_x=%.2f grad_w=%.2f grad_b=%.2f"          % (out.data, x.grad, w.grad, b.grad))  if __name__ == '__main__':    train_one_step()

1. self.grad = 0.0每个张量初始背着的责任为零，等反向传播来填。
2. out = Value(self.data + other.data, (self,), '+')前向算结果，同时把“孩子”和运算类型写进配方单。
3. self.grad += 1.0 * out.grad加法反向：把上游责任原样转给两个孩子。
4. self.grad += other.data * out.grad乘法反向：用“对方的值”当敏感系数。
5. topo.append(v)拓扑排序：保证反向时先处理靠后的节点。
6. order.reverse(); order = list(reversed(topo))用逆拓扑序逐节点派发责任，这就是反向传播。
7. for node in reversed(topo): node._backward()autograd 的 backward() 本质就是这一行循环。
8. x = Value(2.0)叶子节点，模拟训练输入。

常见误区

面试题