👨‍💻 作者简介：非科班转码，正在不断丰富自己的技术栈
🗒️ 博客主页：https://raelum.blog.csdn.net
🎯 主要领域：NLP、RS、GNN
📢 如果这篇文章有帮助到你，可以关注❤️ + 点赞👍 + 收藏⭐ + 留言💬，这将是我创作的最大动力

一、前言

nn.CrossEntropyLoss 常用作多分类问题的损失函数（对交叉熵还不了解的读者可以看我的这篇文章），本文将围绕PyTorch的官方文档对重要知识点进行逐一讲解（不会全部讲解）。

import torch
import torch.nn as nn
1
2

二、理论基础

对于 $C(C>2)$ 分类问题，先不考虑 batch 的情形，设神经网络的输出（还未经过 Softmax）为 { x c } c = 1 C \{x_c\}_{c=1}^C {xc​}c=1C​，经过 Softmax 后得到

$$q_i=\frac{\exp (x_i)}{{\sum }_{c=1}^C\exp (x_c)}$$

从而该样本的交叉熵损失为

$$H(p,q)=-\sum _{i=1}^C{p}_i\log q_i=-\sum _{i=1}^C{p}_i\log \frac{\exp (x_i)}{{\sum }_{c=1}^C\exp (x_c)}$$

其中 $(p_1,p_2,\cdots ,p_C)$ 是 One-Hot 向量。

不妨令 p y = 1   ( y ∈ { 1 , 2 , ⋯   , C } ) p_y=1\,(y\in\{1,2,\cdots,C\}) py​=1(y∈{1,2,⋯,C})，其余为 $0$，因此上式变为

$$H(p,q)=-\log \frac{\exp (x_y)}{{\sum }_{c=1}^C\exp (x_c)}$$

现在考虑有 batch 的情形，不妨设 batch size 为 $N$，神经网络的输出为 { x n c } n c ,    n = 1 , ⋯   , N ,    c = 1 , ⋯   , C \{x_{nc}\}_{nc},\;n=1,\cdots,N,\;c=1,\cdots,C {xnc​}nc​,n=1,⋯,N,c=1,⋯,C，第 $n$ 个样本的真实类别记为 y n   ( y n ∈ { 1 , 2 , ⋯   , C } ) y_n\,(y_n\in\{1,2,\cdots,C\}) yn​(yn​∈{1,2,⋯,C})，第 $n$ 个样本的交叉熵损失记为 $l_n$，则仿照上式就有

$$l_n=-\log \frac{\exp (x_{n,y_n})}{{\sum }_{c=1}^C\exp (x_{nc})}$$

接下来我们讨论一些特殊情形。当数据不平衡时（某一类的样本数特别多，另一类的样本数特别少），我们需要为每一类的损失安排一个权重用来平衡。权重为 $\mathbf{w}=(w_1,w_2,\cdots ,w_C)$。

📌 模型容易在样本数最多的一个（或几个）类上过拟合，因此对于那些样本数较少的类，我们需要设置更高的权重，这样模型在预测这些类的标签时一旦出错，就会受到更多的惩罚

安排了权重后，相应的损失为

$$l_n=-w_{y_n}\log \frac{\exp (x_{n,y_n})}{{\sum }_{c=1}^C\exp (x_{nc})}$$

计算完 $l_1,l_2,\cdots ,l_N$ 后，我们既可以一次性将它们全部返回（对应 reduction=none），也可以返回它们的均值（对应 reduction=mean），还可以返回它们的和（对应 reduction=sum）：

ℓ = { ( l 1 , ⋯   , l N ) , reduction=none ∑ n = 1 N l n / ∑ n = 1 N w y n , reduction=mean ∑ n = 1 N l n , reduction=sum \ell={(l1,⋯,lN),reduction=none∑Nn=1ln/∑Nn=1wyn,reduction=mean∑Nn=1ln,reduction=sum

ℓ=⎩⎪⎨⎪⎧​(l1​,⋯,lN​),∑n=1N​ln​/∑n=1N​wyn​​,∑n=1N​ln​,​reduction=nonereduction=meanreduction=sum​

在 NLP 任务中，我们往往将填充词元添加到每个序列的末尾，这样一来不同长度的序列可以进行批量加载。训练过程中，我们不希望网络预测出的填充词元被算入损失函数中。不妨设填充词元在词表中的索引为 $i$，则此时应对 $l_n$ 作如下修正：

l n = − w y n ⋅ I ( y n ≠ i ) ⋅ log ⁡ exp ⁡ ( x n , y n ) ∑ c = 1 C exp ⁡ ( x n c ) , where    I ( x ) = { 1 , x    is True 0 , x    is False l_n=-w_{y_n}\cdot \mathbb{I}(y_n\neq i)\cdot\log \frac{\exp(x_{n,y_n}{})}{\sum_{c=1}^C\exp(x_{nc})},\qquad \text{where}\; \mathbb{I}(x)= {1,xis True0,xis False

ln​=−wyn​​⋅I(yn​​=i)⋅log∑c=1C​exp(xnc​)exp(xn,yn​​)​,whereI(x)={1,0,​xis Truexis False​

另外，该场景下的 reduction=mean 对应的损失变为

$$\ell =\sum _{n=1}^N\frac{l_n}{{\sum }_{n=1}^N{w}_{y_n}\cdot \mathbb{I}(y_n\ne i)}$$

📌 需要注意的是，在PyTorch中 y n ∈ { 0 , 1 , ⋯   , C − 1 } y_n\in\{0,1,\cdots,C-1\} yn​∈{0,1,⋯,C−1}，这里我们之所以用 { 1 , 2 , ⋯   , C } \{1,2,\cdots,C\} {1,2,⋯,C} 是为了更自然地衔接上下文

三、主要参数

nn.CrossEntropyLoss 的主要参数如下：

nn.CrossEntropyLoss(weight=None, ignore_index=-100, reduction='mean', label_smoothing=0.0)
1

⚠️ size_average 和 reduce 参数已经弃用，取而代之的是 reduction 参数，所以这里不再讲解

---

有了前面的铺垫，我们就可以很容易理解这些参数了：

• weight：长度为 $C$ 的张量，一般在数据不平衡时才会使用；
• ignore_index：需要忽略的类别的索引，默认为 $-100$，即不忽略；
• reduction：决定以何种形式返回损失。为 none 时返回 $N$ 个样本的损失，为 mean 时返回 $N$ 个样本的损失均值，为 sum 时返回 $N$ 个样本的损失的和。默认为 mean；
• label_smoothing：决定是否开启标签平滑（不了解标签平滑的读者可参考这篇文章），数值在 $[0,1]$ 内。默认为 $0$，即不开启。

3.1 输入与输出

输入分为 input 和 target，input 通常为 $(N,C)$ 的形状（即 batch_size × num_classes），target 通常为 $(N,)$ 的形状，其中的每个分量均位于 $[0,C-1]\cap \mathbb{Z}$ 中，代表样本属于的类别。

📌 input 和 target 还可以是其他类型的输入，但本文只讨论这种使用最为广泛的输入
📌 input 是神经网络的原始输出（未经过 Softmax），nn.CrossEntropyLoss 会自动对其应用 Softmax

torch.manual_seed(0)
batch_size = 3
num_classes = 5
criterion_1 = nn.CrossEntropyLoss(reduction='none')
criterion_2 = nn.CrossEntropyLoss()
criterion_3 = nn.CrossEntropyLoss(reduction='sum')

inputs = torch.randn(batch_size, num_classes)  # 避免与input关键字冲突（当然这无所谓）
target = torch.randint(num_classes, size=(batch_size, ))

print(criterion_1(inputs, target))  # 输出3个样本的loss
# tensor([1.4639, 3.0493, 2.3056])
print(criterion_2(inputs, target))  # 输出3个样本的loss的均值
# tensor(2.2729)
print(criterion_3(inputs, target))  # 输出3个样本的loss的和
# tensor(6.8188)

print(sum(criterion_1(inputs, target)) == criterion_3(inputs, target))
# tensor(True)
print(sum(criterion_1(inputs, target)) / batch_size == criterion_2(inputs, target))
# tensor(True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四、从零开始实现 nn.CrossEntropyLoss

为了加深理解，接下来我们从零开始实现 nn.CrossEntropyLoss（当然会和官方不同，为了追求可读性会采用傻瓜式实现）。

首先确定框架（为简便起见这里不考虑 label_smoothing）：

class CrossEntropyLoss(nn.Module):

    def __init__(self, weight=None, ignore_index=-100, reduction='mean'):
        super().__init__()
        self.weight = weight
        self.ignore_index = ignore_index
        self.reduction = reduction
        
    def forward(self, inputs, target):
        pass
1
2
3
4
5
6
7
8
9
10

为方便计算，我们对第二章节的损失计算公式进行改写

$$l_n=w_{y_n}\cdot \mathbb{I}(y_n\ne i)\cdot [-x_{n,y_n}+\log \sum _{c=1}^C\exp (x_{nc})]$$

采用更符合 Python 的表述方式来改写上式

$$l_n=\mathbf{w}[y_n]\cdot \mathbb{I}(y_n\ne i)\cdot [-{\mathbf{x}}_{\mathbf{n}}[y_n]+\log \sum _{c=1}^C\exp ({\mathbf{x}}_{\mathbf{n}}[c])]$$

其中 $\mathbf{w}=(w_1,\cdots ,w_C),{\mathbf{x}}_{\mathbf{n}}=(x_{n1},\cdots ,x_{nC})$。再令 $\mathbf{X}=({\mathbf{x}}_1;\cdots ;{\mathbf{x}}_{\mathbf{N}}),\mathbf{y}=(y_1,\cdots ,y_C)$，则显然 $\mathbf{X}$ 就是我们的 input，$\mathbf{y}$ 就是 target，于是我们可以进行批量计算

$$(l_1,\cdots ,l_N)=\mathbf{w}[\mathbf{y}]\ast \mathbb{I}(\mathbf{y}\ne i)\ast (-\mathbf{X}[\text{range}(\text{len}(\mathbf{y})),\mathbf{y}]+\log (\text{sum}(\exp (\mathbf{X}),\text{dim}=1)))$$

其中 $\ast$ 代表按元素相乘。上式采用了广播机制。

class CrossEntropyLoss(nn.Module):

    def __init__(self, weight=None, ignore_index=-100, reduction='mean'):
        super().__init__()
        self.weight = weight
        self.ignore_index = ignore_index
        self.reduction = reduction

    def forward(self, inputs, target):
        if self.weight is not None:
            n_samples_weight = self.weight[target]  # 每个样本的权重
        else:
            n_samples_weight = torch.ones_like(target).float()  # 不提供权重则默认全为1
        indicator = (target != self.ignore_index).long().float()  # long()方法可以将布尔型张量转化成0-1张量
        raw_loss = -inputs[torch.arange(len(target)), target] + torch.log(torch.sum(torch.exp(inputs), dim=1))
        result = n_samples_weight * indicator * raw_loss
        if self.reduction == 'mean':
            return torch.sum(result) / n_samples_weight.dot(indicator)
        elif self.reduction == 'sum':
            return torch.sum(result)
        else:
            return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果与 PyTorch 官方的 nn.CrossEntropyLoss 的完全相同，这里不再展示，读者可自行验证。