对于交叉熵损失函数的来由有很多资料可以参考，这里就不再赘述。本文主要尝试对交叉熵损失函数的内部运算做深度解析。

1. 函数介绍

  Pytorch官网中对交叉熵损失函数的介绍如下：

CLASS torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=- 100,reduce=None, reduction=‘mean’, label_smoothing=0.0)

  该损失函数计算输入值（input）和目标值（target）之间的交叉熵损失。交叉熵损失函数可用于训练一个$C$类别的分类问题。参数weight给定时，其为分配给每一个类别的权重的一维张量（Tensor）。当数据集分布不均衡时，这是很有用的。
  函数输入（input）应包含每一个类别的原始、非标准化分数。对于未批量化的输入，输入必须是大小为$（C）$的张量,$（minibatch，C）$或$（minibatch，C，d_1，d_2，...，d_K）$，在K维情况下，$K\ge 1$。
  函数目标值（target）有两种情况，本文只介绍其中较为有效的一种情况，即target为类索引。
   本文以下内容均为target为类索引的情况。

  函数目标值（target）取值为在$[0，C)$之间的类索引，$C$为类别数。参数reduction设为'none'时，交叉熵损失可描述如下：
l ( x , y ) = L = { l 1 , . . . , l N } T , l n = − w y n l o g e x p ( x n , y n ) ∑ c = 1 C e x p ( x n , c ) ⋅ 1 { y n   / = i g n o r e _ i n d e x } (1) \large l(x,y) = L = \left \{ l_1,...,l_N \right \}^T, \\ \large l_n = -w_{yn}log\frac{exp(x_{n,y_n})}{\sum_{c=1}^{C}exp(x_{n,c})}\cdot 1\left \{ y_n\mathrlap{\,/}{=}ignore\_index \right \}\tag{1} l(x,y)=L={ l1​,...,lN​}T,ln​=−wyn​log∑c=1C​exp(xn,c​)exp(xn,yn​​)​⋅1{ yn​/​=ignore_index}(1)
​
  其中，$x$是输入，$y$是目标值，$w$是weight，$C$是类别数，$N$为batch size。在reduction不为'none'时（默认为'mean'），有：
l ( x , y ) = { ∑ n = 1 N 1 ∑ n = 1 N w y n ⋅ 1 { y n   / = i g n o r e _ i n d e x } l n , i f   r e d u c t i o n = ‘ m e a n ’ ; ∑ n = 1 N l n , i f   r e d u c t i o n = ‘ s u m ’ . (2) \large l(x,y) = \left\{\begin{matrix} \sum_{n=1}^{N}\frac{1}{\sum_{n=1}^{N}w_{yn} \cdot1\left \{ y_n\mathrlap{\,/}{=}ignore\_index \right \}}l_n, \quad if \, reduction=‘mean’; \\ \sum_{n=1}^{N}l_n, \quad if \, reduction=‘sum’ . \end{matrix}\right. \tag{2} l(x,y)=⎩⎨⎧​∑n=1N​∑n=1N​wyn​⋅1{ yn​/​=ignore_index}1​ln​,ifreduction=‘mean’;∑n=1N​ln​,ifreduction=‘sum’.​(2)

 需要指出的是，在这种情况下的交叉熵损失等价于LogSoftmax和NLLLoss的组合。¹

  因此，我们可以从LogSoftmax和NLLLoss来深度解析交叉熵损失函数的内部运算。

2. LogSoftmax函数

  LogSoftmax()函数²公式如下：
$$LogSoftmax(x_i)=log(\frac{exp(x_i)}{{\sum }_{j}exp(x_j)})\text{\hspace{1em}(3)}$$
  即，先对输入值进行Softmax归一化处理，然后对归一化值取对数。这部分对应公式（1）中的$\log \frac{exp(x_{n,y_n})}{{\sum }_{c=1}^{C}exp(x_{n,c})}$。

  代码示例如下：

>>> import torch.nn as nn
>>> SM = nn.Softmax(dim=1) #Softmax函数
>>> x = torch.tensor([[1.0,3.0,4.0],[7.0,3.0,8.0],[9.0,7.0,5.0]])
>>> x
tensor([[1., 3., 4.],
        [7., 3., 8.],
        [9., 7., 5.]])
 
>>> output_SM = SM(x) #第一步，对x进行Softmax归一化处理
>>> output_SM
#每一行元素相加之和等于1
tensor([[0.0351, 0.2595, 0.7054],
        [0.2676, 0.0049, 0.7275],
        [0.8668, 0.1173, 0.0159]]) 
>>> out_L_SM = torch.log(output_SM) #第二步，对输出取log
>>> out_L_SM
tensor([[-3.3490, -1.3490, -0.3490],
        [-1.3182, -5.3182, -0.3182],
        [-0.1429, -2.1429, -4.1429]])
        
#直接使用LogSoftmax函数，一步到位
>>> L_SM = nn.LogSoftmax(dim=1)
>>> out_L_SM_ = L_SM(x)
>>> out_L_SM_
tensor([[-3.3490, -1.3490, -0.3490],
        [-1.3182, -5.3182, -0.3182],
        [-0.1429, -2.1429, -4.1429]])

​

3. NLLLoss函数

  Pytorch中的NLLLoss函数³“名不副实”，虽然名为负对数似然函数，但其内部并没有进行对数计算，而只是对输入值求平均后取负（函数参数reduction为默认值'mean'，参数weight为默认值'none'时）。

  官网介绍如下：

CLASS torch.nn.NLLLoss(weight=None, size_average=None, ignore_index=- 100, reduce=None, reduction=‘mean’)

  参数reduction值为'none'时：
l ( x , y ) = L = { l 1 , . . . , l N } T ,   l n = − w y n x n , y n , w c = w e i g h t [ c ] ⋅ 1 { c   / = i g n o r e _ i n d e x } , (4) \large l(x,y) = L = \left \{ l_1,...,l_N \right \}^T,\ l_n = -w_{yn}x_{n,yn}, w_c = weight[c]\cdot1\left \{ c\mathrlap{\,/}{=}ignore\_index\right \},\tag{4} l(x,y)=L={ l1​,...,lN​}T, ln​=−wyn​xn,yn​,wc​=weight[c]⋅1{ c/​=ignore_index},(4)
  其中，$x$为输入，$y$为目标值，$w$为weight，$N$为batch size。
  参数reduction值不为'none'时（默认为'mean'），有：
​$$l(x,y)=\{\begin{array}{c}{\sum }_{n=1}^N\frac{1}{{\sum }_{n=1}^N{w}_{yn}}{l}_n,ifreduction=‘mean’;\\ {\sum }_{n=1}^N{l}_n,ifreduction=‘sum’.\end{array}\text{\hspace{1em}(5)}$$
  可以看出，当reduction为'mean'时，即是对$l_n$求加权平均值。weight参数默认为1，因此默认情况下，即是对$l_n$求平均值。又$l_n=-w_{yn}{x}_{n,yn}$，所以weight为默认值1时，$l_n=-x_{n,yn}$。故此时，即是对$x$求平均后取负。 这部分对于公式（2）中的 ∑ n = 1 N 1 ∑ n = 1 N w y n ⋅ 1 { y n   / = i g n o r e _ i n d e x } l n \textcolor{red}{\sum_{n=1}^{N}\frac{1}{\sum_{n=1}^{N}w_{yn} \cdot1\left \{ y_n\mathrlap{\,/}{=}ignore\_index \right \}}l_n} ∑n=1N​∑n=1N​wyn​⋅1{ yn​/​=ignore_index}1​ln​。
​
  实例代码验证如下：

>>> import torch
>>> NLLLoss = torch.nn.NLLLoss() #Pytorch负对数似然损失函数
>>> input = torch.randn(3,3)
>>>input
tensor([[1.4550, 2.3858, 1.1724],
        [0.4952, 1.5870, 0.9594],
        [1.4170, 0.4525, 0.2519]])
        
>>>target = torch.tensor([1,0,2]) #类索引目标值
>>> loss = NLLLoss(input, target)
>>> loss
tensor(-1.0443)

  平均取负有：$Value=-\frac{1}{3}\left(2.3858+0.4952+0.2519\right)=-1.0443$
  显然，平均取负结果和NLLLoss运算结果相同。

注：笔者窃以为，公式（5）中上式可写为 $\frac{{\sum }_{n=1}^N{l}_n}{{\sum }_{n=1}^N{w}_{yn}}$，如此则更容易理解。公式（2）同理。

4. 小结

  本文通过将CrossEntropyLoss拆解为LogSoftmax和NLLLoss两步，对交叉熵损失内部计算做了深度的解析，以更清晰地理解交叉熵损失函数。需要指出的是，本文所介绍的内容，只是对于CrossEntropyLoss的target为类索引的情况，CrossEntropyLoss的target还可以是每个类别的概率（Probabilities for each class），这种情况有所不同。

---

  学习总结，以作分享，如有不妥，敬请指出。

---

Reference

​

---

1. https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html?highlight=crossentropyloss#torch.nn.CrossEntropyLoss ︎

2. https://pytorch.org/docs/stable/generated/torch.nn.LogSoftmax.html?highlight=logsoftmax#torch.nn.LogSoftmax ︎

3. https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html?highlight=nllloss#torch.nn.NLLLoss ︎