机器学习基础：极大似然估计与交叉熵

极大似然法

考虑我们在训练一个参数为$\mathbf{\varphi }$、输入为$\mathbf{x}$的模型$\mathbf{f}[\mathbf{x},\mathbf{\varphi }]$。如果转换一下视角，计算模型在给定输入$\mathbf{x}$时对可能的输出$\mathbf{y}$计算条件概率分布$Pr(\mathbf{y}|\mathbf{x})$。对每一个样本$({\mathbf{x}}_{\mathbf{i}},{\mathbf{y}}_{\mathbf{i}})$，损失函数鼓励在分布$Pr({\mathbf{y}}_{\mathbf{i}}|{\mathbf{x}}_{\mathbf{i}})$ 下输出${\mathbf{y}}_{\mathbf{i}}$时有高的概率。

但是如何适配模型$\mathbf{f}[\mathbf{x},\mathbf{\varphi }]$去计算概率分布呢？我们首先选择一个定义在输出$\mathbf{y}$的值域内的参数化概率分布$Pr(\mathbf{y}|\mathbf{\theta })$， 再基于训练样本让模型对概率分布的参数进行估计。于是模型对每一个训练输入${\mathbf{x}}_{\mathbf{i}}$计算得到不同的分布参数${\mathbf{\theta }}_{\mathbf{i}}=\mathbf{f}[{\mathbf{x}}_{\mathbf{i}},\mathbf{\varphi }]$，其训练输出${\mathbf{y}}_{\mathbf{i}}$在其相应的概率分布$Pr({\mathbf{y}}_{\mathbf{i}}|{\mathbf{\theta }}_{\mathbf{i}})$下应该有较高的概率。所以，我们会选择使所有的$I$个样本的组合概率最大的模型参数：
$$\begin{array}{rl}\hat{\mathbf{\varphi }}& =\underset{\varphi }{\mathrm{argmax}}\left[\prod _{i=1}^I\mathrm{Pr}\left({\mathbf{y}}_i\mid {\mathbf{x}}_i\right)\right]\\ & =\underset{\varphi }{\mathrm{argmax}}\left[\prod _{i=1}^I\mathrm{Pr}\left({\mathbf{y}}_i\mid {\mathbf{\theta }}_i\right)\right]\\ & =\underset{\varphi }{\mathrm{argmax}}\left[\prod _{i=1}^I\mathrm{Pr}\left({\mathbf{y}}_i\mid \mathbf{f}\left[{\mathbf{x}}_i,\mathbf{\varphi }\right]\right)\right](1)\end{array}$$
上式中的组合概率项被称为参数的似然(likelihood)，上式即极大似然法(Maximum likelihood criterion)，也被称为极大似然估计(Maximum likelihood estimation, MLE)。

极大似然法有两个假设，即通常所说的假设数据是独立同分布的(independent and identically distributed (i.i.d.))。即首先假设数据来自相同的数据分布，其次假设在给定输入时条件概率$Pr({\mathbf{y}}_{\mathbf{i}}|{\mathbf{x}}_{\mathbf{i}})$ 是独立的，所以训练数据的总似然满足下式的分解：
$$Pr({\mathbf{y}}_1,{\mathbf{y}}_2,\dots ,{\mathbf{y}}_{\mathbf{I}}|{\mathbf{x}}_1,{\mathbf{x}}_2,\dots ,{\mathbf{x}}_{\mathbf{I}})=\prod _{i=1}^I\mathrm{Pr}\left({\mathbf{y}}_i\mid {\mathbf{x}}_i\right)(2)$$
但公式(1)的最大似然法不是很实用，因为每一项$Pr({\mathbf{y}}_{\mathbf{i}}|\mathbf{f}\left[{\mathbf{x}}_i,\mathbf{\varphi }\right])$可能会很小，这样许多项的乘积会非常非常小，在实际计算的精度很难去量化它，所以一般会使用最大对数似然：
$$\begin{array}{rl}\hat{\mathbf{\varphi }}& =\underset{\varphi }{\mathrm{argmax}}\left[\prod _{i=1}^I\mathrm{Pr}\left({\mathbf{y}}_i\mid \mathbf{f}\left[{\mathbf{x}}_i,\mathbf{\varphi }\right]\right)\right]\\ & =\underset{\varphi }{\mathrm{argmax}}\left[\log \left[\prod _{i=1}^I\mathrm{Pr}\left({\mathbf{y}}_i\mid \mathbf{f}\left[{\mathbf{x}}_i,\mathbf{\varphi }\right]\right)\right]\right]\\ & =\underset{\varphi }{\mathrm{argmax}}\left[\sum _{i=1}^I\log \left[\mathrm{Pr}\left({\mathbf{y}}_i\mid \mathbf{f}\left[{\mathbf{x}}_i,\mathbf{\varphi }\right]\right)\right]\right](3)\end{array}$$
而通常在进行模型训练时，我们一般会最小化损失，所以会将上述的最大对数似然添加一个负号变成负对数似然法（negetive log-likelihood criterion）：
$$\begin{array}{rl}\hat{\mathbf{\varphi }}& =\underset{\varphi }{\mathrm{argmin}}\left[-\sum _{i=1}^I\log \left[\mathrm{Pr}\left({\mathbf{y}}_i\mid \mathbf{f}\left[{\mathbf{x}}_i,\mathbf{\varphi }\right]\right)\right]\right]\\ & =\underset{\varphi }{\mathrm{argmin}}\left[L[\mathbf{\varphi }]\right](4)\end{array}$$

二分类

二分类(binary classification)的目标是给数据$\mathbf{x}$一个0或1的标签 y ∈ { 0 , 1 } y \in \{0, 1\} y∈{0,1}。比如我们会判断一封邮件是否是垃圾邮件，一个西瓜是好瓜还是坏瓜。

我们用负对数似然来推导出二分类的损失函数，首先在标签y的值域选择一个概率分布，伯努利分布(Bernouli distribution)刚好是一个合适的选择，它只有一个参数$\lambda \in [0,1]$表示y=1的概率：
$$\mathrm{Pr}(y\mid \lambda )=\{\begin{array}{ll}1-\lambda & y=0\\ \lambda & y=1\end{array},(5)$$
上式也可以等价地写成更紧凑的指数形式：
$$Pr(y|\lambda )=(1-\lambda {)}^{1-y}\cdot {\lambda }^y(6)$$
接着， 我们用机器学习模型$f[\mathbf{x},\mathbf{\varphi }]$来预测概率分布的参数$\lambda$，因为$\lambda$的值域为[0, 1]，但是我们并不能保证模型输出在这个范围内，于是我们使用sigmoid函数将模型的输出映射到[0, 1]:
$$sig[z]=\frac{1}{1+\exp [-z]}(7)$$
所以模型预测的概率分布参数$\lambda =sig[f[\mathbf{x},\mathbf{\varphi }]]$，式(6)的似然变成了:
$$Pr(y|\mathbf{x})=(1-sig[f[\mathbf{x},\mathbf{\varphi }]]{)}^{1-y}\cdot sig[f[\mathbf{x},\mathbf{\varphi }]{]}^y(8)$$
所以二分类的损失函数为在训练集上的负对数似然：
$$L[\mathbf{\varphi }]=\sum _{i=1}^I-(1-y_i)\log [(1-sig[f[\mathbf{x},\mathbf{\varphi }]]-y_i\log \left[sig[f[\mathbf{x},\mathbf{\varphi }]]\right](9)$$
上式也被称为二元交叉熵损失(binary cross-entropy loss)。

多分类

多分类(multiclass classification)是将数据$\mathbf{x}$分类到K>2个类别中的一个，即 y ∈ { 1 , 2 , … , K } y \in \{ 1, 2, \ldots, K \} y∈{1,2,…,K}， 比如预测手写数字是0-9里的哪一个，预测一个不完整句子的下一个可能词是什么。

我们再次尝试用负对数似然来推导出多分类的损失函数，首先在标签y的值域选择一个概率分布，因为 y ∈ { 1 , 2 , … , K } y \in \{ 1, 2, \ldots, K \} y∈{1,2,…,K}，所以选择类别分布(categorical distribution)，它有K个参数${\lambda }_1,{\lambda }_2,\dots ,{\lambda }_K$来决定每个类别的概率，这些参数的值域都为[0, 1]，并且它们的和为1以确保概率分布的有效性：
$$Pr(y=k)={\lambda }_k(10)$$
接着， 我们用有K个输出的模型$f[\mathbf{x},\mathbf{\varphi }]$来预测K个参数，我们同样无法确保模型的输出满足类别分布的要求，与二分类一样，我们也使用一个映射函数，这次我们选取的函数为softmax函数，它的输入为长度为K的任意向量，其输出为同样长度的向量，每个向量的值都在[0,1]范围内并且向量元素之和为1。第k个softmax函数的输出为：
$${\text{softmax}}_k[\mathbf{z}]=\frac{\exp [z_k]}{{\sum }_{k^{\prime }=1}^K\exp [z_{k^{\prime }}]}(11)$$
于是输入$\mathbf{x}$得到标签y的似然为：
$$Pr(y=k|\mathbf{x})={\text{softmax}}_k[\mathbf{f}[\mathbf{x},\mathbf{\varphi }]](12)$$
因此得到多分类的损失函数为下式定义的在训练集上的负对数似然：
$$\begin{array}{rl}L[\mathbf{\varphi }]& =-\sum _{i=1}^I\log [{\text{softmax}}_{y_i}[\mathbf{f}[x_i,\mathbf{\varphi }]]]\\ & =-\sum _{i=1}^I\left(f_{y_i}[x_i,\mathbf{\varphi }]-\log \left[\sum _{k^{\prime }=1}^K\exp [f_{k^{\prime }}[x_i,\mathbf{\varphi }]]\right]\right)(13)\end{array}$$
上式中的$f_k[x_i,\mathbf{\varphi }]$是指神经网络的第k个输出，而上式也被称为多分类交叉熵损失(multiclass cross-entropy loss)。

交叉熵与负对数似然

在前面推导二分类和多分类的损失函数时，提到它们也被称为交叉熵损失，事实上交叉熵损失与使用负对数似然是等价的。

交叉熵损失的思想是找到使得观测数据y的经验分布q(y)和模型分布$Pr(y|\mathbf{\theta })$距离最小的参数$\mathbf{\theta }$。两个概率分布q(z)和p(z)的距离可以使用KL散度(Kullback-Leibler(KL) divergence)来评估：
$$\begin{array}{rl}{D}_{KL}[q||p]& =\int q(z)\log \left[\frac{q(z)}{p(z)}\right]dz\\ & ={\int }_{-\infty }^{\infty }q(z)\log [q(z)]dz-{\int }_{-\infty }^{\infty }q(z)\log [p(z)]dz\end{array}(14)$$
数据集 { y i } i = 1 I \{y_i\}^I_{i=1} {yi​}i=1I​的经验数据分布可用下式来表示：
$$q(y)=\frac{1}{I}\sum _{i=1}^I\delta [y-y_i](15)$$
上式中的$\delta [\cdot ]$是Dirac delta函数（Dirac delta函数 $\delta [\mathbf{z}]$(即信号与系统里说的脉冲函数)的面积为1且全部集中在$\mathbf{z}=0$处，有N个元素的数据集可以被看作对包括N个中心为${\mathbf{x}}_i$的delta函数求和并用1/N做归一化的概率分布(如上式所示意)，delta函数的一个关键性质是$\int f[\mathbf{x}]\delta [\mathbf{x}-{\mathbf{x}}_0]d\mathbf{x}=f[{\mathbf{x}}_0]$）。

我们想要减少模型分布$Pr(y|\mathbf{\theta })$和上述经验分布的KL散度：
$$\begin{array}{rl}\hat{\mathbf{\theta }}& =\underset{\mathbf{\theta }}{\mathrm{argmin}}\left[{\int }_{-\infty }^{\infty }q(y)\log [q(y)]dy-{\int }_{-\infty }^{\infty }q(y)\log [\mathrm{Pr}(y\mid \mathbf{\theta })]dy\right]\\ & =\underset{\mathbf{\theta }}{\mathrm{argmin}}\left[-{\int }_{-\infty }^{\infty }q(y)\log [\mathrm{Pr}(y\mid \mathbf{\theta })]dy\right],(16)\end{array}$$
上式的第一行里的第一项因为它不依赖于$\mathbf{\theta }$所以消失了，剩下的第二项被称为交叉熵(cross-entropy)。

将式(15)代入到上式：
$$\begin{array}{rl}\hat{\mathbf{\theta }}& =\underset{\mathbf{\theta }}{\mathrm{argmin}}\left[-{\int }_{-\infty }^{\infty }\left(\frac{1}{I}\sum _{i=1}^I\delta \left[y-y_i\right]\right)\log [\mathrm{Pr}(y\mid \mathbf{\theta })]dy\right]\\ & =\underset{\mathbf{\theta }}{\mathrm{argmin}}\left[-\frac{1}{I}\sum _{i=1}^I\log \left[\mathrm{Pr}\left(y_i\mid \mathbf{\theta }\right)\right]\right]\\ & =\underset{\mathbf{\theta }}{\mathrm{argmin}}\left[-\sum _{i=1}^I\log \left[\mathrm{Pr}\left(y_i\mid \mathbf{\theta }\right)\right]\right].(17)\end{array}$$
上面的第一行到第二行利用了delta函数的性质，第二行到第三行是因为系数1/I不影响最小值的位置。

在机器学习中，分布参数$\mathbf{\theta }$由模型$\mathbf{f}[{\mathbf{x}}_{\mathbf{i}},\mathbf{\varphi }]$计算得到，于是我们将式(17)可变成下式：
$$\hat{\mathbf{\varphi }}=\underset{\mathbf{\varphi }}{\mathrm{argmin}}\left[-\sum _{i=1}^I\log \left[\mathrm{Pr}\left(y_i\mid \mathbf{f}[{\mathbf{x}}_{\mathbf{i}},\mathbf{\varphi }]\right)\right]\right]$$
如果对比一下，就会发现上式与负对数似然的定义式(4)是一样的，我们经过推导证明了交叉熵与负对数似然是等价的。

pytorch里的交叉熵实现

pytorch里不同的实现交叉熵的方法：

• torch.nn.functional.binary_cross_entropy 计算二元交叉熵，输入为概率，也就是logits值要先经过sigmoid函数转换为概率。
• torch.nn.functional.binary_cross_entropy_with_logits 计算二元交叉熵，输入为logits。它相当于将Sigmoid层和BCELoss层合成为一个层，可以使用log-sum-exp技巧使得数值计算更稳定。
• torch.nn.functional.cross_entropy 计算交叉熵，使用logits作为输入，在其内部实现了LogSoftmax。有ignore_index参数用来忽略掉一些目标值使其对梯度没有影响。
• torch.nn.functional.nll_loss 与cross_entropy类似，只是要自己将logits经过LogSoftmax后再作为其输入。

# BINARY LABELS
import torch

labels = torch.tensor([1, 0, 1, 1, 1, 0], dtype=torch.float)
logits = torch.tensor([2.2, -1.1, 1.2, 2.2, 0.1, -0.5], dtype=torch.float)
torch.nn.functional.binary_cross_entropy_with_logits(logits, labels)
# tensor(0.3132)
## logits 需要先经过sigmoid转换
torch.nn.functional.binary_cross_entropy(torch.sigmoid(logits), labels)
# tensor(0.3132)

## MULTICLASS
labels = torch.tensor([1, 0, 2], dtype=torch.long)
logits = torch.tensor([[2, -0.5, 0.1],
                        [-1.1, 2, 0.0],
                        [1.2, 2.2, 3.1]], dtype=torch.float)
torch.nn.functional.cross_entropy(logits, labels)
# tensor(2.1388)
torch.nn.functional.nll_loss(torch.nn.functional.log_softmax(logits, dim=1), labels)
# tensor(2.1388)


## BINARY CROSS ENTROPY VS MULTICLASS IMPLEMENTATION（用交叉熵实现二分类）
labels = torch.tensor([1, 0, 1], dtype=torch.float)
probas = torch.tensor([0.9, 0.1, 0.8], dtype=torch.float)
torch.nn.functional.binary_cross_entropy(probas, labels)
# tensor(0.1446)

labels = torch.tensor([1, 0, 1], dtype=torch.long)
probas = torch.tensor([[0.1, 0.9],
                        [0.9, 0.1],
                        [0.2, 0.8]], dtype=torch.float)
torch.nn.functional.nll_loss(torch.log(probas), labels)
# tensor(0.1446)

参考资料

1. 《Understanding Deep Learning》第5章（本文的图片来自此书）

2. https://sebastianraschka.com/faq/docs/pytorch-crossentropy.html

3. pytorch文档