别再混淆了！PyTorch里NLLLoss和CrossEntropyLoss到底啥关系？一个例子讲清楚

深入解析PyTorch中的NLLLoss与CrossEntropyLoss：从数学原理到代码实践

在深度学习模型的训练过程中，损失函数的选择直接影响着模型的收敛速度和最终性能。对于分类任务而言，负对数似然损失(NLLLoss)和交叉熵损失(CrossEntropyLoss)是最常用的两种损失函数。许多PyTorch开发者在使用时会感到困惑：它们之间到底有什么区别？为什么有时候计算结果相同？本文将带你彻底理清这两个损失函数的关系。

1. 理解分类任务中的损失函数基础

当我们构建一个分类模型时，模型会为每个输入样本输出一个概率分布，表示该样本属于各个类别的可能性。损失函数的作用就是量化模型预测的概率分布与真实分布之间的差异。

在PyTorch中，nn.NLLLoss()和nn.CrossEntropyLoss()都常用于分类任务，但它们的设计理念和使用方式有所不同。要真正理解它们的区别和联系，我们需要从数学基础开始。

1.1 似然与最大似然估计

似然(Likelihood)是统计学中的一个核心概念，它描述的是在给定模型参数下，观察到当前数据的概率。与概率不同，似然关注的是参数而非事件。

最大似然估计(Maximum Likelihood Estimation, MLE)是一种参数估计方法，其目标是找到一组参数，使得在这组参数下观察到当前数据的概率最大。用数学表达式表示就是：

$$ \hat{\theta} = \arg\max_{\theta} P(X|\theta) $$

其中，$X$是观察到的数据，$\theta$是模型参数。

1.2 从似然到负对数似然

在实际应用中，我们通常会对似然函数取对数，转化为对数似然(Log-Likelihood)。这样做有几个好处：

1. 将连乘转换为连加，简化计算
2. 避免数值下溢问题
3. 保持函数的单调性，不影响极值点的位置

对数似然的表达式为：

$$ \log P(X|\theta) = \sum_{i=1}^n \log P(x_i|\theta) $$

为了将其转化为最小化问题（这是优化算法的常规做法），我们进一步取负，得到负对数似然(Negative Log-Likelihood, NLL)：

$$ NLL = -\log P(X|\theta) = -\sum_{i=1}^n \log P(x_i|\theta) $$

在分类问题中，我们希望最小化这个负对数似然值，即找到使模型预测概率最大的参数。

2. 交叉熵与负对数似然的关系

交叉熵(Cross Entropy)是信息论中的概念，用于衡量两个概率分布之间的差异。给定真实分布$p$和预测分布$q$，交叉熵定义为：

$$ H(p,q) = -\sum_x p(x)\log q(x) $$

在分类任务中，真实分布$p$通常是one-hot编码（即真实类别概率为1，其他为0），因此交叉熵可以简化为：

$$ H(p,q) = -\log q(y) $$

其中$y$是真实类别。这与负对数似然的表达式完全一致。这就是为什么在分类问题中，交叉熵损失和负对数似然损失本质上是相同的。

2.1 数学等价性的证明

让我们更严谨地证明这一点。假设我们有一个分类问题，类别数为$C$，真实标签为$y$（one-hot编码），模型预测的概率分布为$\hat{y}$。

负对数似然损失为：

$$ NLL = -\log \hat{y}_y $$

交叉熵损失为：

$$ CE = -\sum_{i=1}^C p_i \log \hat{y}_i = -\log \hat{y}_y $$

因为$p_i=1$当且仅当$i=y$，否则$p_i=0$。因此两者在分类问题中是完全等价的。

2.2 为什么PyTorch中有两个实现？

既然数学上是等价的，为什么PyTorch要提供两个不同的实现呢？这主要是出于计算效率和接口设计的考虑：

1. 计算流程的差异：CrossEntropyLoss内部组合了LogSoftmax和NLLLoss，一步完成计算
2. 接口灵活性：NLLLoss允许用户自定义前面的变换操作，不只是LogSoftmax
3. 数值稳定性：CrossEntropyLoss的实现经过了优化，数值上更稳定

3. PyTorch中的具体实现与使用

理解了理论基础后，我们来看PyTorch中这两个损失函数的具体实现和使用方法。

3.1 NLLLoss的使用方法

nn.NLLLoss()的全称是Negative Log Likelihood Loss，它的计算过程是：

1. 对输入应用LogSoftmax（这一步需要用户手动完成）
2. 根据真实标签选择对应的对数概率
3. 取负值并求平均（默认reduction='mean'）

典型的使用代码如下：

import torch import torch.nn as nn # 定义模型和损失函数 model = MyModel() log_softmax = nn.LogSoftmax(dim=1) nll_loss = nn.NLLLoss() # 前向传播 outputs = model(inputs) log_probs = log_softmax(outputs) # 计算损失 loss = nll_loss(log_probs, targets)

3.2 CrossEntropyLoss的使用方法

nn.CrossEntropyLoss()将LogSoftmax和NLLLoss组合在一起，使用起来更加方便：

import torch.nn as nn # 定义模型和损失函数 model = MyModel() ce_loss = nn.CrossEntropyLoss() # 前向传播和损失计算一步完成 outputs = model(inputs) loss = ce_loss(outputs, targets)

3.3 关键区别对比表

4. 实际代码示例与常见误区

让我们通过具体的代码示例来展示这两个损失函数的实际使用，并分析常见的错误用法。

4.1 正确使用示例

import torch import torch.nn as nn # 模拟数据：batch_size=2, num_classes=3 logits = torch.tensor([[1.2, 0.5, -0.3], [0.7, 2.1, -1.5]]) targets = torch.tensor([0, 1]) # 真实类别索引 # 使用CrossEntropyLoss ce_loss = nn.CrossEntropyLoss() loss_ce = ce_loss(logits, targets) print(f"CrossEntropyLoss: {loss_ce.item()}") # 使用NLLLoss（正确方式） log_softmax = nn.LogSoftmax(dim=1) nll_loss = nn.NLLLoss() log_probs = log_softmax(logits) loss_nll = nll_loss(log_probs, targets) print(f"NLLLoss (correct): {loss_nll.item()}")

输出结果将会显示两个损失值相同，因为它们本质上是相同的计算过程。

4.2 常见错误用法

错误1：直接对原始logits使用NLLLoss

# 错误用法：直接对logits使用NLLLoss nll_loss = nn.NLLLoss() loss_wrong = nll_loss(logits, targets) # 错误！ print(f"NLLLoss (wrong): {loss_wrong.item()}")

这种用法会导致错误的结果，因为NLLLoss期望输入是log概率，而原始logits不是。

错误2：使用Softmax而非LogSoftmax

# 错误用法：使用Softmax而非LogSoftmax softmax = nn.Softmax(dim=1) nll_loss = nn.NLLLoss() probs = softmax(logits) loss_wrong2 = nll_loss(probs, targets) # 仍然错误！ print(f"NLLLoss with Softmax: {loss_wrong2.item()}")

这种用法也会导致错误，因为NLLLoss需要的是log概率，而不是概率本身。

4.3 性能对比实验

为了更直观地展示这两种损失函数的等价性，我们可以设计一个小实验：

import torch import torch.nn as nn import torch.optim as optim # 创建一个简单的分类模型 class SimpleModel(nn.Module): def __init__(self, input_size=10, num_classes=3): super().__init__() self.fc = nn.Linear(input_size, num_classes) def forward(self, x): return self.fc(x) # 生成随机数据 torch.manual_seed(42) X = torch.randn(100, 10) # 100 samples, 10 features y = torch.randint(0, 3, (100,)) # 3 classes # 使用CrossEntropyLoss训练 model_ce = SimpleModel() optimizer_ce = optim.SGD(model_ce.parameters(), lr=0.1) ce_loss = nn.CrossEntropyLoss() for epoch in range(100): optimizer_ce.zero_grad() outputs = model_ce(X) loss = ce_loss(outputs, y) loss.backward() optimizer_ce.step() # 使用NLLLoss训练 model_nll = SimpleModel() optimizer_nll = optim.SGD(model_nll.parameters(), lr=0.1) log_softmax = nn.LogSoftmax(dim=1) nll_loss = nn.NLLLoss() for epoch in range(100): optimizer_nll.zero_grad() outputs = model_nll(X) log_probs = log_softmax(outputs) loss = nll_loss(log_probs, y) loss.backward() optimizer_nll.step() # 比较两个模型的最终参数 print("Parameter difference:", torch.sum(torch.abs(model_ce.fc.weight - model_nll.fc.weight)).item())

实验结果显示，两种训练方式最终得到的模型参数几乎相同，验证了它们在功能上的等价性。

5. 最佳实践与选择建议

在实际项目中，应该如何在这两个损失函数之间做出选择呢？以下是一些实用的建议：

5.1 何时使用CrossEntropyLoss

• 大多数分类任务：这是PyTorch中最常用的分类损失函数
• 希望代码简洁：一步完成计算，减少出错可能
• 关注数值稳定性：内部实现经过了优化
• 标准分类问题：当你的模型输出是logits时

5.2 何时使用NLLLoss

• 需要自定义概率变换：比如你想使用其他的归一化方法
• 实现特殊损失函数：组合NLLLoss与其他操作
• 研究新型损失函数：作为构建更复杂损失的基础
• 模型已经输出log概率：某些模型如语言模型可能直接输出log概率

5.3 其他注意事项

1. 维度问题：确保LogSoftmax/NLLLoss在正确的维度上操作（通常是特征维度）
2. 类别不平衡：可以通过weight参数为不同类别设置不同的权重
3. 多标签分类：这两个损失函数不适用于多标签分类，应考虑BCEWithLogitsLoss
4. 数值稳定性：虽然CrossEntropyLoss已经优化，但对于极端情况仍需注意

# 处理类别不平衡的示例 class_weights = torch.tensor([0.1, 0.3, 0.6]) # 假设类别0、1、2的权重 ce_loss = nn.CrossEntropyLoss(weight=class_weights) nll_loss = nn.NLLLoss(weight=class_weights)

在实际项目中，我通常首选CrossEntropyLoss，因为它简洁高效。只有在需要特殊处理概率输出时，才会考虑使用NLLLoss组合其他操作。记住，无论选择哪个，理解其背后的数学原理才是写出正确代码的关键。