← PyTorch From First Principles

Autograd:PyTorch 记录了什么,梯度断在哪里?

跟踪 PyTorch 执行时构建的动态 autograd 图,区分叶张量与中间张量,检查 grad_fn、detach、no_grad、保留梯度与图生命周期,找到预期损失到参数依赖消失的第一条边。

这里有个双参数训练循环。它能跑,不警告,损失归零。

import torch

x = torch.tensor([1.0, 2.0, 3.0, 4.0])
target = torch.tensor([3.0, 6.0, 9.0, 12.0])

w1 = torch.tensor(0.5, requires_grad=True)
w2 = torch.tensor(1.0, requires_grad=True)
params = [w1, w2]

feature_log = []

def stage_one(t):
    f = w1 * t
    detached = f.detach()          # keep the values for later inspection
    feature_log.append(detached)
    return detached

learning_rate = 0.02

for step in range(400):
    f = stage_one(x)
    prediction = w2 * f
    loss = ((prediction - target) ** 2).mean()

    loss.backward()

    with torch.no_grad():
        for p in params:
            if p.grad is not None:
                p -= learning_rate * p.grad
                p.grad.zero_()

    if step in (0, 9, 99, 399):
        print(f"step={step:3d} loss={loss.item():.6f} "
              f"w1={w1.item():.4f} w2={w2.item():.4f}")
step=  0 loss=46.875000 w1=0.5000 w2=1.3750
step=  9 loss=11.521060 w1=0.5000 w2=3.7071
step= 99 loss=0.000009 w1=0.5000 w2=5.9979
step=399 loss=0.000000 w1=0.5000 w2=6.0000

按第 1 章教的读列。损失降到零,这是我们要的结果。而 w1 从不动。不是慢,不是一点点:四百步保持 0.5000,w2 爬到正好 6.0,即让 w1 * w2 等于要学的 3 的值。一半模型冻住,另一半干了全部活,目标反正满足了。

第 1、2 章给的检查都说这个程序没问题。三个阶段都在,都在执行:前向跑了,backward() 跑了,更新跑了。每个形状都该是什么形状,没有广播乱跑,dtype 与设备都没问题。没有异常可读,没有 traceback 误导。

出问题的证据在还没学会看的位置:

print("w1.grad:", w1.grad)
print("w2.grad:", w2.grad)
w1.grad: None
w2.grad: tensor(0.)

w2 有梯度。w1 完全没有梯度,从来没有,这就是更新循环四百次悄悄跳过它的原因。所以 backward() 在 w1 参与算出的损失上被调用了,w1 什么都没收到。

这就是本章主题。当那些张量算子执行时,PyTorch 在数值旁边还建了第二样东西:一份哪些算子产出哪些结果的记录,足够事后对整个计算求导。loss.backward() 遍历这份记录。当梯度缺失、陈旧或去了没想的地方,解释几乎总在记录的结构里,而不是算术里。

本章回答的问题是:

前向时 PyTorch 到底记下什么,反向时它如何变成梯度,参数到损失的通路可以在哪里无声消失?

读完,你应该能看一段没见过的计算,说出哪些张量参与 autograd,连接在哪,.grad 在哪被填、在哪不会,以及梯度缺失时找到参数与损失断开的确切算子。

稍后我们会回来,用证据而不是猜测修这个循环。

前向写下了什么

从比任何真实模型都小的地方开始,组合短到能纸上求导。

w = torch.tensor(2.0, requires_grad=True)
x = w * 3
y = x ** 2

三张量,两算子。跑之前先算出导数该是什么。代入,y = (3w)² = 9w²,所以 dy/dw = 18w,在 w = 2 为 36。记住这个数,要拿它核对 PyTorch。

再看三张量带着什么。第 2 章的 describe 管形状、dtype、设备与步长。本章需要另一组属性,对应版本如下:

def describe(name, t):
    print(f"{name:<6} value={t.item():<8.3f} "
          f"requires_grad={str(t.requires_grad):<5} "
          f"is_leaf={str(t.is_leaf):<5} "
          f"grad_fn={type(t.grad_fn).__name__ if t.grad_fn is not None else 'None'}")

describe("w", w)
describe("x", x)
describe("y", y)
w      value=2.000    requires_grad=True  is_leaf=True  grad_fn=None
x      value=6.000    requires_grad=True  is_leaf=False grad_fn=MulBackward0
y      value=36.000   requires_grad=True  is_leaf=False grad_fn=PowBackward0

三个属性,各回答一个问题。

requires_grad 回答反向 autograd 是否需要跟踪该张量求梯度。我们在 w 上显式置了它。在普通 grad 模式下,结果依赖至少一个需要梯度的张量的可微算子,通常产出也需要梯度的结果。

这个传播不是无条件的。torch.no_grad() 与 torch.inference_mode() 等梯度模式能压住记录,有些算子产出不可微。好用的规则是:把 requires_grad 当记录下来的可微通路的证据,而不是假定它穿过每个算子。

is_leaf 需要更精确的规则。对 requires_grad=True 的张量,叶是没有被 autograd 记录的算子产出的。w 是叶,算出的 x、y 不是。

requires_grad=False 的张量按约定算叶,即使它们是普通张量算子的结果。所以 is_leaf 不是“创建而非算出”的同义词,也不是“可训练”的同义词。它在这里最有用的角色是告诉我们 autograd 通常会不会把请求的梯度累积进这个张量的 .grad。

grad_fn 回答哪个算子产出这个值,怎么对它求导?MulBackward0 是知道如何把对 x 的梯度变成对乘法输入梯度的对象。w 没有,因为没记录产出过它。

这三个属性按此顺序,是 autograd 出乎意料时先打印的东西。本章剩下大半是学会读它们。

记录是能走的真实对象

grad_fn 不是标签。它是图里的节点,每个节点经 next_functions 知道前驱:

print(y.grad_fn)
print(y.grad_fn.next_functions)
print(y.grad_fn.next_functions[0][0].next_functions)
<PowBackward0 object at 0x7f3c4b438130>
((<MulBackward0 object at 0x7f3c4b438040>, 0),)
((<AccumulateGrad object at 0x7f3b924e6140>, 0), (None, 0))

从上往下读。产出 y 的节点是幂。它的唯一前驱是产出 x 的乘法。乘法有两个前驱,因为乘法有两个操作数:一个是 AccumulateGrad,另一个是 None。None 是常量 3,不需要梯度,无处可送。

AccumulateGrad 是有意思的那个,值得走一遍结构看它坐在哪。短递归打印就够:

def show_graph(fn, depth=0):
    if fn is None:
        return
    indent = "  " * depth
    name = type(fn).__name__
    if name == "AccumulateGrad":
        print(f"{indent}{name} -> leaf tensor, value {fn.variable.item()}")
    else:
        print(f"{indent}{name}")
    for nxt, _ in fn.next_functions:
        show_graph(nxt, depth + 1)

show_graph(y.grad_fn)
PowBackward0
  MulBackward0
    AccumulateGrad -> leaf tensor, value 2.0

这就是记录,打印出来了。形状正好是我们写的计算的反向:平方,然后乘法,然后一个负责把到达的梯度加进叶张量 .grad 的节点。而它真是我们的叶张量,不是拷贝:

accumulate = y.grad_fn.next_functions[0][0].next_functions[0][0]
print("AccumulateGrad.variable is w:", accumulate.variable is w)
AccumulateGrad.variable is w: True

这一行比任何图的比喻都值钱。对普通需要梯度的叶张量,AccumulateGrad 就是 autograd 把到达的梯度累积进 .grad 的节点。

这不意味着每个被填的 .grad 都对应 AccumulateGrad 节点。非叶张量也能用 retain_grad() 被要求保留梯度。区别是叶梯度累积默认发生,保留中间梯度是显式请求的。

这个 walker 不会常写。写一次,在结构已知的计算上写,“PyTorch 建图”就从断言变成见过的东西。

backward() 拿它做什么

现在跑反向,与纸上 36 对照:

y.backward()
print("w.grad:", w.grad.item())
w.grad: 36.0

三件事,值得分开,因为不同失败影响不同件。

选了起始梯度。 反向需要种子:输出对自己的导数。标量输出是 1.0,PyTorch 给。非标量输出没有唯一显然的种子,所以它拒绝:

v = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
z = v ** 2
z.backward()
RuntimeError: grad can be implicitly created only for scalar outputs

可以自己给种子,偶尔这是最清楚的提问方式:

z.backward(torch.ones_like(z))
print(v.grad)
tensor([2., 4., 6.])

backward() 的参数是用在雅可比-向量积里的向量,也可以当调查工具。只给一个输出元 1.0 其余 0.0,就隔离了该输出元的贡献。

大多数标准训练循环先把目标缩成标量再调 backward(),种子可自动推断。输出非标量时,检查其形状,明确决定你要 PyTorch 算什么向量-雅可比积。

按序访问了节点。 从 loss.grad_fn 出发,autograd 走记录,每节点把从上方到达的梯度用该算子的局部导数处理。这就是链式法则,一次一个算子。对我们的计算:

dy/dy = 1
dy/dx = 2x  = 12          (PowBackward0)
dy/dw = 12 × 3 = 36       (MulBackward0, whose local derivative is 3)

不需要构造 dy/dw 的整体符号表达式。每个反向节点实现其算子的局部求导规则,autograd 遍历时把局部结果数值复合。

Transformer 里单个算子显然大得多、贵得多,但求导原理不变:局部反向规则复合成完整计算的梯度。

结果累积进叶。 遍历止于 AccumulateGrad 节点,每个把到达的梯度加进对应张量的 .grad。第 1 章从外面观察到这个行为:梯度每轮变大直到调 zero_()。现在能看到负责的节点。

梯度贡献为何相加

第 1 章解释了跨多次 backward() 的累积。梯度相加还有第二个更根本的原因,来自同一节点。

让 w 有两条到损失的路:

w = torch.tensor(2.0, requires_grad=True)

a = 3 * w
b = w ** 2
loss = a + b

show_graph(loss.grad_fn)
AddBackward0
  MulBackward0
    AccumulateGrad -> leaf, value 2.0
  PowBackward0
    AccumulateGrad -> leaf, value 2.0

两条路离开加法,都到达叶。手求导:loss = 3w + w²,所以 dloss/dw = 3 + 2w,在 w = 2 为 7。

loss.backward()
print("w.grad:", w.grad.item())
w.grad: 7.0

两条路贡献 3 与 4,总和是和。这不是 PyTorch 对分支的特殊规则;是变量经多条路影响结果时链式法则说的事。而机制在上面打印里可见,只要检查两个 AccumulateGrad 行是一个节点还是两个:

left = loss.grad_fn.next_functions[0][0].next_functions[0][0]
right = loss.grad_fn.next_functions[1][0].next_functions[0][0]
print("same AccumulateGrad node:", left is right)
same AccumulateGrad node: True

一个节点,被到达两次。每次遍历把贡献加进同一 .grad。

这统一了分开看似无关的两件事。残差分支加总的梯度、共享嵌入每处用到的位置加总的梯度、两次没清零的反向加总的梯度——都是同一节点做同样的加法。这也是 zero_grad() 重要且是你的责任的原因:PyTorch 分不出“这两个贡献属于同一步”与“上一步梯度没清”。

第 2 章的广播是值得认出的特例。当 (1, 128) 操作数对 (32, 128) 广播,同样的值参与结果 32 行,反向把 32 份贡献加总回原形状。当广播沿一维或多维扩展了操作数,反向沿扩展维对相应梯度求和,缩回操作数原形状。平均来自计算里别的算子,比如后面的 .mean()。

算出来不等于留下来

回到第一个例子,问中间量的梯度:

w = torch.tensor(2.0, requires_grad=True)
x = w * 3
y = x ** 2
y.backward()

print("w.grad:", w.grad)
print("x.grad:", x.grad)
w.grad: tensor(36.)
x.grad: None
UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being
accessed. Its .grad attribute won't be populated during autograd.backward(). If you
indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad()
on the non-leaf Tensor.

这产出一个具体而常见的错误结论:x.requires_grad 是 True,x 明明参与计算,backward() 跑了,而 x.grad 是 None,所以反向一定哪里坏了。

什么都没坏。导数 dy/dx 算了——必须算,因为 PowBackward0 交给 MulBackward0 的就是它,没有它 w.grad 不存在。算了,用了,丢了。x 背后没有 AccumulateGrad 节点,无处可存。

精确记住这个区分,大量困惑塌到它上面:

反向中算出梯度与在张量 .grad 字段留下梯度是两件事。路径上每个张量都参与前者。默认只有需要梯度的叶张量参与后者。

要看中间梯度就说出来:

w = torch.tensor(2.0, requires_grad=True)
x = w * 3
x.retain_grad()
y = x ** 2
y.backward()

print("x.grad:", x.grad.item(), " w.grad:", w.grad.item())
x.grad: 12.0  w.grad: 36.0

12 是 x = 6 处的 2x,正是上面链式跟踪预测的数。retain_grad() 没改变算了什么。它给本来穿堂而过的值接了存储。

就该这么想,它也告诉你怎么用。retain_grad() 是仪器,不是设置。有用的问题从来不是“这里该不该 retain”,而是:

为了区分我正在考虑的解释,我需要观察哪个导数?

那就只 retain 那一个。大模型里到处 retain 中间梯度又费内存又给出一墙数字而不是答案。

两种替代值得知道,它们以更小扰动回答同类问题。

torch.autograd.grad() 返回梯度而不累积,可以在不动任何 .grad 字段的情况下提问:

w = torch.tensor(2.0, requires_grad=True)
a = w * 3
b = a ** 2

print(torch.autograd.grad(b, a, retain_graph=True)[0].item())
print(torch.autograd.grad(b, w)[0].item())
print("w.grad is still:", w.grad)
12.0
36.0
w.grad is still: None

在活训练循环里调查又不想仪器改变优化器要吃掉的梯度时,就用它。

hook 在梯度经过时观察,不存储:

w = torch.tensor(2.0, requires_grad=True)
u = w * 3
u.register_hook(lambda g: print("gradient flowing into u:", g.item()))
(u ** 2).backward()
gradient flowing into u: 12.0

有意思的事件稀少时 hook 赚回位置——700 步才变非有限的值、大多数 batch 正常、一个 batch 巨大的梯度——因为 hook 能设条件平时沉默。第 11 章会在全模型上这样用。这里要点更窄:边界处的梯度无论有无人存储都存在,hook 就是证明。

通路断在哪

前面讲的都是记录完好的情况。有意思的失败是记录不完好的,而连接不存在的机制只有几种。按证据认出它们,就是 missing gradients 大半的可处理性。

张量从没进来

最简单。没带 requires_grad=True 建的张量没有 AccumulateGrad 节点,除非别的算子把 autograd 带进来,它参与的算子不被记录:

x = torch.tensor([2.0])
y = x * 3
loss = y.sum()
loss.backward()
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

这个响亮,因为全程没参与张量,损失根本没有 grad_fn,backward() 无从开始。第 1 章用不同原因见过同样信息——更新把 w 重绑定到新的非跟踪张量——提醒信息标识的是状态,不是病因。

重要的是信息不出现要什么条件。去损失的路上任一操作数需要梯度,loss.requires_grad 就是 True,backward() 就跑,不管别的算子怎样。需要梯度的损失只说有东西连着,不说你在乎的东西连着。

通路被切:detach()

detach() 返回与原张量同样值、但与产生它的历史断开的张量:

w = torch.tensor([2.0, 3.0], requires_grad=True)
h = w * 3
d = h.detach()

describe_flags = lambda n, t: print(f"{n:<3} requires_grad={t.requires_grad} "
                                   f"is_leaf={t.is_leaf} grad_fn={t.grad_fn}")
describe_flags("h", h)
describe_flags("d", d)
print("same storage:", d.data_ptr() == h.data_ptr())
h   requires_grad=True is_leaf=False grad_fn=<MulBackward0 object at ...>
d   requires_grad=False is_leaf=True grad_fn=None
same storage: True

注意最后一行。detach() 没拷贝任何东西;两张量共享同一内存的值。变的是记录:d 没有 grad_fn,d 下游再也回不到 w。它又是叶了,在从 detach 点开始的计算里。

这个共享有个后果,出乎意料前先知道。经 detach 张量写会改原件:

with torch.no_grad():
    d[0] = 99.0
print("h:", h)
h: tensor([99.,  9.], grad_fn=<MulBackward0>)

如果 h 被某节点为反向存着,这次写会在后面的 backward 调用才报错,而不是这里。本章末尾回到这个机制。

detach() 值得这么多 attention 不是因为它危险。它是合法且经常必要的操作:在不保留上游图的情况下记日志或存值,故意截断梯度通路,或构造不应向产生它的计算传梯度的目标时有用。

对冻结模型参数本身,更直接的机制通常是把那些参数的 requires_grad 置 False。detach 更适合想成某次计算里的边界,而不是冻结模块的通用机制。它值得 attention 是因为它静默失败。detach 下游代码继续产出完全合理的数字。什么都不抛。唯一症状是梯度在上游某处不再到达,而开篇循环说明损失照样可能下降。

所以在不熟悉代码里遇到每个 detach 都要问:

这个边界是故意的吗,它坐的位置是作者以为的位置吗?

区域没被记录:torch.no_grad()

torch.no_grad() 看起来做同样的事,把两者都说成“关掉梯度”是大量不精确调试的来源。它们作用在不同对象上。

detach() 作用于一个张量,切断它与之前反向 autograd 历史的链接。torch.no_grad() 作用于一段代码:在该区域内执行的普通可微张量算子被排除在反向 autograd 图之外。

有个实现细节值得知道,如果你在调不寻常的代码:显式接受 requires_grad 参数的张量工厂函数是 no_grad 的例外,no_grad 也不关前向自动微分。第二个操作数一进来区别就现形:

p = torch.tensor(1.0, requires_grad=True)
q = torch.tensor(2.0, requires_grad=True)

out1 = p.detach() * q
with torch.no_grad():
    out2 = p * q

print("out1:", out1.requires_grad, type(out1.grad_fn).__name__)
print("out2:", out2.requires_grad, out2.grad_fn)
out1: True MulBackward0
out2: False None

detach p 从记录去掉一个操作数,乘法仍被记录因为 q 还在。梯度流向 q 而不流向 p。no_grad 里乘法本身没被记录,两操作数什么都收不到。

还有两条性质值得说清,因为都会被错 assumed。

no_grad 不改它碰的张量。事后 p.requires_grad 仍 True,块外对 p 的算子照常记录。它是块的属性,不是穿过它的值的属性。这正是第 1 章参数更新能用的原因:算术没被记录,w 在另一边仍是可训练叶。

当前状态可直接观察,当你怀疑框架、回调或评估包装把你放进没写的块时重要:

print(torch.is_grad_enabled())

还有 torch.enable_grad(),在 no_grad 区里重开记录,以及更激进的 torch.inference_mode(),产出的张量带着限制走:

w = torch.tensor(2.0, requires_grad=True)
with torch.inference_mode():
    a = w * 3

b = a * w
b.backward()
RuntimeError: Inference tensors cannot be saved for backward. Please do not use
Tensors created in inference mode in computation tracked by autograd.

知道 inference_mode 存在的原因就是这条信息。本书到此提它。推理模式为以后不与 autograd 交互的计算设计。除了 no_grad 还关掉更多 autograd 记账,能带来更多性能好处。代价更严:在推理模式建的张量不能再参与 autograd 要记录的计算。失败在复用的地方浮现,可能离产出它的块很远。no_grad 没这个限制,不带梯度算出的值以后可能进图时,no_grad 是更安全的选择。

值离开了张量系统

.item() 把标量张量的值抽成 Python 数。NumPy 转换是同类边界,但需要梯度的张量通常不能直接 .numpy()。实践里为观察导出值常看到 t.detach().cpu().numpy()。

值一旦离开 autograd 连着的张量计算,用该值重建新张量重建不了产生它的历史:

w = torch.tensor(2.0, requires_grad=True)
prediction = w * 3

bad = torch.tensor((prediction - 6.0).item() ** 2, requires_grad=True)
bad.backward()

print("bad.grad:", bad.grad, " w.grad:", w.grad)
bad.grad: tensor(1.)  w.grad: None

看它产出了什么。backward() 没抱怨跑了。梯度存在。是 bad 对自己的梯度,在只装一个张量的图里,它关于 w 什么都不说。构造里的 requires_grad=True 没重连任何东西;它建了全新的起点。

这是后面反复出现的原则最清楚的小例子:

requires_grad=True 声明从这个张量往前跟踪梯度。它恢复不了到 earlier 计算的连接。

NumPy 往返也一样。PyTorch 里有的算子就留在 PyTorch 里;.item() 与 .numpy() 用来观察,不用来做需要求导的计算。

找到第一条断边

第 2 章核心技术是找第一个错的张量而不是第一个不合法的算子,因为抛错的行常在犯错的行下游。梯度需要同样的移动,改一下:

找到参数到损失的通路停止存在的位置,而不是 .grad 恰好为 None 的行。

这重要是因为两行几乎从不是同一行。w1.grad is None 在你碰巧检查的地方被发现——优化器步、日志行、训练末尾。断裂在记录被切的地方。两者之间一切完好,改那个区域的任何东西都没用。

两个搜索方向,适合不同场景。

往前,从参数出发

给前向打点,看三属性变化。能跑计算、手头有源码时用这个版本:

def track(name, t):
    print(f"{name:<14} requires_grad={str(t.requires_grad):<5} "
          f"is_leaf={str(t.is_leaf):<5} "
          f"grad_fn={type(t.grad_fn).__name__ if t.grad_fn is not None else 'None'}")
    return t

用在开篇循环,一步,展平写出让每个中间可见:

track("w1", w1)
raw = track("w1 * x", w1 * x)
f = track("stage_one out", raw.detach())
pred = track("w2 * f", w2 * f)
err = track("pred - target", pred - target)
loss = track("loss", (err ** 2).mean())
w1             requires_grad=True  is_leaf=True  grad_fn=None
w1 * x         requires_grad=True  is_leaf=False grad_fn=MulBackward0
stage_one out  requires_grad=False is_leaf=True  grad_fn=None
w2 * f         requires_grad=True  is_leaf=False grad_fn=MulBackward0
pred - target  requires_grad=True  is_leaf=False grad_fn=SubBackward0
loss           requires_grad=True  is_leaf=False grad_fn=MeanBackward0

跟踪精确点名边界。requires_grad 先 True,再 False,又 True,转变发生在一行。该行张量是无 grad_fn 的叶,这是从外面进入计算的值的签名,而不是算出的值。

最后三行值得研究,因为 bug 靠它们活下来。loss.requires_grad 是 True。loss.grad_fn 存在。backward() 会跑并填梯度。所有这些是关于 w2 的陈述,关于 w1 一句不是。检查损失是否连着图是真检查,也是这类 bug 能过的检查。

往后,从损失出发

另一个方向问图自己能到达哪些叶。当前向散在模块与 helper、逐行打点不方便时用——这就是大多数真实代码。

def reachable_leaves(loss):
    """Every leaf tensor that backward() from this loss would accumulate into."""
    found, seen, stack = [], set(), [loss.grad_fn]
    while stack:
        fn = stack.pop()
        if fn is None or id(fn) in seen:
            continue
        seen.add(id(fn))
        if type(fn).__name__ == "AccumulateGrad":
            found.append(fn.variable)
        for nxt, _ in fn.next_functions:
            stack.append(nxt)
    return found
f = (w1 * x).detach()
loss = ((w2 * f - target) ** 2).mean()

reached = {id(t) for t in reachable_leaves(loss)}
for name, p in (("w1", w1), ("w2", w2)):
    print(f"{name}: reachable from loss = {id(p) in reached}")
w1: reachable from loss = False
w2: reachable from loss = True

这在 backward() 调用前回答可达性。概念上走的正是 autograd 引擎稍后用的前驱结构,但这个 helper 不是 autograd 引擎的重实现。

它也有意探到应用逻辑通常不该依赖的层:AccumulateGrad 之类的具体节点名与 .variable 之类的属性在这里为理解与调试有用,生产代码应尽量用 torch.autograd.grad() 之类的受支持接口。

问单个张量有更轻的办法,用前面的工具:

g = torch.autograd.grad(loss, [w1, w2], allow_unused=True, retain_graph=True)
print("d loss/d w1:", g[0])
print("d loss/d w2:", g[1])
d loss/d w1: None
d loss/d w2: tensor(-18.7500)

allow_unused=True 让它成为诊断而不是报错。不带它,PyTorch 抛 The differentiated Tensor at index 0 appears to not have been used in the graph,同一发现以异常交付。两种形式都回答精确问题:这损失到这张量有没有可微通路,有或没有。

修复,再证明修复

断裂在 stage_one 的 return,它返回为日志做的 detach 拷贝,而不是算出的张量:

def stage_one(t):
    f = w1 * t
    feature_log.append(f.detach())
    return f

现在验证,这是区分修复与巧合的部分。修复前损失已归零,所以“损失下降”什么都证明不了。我们说坏的是 w1 到损失的通路,证据必须关于 w1:

step=  0 loss=46.875000 w1=1.2500 w2=1.3750
step=  9 loss=0.031576 w1=1.7079 w2=1.7861
step= 99 loss=0.000000 w1=1.6931 w2=1.7719
step=399 loss=0.000000 w1=1.6931 w2=1.7719
print("w1 * w2 =", (w1 * w2).item())
w1 * w2 = 3.0000007152557373

w1 动了,以前从不动。两参数都收到梯度,乘积收敛到要学的乘数。这就是诊断预测的证据。

这个一般形式说出来,因为它适用于本书每个修复:

说出错的量是什么,说它应该变成什么,观察到它确实变了。症状消失不等于机制恢复。

为什么 .grad 是 None?

现在有零件 proper 回答,而不是试。这个问题分解,每部分带证据。

backward() 真跑了吗? 需要梯度的新叶张量通常以 .grad is None 开始。之后字段里可能是累积梯度,可能被显式清零,可能被重置为 None,所以结合训练循环解释当前值。这听起来显然到不用检查,直到你遇到异常、提前 continue、梯度累积计划或条件分支让这步跳过调用的代码。

张量需要梯度吗? t.requires_grad。False 则无论别的什么都不存梯度。但置 True 前先问它为什么 False。故意冻结的参数、被 detach 拷贝替换的张量、创建就没 flag 的张量是三种情况,三种修法,只有一种是 requires_grad_(True) 修好的。

是叶吗? t.is_leaf。需要梯度而非叶,.grad is None 就是文档默认,什么都没坏。导数算了反向用了,只是无处存。要看用 retain_grad() 或 torch.autograd.grad()。

连着这个损失吗? 可达检查,或 torch.autograd.grad(loss, t, allow_unused=True)。前三个回答不了这个问题,而静默失败恰恰栽在这里。张量可以需要梯度、是叶、完全不在损失建出的图里。

断在哪? 从张量往前跟踪,找到 requires_grad 变成 False 的算子;或从损失往后走,找到预期分支缺失的位置。候选就是上面的机制:detach()、no_grad 区、抽到 Python/NumPy 又重建、从一开始就没要梯度的张量。

我在看参与过的对象吗? Python 名字可重绑定。self.weight 被重赋值,或参数被替换而非原地改,前向里的张量与你打印的张量可能是不同对象——收到梯度的那个与你在看的那个。id() 前后一比定案。第 1 章在重绑定更新见过,第 4、5 章在优化器与模块持有各自引用后回来。

有个区分值得拎出来,因为两种状态看起来像、意思相反:

w = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(2.0, requires_grad=True)
x = torch.tensor(0.0)

loss = (w * x + b - 1.0) ** 2
loss.backward()

print("w.grad:", w.grad, " b.grad:", b.grad)
w.grad: tensor(0.)  b.grad: tensor(2.)

w.grad 是 tensor(0.),不是 None。w 连着,梯度算了,确实是零因为乘它的输入是零。已知反向后需要梯度的叶张量上,显式零说参数连着、导数值为零。None 要多查:张量可能断连,反向可能没到,字段可能被重置为 None,你看的可能是没 retain 的非叶。

所以零与 None 是不同诊断状态,但不结合检查紧前发生了什么都不该解释。搞混会让你在输入为零的问题上去找图断裂,或反过来。

图有生命周期

同一损失调两次 backward(),PyTorch 会:

w = torch.tensor(2.0, requires_grad=True)
loss = (w * 3) ** 2

loss.backward()
loss.backward()
RuntimeError: Trying to backward through the graph a second time (or directly access
saved tensors after they have already been freed). Saved intermediate values of the
graph are freed when you call .backward() or autograd.grad(). Specify
retain_graph=True if you need to backward through the graph a second time or if you
need to access saved tensors after calling backward.

标准回应是加 retain_graph=True,标准回应经常错,因为它把信息当障碍。先理解释放在放什么。

反向函数需要前向的值。微分 u² 要知道 u,所以 PowBackward0 引用着它——能直接看到引用:

w = torch.tensor(2.0, requires_grad=True)
u = w * 3
loss = u ** 2

print("saved:", loss.grad_fn._saved_self)
loss.backward()
print("saved:", loss.grad_fn._saved_self)
saved: tensor(6., grad_fn=<MulBackward0>)
RuntimeError: Trying to backward through the graph a second time (or directly access
saved tensors after they have already been freed) ...

在这。反向节点存了中间值 6.0,反向后存的值不可用了。

存下的激活是训练内存的重要部分,某些结构、batch 与序列长下能超过参数内存。这就是不再需要的值及时释放重要的原因。

_saved_self 之类的属性把有用的 autograd 内部暴露出来做调查,PyTorch 文档解释存下张量时自己也用它们。但某反向节点具体有哪些 _saved_* 属性是实现细节,当检查技术用,不当应用接口。反向用完 PyTorch 就释放它们,因为压倒性常见情况——一次前向、一次反向、下一 batch——留着就是浪费内存。

注意没释放什么。图结构还在:

print(type(loss.grad_fn).__name__)
show_graph(loss.grad_fn)
PowBackward0
PowBackward0
  MulBackward0
    AccumulateGrad -> leaf tensor, value 2.0

所以记录的形状留着,anat求导要的值没了。这个精确有用:“图被释放了”不完全对,它解释了为什么反向后检查工具还管用而第二次 backward() 不行。

这把报错变成关于程序的问题:

这段代码为什么遍历同一图两次?

常见三答案,三种回应。

新前向本该建新图。 常见情况,不必要的 retain_graph=True 会让存下的状态留得过久,内存大涨。更好的修复通常是弄清陈旧前向状态为何被复用,构造想要的新图:

for batch in batches:
    loss = compute_loss(model, batch)     # new graph
    loss.backward()                       # traversed once, freed
    step(params)

如果循环外算的损失在循环里求导,或复用上轮缓存的损失,retain 图让异常消失,程序继续对陈旧计算求导。

算法真要对一图反向两次。 有:梯度惩罚项、元学习更新、同一前向要两个不同梯度的情况。那 retain_graph=True 就是正确工具,内存代价认了。

状态跨轮携带。 有意思的那个,因为“加 retain_graph=True”在这里改数学而不只是改内存。看携带隐状态的循环,测每步图深:

def depth(fn):
    if fn is None:
        return 0
    return 1 + max([depth(n) for n, _ in fn.next_functions] or [0])

w = torch.tensor(0.9, requires_grad=True)
hidden = torch.tensor(1.0)

for step in range(5):
    hidden = hidden * w + 0.1
    loss = hidden ** 2
    print(f"step={step} depth={depth(loss.grad_fn)}")
    loss.backward(retain_graph=True)

print(f"w.grad: {w.grad.item():.4f}")
step=0 depth=4
step=1 depth=6
step=2 depth=8
step=3 depth=10
step=4 depth=12
w.grad: 26.2882

图每步长两节点不停。每步存下的激活都活着,因为当前图还引用它们。长序列上这正是内存泄漏的形状,也是训练跑到 4000 步死掉、40 步还好好的常见死法之一。

把携带状态 detach,图深恒定:

w = torch.tensor(0.9, requires_grad=True)
hidden = torch.tensor(1.0)

for step in range(5):
    hidden = hidden * w + 0.1
    loss = hidden ** 2
    print(f"step={step} depth={depth(loss.grad_fn)}")
    loss.backward()
    hidden = hidden.detach()

print(f"w.grad: {w.grad.item():.4f}")
step=0 depth=4
step=1 depth=4
step=2 depth=4
step=3 depth=4
step=4 depth=4
w.grad: 10.0000

两版本都跑,都不抛。梯度不同:26.29 与 10.00。

区别就是全部要点,精确说每个算了什么。第一个把每步损失经完整历史求导到开头,五结果累积——正是五损失之和对 w 的梯度。独立确认:

w = torch.tensor(0.9, requires_grad=True)
h = torch.tensor(1.0)
total = 0
for _ in range(5):
    h = h * w + 0.1
    total = total + h ** 2
total.backward()
print(f"{w.grad.item():.4f}")
26.2882

同样数。第二个版本每损失只经一步求导,丢了对 earlier 步的依赖。

两种计算都有意义,数学选择由携带状态是否与 earlier 历史保持连接决定。

第一个版本 hidden 跨步连着,每后损失依赖完整前史。retain_graph=True 让保留下来的历史可被多次反向遍历成为可能;它本身不是定义全历史算法的东西。

第二个版本每步后 hidden.detach() 故意切断历史,给出单步截断的 TBPTT。截断在保留全历史太贵时的循环或带状态序列模型里常见,但不是所有长序列模型训练方式的通用描述。

重要教训是加 retain_graph=True 可能启用图结构数学含义还没检查过的代码。因为信息让你加,你在不知道有选择摆在面前的情况下选了其中之一。

先弄清图为什么要活,再让 PyTorch 留它。flag 有内存代价,在携带状态的循环里还有数学含义。

原地算子与反向要的值

关于原地算子流传的两句话都错:说它们破坏 autograd,说没事因为 PyTorch 会告诉你。真相更窄更有用,直接从刚看的存下张量跟出来。

同一个原地算子用两次,计算只差消费者:

w = torch.tensor([2.0], requires_grad=True)
u = w * 3
v = u + 1
u.add_(10)
v.sum().backward()
print("case A, w.grad =", w.grad.item())
case A, w.grad = 3.0
w = torch.tensor([2.0], requires_grad=True)
u = w * 3
v = u ** 2
u.add_(10)
v.sum().backward()
RuntimeError: one of the variables needed for gradient computation has been modified
by an inplace operation: [torch.FloatTensor [1]], which is output 0 of Add, is at
version 1; expected version 0 instead.

同样原地调用,相反结局。区别在消费算子求导要什么:

w = torch.tensor([2.0], requires_grad=True)
u = w * 3
print("AddBackward0 saved a copy of its input:", hasattr((u + 1).grad_fn, "_saved_self"))
print("PowBackward0 saved:", (u ** 2).grad_fn._saved_self)
AddBackward0 saved a copy of its input: False
PowBackward0 saved: tensor([6.], grad_fn=<MulBackward0>)

u + 1 对 u 的导数是 1,AddBackward0 前向什么都不用,之后 u 变成什么样无所谓。u² 导数是 2u,PowBackward0 存了 u,改 u 让它失效。

PyTorch 宁可检出也不悄悄算错梯度。每个张量带版本计数,每次原地修改加一,每个存下张量记下见到时的版本:

w = torch.tensor([2.0], requires_grad=True)
u = w * 3

print("u._version:", u._version)
u.add_(10)
print("u._version:", u._version)
u._version: 0
u._version: 1

反向时比较记录版本与当前版本。机制就这些,报错信息逐字解释:is at version 1; expected version 0。

它也解释误导人的细节。信息说被改的张量是 output 0 of Add——Add,不是 Pow。u.add_(10) 后最近产出 u 的算子是原地加,autograd 就这么描述它。信息标识被改的张量,用它当前 provenance。它没点名存下值失效的节点。读这种信息,张量是线索;信息里的算子名是它最后落在哪,不是冲突在哪。

跟出的实用规则不是禁令。PyTorch 支持很多原地算子,但 autograd 文档自己也不鼓励只为省内存依赖它们:autograd 本来就积极复用缓冲,原地写法的内存好处常比预期小。

对我们重要的是不是原地算子 categorically 好坏,而是为什么某个改动被接受、另一个让反向失效。

x = torch.tensor([-1.0, 2.0], requires_grad=True)
h = x * 2
h = torch.relu_(h)
h.sum().backward()
print("x.grad:", x.grad)
x.grad: tensor([0., 2.])

这行因为 ReLU 反向要的是输出来决定哪些位置过梯度,而输出就是改后的张量。真实模型里 nn.ReLU(inplace=True) 与各种 fused 原地算子不是在冒险。

所以有用的表述是:

一种重要的 autograd 失败发生在原地算子改了反向稍后要用的 earlier 值的张量。PyTorch 用版本计数跟踪这些改动,存下值不可信时抛错。

原地算子还有额外限制,包括直接对需要梯度的叶张量做、涉及别名视图的改动。所以“这张量为反向存了吗”解释了上面例子,但不是所有合法原地算子的完整规则。

诊断签名足够具体到可搜:在 backward() 期间提到版本号的错,点的张量形状通常能对上某个中间量。从那里在前向存值与 backward 调用之间找原地算子——+=、-=、*=、下划线结尾方法、切片赋值、经视图或共享存储的 detach 张量的写。

大模型里被失效的张量难认时,torch.autograd.detect_anomaly() 会报告失败反向节点对应的前向算子,通常立刻定位:

with torch.autograd.detect_anomaly():
    loss = compute_loss()
    loss.backward()

它加可观诊断开销,为调查而设,不是正常训练用的。它在这里赚回位置,因为它是 PyTorch 内建把反向失败与产出问题节点的前向算子关联的最方便办法之一。第 11 章对非有限梯度再用它。

记录由实际运行的算子建成

有个假设值得显式打掉,因为它是从别的框架与模型代码纸面样子自然带来的。在普通 eager PyTorch 执行里,autograd 不在模型类写下时定义固定求导图。反向图由该次前向实际执行的算子构造,普通 Python 控制流能让每次调用的图不同:

def f(w, x):
    y = w * x
    if y.sum() > 0:
        return y ** 2
    return y.abs()

w = torch.tensor(2.0, requires_grad=True)

for x in (torch.tensor(1.0), torch.tensor(-1.0)):
    out = f(w, x)
    print(f"x={x.item():+.0f} grad_fn={type(out.grad_fn).__name__} "
          f"gradient={torch.autograd.grad(out, w)[0].item():+.1f}")
x=+1 grad_fn=PowBackward0 gradient=+4.0
x=-1 grad_fn=AbsBackward0 gradient=+1.0

同样函数,同样参数,两张不同的图,两个不同的梯度,因为依赖数据的分支选了不同算子。长度依赖输入的循环、提前退出、随 batch 变的掩码、条件施加的层都有同样性质。

跟出三后果,每个以后都用得上。

前向与建图是同一事件,这就是不跑模型检查不了它的 autograd 结构的原因,也是本章每个诊断都要先有真实前向的原因。

图对建出它的那轮有效。跨轮复用是上一节的场景,现在有了理由而不只是规则。

bug 可以存在于今天数据没走的路径上。触发另一分支的 batch 能在跑了一周的代码里产出梯度失败。复现不了 autograd 报错时,前向的分支结构是好去处,失败的 batch 值得存下。

第 13 章从反方向回来,torch.compile 试图提前捕获图,控制流成为它放弃的原因。

在 autograd 失败上用 AI

autograd 是助手能产出看似合理、语法完美、消掉可见症状同时改变计算的修复的领域。

给断连张量置 requires_grad_(True) 能建新梯度起点而不重连 earlier 历史。用 retain_graph=True 只有在所需图状态在否则释放前被保留时才允许多次遍历。换掉原地算子可能消掉版本计数报错而周围计算概念上仍错。

每个建议都可以合法。没知道真正坏的机制前都不该接受。三者都改症状。是否恢复你想要的计算是另一个问题,报错信息里没有足够信息回答。

所以先要可检查的结构断言,再要改动:

Here is a PyTorch computation. Parameter p ends up with p.grad is None
after loss.backward().

Do not modify the code and do not propose a fix yet.

1. Trace the path from p to loss, operation by operation. For each
   intermediate tensor, predict requires_grad, is_leaf, whether it should
   have a grad_fn, and whether its .grad will be populated by default
   after backward().

2. Identify the first operation after which the result no longer has a
   differentiable path back to p, and name the mechanism: a tensor that
   never required gradients, a detach, a no_grad region, a value extracted
   to Python or NumPy, or a name rebound to a different tensor.

3. State which of your predictions would change if your diagnosis is wrong,
   and give me the smallest set of print statements that distinguishes your
   explanation from the alternatives.

Then stop.

价值在第二、三部分。要边界迫使承诺一个位置,而不是罗列有时对的 missing gradients 清单。问诊断错了哪些预测会变,迫使答案可证伪,跑打印要么确认机制,要么告诉你哪个假设接下来查。

边界确认后,后续也值得仔细措辞:

The break is at <operation>. Before changing it, tell me what the detach
there was doing for the program: what breaks if I remove it, and is there
a place where the value is still needed in detached form?

因为真实代码里的 detach() 常常在干活。有时位置错了,像开篇循环,有时拿掉它依赖它的日志、目标或冻结分支会悄悄坏掉。

第 1、2 章规则没变:先要关于程序的预测,再要对程序的重写;只有能说出修复纠正了哪个量并观察到纠正时,才接受修复。

你现在应该能回答什么

这里有真实代码库里会遇到的片段——双阶段模型,有人已注意到 encoder_scale.grad 是 None,已加了一行想修它。

encoder_scale = torch.tensor(2.0, requires_grad=True)
head_weight = torch.tensor(0.5, requires_grad=True)

x = torch.tensor([1.0, 2.0, 3.0])
target = torch.tensor([2.0, 4.0, 6.0])

with torch.no_grad():
    features = encoder_scale * x

features.requires_grad_(True)          # added to "fix" the missing gradient

prediction = head_weight * features
loss = ((prediction - target) ** 2).mean()
loss.backward()
encoder_scale  requires_grad=True  is_leaf=True  grad_fn=None          grad=None
head_weight    requires_grad=True  is_leaf=True  grad_fn=None          grad=tensor(-18.6667)
features       requires_grad=True  is_leaf=True  grad_fn=None          grad=tensor([-0.3333, -0.6667, -1.0000])
prediction     requires_grad=True  is_leaf=False grad_fn=MulBackward0  grad=None
loss           requires_grad=True  is_leaf=False grad_fn=MeanBackward0 grad=None

哪些张量参与 autograd? features、head_weight、prediction、减法、平方与 mean。x 与 target 不需要梯度。encoder_scale 需要梯度但不参与这张图:用它的乘法在 torch.no_grad() 里跑,从没被记录。

哪些是叶? encoder_scale、head_weight、x、target——还有值得停一下的 features。它由算子产出,但没被记录的算子,所以无 grad_fn,以输入而不是算出值的身份进图。prediction、误差与损失是非叶。

哪些有 grad_fn? prediction(MulBackward0)、减法(SubBackward0)、平方、损失(MeanBackward0)。其余都是 None,包括 features。

.grad 在哪被填? head_weight.grad 与 features.grad。两者都是需要梯度的叶,都从损失可达。encoder_scale.grad 保持 None。

加的那行修了什么吗? 没有,这正是本章一直铺垫的情形。features.requires_grad_(True) 让 features 成为新的需要梯度的叶张量,backward() 现在给 features.grad 填上真实、有限、形状正确的数。这本身不让 features 成为模型参数,也不保证任何更新步会改它。梯度出现了。症状没了。而 encoder_scale.grad 仍是 None,因为声明从 features 往前跟踪梯度,重建不了穿过从没记录的算子往后的通路。这行在模型中段建了新起点,而不是重连旧的。

第一条断边在哪? 在 no_grad 块。块前 encoder_scale 需要梯度;块后 features 无 grad_fn。该点下游一切完好,这正是改下游任何东西——像加的那行——都没用的原因。

这是 bug 吗? 完全取决于意图,这就是为什么这是对的问题而不是答案。编码器故意冻结,在不记录 autograd 历史的情况下跑其前向正是想要的。但那时如果下游 head 里唯一可训练状态,加的 features.requires_grad_(True) 通常多余:它建并留了对 features 的梯度,尽管没人打算更新 features 本身。编码器本想微调,这悄悄只训练 head,可见症状只是模型 plateau。

从外面怎么区分这两种? 看 encoder_scale 训不训练动。快照,跑几步,对比。打算冻结的参数与意外断连的参数损失曲线相同、.grad 值相同;区别在作者意图,唯一检查办法是弄清程序实际在训练哪些参数,与它声称训练的对比。

编码器该训,修复是什么? 去掉 no_grad 块,去掉为补偿它加的行。不是 encoder_scale.requires_grad_(True),它本来就是 true。而修复生效的证据不只是下游存在某个梯度——features.grad 已经给了我们一个。相关证据是 encoder_scale.grad 现在被填,且更新步运行时 encoder_scale 真动。

为什么 backward() 成功了? 因为 loss.requires_grad 是 True,路径上任一张量需要梯度它就是 True。backward() 跑成功只证明有东西连着,关于什么连着什么都没证明。

练习

这些是用来跑的,对应本章配套 notebook。

  1. 检查前先手画图。 对 w = torch.tensor(3.0, requires_grad=True)、a = w + 1、b = a * w、c = b ** 2,手画记录,预测每个 requires_grad、is_leaf 与 grad_fn,解析预测 dc/dw。然后跑 show_graph(c.grad_fn) 与 c.backward() 全核对。注意 w 出现两次;从打印的图解释为什么它的两份贡献相加。

  2. 看没留下的梯度。 同样计算,用 hook 在 b 上观察反向流经它的梯度,再用 retain_grad() 重复,再用 torch.autograd.grad() 重复。确认三者报同样数,说出哪个没动 .grad 字段。

  3. 看起来相同的两种切断。 建两可训练叶的计算,一版用 detach() 去掉一条路,一版把同条路放 torch.no_grad() 里算。找一个打印性质区分两种情形。再构造它们不等价的情形,用单算子双操作数。

  4. 损失检不出的陷阱。 拿开篇循环在坏版本确认每步 loss.requires_grad 是 True 且 loss.grad_fn 存在。然后写最小的会挂的检查。论证它该永久留在训练循环还是只在调查时用。

  5. 故意反向两次。 构造两损失共享中间量的计算,两边都求梯度。先用 retain_graph=True 做,再用两次前向做,再用一次 torch.autograd.grad 取两输出做。对比所得梯度并解释差异。

  6. 让图长大。 用本章隐状态循环跑 200 步 retain_graph=True,记录图深。跑之前预测 step 200 的深度。然后 detach 状态确认深度恒定。解释长序列上第一版最终会出什么事。

  7. 找到存下的张量。 作为版本相关的检查练习,构造只差消费算子的两个原地修改,一个 autograd 接受、一个拒绝。在消费者的 grad_fn 上检查可用的 _saved_* 属性与张量改前改后的 _version。再解释报错信息点的算子。

  8. 只在有时存在的分支。 写前向的图依赖输入 batch 的某性质,构造一批产出可用梯度、一批产出断连参数。再写在任何 batch 都抓住它的断言。

  9. 审计没见过的模型。 拿任何不是你写的模型,跑一次前向反向,用 reachable_leaves 列出损失实际能到达的参数。与你以为在训练的参数对比。

下一步:建网

三层齐了。第 1 章确立训练做什么:前向、反向、更新,三个可分阶段,三种失败。第 2 章确立流经它的东西:张量带形状,形状带着没人强制的含义。本章确立 PyTorch 在张量流动时记录的东西——执行中建成的算子图,引用着要累积的叶与求导要的值。

三者够不用 PyTorch 神经网络机器建神经网络,下一章就是。权重直接做可训练叶建;前向写成显式矩阵乘与激活;损失手写并与 PyTorch 自带对;backward() 在你建的参数上填梯度;更新循环自己写。

里面一切都是这三章的机制,规模稍大。参数是刚走过的 AccumulateGrad 节点的叶。图每轮重建,循环才转得起来。失败模式是你有证据的那些:没连着的参数,该清没清累积的梯度,该抛错却广播的形状。

然后,网存在且能跑后,我们用 nn.Module、nn.Linear 与优化器替换手写部分——那不是新机器。它们是组织张量、叶与梯度的方式,我们已经手建过。

不用 nn.Module 的神经网络。