损失函数-负对数似然和交叉熵(Pytorch中的应用)

文章目录

    • 1、负对数似然损失函数
      • 1.1、似然
      • 1.2、似然函数
      • 1.3、极大似然估计
      • 1.4、对数似然
      • 1.5、负对数似然
      • 1.6、pytorch中的应用
    • 2、交叉熵损失函数
      • 2.1、信息量
      • 2.2、信息熵
      • 2.3、相对熵(KL散度)
      • 2.4、交叉熵
      • 2.5、pytorch中的应用
    • 3、使用总结

1、负对数似然损失函数

1.1、似然

在解释负对数似然之前,首先要了解什么是似然。似然(likelihood)和概率(probability)有着一定的区别和联系。似然和概率是针对不同内容的估计和近似。概率表达了给定参数 θ \theta θ下样本随机向量 X = x X=x X=x的可能性,而似然表达了给定样本 X = x X=x X=x下参数 θ = θ 1 \theta=\theta_1 θ=θ1(相对于另外的参数取值 θ 2 \theta_2 θ2)为真实值的可能性。用一句话可以总结为:概率是已知参数,推数据。似然是已知数据,推参数。

1.2、似然函数

下面来看一下函数 P ( x ∣ θ ) P(x|\theta) P(xθ),输入有两个, x x x表示某一个具体的数据; θ \theta θ表示模型的参数:

  1. 如果 θ \theta θ是已知确定的, x x x是变量,这个函数叫做概率函数(probability function),它描述对于不同的样本点,其出现的概率是多少。

  2. 如果 x x x是已知确定的, θ \theta θ是变量,这个函数叫做似然函数(likelihood function),他描述对于不同的模型参数,出现 x x x这个样本点的概率是多少。

1.3、极大似然估计

假设有训练集 D D D,令 D c D_c Dc表示训练集 D D D中第 c c c类样本组成的集合,假设这些样本是独立同分布的,则参数 θ c \theta_c θc对于数据集 D c D_c Dc的似然是
P ( D c ∣ θ c ) = ∏ x ∈ D c P ( x ∣ θ c ) P(D_c|\theta_c)=\prod_{x \in D_c}P(x|\theta_c) P(Dcθc)=xDcP(xθc)
θ c \theta_c θc进行极大似然估计(Maximum likelihood estimation,MLE),就是去寻找能最大化似然 P ( D c ∣ θ c ) P(D_c|\theta_c) P(Dcθc)的参数值 θ c ^ \hat{\theta_c} θc^。直观上看,极大似然估计是试图在 θ c \theta_c θc所有可能的取值中,找到一个能使数据出现“可能性”最大的值。

1.4、对数似然

从公式可以看出,似然函数是很多个数相乘的形式。然而很多个数相乘并不容易计算容易造成下溢,不方便求导,通常对其求对数。使用对数似然(log-likelihood),连乘就可以写成连加的形式:
L ( θ c ) = l o g    P ( D c ∣ θ c ) = ∑ x ∈ D c l o g    P ( x ∣ θ c ) L(\theta_c)=log \; P(D_c|\theta_c)=\sum_{x \in D_c}log \; P(x|\theta_c) L(θc)=logP(Dcθc)=xDclogP(xθc)

1.5、负对数似然

对数似然是对概率分布求对数,概率 P ( x ) P(x) P(x)的值为 [ 0 , 1 ] [0,1] [0,1]区间,取对数后为 ( − ∞ , 0 ] (- \infty ,0] (,0]区间。再在这个前面加个符号,变成 [ 0 , ∞ ] [0,\infty] [0,]区间,就得到了负对数似然(Negative log-likelihood, NLL)
L ( θ c ) = − ∑ x ∈ D c l o g    P ( x ∣ θ c ) L(\theta_c)=-\sum_{x \in D_c}log \; P(x|\theta_c) L(θc)=xDclogP(xθc)
这样就得到了负对数似然函数,我们的目标是要选择合适的参数 θ \theta θ使得这个函数的数值最小。

看到有个博客举了一个关于硬币的例子来解释什么是最大似然估计,我在这个基础上加工一下看看负对数似然是怎么回事。假设有一个形状不规则的硬币,我们不知道它正面朝上的概率是多少,用 θ \theta θ表示,为模型的参数。想要求得这个模型参数 θ \theta θ是多少合适,就需要数据来进行估计。于是拿这枚硬币抛了10次,得到的数据为:“反正正正正反正正正反”。根据这个实验的结果我们就可以得到负对数似然函数为:
L ( θ ) = − ( l o g ( 1 − θ ) + l o g ( θ ) + l o g ( θ ) + l o g ( θ ) + l o g ( θ ) + l o g ( 1 − θ ) + l o g ( θ ) + l o g ( θ ) + l o g ( θ ) + l o g ( 1 − θ ) ) = − ( 3 l o g ( 1 − θ ) + 7 l o g ( θ ) ) L(\theta)=-(log(1-\theta)+log(\theta)+log(\theta)+log(\theta)+log(\theta)+log(1-\theta)\\+log(\theta)+log(\theta)+log(\theta)+log(1-\theta))=-(3log(1-\theta)+7log(\theta)) L(θ)=(log(1θ)+log(θ)+log(θ)+log(θ)+log(θ)+log(1θ)+log(θ)+log(θ)+log(θ)+log(1θ))=(3log(1θ)+7log(θ))
而我们的目标是使得负对数似然损失函数的值越小越好,我们可以画出损失函数的图像为:

import numpy as np
import matplotlib.pyplot as plt
theta=np.arange(0,1,0.01)
y=-(3*np.log(1-theta)+7*np.log(theta))
plt.plot(theta, y, label="NNLLoss")
plt.xlabel("theta")
plt.ylabel("Loss")
plt.legend()
plt.show()

损失函数-负对数似然和交叉熵(Pytorch中的应用)_第1张图片

可以看出,在 θ = 0.7 \theta=0.7 θ=0.7时,负对数似然损失函数取得的值最小,至此就求出了负对数似然损失函数最小的参数取值。(这里正面朝上的概率竟然为0.7,与我们的常识不符呀,有可能是因为抛的次数太少了,或者它确实就是个不规则的硬币哈哈哈,不过都不重要)。

1.6、pytorch中的应用

Pytorch中对应的负对数似然损失函数为:

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

当网络的输出为每个类别的对数概率的时候才可以使用该损失函数,因此可以在网络的最后一层添加一个LogSoftmax层来获得对数概率。

如果不添加LogSoftmax层,也可以直接使用CrossEntropyLoss损失函数。即CrossEntropyLoss=LogSoftmax+NLLLoss

这个损失所使用的标签应该是 [ 0 , C − 1 ] [0, C-1] [0,C1]范围内的一个类索引,其中C=类的数量。因此不需要使用one-hot编码(使用one-hot编码会错,这个在下面的代码中进行验证)。

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 } \mathscr{l}(x,y)=L=\{l_1, \cdots ,l_N\}^T, \; \; \; l_n=-w_{y_n}x_{n,y_n}\;w_c=weight[c] \cdot1 \{c \neq ignore\_index\} l(x,y)=L={l1,,lN}T,ln=wynxn,ynwc=weight[c]1{c=ignore_index}
其中, x x x是输入, y y y是目标, w w w是权重, N N N是批次大小。weight参数如果没有设置的话,默认为1。如果reduction不是none(默认是mean),那么:
l ( x , y ) = { ∑ n = 1 N 1 ∑ n = 1 N w w y n l n , if  r e d u c t i o n  = ’mean’ ∑ n = 1 N l n , if  r e d u c t i o n  = ’sum’ \mathscr{l}(x,y)=\begin{cases} \sum_{n=1}^N \frac{1}{\sum_{n=1}^N w_{w_{yn}}}l_n, & \text{if $reduction$ = 'mean'} \\ \sum_{n=1}^N l_n, & \text{if $reduction$ = 'sum'} \end{cases} l(x,y)={n=1Nn=1Nwwyn1ln,n=1Nln,if reduction = ’mean’if reduction = ’sum’
下面用一段代码看看torch.nn.NLLLoss如何使用:

import torch
#就是求完softmax后对每一个数求log
logsoftmax=torch.nn.LogSoftmax()
lossFun=torch.nn.NLLLoss()
input=torch.rand(3,5,requires_grad=True)
print(input)
tensor([[0.1805, 0.5916, 0.0331, 0.4528, 0.0881],
        [0.5859, 0.1316, 0.1232, 0.5722, 0.6810],
        [0.8561, 0.3857, 0.6185, 0.5923, 0.4002]])
lsoftmax=logsoftmax(input)
lsoftmax
tensor([[-1.7221, -1.3110, -1.8695, -1.4497, -1.8145],
        [-1.4703, -1.9246, -1.9330, -1.4840, -1.3752],
        [-1.3391, -1.8094, -1.5766, -1.6028, -1.7949]])
#不使用one-hot编码
label=torch.tensor([1,0,4])
loss=lossFun(lsoftmax,label)
loss
tensor(1.5254)
#测试使用one-hot编码
onehot_label=torch.tensor([[0.0,1.0,0.0,0.0,0.0],
                   [1.0,0.0,0.0,0.0,0.0],
                   [0.0,0.0,0.0,0.0,1.0]])
lossFun=torch.nn.NLLLoss()
loss=lossFun(lsoftmax,onehot_label)
loss
RuntimeError: 0D or 1D target tensor expected, multi-target not supported

模型输出在经过LogSoftmax函数后,在经过负对数似然函数的计算过程为:
L o s s = − ( − 1.3110 − 1.4703 − 1.7949 ) / 3 = 1.5254 Loss=-(-1.3110-1.4703-1.7949)/3=1.5254 Loss=(1.31101.47031.7949)/3=1.5254
因此在pytorch中,nn.NLLLoss()函数虽然叫负对数似然函数,但是该函数并没有进行对数运算,而须在最后一层的激活函数上使用nn.LogSoftmax()函数,然后nn.NLLLoss()函数只是做了求和取平均再取反的运算。因此在分类问题中要使用nn.NLLLoss(),必须和nn.LogSoftmax()函数一起使用。当然也可以直接使用nn.CrossEntropyLoss()

在使用nn.NLLLoss()时使用one-hot编码会报错,在使用nn.CrossEntropyLoss()的时候使用one-hot不会报错。

2、交叉熵损失函数

下面看一看交叉熵损失以及如何在Pytorch中使用它。

交叉熵主要是用来判定实际的输出与期望的输出的接近程度。要理解交叉熵,需要先理解以下几个概念。

2.1、信息量

信息是用来消除随机不确定性的东西,也就是说衡量信息量的大小就是看这个信息消除不确定性的程度。

“人会死”,这条信息没有减少不确定性,因为人肯定会死亡的,信息量为0。;“明天会下雨”,我们不知道明天到底会不会下雨,因此明天会下雨的不确定性因素很大,而这句话消除了明天会下雨的不确定性,以按照定义,这句话的信息量很大。

综上所述:信息量的大小与信息发生的概率成反比。概率越大,信息量越小。概率越小,信息量越大。设某一事件发生的概率是 p ( x ) p(x) p(x),其信息量表示为:
I ( x ) = − l o g ( p ( x ) ) I(x)=-log(p(x)) I(x)=log(p(x))

2.2、信息熵

信息熵也被称为熵,用来表示所有信息量的期望,即:
H ( X ) = − ∑ i = 1 n p ( x i ) l o g ( p ( x i ) ) H(X)=-\sum_{i=1}^np(x_i)log(p(x_i)) H(X)=i=1np(xi)log(p(xi))
举一个例子,使用明天的天气概率来计算熵:

序号 事件 概率p 信息量
1 晴天 0.5 -log(0.5)
2 雨天 0.2 -log(0.2)
3 多云 0.3 -log(0.3)

则熵为:
H ( X ) = − ( 0.5 ∗ l o g ( 0.5 ) + 0.2 ∗ l o g ( 0.2 ) + 0.3 ∗ l o g ( 0.3 ) ) H(X)=-(0.5*log(0.5)+0.2*log(0.2)+0.3*log(0.3)) H(X)=(0.5log(0.5)+0.2log(0.2)+0.3log(0.3))

2.3、相对熵(KL散度)

如果对于同一个随机变量X有两个单独的概率分布 P ( X ) P(X) P(X) Q ( X ) Q(X) Q(X),其中 Q ( X ) Q(X) Q(X)表示模型所预测的分布, P ( X ) P(X) P(X)表示样本的真实分布。则KL散度用来衡量这两个概率分布之间的差异。计算公式为:
D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) l o g ( p ( x i ) q ( x i ) ) D_{KL}(p||q)=\sum_{i=1}^np(x_i)log(\frac{p(x_i)}{q(x_i)}) DKL(pq)=i=1np(xi)log(q(xi)p(xi))
KL散度越小,表示 P ( X ) P(X) P(X) Q ( X ) Q(X) Q(X)的分布更加接近,可以通过反复训练 Q ( X ) Q(X) Q(X)的分布逼近 P ( X ) P(X) P(X)

2.4、交叉熵

将KL散度展开为:
D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) l o g ( p ( x i ) q ( x i ) ) = ∑ i = 1 n p ( x i ) l o g ( p ( x i ) ) − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) = − H ( p ( x ) ) + [ − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) ] D_{KL}(p||q)=\sum_{i=1}^np(x_i)log(\frac{p(x_i)}{q(x_i)})\\ =\sum_{i=1}^n p(x_i)log(p(x_i))-\sum_{i=1}^n p(x_i)log(q(x_i))\\=-H(p(x))+[-\sum_{i=1}^n p(x_i)log(q(x_i))] DKL(pq)=i=1np(xi)log(q(xi)p(xi))=i=1np(xi)log(p(xi))i=1np(xi)log(q(xi))=H(p(x))+[i=1np(xi)log(q(xi))]
其中 H ( p ( x ) ) H(p(x)) H(p(x))表示信息熵, − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) -\sum_{i=1}^n p(x_i)log(q(x_i)) i=1np(xi)log(q(xi))代表交叉熵,则KL散度=交叉熵-信息熵

进而得到交叉熵的公式为:
H ( p , q ) = − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) H(p,q)=-\sum_{i=1}^n p(x_i)log(q(x_i)) H(p,q)=i=1np(xi)log(q(xi))
而在训练过程中,标签通常采用one-hot编码表示,而样本真实分布的概率 p ( x i ) p(x_i) p(xi)为1。那么就可以得到交叉熵简化后的公式为:
H ( p , q ) = − ∑ i = 1 n l o g ( q ( x i ) ) H(p,q)=-\sum_{i=1}^n log(q(x_i)) H(p,q)=i=1nlog(q(xi))
这与上面推导的负对数似然损失函数是一样的哇!!!

2.5、pytorch中的应用

Pytorch中对应的交叉熵损失函数为:

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

计算公式为,当reduction设置为none时,表示为
l ( x , y ) = L = { l 1 , ⋯   , l N } T ,        l n = − ∑ c = 1 C w c l o g e x p ( x n , c ) ∑ i = 1 C e x p ( x n , i ) y n , c \mathscr{l}(x,y)=L=\{l_1, \cdots ,l_N\}^T, \; \; \; l_n=-\sum_{c=1}^C w_clog\frac{exp(x_{n,c})}{\sum_{i=1}^Cexp(x_{n,i})}y_{n,c} l(x,y)=L={l1,,lN}T,ln=c=1Cwclogi=1Cexp(xn,i)exp(xn,c)yn,c
如果reduction不是none(默认是mean),那么:
l ( x , y ) = { ∑ n = 1 N l n N , if  r e d u c t i o n  = ’mean’ ∑ n = 1 N l n , if  r e d u c t i o n  = ’sum’ \mathscr{l}(x,y)=\begin{cases} \frac{\sum_{n=1}^Nl_n}{N}, & \text{if $reduction$ = 'mean'} \\ \sum_{n=1}^N l_n, & \text{if $reduction$ = 'sum'} \end{cases} l(x,y)={Nn=1Nln,n=1Nln,if reduction = ’mean’if reduction = ’sum’
在使用交叉熵损失函数的时,网络的最后一层不需要加softmax层,因为pytorch中的CrossEntropyLoss()帮助我们实现了该操作,如果添加了softmax,那么就重复了,但效果并不会有什么影响。下面我们看一下交叉熵损失函数的计算过程,以及使用pytorch的实现过程。

根据交叉熵损失函数手动计算

首先假设batch_size为4,分类为3的网络最后一层的输出。

import torch
input=torch.rand(4,3)
input
tensor([[0.0515, 0.6730, 0.2852],
        [0.0362, 0.3434, 0.7450],
        [0.7136, 0.6566, 0.2402],
        [0.6989, 0.0917, 0.7857]])

根据交叉熵损失函数,计算完softmax之后还需要计算每一个值的log数值,因此我们可以使用LogSoftmax函数来计算。

output=torch.nn.LogSoftmax(dim=1)(input)
output
tensor([[-1.4170, -0.7956, -1.1834],
        [-1.4796, -1.1724, -0.7708],
        [-0.9429, -0.9999, -1.4163],
        [-0.9691, -1.5762, -0.8823]])

假设标签为:

[1,0,2,1]

根据交叉熵的计算公式,最终的损失为:
l o s s = − ( − 0.7956 − 1.4796 − 1.4163 − 1.5762 ) / 4 = 1.3169 loss=-(-0.7956-1.4796-1.4163-1.5762)/4=1.3169 loss=(0.79561.47961.41631.5762)/4=1.3169
使用pytorch进行计算

#未使用one-hot编码
target = torch.tensor([1,0,2,1])
loss = torch.nn.CrossEntropyLoss()
output = loss(input, target)
output
tensor(1.3169)

上述为未使用one-hot编码,下面试一下标签使用one-hot编码:

#未使用one-hot编码
target = torch.tensor([[0.0,1.0,0.0],
                      [1.0,0.0,0.0],
                      [0.0,0.0,1.0],
                      [0.0,1.0,0.0]])
loss = torch.nn.CrossEntropyLoss()
output = loss(input, target)
output
tensor(1.3169)

可见在使用交叉熵损失函数时,标签可以使用one-hot编码,也可以不使用one-hot编码。

3、使用总结

虽然负对数似然损失函数和交叉熵损失函数的公式类似,但是他们在pytorch中的使用有一定的差别,下面是对pytorch中的nn.NLLLoss()nn.CrossEntropyLoss()的使用总结:

  1. 在使用nn.NLLLoss()是,需要结合nn.LogSoftmax()一起使用,而nn.CrossEntropyLoss()不需要。
  2. 使用nn.CrossEntropyLoss()时,网络的最后一层不需要加softmax层。
  3. 使用nn.NLLLoss()是,标签不能使用one-hot编码标签,在使用nn.CrossEntropyLoss()时,可以使用one-hot标签,也可以不使用one-hot标签。

参考:

1.https://www.jianshu.com/p/269ad3103c41?utm_campaign=hugo&utm_content=note&utm_medium=reader_share&utm_source=qq

2.https://blog.csdn.net/u011508640/article/details/72815981

3.https://www.jianshu.com/p/472c82eb8c21

你可能感兴趣的:(机器学习(深度学习),深度学习,pytorch)