Softmax函数与交叉熵

墨蓝 2022-05-16 02:16 280阅读 0赞

*  [https://blog.csdn.net/behamcheung/article/details/71911133][https_blog.csdn.net_behamcheung_article_details_71911133]
 *  
 *  [Softmax函数][Softmax]
    
     *  [背景与定义][Link 1]
     *  [导数][Link 2]
     *  [softmax的计算与数值稳定性][softmax]
 *  [Loss function][]
    
     *  [对数似然函数][Link 3]
     *  [交叉熵][Link 4]
     *  [Loss function求导][Loss function 1]
 *  [TensorFlow][]
    
     *  [方法1手动实现不建议使用][1]
     *  [方法2使用tfnnsoftmax\_cross\_entropy\_with\_logits推荐使用][2_tfnnsoftmax_cross_entropy_with_logits]
     *  [区别][Link 5]
 *  [总结][Link 6]
 *  [Reference][]

# Softmax函数 #

## 背景与定义 ##

在Logistic regression二分类问题中，我们可以使用`sigmoid`函数将输入Wx+bWx+b映射到(0,1)(0,1)区间中，从而得到属于某个类别的概率。将这个问题进行泛化，推广到多分类问题中，我们可以使用`softmax`函数，对输出的值归一化为概率值。

这里假设在进入`softmax`函数之前，已经有模型输出CC值，其中CC是要预测的类别数，模型可以是全连接网络的输出aa，其输出个数为CC，即输出为a1,a2,...,aCa1,a2,...,aC。

所以对每个样本，它属于类别ii的概率为：

yi=eai∑Ck=1eak ∀i∈1...Cyi=eai∑k=1Ceak ∀i∈1...C

通过上式可以保证∑Ci=1yi=1∑i=1Cyi=1，即属于各个类别的概率和为1。

## 导数 ##

对`softmax`函数进行求导，即求

∂yi∂aj∂yi∂aj

第ii项的输出对第jj项输入的偏导。  
代入`softmax`函数表达式，可以得到：

∂yi∂aj=∂eai∑Ck=1eak∂aj∂yi∂aj=∂eai∑k=1Ceak∂aj

用我们高中就知道的求导规则：对于

f(x)=g(x)h(x)f(x)=g(x)h(x)

它的导数为

f′(x)=g′(x)h(x)−g(x)h′(x)\[h(x)\]2f′(x)=g′(x)h(x)−g(x)h′(x)\[h(x)\]2

所以在我们这个例子中，

g(x)=eaih(x)=∑k=1Ceakg(x)=eaih(x)=∑k=1Ceak

上面两个式子只是代表直接进行替换，而非真的等式。

eaieai（即g(x)g(x)）对ajaj进行求导，要分情况讨论：  
1. 如果i=ji=j，则求导结果为eaieai  
2. 如果i≠ji≠j，则求导结果为00

再来看∑Ck=1eak∑k=1Ceak对ajaj求导，结果为eajeaj。

所以，当i=ji=j时：

∂yi∂aj=∂eai∑Ck=1eak∂aj=eaiΣ−eaieajΣ2=eaiΣΣ−eajΣ=yi(1−yj)∂yi∂aj=∂eai∑k=1Ceak∂aj=eaiΣ−eaieajΣ2=eaiΣΣ−eajΣ=yi(1−yj)

当i≠ji≠j时：

∂yi∂aj=∂eai∑Ck=1eak∂aj=0−eaieajΣ2=−eaiΣeajΣ=−yiyj∂yi∂aj=∂eai∑k=1Ceak∂aj=0−eaieajΣ2=−eaiΣeajΣ=−yiyj

其中，为了方便，令Σ=∑Ck=1eakΣ=∑k=1Ceak

对`softmax`函数的求导，我在两年前微信校招面试基础研究岗位一面的时候，就遇到过，这个属于比较基础的问题。

## softmax的计算与数值稳定性 ##

在Python中，`softmax`函数为：

def softmax(x):
        exp_x = np.exp(x)
        return exp_x / np.sum(exp_x)

*  1
 *  2
 *  3

传入`[1, 2, 3, 4, 5]`的向量

>>> softmax([1, 2, 3, 4, 5])
    array([ 0.01165623,  0.03168492,  0.08612854,  0.23412166,  0.63640865])

*  1
 *  2

但如果输入值较大时：

>>> softmax([1000, 2000, 3000, 4000, 5000])
    array([ nan,  nan,  nan,  nan,  nan])

*  1
 *  2

这是因为在求`exp(x)`时候溢出了：

import math
    math.exp(1000)
    # Traceback (most recent call last):
    #   File "<stdin>", line 1, in <module>
    # OverflowError: math range error

*  1
 *  2
 *  3
 *  4
 *  5

一种简单有效避免该问题的方法就是让`exp(x)`中的`x`值不要那么大或那么小，在`softmax`函数的分式上下分别乘以一个非零常数：

yi=eai∑Ck=1eak=Eeai∑Ck=1Eeak=eai+log(E)∑Ck=1eak+log(E)=eai+F∑Ck=1eak+Fyi=eai∑k=1Ceak=Eeai∑k=1CEeak=eai+log(E)∑k=1Ceak+log(E)=eai+F∑k=1Ceak+F

这里log(E)log(E)是个常数，所以可以令它等于FF。加上常数FF之后，等式与原来还是相等的，所以我们可以考虑怎么选取常数FF。我们的想法是让所有的输入在0附近，这样eaieai的值不会太大，所以可以让FF的值为：

F=−max(a1,a2,...,aC)F=−max(a1,a2,...,aC)

这样子将所有的输入平移到0附近（当然需要假设所有输入之间的数值上较为接近），同时，除了最大值，其他输入值都被平移成负数，ee为底的指数函数，越小越接近0，这种方式比得到`nan`的结果更好。

def softmax(x):
        shift_x = x - np.max(x)
        exp_x = np.exp(shift_x)
        return exp_x / np.sum(exp_x)

*  1
 *  2
 *  3
 *  4

>>> softmax([1000, 2000, 3000, 4000, 5000])
    array([ 0.,  0.,  0.,  0.,  1.])

*  1
 *  2

当然这种做法也不是最完美的，因为`softmax`函数不可能产生0值，但这总比出现`nan`的结果好，并且真实的结果也是非常接近0的。

# Loss function #

## 对数似然函数 ##

机器学习里面，对模型的训练都是对Loss function进行优化，在分类问题中，我们一般使用[最大似然估计][Link 7]（Maximum likelihood estimation）来构造损失函数。对于输入的xx，其对应的类标签为tt，我们的目标是找到这样的θθ使得p(t|x)p(t|x)最大。在二分类的问题中，我们有：

p(t|x)=(y)t(1−y)1−tp(t|x)=(y)t(1−y)1−t

其中，y=f(x)y=f(x)是模型预测的概率值，tt是样本对应的类标签。

将问题泛化为更一般的情况，多分类问题：

p(t|x)=∏i=1CP(ti|x)ti=∏i=1Cytiip(t|x)=∏i=1CP(ti|x)ti=∏i=1Cyiti

由于连乘可能导致最终结果接近0的问题，一般对似然函数取对数的负数，变成最小化对数似然函数。

−log p(t|x)=−log∏i=1Cytii=−∑i=iCtilog(yi)−log p(t|x)=−log∏i=1Cyiti=−∑i=iCtilog(yi)

## 交叉熵 ##

说交叉熵之前先介绍相对熵，相对熵又称为KL散度（Kullback-Leibler Divergence），用来衡量两个分布之间的距离，记为DKL(p||q)DKL(p||q)

DKL(p||q)=∑x∈Xp(x)logp(x)q(x)=∑x∈Xp(x)log p(x)−∑x∈Xp(x)log q(x)=−H(p)−∑x∈Xp(x)log q(x)DKL(p||q)=∑x∈Xp(x)logp(x)q(x)=∑x∈Xp(x)log p(x)−∑x∈Xp(x)log q(x)=−H(p)−∑x∈Xp(x)log q(x)

这里H(p)H(p)是pp的熵。

假设有两个分布pp和qq，它们在给定样本集上的相对熵定义为：

CE(p,q)=−∑x∈Xp(x)log q(x)=H(p)+DKL(p||q)CE(p,q)=−∑x∈Xp(x)log q(x)=H(p)+DKL(p||q)

从这里可以看出，交叉熵和相对熵相差了H(p)H(p)，而当pp已知的时候，H(p)H(p)是个常数，所以交叉熵和相对熵在这里是等价的，反映了分布pp和qq之间的相似程度。关于熵与交叉熵等概念，可以参考该[博客][Link 8]再做了解。

回到我们多分类的问题上，真实的类标签可以看作是分布，对某个样本属于哪个类别可以用One-hot的编码方式，是一个维度为CC的向量，比如在5个类别的分类中，`[0, 1, 0, 0, 0]`表示该样本属于第二个类，其概率值为1。我们把真实的类标签分布记为pp，该分布中，ti=1ti=1当ii属于它的真实类别cc。同时，分类模型经过softmax函数之后，也是一个概率分布，因为∑Ci=1yi=1∑i=1Cyi=1，所以我们把模型的输出的分布记为qq，它也是一个维度为CC的向量，如`[0.1, 0.8, 0.05, 0.05, 0]`。  
对一个样本来说，真实类标签分布与模型预测的类标签分布可以用交叉熵来表示：

lCE=−∑i=1Ctilog(yi)lCE=−∑i=1Ctilog(yi)

可以看出，该等式于上面对数似然函数的形式一样！

最终，对所有的样本，我们有以下loss function：

L=−∑k=1n∑i=1Ctkilog(yki)L=−∑k=1n∑i=1Ctkilog(yki)

其中tkitki是样本kk属于类别ii的概率，ykiyki是模型对样本kk预测为属于类别ii的概率。

## Loss function求导 ##

对单个样本来说，loss function lCElCE对输入ajaj的导数为：

∂lCE∂aj=−∑i=1C∂tilog(yi)∂aj=−∑i=1Cti∂log(yi)∂aj=−∑i=1Cti1yi∂yi∂aj∂lCE∂aj=−∑i=1C∂tilog(yi)∂aj=−∑i=1Cti∂log(yi)∂aj=−∑i=1Cti1yi∂yi∂aj

上面对∂yi∂aj∂yi∂aj求导结果已经算出：

当i=ji=j时：∂yi∂aj=yi(1−yj)∂yi∂aj=yi(1−yj)

当i≠ji≠j时：∂yi∂aj=−yiyj∂yi∂aj=−yiyj

所以，将求导结果代入上式：

−∑i=1Cti1yi∂yi∂aj=−tiyi∂yi∂ai−∑i≠jCtiyi∂yi∂aj=−tjyiyi(1−yj)−∑i≠jCtiyi(−yiyj)=−tj+tjyj+∑i≠jCtiyj=−tj+∑i=1Ctiyj=−tj+yj∑i=1Cti=yj−tj−∑i=1Cti1yi∂yi∂aj=−tiyi∂yi∂ai−∑i≠jCtiyi∂yi∂aj=−tjyiyi(1−yj)−∑i≠jCtiyi(−yiyj)=−tj+tjyj+∑i≠jCtiyj=−tj+∑i=1Ctiyj=−tj+yj∑i=1Cti=yj−tj

# TensorFlow #

## 方法1：手动实现（不建议使用） ##

在TensorFlow中，已经有实现好`softmax`函数，所以我们可以自己构造交叉熵损失函数：

import tensorflow as tf
    import input_data
    
    x = tf.placeholder("float", shape=[None, 784])
    label = tf.placeholder("float", shape=[None, 10])
    
    w_fc1 = tf.Variable(tf.truncated_normal([784, 1024], stddev=0.1))
    b_fc1 = tf.Variable(tf.constant(0.1, shape=[1024]))
    h_fc1 = tf.matmul(x, w_fc1) + b_fc1
    
    w_fc2 = tf.Variable(tf.truncated_normal([1024, 10], stddev=0.1))
    b_fc2 = tf.Variable(tf.constant(0.1, shape=[10]))
    y = tf.nn.softmax(tf.matmul(h_fc1, w_fc2) + b_fc2)
    
    cross_entropy = -tf.reduce_sum(label * tf.log(y))

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15

`cross_entropy = -tf.reduce_sum(label * tf.log(y))`是交叉熵的实现。先对所有的输出用`softmax`进行转换为概率值，再套用交叉熵的公式。

## 方法2：使用`tf.nn.softmax_cross_entropy_with_logits`（推荐使用） ##

import tensorflow as tf
    import input_data
    
    x = tf.placeholder("float", shape=[None, 784])
    label = tf.placeholder("float", shape=[None, 10])
    
    w_fc1 = tf.Variable(tf.truncated_normal([784, 1024], stddev=0.1))
    b_fc1 = tf.Variable(tf.constant(0.1, shape=[1024]))
    h_fc1 = tf.matmul(x, w_fc1) + b_fc1
    
    w_fc2 = tf.Variable(tf.truncated_normal([1024, 10], stddev=0.1))
    b_fc2 = tf.Variable(tf.constant(0.1, shape=[10]))
    y = tf.matmul(h_fc1, w_fc2) + b_fc2
    
    cross_entropy = -tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels=label, logits=y))

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15

TensorFlow已经实现好函数，用来计算`label`和`logits`的`softmax`交叉熵。注意，该函数的参数`logits`在函数内会用`softmax`进行处理，所以传进来时不能是`softmax`的输出了。

## 区别 ##

既然我们可以自己实现交叉熵的损失函数，为什么TensorFlow还要再实现`tf.nn.softmax_cross_entropy_with_logits`函数呢？

这个问题在Stack overflow上已经有Google的人出来回答（[传送门][Link 9]），原话是：

> If you want to do optimization to minimize the cross entropy, AND you’re softmaxing after your last layer, you should use tf.nn.softmax\_cross\_entropy\_with\_logits instead of doing it yourself, because it covers numerically unstable corner cases in the mathematically right way. Otherwise, you’ll end up hacking it by adding little epsilons here and there.

也就是说，方法1自己实现的方法会有在前文说的数值不稳定的问题，需要自己在`softmax`函数里面加些trick。所以官方推荐如果使用的loss function是最小化交叉熵，**并且**，最后一层是要经过softmax函数处理，则最好使用`tf.nn.softmax_cross_entropy_with_logits`函数，因为它会帮你处理数值不稳定的问题。

# 总结 #

全文到此就要结束了，可以看到，前面介绍这么多概念，其实只是为了解释在具体实现时候要做什么样的选择。可能会觉得有些小题大做，但对于NN这个黑盒子来说，我们现暂不能从理论上证明其有效性，那在工程实现上，我们不能再将它当作黑盒子来使用。

# Reference #

1.  [http://eli.thegreenplace.net/2016/the-softmax-function-and-its-derivative/][http_eli.thegreenplace.net_2016_the-softmax-function-and-its-derivative]
2.  [http://peterroelants.github.io/posts/neural\_network\_implementation\_intermezzo02/][http_peterroelants.github.io_posts_neural_network_implementation_intermezzo02]
3.  [http://cs231n.github.io/linear-classify/][http_cs231n.github.io_linear-classify]
4.  [http://cs229.stanford.edu/notes/cs229-notes1.pdf][http_cs229.stanford.edu_notes_cs229-notes1.pdf]
5.  [http://blog.csdn.net/rtygbwwwerr/article/details/50778098][Link 8]
6.  [http://stackoverflow.com/questions/34240703/difference-between-tensorflow-tf-nn-softmax-and-tf-nn-softmax-cross-entropy-with][http_stackoverflow.com_questions_34240703_difference-between-tensorflow-tf-nn-softmax-and-tf-nn-softmax-cross-entropy-with]

博客原文地址：[http://blog.csdn.net/behamcheung/article/details/71911133][http_blog.csdn.net_behamcheung_article_details_71911133]

[https_blog.csdn.net_behamcheung_article_details_71911133]: https://blog.csdn.net/behamcheung/article/details/71911133
[Softmax]: https://blog.csdn.net/behamcheung/article/details/71911133#softmax%E5%87%BD%E6%95%B0
[Link 1]: https://blog.csdn.net/behamcheung/article/details/71911133#%E8%83%8C%E6%99%AF%E4%B8%8E%E5%AE%9A%E4%B9%89
[Link 2]: https://blog.csdn.net/behamcheung/article/details/71911133#%E5%AF%BC%E6%95%B0
[softmax]: https://blog.csdn.net/behamcheung/article/details/71911133#softmax%E7%9A%84%E8%AE%A1%E7%AE%97%E4%B8%8E%E6%95%B0%E5%80%BC%E7%A8%B3%E5%AE%9A%E6%80%A7
[Loss function]: https://blog.csdn.net/behamcheung/article/details/71911133#loss-function
[Link 3]: https://blog.csdn.net/behamcheung/article/details/71911133#%E5%AF%B9%E6%95%B0%E4%BC%BC%E7%84%B6%E5%87%BD%E6%95%B0
[Link 4]: https://blog.csdn.net/behamcheung/article/details/71911133#%E4%BA%A4%E5%8F%89%E7%86%B5
[Loss function 1]: https://blog.csdn.net/behamcheung/article/details/71911133#loss-function%E6%B1%82%E5%AF%BC
[TensorFlow]: https://blog.csdn.net/behamcheung/article/details/71911133#tensorflow
[1]: https://blog.csdn.net/behamcheung/article/details/71911133#%E6%96%B9%E6%B3%951%E6%89%8B%E5%8A%A8%E5%AE%9E%E7%8E%B0%E4%B8%8D%E5%BB%BA%E8%AE%AE%E4%BD%BF%E7%94%A8
[2_tfnnsoftmax_cross_entropy_with_logits]: https://blog.csdn.net/behamcheung/article/details/71911133#%E6%96%B9%E6%B3%952%E4%BD%BF%E7%94%A8tfnnsoftmaxcrossentropywithlogits%E6%8E%A8%E8%8D%90%E4%BD%BF%E7%94%A8
[Link 5]: https://blog.csdn.net/behamcheung/article/details/71911133#%E5%8C%BA%E5%88%AB
[Link 6]: https://blog.csdn.net/behamcheung/article/details/71911133#%E6%80%BB%E7%BB%93
[Reference]: https://blog.csdn.net/behamcheung/article/details/71911133#reference
[Link 7]: https://zh.wikipedia.org/wiki/%E6%9C%80%E5%A4%A7%E4%BC%BC%E7%84%B6%E4%BC%B0%E8%AE%A1
[Link 8]: http://blog.csdn.net/rtygbwwwerr/article/details/50778098
[Link 9]: http://stackoverflow.com/a/34243720
[http_eli.thegreenplace.net_2016_the-softmax-function-and-its-derivative]: http://eli.thegreenplace.net/2016/the-softmax-function-and-its-derivative/
[http_peterroelants.github.io_posts_neural_network_implementation_intermezzo02]: http://peterroelants.github.io/posts/neural_network_implementation_intermezzo02/
[http_cs231n.github.io_linear-classify]: http://cs231n.github.io/linear-classify/
[http_cs229.stanford.edu_notes_cs229-notes1.pdf]: http://cs229.stanford.edu/notes/cs229-notes1.pdf
[http_stackoverflow.com_questions_34240703_difference-between-tensorflow-tf-nn-softmax-and-tf-nn-softmax-cross-entropy-with]: http://stackoverflow.com/questions/34240703/difference-between-tensorflow-tf-nn-softmax-and-tf-nn-softmax-cross-entropy-with
[http_blog.csdn.net_behamcheung_article_details_71911133]: http://blog.csdn.net/behamcheung/article/details/71911133