03 · 就地操作：三种报错，三个不同的原因

⏱ 106 分钟 ｜ ⚠️ 实测：三种形态的报错原文完全不同，而最贵的那一种根本不报错 —— 只是悄悄算错

🎯 一句话

就地操作省下的是一次内存分配，付出的代价是「autograd 记的账可能对不上」。 PyTorch 用一个叫版本计数器的东西来抓这件事 —— 它能抓住三种形态，抓不住第四种。 本章把这四种形态各跑一遍，报错原文逐字抄下来，然后告诉你分别该怎么改。

⭐ 本章存在的理由：ML 基础 11 章的「梯度断流四来源」里，第四条只写了一句 「原地操作（in-place）：x += 1 有时会破坏计算图，改成 x = x + 1」。 这一章就是把那个「有时」拆开 —— 什么时候会、什么时候不会、什么时候会但不报错。

🧩 一、先说清什么算「就地」

判据只有一条：结果写回原来那块内存，还是写进新分配的一块。

import torch

a = torch.tensor([1.0, 2.0])
b = a + 1                      # 非就地：结果放进新分配的一块内存
print("a + 1     和 a 同一块内存吗:", b.data_ptr() == a.data_ptr())
before = a.data_ptr()
a.add_(1)                      # ⭐ 下划线后缀 = 就地
print("a.add_(1) 之后 a 还是原来那块吗:", a.data_ptr() == before, " a =", a.tolist())

x = torch.tensor([1.0, 2.0])
y = x
y += 1                         # ⭐ += 也是就地
print("y += 1     之后 x =", x.tolist(), " y is x:", y is x)

p = torch.tensor([1.0, 2.0])
q = p
q = q + 1                      # 不是就地：q 被重新绑到了新对象上
print("q = q + 1  之后 p =", p.tolist(), " q is p:", q is p)

s = torch.tensor([1.0, 2.0, 3.0])
s[0] = 99                      # ⭐ 下标赋值也是就地
print("s[0] = 99  之后 s =", s.tolist())

实测输出：

⭐ 三种写法都是就地，别只盯着下划线：

⚠️ y += 1 和 y = y + 1 在纯 Python 的数字上没区别，在张量上是两件事。 上面 y += 1 把 x 也改掉了（它们本来就是同一个对象），q = q + 1 没有。 💀 这是「我明明没动那个变量，它怎么变了」的头号来源。

🧩 二、版本计数器：它怎么发现你改了

PyTorch 给每一块张量存储挂了一个整数，每被就地改一次就加一：

import torch

t = torch.tensor([1.0, 2.0])
print("刚建出来      _version =", t._version)
t += 1
print("+= 之后        _version =", t._version)
t.mul_(2)
print("mul_ 之后      _version =", t._version)
u = t * 3
print("非就地的产物   _version =", u._version, "  而 t 仍然是", t._version)

x = torch.tensor([1.0, 2.0, 3.0])
v = x[0:2]                       # 视图：和 x 共享同一块内存
v += 1
print("改视图之后     x._version =", x._version, " v._version =", v._version)

d = x.detach()                   # ⚠️ detach 出来的也共享同一个计数器
d.mul_(2)
print("改 detach 之后 x._version =", x._version)

实测输出：

⭐ 整套机制就三句话：

1. 前向的时候，grad_fn 节点把要用的张量存下来，顺手记下它当时的版本号。
2. 反向的时候，节点拿出存的张量，对一下版本号。
3. 对不上就报错 —— 因为存的那个值已经不是它当初存的那个了。

⭐ 计数器是跟着内存走的，不是跟着变量名走的。上面实测：改 x[0:2] 这个视图， x 自己的版本号也从 0 变成 1；改 x.detach() 出来的张量，x 的版本号变成 2。 ⚠️ 所以「我改的是另一个变量」不是免罪理由，第八节会看到这一条坑死人。

⭐ 为什么是版本号而不是拷贝一份：拷贝就没有省内存这件事了。 版本号只多占 8 个字节，而 02 章第七节量过， 一次前向为反向存下的东西是 44.0 MB 量级 —— 用 8 字节换 44 MB 的正确性检查，这买卖太划算了。

🧩 三、形态①：叶子被就地改（报在你写的那一行）

import torch

x = torch.tensor([1.0, 2.0], requires_grad=True)
try:
    x += 1
except RuntimeError as e:
    print("形态① ->", e)

y = torch.tensor([1.0, 2.0])           # 不要梯度，随便改
y += 1
print("不要梯度的张量:", y.tolist())

z = torch.tensor([1.0, 2.0], requires_grad=True)
with torch.no_grad():                  # ⭐ 优化器就是这么更新参数的
    z -= 0.5
print("no_grad 里改叶子:", z.tolist(), " is_leaf =", z.is_leaf,
      " requires_grad =", z.requires_grad)

实测输出（⭐ 报错是真实原文）：

⭐ 关键词：a leaf Variable that requires grad。

⭐ 那个例外正是优化器的工作方式：optimizer.step() 内部就是在 no_grad 下对参数做就地减法。 第九节会把这两行手写出来。

🧩 四、形态②：叶子的视图被就地改（报的是另一句话）

import torch

x = torch.zeros(3, requires_grad=True)
try:
    x[0] = 1.0                     # 下标赋值：先取视图，再往视图里写
except RuntimeError as e:
    print("x[0] = 1.0  ->", e)

w = torch.zeros(3, requires_grad=True)
try:
    w[0:2] += 1
except RuntimeError as e:
    print("w[0:2] += 1 ->", e)

# ⭐ 正确写法：非就地地造一个新张量
m = torch.zeros(3, requires_grad=True)
out = m + torch.tensor([1.0, 0.0, 0.0])
print("非就地版本 ->", out.tolist(), " grad_fn =", type(out.grad_fn).__name__)

实测输出：

⭐ 关键词多了三个字：a view of a leaf Variable。

⚠️⚠️ 注意 x[0] = 1.0 报的是「视图」那一句，不是形态①那一句。 因为 x[0] = v 在底层是两步：先取出 x[0] 这个视图，再往视图里写。 ⭐ 这也是第 01 章那句「切片改的只是说明书，底下还是同一块内存」的直接后果 —— 你以为你在改 x 的一个元素，autograd 看到的是「有人在改一个视图」。

⭐ 最后一行那个模式值得单独记：很多人写「先开一个 zeros(n, requires_grad=True)，然后一位一位填」， 这在 NumPy 里是标准写法，在 PyTorch 里每一次赋值都撞形态②。 正确的做法是先把各段算出来，最后拼。

🧩 五、形态③：反向要用的中间结果被就地改（报在 backward() 那一行）

import torch

x = torch.tensor([1.0, 2.0], requires_grad=True)
y = torch.sigmoid(x)
y += 1                     # 💀 sigmoid 的输出正是它反向要用的东西
try:
    y.sum().backward()     # ⚠️ 报错发生在这里，不在上面那行
except RuntimeError as e:
    print("形态③ ->", e)

实测输出（⭐ 一字未改）：

⭐ 这条报错信息量最大，逐段拆：

⚠️⚠️ 报错的位置和出错的位置差了一整段：错是 y += 1 犯的，报是 backward() 报的。 💀 在真实训练循环里，这意味着报错栈顶是 loss.backward() 那一行，而真凶在几十行之前的 forward 里。 第十一节的 set_detect_anomaly 就是干这个的。

🧩 六、为什么 x * 2 不报错、sigmoid 报错

同样是「就地改中间结果」，有的炸有的不炸。这不是玄学，判据很硬：

import torch


def try_one(name, f):
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y = f(x)
    y.mul_(2)                       # 就地改中间结果
    try:
        y.sum().backward()
        print(f"{name:14s} 没报错，x.grad = {x.grad.tolist()}")
    except RuntimeError as e:
        print(f"{name:14s} 报错：{str(e)[:88]}")


try_one("x * 2", lambda t: t * 2)
try_one("x ** 2", lambda t: t ** 2)
try_one("torch.exp", torch.exp)
try_one("torch.sigmoid", torch.sigmoid)
try_one("torch.tanh", torch.tanh)
try_one("torch.relu", torch.relu)

实测输出：

⭐ 判据是一句话：这个算子的反向，要不要用它自己的【输出】。

⭐ 指数族全都存输出，因为它们的导数能用输出本身表达（e^x 的导数就是 e^x）， 这样能少存一份 —— 是个非常划算的优化，代价就是输出不能被动。

⚠️ 别把「这次没报错」当成安全。x * 2 那一行 x.grad = [4.0, 4.0] 是对的 （y 被 mul_(2) 变成了 4x，导数确实是 4）—— 它只是恰好不需要那个输出而已。 💀 换一个激活函数，同一段代码就炸；而报错会出现在你以为跟这次改动无关的地方。

🛑 读到这里可以停 —— 前半章讲完了（约 37 分钟）。 后半章还有：💀 形态④：根本不报错的那种 · no_grad 和 detach 都拦不住版本计数器 · 那还要不要用就地操作 · nn.ReLU(inplace=True) 什么时候安全 · 撞上了怎么定位、怎么改 回来的时候不用重读，直接从下一节接着看就行。

🧩 七、💀 形态④：根本不报错的那种

前三种都有版本计数器兜着。这一种没有 —— 它是本章最贵的一节。

破法一：.data 绕过版本计数器

import torch

x = torch.tensor([2.0], requires_grad=True)
y = torch.sigmoid(x)
y.sum().backward()
print("正确的 x.grad          =", x.grad.item())

x2 = torch.tensor([2.0], requires_grad=True)
y2 = torch.sigmoid(x2)
y2.data.mul_(0)                 # 💀 .data 不碰版本计数器
y2.sum().backward()
print("用 .data 改过之后 x.grad =", x2.grad.item(), " ← 没有任何报错")
print("y2 的版本号仍然是", y2._version)

实测输出：

💀💀 梯度从 0.10499362647533417 变成了 0.0，版本号还停在 0，程序一声不吭跑完。 在真实训练里，这表现为「loss 不降但也不报错」—— 而 ML 基础 11 章 排查「梯度断流」的第一条查的就是 .detach() / .data。⭐ 这就是它排第一的原因。

⭐ .data 是什么：它是 detach() 的老写法，但比 detach() 更危险 —— detach() 共享版本计数器（第八节实测会报错），.data 不共享。

⭐ 一句话结论：现代 PyTorch 代码里不应该出现 .data。 要断图用 detach()（第 04 章）， 要改参数用 with torch.no_grad():。⚠️ 老教程和老仓库里 .data 满地都是，抄的时候要换掉。

破法二：前向的值被悄悄改掉（autograd 根本不知情）

版本计数器只管「反向要用的张量」。⚠️ 你自己还要用的张量，它一概不管。

import torch
import torch.nn as nn

torch.manual_seed(0)
x = torch.randn(1, 4)
backbone = nn.Linear(4, 4)

feat = backbone(x)                 # 你打算留着做别的用（比如算一个辅助 loss）
before = feat.detach().clone()
h = torch.relu_(feat)              # ⚠️ 就地版 relu

print("relu 之前的 feat:", [round(v, 4) for v in before[0].tolist()])
print("relu 之后的 feat:", [round(v, 4) for v in feat[0].detach().tolist()])
print("feat 和 h 是同一个对象吗:", feat is h)

实测输出：

⚠️ 第二个数从 -0.1264 变成了 0.0，而 feat 这个名字你根本没碰过。 torch.relu_ 返回的就是 feat 自己（feat is h 为 True）。 💀 接下来你拿 feat 去算辅助 loss / 存特征 / 做可视化，用到的全是 relu 之后的值， 数值全错、一行报错没有。

这类事故的三个典型现场：

⭐ 通用防线一句话：要留着用的张量，先 .clone()。（上面代码里 before 就是这么来的。）

🧩 八、no_grad 和 detach 都拦不住版本计数器

很多人以为「包一层 no_grad 就不记账了」，或者「先 detach 再改就安全了」。两个都不成立：

import torch

x = torch.tensor([2.0], requires_grad=True)
y = torch.sigmoid(x)
with torch.no_grad():           # ⚠️ 以为这样就「不记账」了
    y.mul_(0)
try:
    y.sum().backward()
except RuntimeError as e:
    print("no_grad 里改   ->", str(e)[:96])

x2 = torch.tensor([2.0], requires_grad=True)
y2 = torch.sigmoid(x2)
y2.detach().mul_(0)             # ⚠️ detach 出来的和 y2 是同一块内存、同一个计数器
try:
    y2.sum().backward()
except RuntimeError as e:
    print("detach 之后改  ->", str(e)[:96])

实测输出：

⭐ 两个都照样报形态③。原因分别是：

💀 这两条合起来解释了一个常见的错误修法：撞上形态③之后， 有人把那一行包进 no_grad、或者加个 detach()，然后发现还是报同样的错，就以为报错信息在骗人。 ⭐ 它没骗你 —— 它抓的是「这块内存的内容变了」，跟你用什么姿势改的无关。

⭐ 正确的修法只有一个方向：别改它。 把 y.mul_(0) 换成 y2 = y * 0。

⚠️ 这三个词的区别是下一章的正题。 这里只需要记住一条：它们都不是「就地操作的免罪符」。

🧩 九、那还要不要用就地操作

要。而且你每一次训练迭代都在用，只是没意识到。

它省的到底是什么

import torch
import torch.nn as nn

x = torch.randn(4, 8)
out1 = nn.ReLU(inplace=False)(x)
print("inplace=False 输出和输入同一块内存吗:", out1.data_ptr() == x.data_ptr())

x2 = torch.randn(4, 8)
out2 = nn.ReLU(inplace=True)(x2)
print("inplace=True  输出和输入同一块内存吗:", out2.data_ptr() == x2.data_ptr())

one = torch.randn(256, 1024)
print("一个 256x1024 的 float32 张量 =",
      one.numel() * one.element_size() / 1024 / 1024, "MB")

实测输出：

⭐ 省的是「输出那一份新分配的内存」。按上面这个尺寸算账：batch 256、宽度 1024 的激活值一份是 1.0 MB， 一个 6 层的网络里每层一个 ReLU，inplace=True 就少分配 6 份、也就是 6 MB。 ⚠️ 这是按张量大小算出来的账，不是实测峰值 —— 真实峰值还受分配器复用影响。 🗓️ 未实跑 —— 需要 GPU：显存上的实际峰值差异要用 torch.cuda.max_memory_allocated() 才能量，本机没有卡。

⚠️ 它不省「反向存下来的那一份」。02 章第七节量的那 44.0 MB 是 grad_fn 存的东西， inplace=True 之后 ReLU 存的仍然是它的输出（只不过那块内存和输入共用）。 ⭐ 所以别指望 inplace=True 解决 OOM —— 真正的大头在 AI 基础设施 09。

训练循环里你已经在用的两处

import torch

w = torch.tensor([1.0], requires_grad=True)
(w * w).backward()
with torch.no_grad():
    w -= 0.1 * w.grad                 # ⭐ 就地：w 还是原来那个叶子
print("就地更新后  :", w.tolist(), " is_leaf =", w.is_leaf, " grad_fn =", w.grad_fn)

v = torch.tensor([1.0], requires_grad=True)
opt = torch.optim.SGD([v], lr=0.1)     # 优化器记住的是「这个对象」
(v * v).backward()
v = v - 0.1 * v.grad                   # ⚠️ 非就地：名字被重新绑到了新对象上
print("非就地更新后:", v.tolist(), " is_leaf =", v.is_leaf,
      " grad_fn =", type(v.grad_fn).__name__)
print("优化器手里那个还是:", opt.param_groups[0]["params"][0].tolist())

实测输出：

⭐ 两个数值都是 0.8，但后果天差地别：

⭐ 这就是为什么 optimizer.step() 必须就地改参数：优化器在构造时记下的是那些张量对象， 你要是换了个新对象，它手里那份就成了孤儿。 ⚠️ 另一处更常见的就地是 optimizer.zero_grad() / p.grad.zero_() —— 清零也是就地写。

🛑 第二个休息点 —— 中段讲完了（约 26 分钟）。 最后一段还有：nn.ReLU(inplace=True) 什么时候安全 · 撞上了怎么定位、怎么改 这一章确实长，分三次读完全没问题 —— 回来直接从下一节接着看。

🛑 读到这里可以停 —— 已经读了约 64 分钟。 最后一段还有（约 20 分钟）：nn.ReLU(inplace=True) 什么时候安全 · 撞上了怎么定位、怎么改 回来的时候不用重读，直接从下一节接着看就行。

🧩 十、nn.ReLU(inplace=True) 什么时候安全

⭐ 先说站内现状：inplace=True 这个写法在立项时全站 392 页 HTML 里命中 0 次（旧板块至今仍是 0） —— 也就是说你在站内任何一页抄到的代码都不带它。但它在外面的开源实现里（torchvision 的 ResNet 就是）遍地都是， 所以你迟早会抄到。

import torch
import torch.nn as nn

torch.manual_seed(0)
x = torch.randn(2, 4, requires_grad=True)
ok = nn.Sequential(nn.Linear(4, 4), nn.ReLU(inplace=True), nn.Linear(4, 1))
ok(x).sum().backward()
print("Linear 后面接 inplace ReLU：跑通，x.grad 形状 =", tuple(x.grad.shape))

x2 = torch.tensor([1.0, -2.0], requires_grad=True)
bad = nn.Sequential(nn.Sigmoid(), nn.ReLU(inplace=True))
try:
    bad(x2).sum().backward()
except RuntimeError as e:
    print("Sigmoid 后面接 inplace ReLU ->", str(e)[:96])

实测输出：

⭐ 判据还是第六节那一条，只不过要看的是【前一个算子】：

⚠️ 还有一种情况报错抓不到：前一个算子的输出你自己还要用（第七节破法二那种）。 ⭐ 典型是残差连接：out = x + f(x) 之后，x 还要参与别的分支时， 一个就地激活会把 x 一起改掉 —— autograd 可能不报错，值已经错了。

⭐ 给一条能直接执行的规矩：

inplace=True 只在两种情况下用：① 你就是在复现一个明确写了它的开源实现； ② 你确实 OOM 了、并且量过它有用。⚠️ 其余一律不写 —— 它省的那点内存不值得你花半天定位一个静默的数值错。

🧩 十一、撞上了怎么定位、怎么改

定位：set_detect_anomaly 会告诉你是 forward 的哪一行

import torch

with torch.autograd.set_detect_anomaly(True):
    a = torch.tensor([1.0, 2.0], requires_grad=True)
    b = torch.sigmoid(a)
    b += 1
    try:
        b.sum().backward()
    except RuntimeError as e:
        print("最终报错:", str(e)[:70])

实测输出（⭐ 前半段是打到 stderr 的 UserWarning，路径按你的机器变）：

⭐ 它多给了一个东西：那个出问题的算子是在 forward 的哪一行造出来的（line 5, in <module>）。 在几百行的模型里，这一句能省掉一小时。

⚠️ 两个使用注意：

四条修法，按优先级

⚠️ 不在这张表里的两个「修法」：

• ❌ 加 .data —— 它只是让报错消失，第七节实测梯度从 0.10499362647533417 变成 0.0。💀 这是把报错换成了静默的错误答案。
• ❌ 加 retain_graph=True —— 那治的是另一个病（图被释放），跟版本号对不上没关系。

📋 四种形态反查表

⭐ 另外两条不属于「三种形态」但常撞上的：

🔗 这一章连到哪里

✅ 检查点

1. 除了下划线后缀，还有哪两类写法也是就地操作？y += 1 和 y = y + 1 在张量上的区别是什么？
2. 版本计数器的三步机制是什么？它是跟着变量名走还是跟着内存走？实测里改 x 的一个视图之后，x._version 变成了几？
3. 形态①的报错原文关键词是什么？它报在哪一行？唯一的例外是什么，为什么那个例外很重要？
4. x[0] = 1.0（x 是要梯度的叶子）报的是形态①还是形态②？为什么？
5. 形态③的报错原文里，哪两段是定位用的关键信息？为什么说「报错的位置和出错的位置差了一整段」？
6. 同样是就地改中间结果，为什么 x * 2 不报错而 torch.sigmoid(x) 报错？判据是什么？
7. 💀 形态④「不报错的那种」有哪两个破法？实测里 .data 让梯度从多少变成了多少？
8. no_grad 和 detach 为什么拦不住版本计数器？分别是什么原因？
9. inplace=True 省的是什么、不省的是什么？为什么 Linear 后面接它安全、Sigmoid 后面接它会炸？
10. 为什么 optimizer.step() 必须就地改参数？实测里非就地更新之后，优化器手里那个参数是多少？
11. set_detect_anomaly 多给了什么信息？为什么不能留在训练脚本里？
12. 四条修法的优先级是什么？哪两个「修法」是绝对不能用的？

🛑 可以停在这里

⚡ 走神救援

⭐ 就地操作省的是一次内存分配，付的是「autograd 记的账可能对不上」。

抓它的机制是版本计数器：前向存下张量并记下版本号，反向时对一下，对不上就报错。⭐ 计数器跟着内存走，不跟着变量名走——所以改视图、改 .detach() 出来的对象，都会让原张量的版本号往上跳。

四种形态：叶子被改（报在你写的那一行；⭐ 例外是包在 no_grad 里就允许——那个例外正是 optimizer.step() 的工作方式）；叶子的视图被改（⚠️ x[0] = 1.0 报的是这一条，因为下标赋值底层是「先取视图再往视图里写」）；反向要用的中间结果被改（⚠️ 报在 backward() 那一行，真凶在几十行之前的前向里）。

⭐ 为什么 x * 2 不炸而 sigmoid 炸：判据是这个算子的反向要不要用它自己的输出——2x 什么都不存，而 exp/sigmoid/tanh/relu 都存输出。

💀 第四种根本不报错：.data 共享内存但不共享版本计数器，梯度会悄悄变成 0 而版本号纹丝不动；另一种是你还要用的张量被就地改掉，值全错、零报错。⭐ 防线：要留着用的先 .clone()，现代代码里不该出现 .data。

⚠️ no_grad 和 detach 都拦不住计数器：前者只管不新建图、版本号照加，后者只是另一个 Python 对象、同一块内存同一个计数器。

那还要不要用就地？要——optimizer.step() 和 zero_grad() 就是；非就地更新参数会让它变成非叶子，优化器手里那个一步都不会动。

下一节 👉 04-detach与no_grad.md