1. 从一次真实的报错说起:为什么我的loss.backward()炸了?
那天下午,我正在调试一个图像分类模型,代码跑得好好的,突然就给我甩了个脸子,终端里蹦出来一行刺眼的红字:RuntimeError: grad can be implicitly created only for scalar outputs。相信不少用过PyTorch的朋友都见过这个“老朋友”,尤其是在你刚接触CrossEntropyLoss,并且手贱(或者说,出于好奇)把reduction参数设成了'none'的时候。
这个报错翻译过来就是:“梯度只能为标量输出隐式地创建”。听起来有点绕,对吧?我用大白话给你解释一下:loss.backward()这个方法,它默认的“工作对象”是一个单一的数值,也就是一个标量。比如,你算出来一个损失值是0.85,那没问题,backward()知道该怎么做,它会沿着计算图一路回溯,算出每个参与运算的参数的梯度。但如果你给它的不是一个数,而是一坨数,比如一个形状为[32, 10]的张量(假设你batch size是32,有10个类别),backward()就懵了:“大哥,你这一下子给我32个样本各自的10个类别的损失,我该先算哪个的梯度?我又该把梯度累加到哪儿去?”
我当时的情况就是如此。我写了一句 loss = nn.CrossEntropyLoss(reduction='none'),本意是想看看每个样本的损失具体是多少,方便我做些样本级别的分析或者加权。结果在loss.backward()的时候,程序就直接“罢工”了。这个报错的核心,其实就是reduction这个参数在背后“捣鬼”。它决定了CrossEntropyLoss计算完损失之后,以什么样的形式交到你手上。是给你一个总览性的单一数字(mean或sum),还是把每个样本的“成绩单”都原封不动地给你(none)。而backward()这个函数,它有个“小脾气”:它只喜欢处理那份总览性的“成绩汇总”,不喜欢处理那一沓厚厚的、每个人的原始试卷。
所以,理解reduction,不仅仅是知道它有三个选项,更是理解PyTorch自动微分(autograd)机制如何工作的一把钥匙。选错了,轻则报错,程序跑不起来;重则可能 silently 地引入bug,让你的模型训练朝着错误的方向狂奔而不自知。接下来,我们就彻底掰开揉碎,看看这个reduction参数到底怎么玩,以及怎么避开它挖的坑。
2. 深入CrossEntropyLoss:reduction参数的三种面孔
要弄明白reduction,我们得先回到CrossEntropyLoss本身是干什么的。简单说,它常用于分类任务,把模型输出的原始分数(logits)和真实的类别标签,换算成一个衡量模型“犯错程度”的数值。这个换算过程本身,比如softmax加负对数似然,我们先不深究。关键是在这个换算之后,reduction参数登场了,它来决定如何“汇总”一个批次(batch)里所有样本的损失。
PyTorch官方给了我们三个选择:‘none’、‘mean’和‘sum’。我们一个一个来看,并用代码和例子把它们讲清楚。
2.1 reduction='none':最原始的“成绩单”
当你设置reduction='none'时,损失函数会变得非常“实诚”。它不会做任何额外的聚合操作,直接返回每个样本的损失值。
import torch
import torch.nn as nn
# 模拟一个batch:4个样本,3个类别
logits = torch.randn(4, 3) # 模型输出的原始分数,shape [4, 3]
labels = torch.tensor([0, 2, 1, 0]) # 真实标签,shape [4]
# 使用 reduction='none'
criterion_none = nn.CrossEntropyLoss(reduction='none')
loss_none = criterion_none(logits, labels)
print(f"logits shape: {logits.shape}")
print(f"loss_none value: {loss_none}")
print(f"loss_none shape: {loss_none.shape}")
运行这段代码,你会看到loss_none是一个形状为[4]的一维张量。它包含了4个独立的数值,分别对应batch中第1个样本的损失、第2个样本的损失……以此类推。
这有什么用呢? 场景其实很多。比如,你想做难例挖掘(Hard Example Mining),需要根据每个样本的损失大小来调整其权重,损失大的样本在下一轮训练中给予更多关注。或者,你在做某些自监督学习、对比学习任务时,需要构造样本对之间的特定损失关系。再比如,你只是想单纯地监控一下每个样本的损失分布,看看模型在哪些数据上表现不稳定。‘none’模式给了你最大的灵活性,让你能接触到最原始的损失信息。
但是,最大的“坑”也在这里:正如开篇报错所示,你无法直接将这个形状为[4]的张量扔给loss.backward()。因为backward()需要的是一个标量来启动整个链式求导过程。直接调用loss_none.backward(),百分百会触发RuntimeError。
2.2 reduction='mean':最常用的“平均分”
这是CrossEntropyLoss的默认参数。也就是说,如果你不指定reduction,用的就是它。
criterion_mean = nn.CrossEntropyLoss(reduction='mean') # 或者直接 nn.CrossEntropyLoss()
loss_mean = criterion_mean(logits, labels)
print(f"loss_mean value: {loss_mean}")
print(f"loss_mean shape: {loss_mean.shape}")
你会看到,loss_mean是一个标量(shape为torch.Size([])),它是一个单一的数值。这个数值是怎么来的呢?它就是上面loss_none里那4个损失值的算术平均值。
loss_mean = (loss_none[0] + loss_none[1] + loss_none[2] + loss_none[3]) / 4
为什么它是默认的,也是最常用的? 因为它符合我们最直观的认知:用一个数字来代表当前这个batch的整体表现。在梯度下降中,我们根据这个“平均损失”来更新模型参数,相当于认为batch中每个样本的贡献是均等的。这对于绝大多数标准的有监督分类任务来说,是合理且稳定的选择。而且,因为它返回的是标量,所以你可以安全地、直接地调用loss_mean.backward(),完全不用担心报错。
2.3 reduction='sum':简单的“总分”
这个选项也很好理解。
criterion_sum = nn.CrossEntropyLoss(reduction='sum')
loss_sum = criterion_sum(logits, labels)
print(f"loss_sum value: {loss_sum}")
print(f"loss_sum shape: {loss_sum.shape}")
同样,loss_sum也是一个标量。它的值是loss_none里所有损失值的总和。
loss_sum = loss_none[0] + loss_none[1] + loss_none[2] + loss_none[3]
它和mean有什么区别? 从标量的角度看,似乎没区别,都能用于backward()。但关键在于梯度的大小!当我们使用loss_mean.backward()时,计算出的梯度会先除以batch size(这里是4),然后再用于更新参数。而使用loss_sum.backward()时,梯度是原始的总和,没有除以batch size。
这意味着什么呢?假设你的学习率(lr)是0.01。使用mean时,每个样本对参数更新的平均“力度”被归一化了,更新步长相对稳定。使用sum时,参数更新的总“力度”会和batch size成正比。如果你的batch size翻倍,那么梯度总和也可能大致翻倍,导致实际更新步长变大,可能会让训练变得不稳定,需要你相应地调整学习率。
所以,在绝大多数情况下,使用默认的‘mean’是更省心、更标准化的做法。除非你有特殊的优化策略,明确需要损失的总和。
为了更直观,我们用一个表格来对比一下:
| reduction 参数 | 输出形态 | 计算公式(假设loss_none为[L1, L2, ..., Ln]) | 能否直接 .backward() | 常见使用场景 |
|---|---|---|---|---|
‘none’ | 张量 (shape [n]) | 返回 [L1, L2, ..., Ln] | 不能,会报错 | 需要样本级别损失的操作(如加权、难例挖掘、监控) |
‘mean’ | 标量 | (L1 + L2 + ... + Ln) / n | 能,最常用 | 标准的分类任务,默认选项 |
‘sum’ | 标量 | L1 + L2 + ... + Ln | 能 | 需要损失总和的任务,或与特定优化策略配合 |
3. 反向传播的“规矩”:为什么标量才是backward()的菜?
现在我们知道了,‘mean’和‘sum’出来的都是标量,可以直接backward(),而‘none’出来的是张量,直接backward()会报错。这背后的原因,我们需要深入到PyTorch的自动微分引擎——autograd里去理解。
你可以把神经网络的前向计算过程想象成搭建一个由各种运算(加法、乘法、矩阵乘、激活函数等)组成的计算图。图中的叶子节点是你的模型参数(requires_grad=True的Tensor),数据流经过中间节点,最终到达输出节点(你的损失值)。
loss.backward()这个指令的作用是:从输出节点(损失值)开始,沿着计算图逆向走一遍,利用链式法则,计算出图中每个叶子节点(参数)的梯度。关键问题来了:这个“逆向走一遍”的过程,需要一个明确的起点。如果终点(损失)是一个标量,比如5.2,那么求导的方向是明确的——就是对这个标量5.2求各个参数的偏导。
但如果终点是一个张量,比如形状是[4]的向量[1.2, 0.8, 2.1, 0.5],问题就复杂了。你是要对向量的第一个元素1.2求导,还是对第二个元素0.8求导?或者是对所有元素求导后的梯度再加起来?autograd系统无法自动做出这个决定,因为它不知道你的意图。这就是报错信息 grad can be implicitly created only for scalar outputs 中 implicitly(隐式)的含义。对于标量输出,PyTorch可以隐式地、唯一地确定求导目标。对于张量输出,你必须显式地告诉它该怎么做。
那么,怎么“显式地”告诉backward()呢?这就是解决reduction='none'报错的钥匙。
4. 实战排雷:解决“none”模式下的反向传播报错
当我们因为某种原因必须使用reduction='none',但又需要做反向传播更新参数时,有几种标准的解决方法。这些方法的核心思想都是一致的:将张量损失(loss tensor)转换为一个标量损失(scalar loss)。
4.1 方法一:手动求和后再backward
这是最直接、最好理解的方法。既然backward()需要标量,那我们就自己造一个标量。对loss_none这个张量所有元素求和,得到的就是一个标量,这个标量在数值上等于reduction='sum'的结果。
# 假设我们已经有了 reduction='none' 的损失
loss_none = criterion_none(logits, labels) # shape [4]
# 错误做法:直接 backward,会报错!
# loss_none.backward()
# 正确做法:先求和,得到一个标量
loss_scalar = loss_none.sum()
print(f"手动求和后的标量损失: {loss_scalar}")
# 现在可以安全地进行反向传播了
loss_scalar.backward()
# 检查某个参数的梯度是否被计算了(例如,如果logits是模型输出,其上游参数梯度会被更新)
# 假设我们有一个简单的模型
model = nn.Linear(10, 3)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# ... 前向传播得到 logits ...
# logits = model(some_input)
# loss_none = criterion_none(logits, labels)
# loss_none.sum().backward() # 这样就能更新model.parameters()的梯度了
# optimizer.step()
这个方法的效果等同于使用reduction='sum'吗? 是的,在数值计算上是完全等价的。调用criterion_sum(logits, labels).backward()和调用criterion_none(logits, labels).sum().backward(),最终计算出的参数梯度是一模一样的。因为计算图是一样的,只是聚合操作(sum)发生的位置不同而已。
4.2 方法二:使用backward(gradient)参数
这是PyTorch提供的一个更通用的接口,也是理解张量反向传播的关键。loss_tensor.backward()其实可以接受一个参数,叫做gradient或者grad_tensors。这个参数就是用来“显式”指定如何对张量输出求导的。
loss_none = criterion_none(logits, labels) # shape [4]
# 创建一个与loss_none形状相同的“权重”张量,这里我们使用全1。
gradient_weights = torch.ones_like(loss_none)
print(f"gradient_weights: {gradient_weights}")
# 使用带参数的backward
loss_none.backward(gradient=gradient_weights)
这行代码loss_none.backward(gradient=gradient_weights)在做什么呢?它实际上是在计算一个加权和的梯度。等价于先计算 (loss_none * gradient_weights).sum() 这个标量,然后再对这个标量进行反向传播。
因为我们的gradient_weights是全1张量,所以(loss_none * 1).sum()就是loss_none.sum()。因此,方法二在gradient_weights全为1时,和方法一是完全等价的。
那这个gradient参数有什么用武之地呢? 它的威力在于可以给每个样本的损失分配不同的权重!这正好呼应了我们使用reduction='none'的初衷之一。
假设我们的4个样本里,第2个和第4个样本更重要,我们希望它们在反向传播中的“话语权”是其他样本的2倍。
loss_none = criterion_none(logits, labels) # 假设值为 [1.2, 0.8, 2.1, 0.5]
# 创建自定义权重:样本0和2权重为1,样本1和3权重为2
custom_weights = torch.tensor([1.0, 2.0, 1.0, 2.0])
print(f"自定义权重: {custom_weights}")
# 进行加权反向传播
loss_none.backward(gradient=custom_weights)
这等价于计算标量损失:1.2*1.0 + 0.8*2.0 + 2.1*1.0 + 0.5*2.0 = 1.2 + 1.6 + 2.1 + 1.0 = 5.9,然后对这个5.9进行反向传播。这样,在参数更新时,第1和第3个样本(索引1和3)的梯度贡献就被放大了。这就是实现样本加权损失的核心操作。很多论文中提到的Focal Loss等,在实现时其本质就是在计算完每个样本的损失后,乘以一个根据难易度动态计算的权重,然后通过这种方式进行反向传播。
4.3 方法对比与选择
| 解决方法 | 代码示例 | 本质 | 适用场景 |
|---|---|---|---|
| 手动求和 | loss_none.sum().backward() | 将reduction='none'转为reduction='sum' | 需要样本损失信息,但更新时希望所有样本平等贡献(或你后续会手动调整学习率)。 |
| backward(gradient) | loss_none.backward(torch.ones_like(loss_none)) | 指定张量输出的梯度权重,计算加权和标量的梯度。 | 更通用。1. 实现样本加权(如Focal Loss)。2. 当损失是向量/张量且每个元素对应不同任务时,指定不同权重。 |
个人经验与建议:如果你只是不小心用了‘none’遇到了报错,想快速修复,用loss.sum().backward()是最清晰的。但如果你是因为需要样本权重而使用‘none’,那么一定要学会并使用backward(gradient)这个方法,它是PyTorch为你提供的强大工具。理解gradient参数,是你从PyTorch使用者迈向理解其底层机制的重要一步。
5. 避坑指南与进阶思考
知道了怎么解决报错,我们再来聊聊怎么从一开始就避免踩坑,以及一些更深入的考量。
5.1 如何正确选择reduction参数?
这是一个“目的决定手段”的问题。
- 99% 的常规分类训练:无脑用默认的
reduction='mean'。这是最安全、最标准、最不容易出错的选项。它保证了损失值和梯度规模对batch size不敏感,学习率设置更有普适性。 - 当你需要调试、分析或实现特定算法时:使用
reduction='none'。- 调试:打印每个样本的损失,看看有没有异常值(比如非常大的损失),这能帮你发现错误标注的数据或训练不稳定的问题。
- 分析:计算损失的标准差、分布等统计信息。
- 实现特定算法:如Focal Loss、样本权重学习、对比学习中的InfoNCE损失(需要构造正负对)等。记住,用了
‘none’,99%的情况下你需要手动处理反向传播,要么.sum().backward(),要么用带权重的.backward(gradient)。
- 特殊场景:考虑使用
reduction='sum'。- 当你的batch size是变化的,并且你希望每个样本的梯度贡献绝对平等,不受batch大小影响时。因为
mean会使小batch的平均梯度“虚高”,大batch的平均梯度“稀释”。而sum能保证每个样本产生的梯度量是恒定的。但这时你必须非常小心地调整全局学习率,因为总的梯度规模会和数据量成正比。 - 在某些分布式训练或梯度累积的设置中,为了保持梯度累加逻辑的一致性,有时也会使用
sum。
- 当你的batch size是变化的,并且你希望每个样本的梯度贡献绝对平等,不受batch大小影响时。因为
5.2 不止CrossEntropyLoss:其他损失函数的reduction
reduction参数并非CrossEntropyLoss独有。PyTorch中绝大多数内置的损失函数,如MSELoss、L1Loss、BCELoss等,都有这个参数,且含义完全相同。所以,你今天为CrossEntropyLoss学到的所有关于reduction和backward的知识,可以无缝应用到其他损失函数上。这是一个一通百通的知识点。
5.3 梯度累积(Gradient Accumulation)下的微妙区别
在GPU内存不够,需要用小batch模拟大batch训练时,我们常用梯度累积技术:多次前向传播,累加梯度,再一次性更新参数。
accumulation_steps = 4
optimizer.zero_grad()
for i, (data, target) in enumerate(dataloader):
output = model(data)
loss = criterion(output, target) # 默认是 ‘mean’
# 将损失除以累积步数,使得“有效”损失是多次的平均
loss = loss / accumulation_steps
loss.backward()
if (i+1) % accumulation_steps == 0:
optimizer.step()
optimizer.zero_grad()
在这个例子里,我们用的是reduction='mean'。注意loss = loss / accumulation_steps这一行。因为每次backward()的损失已经是当前micro-batch的平均值了,我们再除以accumulation_steps,是为了让累积4步后的总梯度,等价于用一个4倍大的batch做一次mean得到的梯度。
试想,如果这里criterion用的是reduction='sum'会怎样? 那么loss已经是当前micro-batch的总和。为了模拟大batch的mean,我们需要除以 (micro_batch_size * accumulation_steps),逻辑会变得更绕一些。这再次说明了,在大多数情况下,坚持使用‘mean’能让你的训练代码逻辑更清晰、更不容易出错。
5.4 一个隐蔽的坑:损失张量间的运算
有时候我们可能会对损失值进行一些运算,比如:
loss1 = criterion1(output, target) # 假设是标量
loss2 = criterion2(output, target) # 假设是标量
total_loss = loss1 + loss2
total_loss.backward()
这没问题。但如果criterion设置成了‘none’:
loss1_none = criterion1(output, target) # 形状 [batch_size]
loss2_none = criterion2(output, target) # 形状 [batch_size]
# 错误!此时 total_loss 仍然是张量,不是标量
total_loss = loss1_none + loss2_none
# total_loss.backward() # 这里会报错!
即使你把两个‘none’的损失相加,结果还是一个相同形状的张量,依然不能直接backward()。你必须先把这个相加后的张量聚合为标量:
total_loss_scalar = (loss1_none + loss2_none).sum() # 或者 .mean()
total_loss_scalar.backward()
这个坑提醒我们,在处理损失时,心里要始终绷紧一根弦:最终送去backward()的那个东西,必须是一个标量。
回过头看最开始的那个报错 RuntimeError: grad can be implicitly created only for scalar outputs,它不再是令人头疼的错误,而是一个清晰的提示,提醒我们去检查损失函数的reduction设置,去思考我们到底需要一个样本级别的损失,还是一个汇总的损失。理解并正确运用reduction参数,是写出正确、高效且灵活的PyTorch训练代码的基本功。下次当你定义损失函数时,不妨花一秒钟想想:我这次需要的是“成绩单”,是“平均分”,还是“总分”?想清楚了,很多bug就从源头被消灭了。
214



被折叠的 条评论
为什么被折叠?



