交叉熵在深度学习中的实践应用

交叉熵在深度学习中的实践应用

flyfish

理论说明

一张图说明Multi-Class 分类 和Multi-Label 分类的区别

假设一共有C类，这样一共有3类，一张图里只有一个目标，表示label的向量里只有一个1
这是Multi-Class，正类（positive class） 只有一个， 有C−1个负类（ negative classes）

假设一共有3类，一张图里有多个目标，表示label的向量里有多个1，也就是正类（positive class）可以有多个
这是Multi-Label。
代码里通常用target 表示ground truth，也就是图片中标签(label)的表示，用target 向量存储这些标签（label）
target 向量中的类别索引对应的值为1，就表示图片中有该类目标

太阳、月亮、云 ，索引分别是0、1、2

如果label是1、0、0表示 有太阳（类别索引0的位置为1）
如果label是0、1、0表示 有月亮（类别索引1的位置为1）

CrossEntropyLoss的两个重要参数
Input: (N,C) C 是类别的数量，N是mini-batch的大小，内容是每个类的得分
Target: (N) N是mini-batch的大小，0 <= targets[i] <= C-1
#存储的是索引 假设一共有3类，如果Target是2 表示one-hot向量 001，Target是1表示010
下面的代码是以Multi-Class分类的交叉熵来描述

假设有这样的数据
target可以换成label，ground truth等，one hot 向量表示

input（predicted values）	target（Ground truth values）
1 、2、 7	0、0、1

交叉熵损失(Cross-Entropy loss)通常定义
公式里的log对应的是以e为底，这里没有使用数学里的ln，对应的函数通常是exp
$$\mathrm{Loss}=-\sum _{i=1}^N{\hat{y}}_i\ast \log \left(y_i\right)$$

${\hat{y}}_i$是ground truth的值（Ground truth values），是打标签（label）的值，是one-hot向量，代码常用一个叫做Target 向量存储这些值
定义下数据

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

input = torch.tensor([[1, 2, 7]]).float()
target = torch.tensor([2]).long()# 001

$一、CrossEntropyLoss$ API实现

可以用直接用CrossEntropyLoss API实现

loss = nn.CrossEntropyLoss() output = loss(input, target)
print(output)#tensor(0.0092)

CrossEntropyLoss的两个重要参数
Input: (N,C) C 是类别的数量，N是mini-batch的大小，内容是每个类的得分
Target: (N) N是mini-batch的大小，0 <= targets[i] <= C-1
存储的是索引 假设一共有3类，如果Target是2 表示one-hot向量 001，Target是1表示010

二、$LogSoftmax+NLLLoss$实现

$y_i$是预测值（predicted values），也就是softmax的结果
我先计算下softmax，按照惯例我会列举softmax多种写法，然后找出你最熟悉的字母
$$S(f_{y_i})=\frac{e^{f_{y_i}}}{{\sum }_j{e}^{f_j}}$$
$$softmax(x_j)=\frac{e^{x_j}}{{\sum }_{i=1}^n{e}^{x_i}}$$
$$s\left(x_i\right)=\frac{e^{x_i}}{{\sum }_{j=1}^n{e}^{x_j}}$$
$$\mathrm{Softmax}\left(x_i\right)=\frac{\exp \left(x_i\right)}{{\sum }_j\exp \left(x_j\right)}$$

$$\mathrm{softmax}\left(z_j\right)=\frac{e^{z_j}}{{\sum }_{k=1}^K{e}^{z_k}}\text{ for }j=1,\dots ,\mathrm{K}$$
把公式拆解
假设有4个数分别是$z_1,z_2,z_3,z_4$我们计算其中一个$z_1$
$$\begin{array}{rl}\mathrm{softmax}\left(z_1\right)& =\frac{e^{z_1}}{{\sum }_{k=1}^K{e}^{z_k}}\text{ for }j=1,\dots ,\mathrm{K}\\ & =\frac{e^{z_1}}{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}\end{array}$$
输出结果都加起来和是1
$$\begin{array}{l}\frac{e^{z_1}}{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}\\ +\frac{e^{z_2}}{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}\\ +\frac{e^{z_3}}{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}\\ +\frac{e^{z_4}}{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}\\ \\ =\frac{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}{e^{z_1}+e^{z_2}+e^{z_3}+e^{z_4}}=1\end{array}$$
那么代码就是这样

def softmax1(x):
    result = np.exp(x) / np.sum(np.exp(x), axis=0)
    return result

问题就出现了 e的n次方 ，
n比较大时容易溢出结果是[nan nan nan]
n比较小时例如 -100000,结果是invalid value encountered in true_divide
所以还需要改进公式
为了使softmax函数在数值上稳定，需要将向量中的值标准化，方法是将分子和分母乘以一个常数
过程证明如下
$$\begin{array}{rl}softmax\left(z_j\right)& =\frac{e^{z_j}}{{\sum }_{k=1}^N{e}^{z_k}}\\ & \\ & =\frac{C{e}^{z_j}}{C{\sum }_{k=1}^N{e}^{z_k}}\\ & \\ & =\frac{e^{z_j+\log (C)}}{{\sum }_{k=1}^N{e}^{z_k+\log (C)}}\end{array}$$
$log(C)的值为-max(z)$,所以代码就变成了下面的样子

 def softmax2(X):
    result = np.exp(X - np.max(X))
    return result / np.sum(result,axis=0)

softmax计算完再计算logsoftmax

log(Softmax(x))
PyTorch官网将式子拆开是 以下字母将采用PyTorch官网使用的字母
$$\log \mathrm{Softmax}\left(x_i\right)=\log \left(\frac{\exp \left(x_i\right)}{{\sum }_j\exp \left(x_j\right)}\right)$$
所以代码可以是这样（多写一份numpy版）

Intermediate1=np.log(softmax2(scores))
Intermediate2=torch.log(torch.tensor(softmax2(scores)))

print("Intermediate1:",Intermediate1)#[-6.00917448 -5.00917448 -0.00917448] 如果末尾保留4为小数，则与tensor数据一致
print("Intermediate2:",Intermediate2)#tensor([-6.0092, -5.0092, -0.0092], dtype=torch.float64)
loss = nn.NLLLoss()
output = loss(Intermediate2.view(1,3), target)
print(output)#tensor(0.0092)

如果是自带的LogSoftmax API实现可以这样写

ls = nn.LogSoftmax(dim=1)
Intermediate = ls(input)
print("Intermediate:",Intermediate)
#Intermediate: tensor([[-6.0092, -5.0092, -0.0092]])
loss = nn.NLLLoss()
output = loss(Intermediate, target)
print(output)#tensor(0.0092)

NLLLoss是negative log likelihood loss缩写 ，计算方法如下
在这个例子中, target是2, one-hot表示为(0,0,1), NLLLoss的计算如下
$$-(0\ast (-6.0092)+0\ast (-5.0092)+1\ast (-0.0092))=0.0092$$
最终结果是0.0092

三、logSumExp实现

关于logsoftmax的变形
$$\begin{array}{rl}\log \left(\frac{e^{x}j}{{\sum }_{i=1}^n{e}^{x_i}}\right)& =\log \left(e^{x_j}\right)-\log \left(\sum _{i=1}^n{e}^{x_i}\right)\\ & =x_j-\log \left(\sum _{i=1}^n{e}^{x_i}\right)\end{array}$$

因为
$$\log \mathrm{SumExp}\left(x_1\dots x_n\right)=\log \left(\sum _{i=1}^n{e}^{x_i}\right)$$
代码编写的依据是
$$\begin{array}{rl}\log \left(\text{Softmax}\left(x_j,x_1\dots x_n\right)\right)& =x_j-\log \mathrm{SumExp}\left(x_1\dots x_n\right)\\ & =x_j-(\log \left(\sum _{i=1}^n{e}^{x_i-c}\right)+c)\end{array}$$
logSumExp中间过程是
根据对数运算法则
$$\begin{array}{rlr}{e}^a\cdot e^b& =e^{a+b}& \\ \log (a\cdot b)& =\log (a)+\log (b)& \\ & & \\ \log \mathrm{SumExp}\left(x_1\dots x_n\right)& =\log \left(\sum _{i=1}^n{e}^{x_i}\right)& \\ & =\log \left(\sum _{i=1}^n{e}^{x_i-c}{e}^c\right)& \\ & =\log \left(e^c\sum _{i=1}^n{e}^{x_i-c}\right)& \\ & =\log \left(\sum _{i=1}^n{e}^{x_i-c}\right)+\log \left(e^c\right)& \\ & =\log \left(\sum _{i=1}^n{e}^{x_i-c}\right)+c& \end{array}$$
换成另一种方式
$$y=\log \mathrm{SumExp}\left(x_1\dots x_n\right)$$

$$\begin{array}{rl}y& =\log \sum _{i=1}^n{e}^{x_i}\\ e^y& =\sum _{i=1}^n{e}^{x_i}\\ e^{-c}{e}^y& =e^{-c}\sum _{i=1}^n{e}^{x_i}\\ e^{y-c}& =\sum _{i=1}^n{e}^{-c}{e}^{x_i}\\ y-c& =\log \sum _{i=1}^n{e}^{x_i-c}\\ y& =\log \sum _{i=1}^n{e}^{x_i-c}+c\end{array}$$
C的取值
$$c=\underset{i}{\max }{x}_i$$

那么代码可以这样写

c=input.max(dim=1,keepdim=True)
d=torch.logsumexp(input, 1,keepdim=True)
Intermediate=input-d
print(Intermediate)#tensor([[-6.0092, -5.0092, -0.0092]]) 与上面的值完全相同
loss = nn.NLLLoss()
output = loss(Intermediate, target)
print(output)#tensor(0.0092)

如果把torch.logsumexp拆开可以这样写

c = input.data.max()
d=(torch.log(torch.sum(torch.exp(input - c), 1, keepdim=True)) + c)
Intermediate=input-d
print(Intermediate)#tensor([[-6.0092, -5.0092, -0.0092]]) 与上面的值完全相同
loss = nn.NLLLoss()
output = loss(Intermediate, target)
print(output)#tensor(0.0092)

完整的源码如下

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

input = torch.tensor([[1, 2, 7]]).float()
target = torch.tensor([2]).long()# 001
#-----------------------------------------------------
# 方法1
loss = nn.CrossEntropyLoss()
output = loss(input, target)
print(output)#tensor(0.0092)
#-----------------------------------------------------
# 方法2
ls = nn.LogSoftmax(dim=1)
Intermediate = ls(input)
print("Intermediate:",Intermediate)
#Intermediate: tensor([[-6.0092, -5.0092, -0.0092]])
loss = nn.NLLLoss()
output = loss(Intermediate, target)
print(output)#tensor(0.0092)
#-----------------------------------------------------
# 方法3
scores = np.array([1, 2, 7])
def softmax1(x):
    result = np.exp(x) / np.sum(np.exp(x), axis=0)
    return result

def softmax2(X):
    result = np.exp(X - np.max(X))
    return result / np.sum(result,axis=0)

print(softmax1(scores))#[0.00245611 0.00667641 0.99086747]
print(softmax2(scores))#[0.00245611 0.00667641 0.99086747]

Intermediate1=np.log(softmax2(scores))
Intermediate2=torch.log(torch.tensor(softmax2(scores)))

print("Intermediate1:",Intermediate1)#[-6.00917448 -5.00917448 -0.00917448] 如果末尾保留4为小数，则与tensor数据一致
print("Intermediate2:",Intermediate2)#tensor([-6.0092, -5.0092, -0.0092], dtype=torch.float64)
loss = nn.NLLLoss()
output = loss(Intermediate2.view(1,3), target)
print(output)#tensor(0.0092)

#一个np类型，一个tensor类型
#输出与上面的Intermediate一致，可以再执行NLLLoss
#主要用于区别softmax2比softmax1更稳定
#-----------------------------------------------------
#方法4
c=input.max(dim=1,keepdim=True)
d=torch.logsumexp(input, 1,keepdim=True)
Intermediate=input-d
print(Intermediate)#tensor([[-6.0092, -5.0092, -0.0092]]) 与上面的值完全相同
loss = nn.NLLLoss()
output = loss(Intermediate, target)
print(output)#tensor(0.0092)
#-----------------------------------------------------
#方法5
c = input.data.max()
d=(torch.log(torch.sum(torch.exp(input - c), 1, keepdim=True)) + c)
Intermediate=input-d
print(Intermediate)#tensor([[-6.0092, -5.0092, -0.0092]]) 与上面的值完全相同
loss = nn.NLLLoss()
output = loss(Intermediate, target)
print(output)#tensor(0.0092)

#-----------------------------------------------------

关于 torch.nn.CrossEntropyLoss的参数

版本 PyTorch 1.5
参数size_average，reduce都是要被废弃的，所以重点是reduction
一共有3个值可以选择 none’ | ‘mean’ | ‘sum’

当batchsize=1时

input = torch.tensor([[1, 2, 7]]).float()
target = torch.tensor([2]).long()# 001

none’ | ‘mean’ | ‘sum’
输出分别是

tensor(0.0092)
tensor([0.0092])
tensor(0.0092)
tensor(0.0092)

没有变化

假设batchsize=3,
3个样本的时候

import torch
import torch.nn as nn

#3个样本
input = torch.tensor([[1, 2, 7],[4,7,9],[8,3,4]]).float()
target = torch.tensor([2,2,0]).long()# 001

loss = nn.CrossEntropyLoss()
loss1 = nn.CrossEntropyLoss(reduction="none")
loss2 = nn.CrossEntropyLoss(reduction="mean")
loss3 = nn.CrossEntropyLoss(reduction="sum")
output = loss(input, target)
output1 = loss1(input, target)
output2 = loss2(input, target)
output3 = loss3(input, target)
print(output)
print(output1)
print(output2)
print(output3)

# tensor(0.0556)
# tensor([0.0092, 0.1328, 0.0247])#none
# tensor(0.0556)#mean
# tensor(0.1668)#sum

默认情况reduction=“mean”
mean表示 均值 0.1668 / 3= 0.0556
sum表示和 0.0092 + 0.1328 + 0.0247 =0.1668

参考
关于论文
tricks-of-the-trade-logsumexp
Understanding Categorical Cross-Entropy Loss, Binary Cross-Entropy Loss, Softmax Loss, Logistic Loss, Focal Loss and all those confusing names
Classification and Loss Evaluation - Softmax and Cross Entropy Loss
The log-sum-exp trick in Machine Learning
torch.nn.CrossEntropyLoss
torch.nn.LogSoftmax
Understanding softmax and the negative log-likelihood