1. 从一行报错开始说起为什么全网都在问这句代码如果你在某个深度学习交流群里待过哪怕一个星期一定会看到类似这样的对话新手A“兄弟们我刚写了个网络训练的时候报错了说loss.backward()有问题这是啥意思”新手B“我照着教程抄的前三行都懂到了loss.backward()就懵了这行到底在干嘛”新手C“我把loss.backward()删了之后 loss 不下降了加上又报梯度为 None谁能救救我”这三个问题本质上都在问同一件事loss.backward()到底什么含义它背后到底发生了什么以及为什么它如此重要。我先给出一个一句话版本的回答loss.backward()的作用是——从损失值出发沿着计算图反向传播把“损失对每一个可训练参数的梯度”计算出来并累加到各个参数的.grad属性上。但是说实话这句话对新手来说仍然像天书。真正要搞懂它你需要理解至少三层东西什么是梯度——它决定了参数往哪个方向更新。什么是计算图——它决定了梯度能怎么算出来。什么是反向传播——它决定了为什么一个backward()就能搞定所有参数的梯度。这篇文章会从这三个层面拆开讲然后再回到loss.backward()本身把常见报错、常见误解、以及实际训练中的坑全部过一遍。读完之后你不仅知道这句话是什么意思还能自己排查那些“梯度为 None”“inplace 操作报错”“梯度累积爆炸”的问题。2. 梯度到底是什么一句被用滥了的“导数”到底在说什么要理解loss.backward()先得理解它计算出来的东西——梯度——到底有什么用。2.1 用一个下山场景理解“梯度”想象你在一片山谷里被蒙住眼睛手里只有一根拐杖任务是走到山谷最低点。你看不见全貌但能感觉到脚下的坡度——往左走地势更低往右走地势更高。你知道该怎么走吗很简单每次朝“下降最快”的方向迈一步。在这个比喻里你的位置就是模型的参数比如权重 w山谷高度就是损失值 loss而拐杖感受到的坡度就是梯度。梯度告诉你的是如果我把某个参数往正方向挪一点点损失会变大还是变小以及变化的幅度有多大。具体到数学上对于一个参数 w损失函数 L 对 w 的偏导数[ \frac{\partial L}{\partial w} ]如果这个值是 3.0意味着 w 增加一点点损失会增加大约 3 倍那么多如果这个值是 -2.5意味着 w 增加一点点损失反而会减小大约 2.5 倍那么多。所以参数更新的规则就自然出现了把 w 往梯度的反方向挪一步。[ w w - \eta \cdot \frac{\partial L}{\partial w} ]这个 \eta 就是学习率learning rate控制每一步迈多大。2.2 为什么说“梯度是向量而不是一个数”很多人有个误解觉得梯度就是一个数字。实际上当你的模型有多个参数时梯度是一个向量每个参数对应一个分量。比如一个简单的线性模型[ y w_1 x_1 w_2 x_2 b ]这里需要求梯度的参数是 (w_1, w_2, b) 三个。loss.backward()算完之后这三个参数各自会得到一个梯度和.grad属性分别存在w1.grad、w2.grad、b.grad里。这也是为什么训练代码里常见这个三段式optimizer.zero_grad() # 把上次的梯度清零 loss.backward() # 计算当前这批数据的梯度 optimizer.step() # 用梯度更新参数zero_grad()是必须的因为梯度是累加的不清理的话上一次的梯度会和这次的叠加在一起。2.3 为什么梯度方向是“下降方向”而不是“上升方向”这个问题很多新手会绕晕。导数的定义就是函数值的变化率但导数为正说明函数在上升那我们要下降不应该走反方向吗对所以参数更新用的是负梯度方向。这里有个容易混淆的点loss.backward()算的是“梯度”而不是“更新量”。它只是告诉你方向真正往哪走是优化器optimizer根据梯度反方向决定的。所以在代码里backward()之后你通常会看到optimizer.step() # 内部执行param.data - lr * param.grad注意这个公式里的减号就是“反方向”的体现。3. 计算图为什么 PyTorch 能自动算出所有梯度理解了梯度是什么下一个问题就是PyTorch 是怎么知道每个参数该用哪条路径来求梯度的这就需要引入计算图的概念。3.1 动态计算图的构建过程当你写这样一段代码import torch x torch.tensor([2.0], requires_gradTrue) w torch.tensor([3.0], requires_gradTrue) b torch.tensor([1.0], requires_gradTrue) y w * x b loss (y - 5) ** 2PyTorch 并没有真的“啪”一下算完就丢而是在计算过程中自动记下了每一步操作符和操作数之间的关系形成一张有向无环图DAG。这张图大概长这样loss (y - 5)^2 | v y w * x b / | \ w x b每次你调用w * x、(y - 5)、平方操作时PyTorch 都会在后台创建一个节点记录“这个结果是由谁和谁计算出来的”。这就是为什么 PyTorch 被称为“动态计算图”框架——图是在运行时实时构建的而不是像某些老派框架那样先定义好静态图再执行。3.2 requires_grad 标志梯度计算的准入证不是所有张量都需要梯度。输入数据 x 通常不需要因为你不希望更新输入但参数 w 和 b 需要因为你要更新它们。这种区别就靠一个属性控制x torch.tensor([2.0], requires_gradFalse) # 不追踪梯度 w torch.tensor([3.0], requires_gradTrue) # 追踪梯度如果一个张量的requires_gradFalse那么它参与计算时PyTorch 不会为它建立反向传播的路径——它就像一个透明人只参与正向计算不参与梯度回溯。这也是后面排查“梯度为 None”问题时最常见的检查点之一你确认过那些参数真的 requires_gradTrue 吗3.3 叶子节点与非叶子节点的区别计算图上还有一个概念容易把人绕晕叶子节点。简单说叶子节点就是用户直接创建的张量比如上面的 w、b、x。而非叶子节点是根据其他张量计算出来的中间结果比如 y、loss。当你调用loss.backward()时PyTorch 会从 loss 出发沿着计算图反向走最后把梯度只存放在 requires_gradTrue 的叶子节点的 .grad 属性上。中间变量如 y默认不会保存梯度除非你显式调用retain_grad()。不过在实际训练中我们几乎不需要中间变量的梯度所以这个默认行为是合理的。提示如果你的模型是层层堆叠的神经网络中间激活值有很多层但真正需要求梯度、并且会拿去更新的是网络参数——它们恰好都是叶子节点。4. backward() 的内部过程链式法则怎么被代码化现在到了最关键的部分backward()内部到底怎么把“一个 loss 的梯度”扩散到所有参数上的。这里绕不开一个数学工具——链式法则。4.1 链式法则从小学就学过的“复合函数求导”回顾一下复合函数求导公式如果 (z f(g(x)))那么[ \frac{dz}{dx} \frac{dz}{dg} \cdot \frac{dg}{dx} ]意思就是要求 z 对 x 的导数可以先求出 z 对中间变量 g 的导数再乘以 g 对 x 的导数。神经网络就是无数个这样的复合函数套在一起。loss 在最外层参数在最里层中间的每一层都是一个中间变量。链式法则让我们可以逐层往回乘最终得到 loss 对每个参数的偏导。4.2 PyTorch 的反向传播实现梯度从一个点开始蔓延继续看 3.1 的例子。执行loss.backward()PyTorch 内部会做以下事情从 loss 节点出发先计算 loss 对 y 的梯度。然后顺着 y w*x b分别计算 y 对 w、y 对 x、y 对 b 的梯度。把这些偏导相乘链式法则得到 loss 对 w、b 的最终梯度。把结果写入 w.grad、b.grad。具体数值可以手算验证loss (y - 5)^2令 u y - 5则 loss u^2先算 loss 对 y 的梯度dloss/dy 2*(y-5)代入 y 32 1 7得到 dloss/dy 2(7-5) 4再看 y w*x b 对 w 的梯度dy/dw x 2链式相乘dloss/dw 4 * 2 8同理 dloss/db 4 * 1 4所以运行完loss.backward()后w.grad会等于tensor([8.])b.grad会等于tensor([4.])。你可以自己跑一下验证基本上就是这个值。4.3 为什么是一趟“传播”而不是逐个求导你可能想问为什么 PyTorch 不直接对每个参数单独求偏导非要搞这么一套传播机制因为参数太多了。一个几百万参数的神经网络如果每个参数都用数值微分法或者逐个求导计算量会爆炸。而反向传播的思想是每个中间结果只需要被计算一次然后沿着路径复用。打个比方你要在一个庞大的园区里给所有房间发通知。你不需要派一个信使从总部单独跑去每个房间——那样会产生 N 条路径。你只需要让信使从总部出发每到一个节点就复制一份通知继续往外发最终每个房间都收到通知而且总路径只是整个园区的网络结构。backward()就是那个信使。4.4 一个容易忽略的细节梯度是累加的前面提到过zero_grad()的重要性这里再展开一下。PyTorch 的backward()计算出的梯度会加到原有的.grad之上而不是覆盖。也就是说loss1.backward() # w.grad 8 loss2.backward() # w.grad 8 另一个值如果你没有在中间调用optimizer.zero_grad()梯度就会越积越大产生意想不到的训练行为。为什么会这样设计因为在某些场景下你确实需要累积梯度比如梯度累积技术——当显存不足、无法使用大批量时可以先跑几个小批次累加梯度再一次更新参数。但在常规训练里你必须每次迭代开始前清零for epoch in range(num_epochs): for batch in dataloader: optimizer.zero_grad() # 清零避免累加 outputs model(batch) # 前向 loss criterion(outputs, targets) # 算损失 loss.backward() # 反向计算梯度 optimizer.step() # 更新参数这个四行组合拳是几乎所有 PyTorch 训练循环的骨架。5. 实战拆解手写一个完整例子并观察梯度变化光讲理论不够我带你完整跑一个例子亲眼看看backward()前后到底发生了什么。5.1 一个最简单的线性回归手工实现我们不调任何高级封装完全用最底层 API 写一个线性回归。import torch # 造一组带噪声的线性数据y 2x 1 noise torch.manual_seed(42) x_data torch.linspace(0, 1, 100).reshape(-1, 1) y_data 2 * x_data 1 0.1 * torch.randn(100, 1) # 初始化参数 w torch.randn(1, 1, requires_gradTrue) b torch.zeros(1, 1, requires_gradTrue) learning_rate 0.1 loss_fn torch.nn.MSELoss() # 训练 50 轮 for epoch in range(50): # 前向传播 y_pred x_data w b loss loss_fn(y_pred, y_data) # 反向传播之前先看一眼梯度 if epoch 0: print(反向传播前 w.grad:, w.grad) print(反向传播前 b.grad:, b.grad) # 反向传播 loss.backward() if epoch 0: print(反向传播后 w.grad:, w.grad) print(反向传播后 b.grad:, b.grad) # 手动更新等效于 optimizer.step() with torch.no_grad(): w - learning_rate * w.grad b - learning_rate * b.grad # 清零梯度否则会累积 w.grad.zero_() b.grad.zero_() if epoch % 10 0: print(fEpoch {epoch}, Loss: {loss.item():.6f})运行这个代码你会看到第一轮输出类似反向传播前 w.grad: None 反向传播后 w.grad: tensor([[...]]) 反向传播后 b.grad: tensor([[...]])注意这个None——在第一次backward()之前参数上的 .grad 是 None而不是 0。这是新手排查时最容易忽略的细节。5.2 观察训练过程中参数是如何逼近真实值的训练结束后打印 w 和 bprint(训练得到的 w:, w.item()) print(训练得到的 b:, b.item())你会发现 w 会逼近 2b 会逼近 1。这正是因为我们每轮都在用loss.backward()算出来的梯度朝反方向更新参数。如果你把loss.backward()注释掉训练就不会有任何变化——因为w.grad还是 Nonew - lr * None会直接报错。5.3 如果用高级 APIbackward 藏在哪了实际项目里我们通常会用到torch.nn.Linear、optimizer.Adam这些高层封装但loss.backward()这一行仍然必不可少import torch import torch.nn as nn model nn.Linear(1, 1) optimizer torch.optim.SGD(model.parameters(), lr0.1) loss_fn nn.MSELoss() # ... 数据准备省略 ... for epoch in range(50): optimizer.zero_grad() y_pred model(x_data) loss loss_fn(y_pred, y_data) loss.backward() # 这一行仍然在 optimizer.step() # 这一行用到了 backward 算出的梯度即使你用了 10 层 Transformer本质依然没变backward 负责算梯度step 负责用梯度更新参数。6. 常见报错的根因梯度为 None、inplace 操作、标量问题现在讲实战中最常见的三类问题。这些坑每一个我都踩过写出来帮你省时间。6.1 “梯度为 None” 的五种情况报错信息里如果出现RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn或者直接w.grad is None优先检查这五项情况根因解决办法requires_gradFalse参数没有开启梯度追踪创建张量时加requires_gradTrue或确保参数被nn.Parameter包装断开了计算图用了.detach()或torch.no_grad()切断了反向传播路径去掉不必要的 detach确认计算路径是连续的参数未参与计算网络里有分支部分参数没被用到检查模型前向逻辑确认参数参与了 loss 的计算叶子节点被原地修改.data赋值或 inplace 操作破坏了 autograd 追踪用param.data ...或重建参数避免 inplace 修改自定义层没注册自定义模块里的参数没放进self.xxx nn.Parameter(...)用nn.Parameter注册参数6.2 “inplace 操作”报错为什么不能“原地修改”PyTorch 的报错信息里有一句经典的话RuntimeError: a leaf Variable that requires grad is being used in an in-place operation.这句话的意思是说你对一个需要梯度的叶子节点做了原地修改比如w 1、w.data.fill_(0)导致 autograd 记录的计算图信息失效了。为什么不能原地修改因为backward()需要使用计算图里保存的原始值来求导。如果中间某个值被改了梯度计算结果就不准确了。比如w torch.tensor([3.0], requires_gradTrue) w.add_(1) # 报错正确做法是用w.data.add_(1)或者直接重新赋值w torch.tensor([3.0], requires_gradTrue) w w 1 # 这样会生成新的叶子节点或者用with torch.no_grad(): w.add_(1)——但这样同样会切断梯度路径所以一般只在更新参数时用。6.3 “backward 只能对标量”到底什么意思又一个经典报错RuntimeError: grad can be implicitly created only for scalar outputs这个是因为loss如果是一个向量或矩阵直接backward()会不知道从哪个方向“回传”。链式法则要求初始梯度是一个标量方向的起始值。所以要么保证 loss 是标量大多数情况下MSELoss()、CrossEntropyLoss()会内部做 reduce输出是标量要么传一个和 loss 形状相同的权重向量作为gradient参数loss loss_vector.mean() # 方法1手动 reduce 成标量 # 或者 loss.backward(gradienttorch.ones_like(loss)) # 方法2指定初始梯度权重日常训练中你几乎不需要用第二种但如果你做多任务学习不同任务 loss 相加后直接 backward本质上也是先加成了标量再传播。7. backward() 的那些“隐藏”行为retain_graph、梯度累积、多任务进阶一点的用法会触及backward()的参数我挑几个高频场景讲透。7.1 retain_graph什么时候需要保留计算图默认情况下backward()执行完后计算图的中间缓存会被释放以节省内存。如果你在同一张图上调用两次backward()第二次就会报错RuntimeError: Trying to backward through the graph a second time, but the saved intermediate results have already been freed.解决办法是设置retain_graphTrueloss.backward(retain_graphTrue) # 保留计算图允许二次 backward loss2.backward()这个需求的常见场景是多任务学习一个网络有多个 loss分别对同一套参数求梯度。注意retain_graphTrue会增加内存占用用完及时设回 False避免显存持续飙高。7.2 梯度累积小显存跑大批量的一种技巧显存不够怎么办梯度累积是一种很流行的方案accumulation_steps 4 # 模拟 batch_size 放大 4 倍 loss 0 for i, (inputs, labels) in enumerate(dataloader): loss model(inputs).loss # 这里只累加 loss if (i 1) % accumulation_steps 0: loss.backward() optimizer.step() optimizer.zero_grad() loss 0注意这里不是每个 batch 都 backward而是累积 4 个 batch 的 loss 之后再做一次 backward。这不仅能省显存还能稳定梯度方向。但要小心累加 loss 的时候不要直接loss ...用一个张量反复加否则计算图会越来越深内存爆炸。正确做法是backward 之后再清零重新累加。7.3 多 loss 场景下梯度会互相影响吗多任务模型经常这样写total_loss loss1 0.5 * loss2 total_loss.backward()本质上backward()对两个分支分别求梯度然后累加到共享参数的.grad上。所以多 loss 的权重系数直接决定了共享层参数更新的偏向。如果 loss1 数量级远大于 loss2模型会偏向优化任务1导致任务2学不好。这里要用到一个小技巧在 backward 之前把各个 loss 归一化到相近的数量级或者用 GradNorm 之类的动态权重方法。但最省事的还是手动调权重。7.4 梯度剪裁backward 之后的常用自救手段梯度爆炸是训练 RNN 或 Transformer 时常见的问题。backward 之后、step 之前做梯度裁剪loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm1.0) optimizer.step()这样能让梯度范数不超过 1.0避免参数一步跳得太远。这行代码的位置很讲究必须在 backward 和 step 之间。你放在 backward 前没有意义放在 step 后又已经晚了。8. 深入理解backward() 与优化器的分工边界很多同学会把backward()和optimizer.step()混在一起觉得它们是一回事。其实二者分工完全不同。8.1 backward 只是“算”step 才是“动”拿做饭打比方loss.backward()等于看菜谱、称量食材——你知道了每样调料该放多少梯度。optimizer.step()等于真正动手炒菜——你把调料按比例放进去更新参数。没有 backwardstep 无米下锅没有 stepbackward 算出的梯度只会躺在.grad里模型永远不变。8.2 不同优化器对梯度的利用方式不同SGD直接使用梯度param - lr * gradMomentum会累积一个“动量项”把历史梯度加权进去Adam会维护一阶矩和二阶矩估计再归一化更新但无论哪种优化器输入的原始梯度都是 backward 算出来的那一个优化器只是在梯度基础上做各种加工。8.3 自定义优化逻辑绕过 optimizer 直接手动更新如果你想完全掌控更新过程可以不用optimizer.step()而是手动写loss.backward() with torch.no_grad(): for p in model.parameters(): if p.grad is not None: p - 0.01 * p.grad这样代码会变成一个极简版 SGD。但实际项目中我不建议这么干因为optimizer封装了大量细节如权重衰减、动量、学习率调度手写容易出错。8.4 学习率调度器与 backward 的关系torch.optim.lr_scheduler通常在每个 epoch 结束时更新学习率它不关心 backward 具体做了什么只关心当前的 epoch 数。scheduler.step() # 通常放在整个 epoch 循环之后这个步骤不要放在每次 backward 后否则学习率会过快地衰减。9. 排查手册当我看到“loss 不下降”时应该怀疑 backward 吗最后给一份实用的排查清单。当你训练效果不佳而怀疑对象是loss.backward()时按这个顺序排查9.1 第一步确认梯度确实被计算出来了在训练循环里手动打印几个参数loss.backward() for name, param in model.named_parameters(): if param.grad is not None: print(name, torch.norm(param.grad).item())如果打印出来全是 0.0说明梯度是 0问题在数据或网络结构如果全是 None说明路径断裂问题在 autograd 追踪。如果梯度值忽大忽小、甚至出现 NaN那就是数值不稳定考虑加归一化层、梯度裁剪、调整学习率。9.2 第二步确认 step 真的执行了有些代码在循环里漏了optimizer.step()导致 loss 一直不降。检查四行组合拳是否齐全。9.3 第三步确认学习率不是 0 或过小学习率太小会导致 loss 下降慢到肉眼不可见。试着把学习率从 1e-3 调到 1e-1看看 loss 是否明显下降。如果 1e-1 时 loss 直接爆炸说明学习率过大再从 1e-2 开始调。9.4 第四步确认 loss 数值本身合理如果 loss 一开始就是 0 或非常小那么梯度也会很小甚至为 0backward 再正确也没有意义。检查数据标签是否错位、模型是否退化比如所有输出恒为常数。9.5 第五步确认没有把 backward 放在 no_grad 上下文里这个是我见过最隐蔽的坑with torch.no_grad(): loss model(x) loss.backward() # 这里虽然不报错但梯度根本不会计算no_grad上下文会禁用所有梯度追踪backward()在这个上下文里面相当于空操作。代码不报错损失不下降非常难排查。排查方法是在 backward 之前打印loss.requires_grad。如果输出False说明 loss 是在 no_grad 环境里计算出来的梯度路径断了。10. 亲手验证一次 backward 的实际行为看到这里你可能还想亲手验证一下 backward 的“延迟生效”和“累加属性”。下面这个脚本可以在 10 秒钟内帮你建立直觉。import torch x torch.tensor(2.0, requires_gradTrue) y x ** 2 print(计算 y 之后x.grad:, x.grad) # None因为还没 backward y.backward() print(第一次 backward 后x.grad:, x.grad) # 4.0 ( 2 * 2) # 再算一次 y 并再次 backward y2 x ** 2 y2.backward() print(第二次 backward 后x.grad:, x.grad) # 8.0累加了如果你把最后打印的 x.grad 从 4.0 变成 8.0你就真正感受到“梯度是累加的”这句话的重量。接下来验证 retain_graphy x ** 2 y.backward() # 第一次正常工作 # y.backward() # 如果取消注释会报错 y.backward(retain_graphTrue) # 加了这个就能再来一次 print(使用 retain_graph 后的 x.grad:, x.grad)我再给你一个有趣的小实验验证“梯度方向是 loss 下降方向”。w torch.tensor(1.0, requires_gradTrue) loss (w - 3) ** 2 # 想让 w 走向 3 loss.backward() print(loss 对 w 的梯度:, w.grad) # 类似 -4.0说明 w 需要增大 with torch.no_grad(): w - 0.1 * w.grad print(更新后的 w:, w.item()) # 1.4比 1.0 更接近 3 了这里的梯度为负说明增大 w 能减少 loss所以更新时用w - lr * grad会让 w 增大。11. 我的经验总结关于 backward 的一些“肌肉记忆”最后聊几个我在实际项目中形成的肌肉记忆希望能帮你少走弯路。第一训练循环里四行组合拳永远按顺序写。zero_grad→forward→loss→backward→step顺序不能乱。zero_grad必须放在backward之前step必须放在backward之后。第二调试时多打印loss.requires_grad。只要看到False前向传播一定有问题别浪费时间查 optimizer。这个习惯帮我定位过至少三次“看起来完全正常但 loss 不下降”的诡异 bug。第三不要随便用.detach()。新手为了打印数值方便经常在 loss 上调用.detach()再.item()这没问题。但有人会把.detach()用在中间层输出上直接切断梯度流导致底层参数梯度为 None。如果你只是想要数值请只在打印或统计时 detach不要把它嵌进前向传播路径。第四遇到 inplace 报错先停手想一想结构不要强行.data绕过。很多人一遇到 inplace 报错就改成.data操作虽然不报错了但梯度路径也被切断了。更合理的方案是重构代码避免对 requires_grad 的张量做原地修改比如把param.add_(x)改成param param x。第五把 backward 当作“查漏工具”来用。当你对某个计算过程不放心可以在 forward 过程中给某些张量设置requires_grad_(True)然后 backward 后查看它们的梯度。这能帮你判断这个张量对 loss 是否有贡献。梯度为 0 不代表没贡献但梯度为 None 就说明路径断了。loss.backward()这一行代码看起来简单但它承载的是整个深度学习训练的核心机制。从梯度的定义到计算图的构建再到链式法则的自动传播每一步都环环相扣。搞懂它你就掌握了“模型如何学习”的最小闭环——以后不管换什么网络结构、什么优化器这行代码的意义都不会变。