计算图:PyTorch 怎么记住每一步

上一章看到 y.backward() 能自动算出梯度。这一章拆开看它是怎么做到的。

先看一个反常的现象

import torch x = torch.tensor([2.0], requires_grad=True) y = x * 3 z = y * y print(y.grad_fn) # <MulBackward0 object> print(z.grad_fn) # <MulBackward0 object>

y 和 z 都"记得"自己是怎么算出来的。

这就是计算图:每个张量都存着一条链,指向产生它的运算,以及那个运算的输入。

链条是怎么搭起来的

上面只看到一个 grad_fn。把运算拆成多步,就看得出它是一条链。

x = torch.tensor([2.0], requires_grad=True) a = x * 2 # a ← MulBackward0,输入是 x b = a + 1 # b ← AddBackward0,输入是 a c = b ** 2 # c ← PowBackward0,输入是 b print(c.grad_fn) # PowBackward0 print(c.grad_fn.next_functions) # ((<AddBackward0>, 0),)

顺着 grad_fn 一路往回走,就回到了 x:

c → PowBackward0 → AddBackward0 → MulBackward0 → x

这条链就是计算图。它在前向计算的时候顺手搭出来,不需要你写任何额外代码。

为什么要建图

因为求导要用链式法则:dc/dx = dc/db · db/da · da/dx。

要从输出往回走一遍,每一步乘上那一层的局部导数。图就是"往回走"的路线。

只有 requires_grad=True 才建图

既然建图有开销,PyTorch 默认就不建。要显式打开。

a = torch.tensor([1.0]) # 不建图 b = torch.tensor([2.0], requires_grad=True) # 建图 print(a.grad_fn) # None print(b.grad_fn) # None ← 它自己是叶子 c = a * b print(c.grad_fn) # <MulBackward0> 只要有一个要,结果就要

概念

含义

叶子张量

自己造出来的(torch.tensor(...)),grad_fn 是 None

非叶子

运算产生的,grad_fn 指向那个运算

is_leaf

判断是不是叶子

x = torch.tensor([1.0], requires_grad=True) y = x * 2 x.is_leaf # True ← 只有叶子会积累 .grad y.is_leaf # False ← 非叶子的 grad 默认不留 y.retain_grad() # 手动让它留

只有叶子的 grad 会留下

backward() 之后,x.grad 有值,y.grad 是 None。

因为模型要学的是参数,参数都是叶子。中间结果的梯度算完就扔,省内存。

图是动态的

到这里你可能会问:这张图什么时候销毁?答案是每轮训练结束就扔。

"动态图"的意思是:每次前向都重新搭一张图,用完就扔。

for epoch in range(3): x = torch.tensor([1.0], requires_grad=True) y = (x * 2).sum() y.backward() print(epoch, x.grad)

每一轮都是新的 x、新的图。这意味着:

好处

说明

能写 if / for

图随代码形状变化,不用预先声明

好调试

可以 print、可以断点

不用手写反向

只需要写前向

代价是每轮都要重新建图,有一点开销。相比计算本身可以忽略。

梯度会累积

图是动态的,但梯度不是——它留在张量上,而且会越加越多。

这是一个必须知道的机制:

x = torch.tensor([1.0], requires_grad=True) (x * 2).backward() print(x.grad) # tensor([2.]) (x * 2).backward() print(x.grad) # tensor([4.]) ← 累加了!不是覆盖

训练循环里必须清零

backward() 是累加梯度,不是覆盖。

所以每一轮训练开头必须:

optimizer.zero_grad() # 清空所有参数的 grad loss.backward() # 算这一轮的梯度 optimizer.step() # 更新参数

忘了清零,梯度会一直累加,模型越训越离谱,而且不报错。

一张图看清

x ──► a = x*2 ──► b = a+1 ──► c = b**2 ──► loss │ ◄──── 反向传播 ◄──────────┘ dc/dx = 2b · 1 · 2

前向:数据从左往右流,同时记下每一步用的什么运算。

反向:沿着记下的链从右往左走,每步用链式法则乘上局部导数。

下一课

图知道了,下一课看 backward() 具体返回什么、.grad 里存的是什么、以及怎么只对某些输入求导。