KL散度、交叉熵与JS散度数学公式以及代码例子

1.1 KL 散度概述

KL 散度 ，Kullback-Leibler divergence，（也称相对熵，relative entropy）是概率论和信息论中十分重要的一个概念，是两个概率分布（probability distribution）间差异的非对称性度量。

对离散概率分布的 KL 散度 计算公式为：
$$KL(p||q)=\sum p(x)\log \frac{p(x)}{q(x)}(1)$$

对连续概率分布的 KL 散度 计算公式为：
$$KL(p||q)=\int p(x)\log \frac{p(x)}{q(x)}dx(2)$$

一般情况下，我们得到的数据都是离散的。

KL 散度 的重要性质：

• KL 散度 的结果是非负的。
• KL 散度 是非对称的，即 $KL(p||q)!=KL(q||p)$

具体内容参考 [1] 《深度学习轻松学》。

1.2 KL 散度计算方法的代码实现

1.2.1 自己编写代码

请结合 公式 (1) 理解以下代码：

import numpy as np
import math

def KL(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return sum(_p*math.log(_p/_q) for (_p,_q) in zip(p,q) if _p != 0 )

P = [0.2, 0.4, 0.4]
Q = [0.4, 0.2, 0.4]

print(KL(P,Q))

输出内容为：

0.13862943611198905

计算过程：$KL(P,Q)=0.2\ast \log \frac{0.2}{0.4}+0.4\ast \log \frac{0.4}{0.2}+0.4\ast \log \frac{0.4}{0.4}=0.13862943611198905$

当然如果是 二分类问题 计算过程也是一样的。

import numpy as np
import math

def KL(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return sum(_p*math.log(_p/_q) for (_p,_q) in zip(p,q) if _p != 0 )

P = [0, 1]
Q = [0.4,0.6]

print(KL(P,Q))

输出结果为：

0.5108256237659907

可以自己复制粘贴填写更多测试数值，需要 保证：

• P 中每一组的各项的和为 1
• Q 中每一组各项的和为 1
• Q 中每一组不允许出现 0

注意： 以上内容只考虑维度为 1 的情况，如 P=[[0.1,0.2,0.7],[0.2,0.3,0.5]] 这种情况没有考虑到。

1.2.2 使用已存在的库 scipy

from scipy import stats

P = [0.2, 0.4, 0.4]
Q = [0.4, 0.2, 0.4]
stats.entropy(P,Q) 

输出内容为：

0.13862943611198905

和上面的例子一样，可以测试那些数据。

2.1 交叉熵基本概述

交叉熵（Cross Entropy）是 Shannon 信息论中一个重要概念，主要用于度量两个概率分布间的差异性信息。

对 二分类 任务的 交叉熵 计算公式为：

$$CrossEntropy(y,\hat{y})=-(y\ast \log (\hat{y})+(1-y)\ast \log (1-\hat{y}))(3)$$
其中，$y$ 可以理解为数据集中的 label，也就是接下来例子中的 $y_{true}$；而 $\hat{y}$ 可以理解与模型的预测标签，也就是接下来的例子中的 $y_{pred}$。

注意： 如果二分类问题时，$y$ 的取值并非 [0,1] 两种这种正常模式，需要分别求和再求均值，这一部分内容将会在后面 2.3 进行讨论。

对 多分类 任务的交叉熵计算公式为：

$$CrossEntropy(y,\hat{y})=\sum y\ast \log (\frac{1}{\hat{y}})(4)$$
公式 4 可以写成如下格式：

$$CrossEntropy(y,\hat{y})=-\sum y\ast \log (\hat{y})(5)$$

其中， 多分类 任务的计算公式同样适用于 二分类 ，因为二分类任务直接等于两个概率运算的和，所以没必要加 $\sum$ 符号。

2.2 交叉熵计算方法的代码实现

2.2.1 自己编写代码

参考 公式4 ，编写代码比较简单。

import math

def CE(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return sum(_p*math.log( 1 /_q) for (_p,_q) in zip(p,q) if _q != 0 )

P = [0.,1.]
Q = [0.6,0.4]

print(CE(P,Q))

计算过程：$CE(P,Q)=0\ast \log (\frac{1}{0.6})+1\ast \log (\frac{1}{0.4})=\log (2.5)=0.91629073187415506518352721176801$

输出内容为：

0.9162907318741551

注意对比前文中对 KL 的实现的代码，非常相似，除了函数名就改动两个地方。

根据 公式5，代码实现如下：

import math

def CE(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return -sum(_p*math.log(_q) for (_p,_q) in zip(p,q) if _q != 0 )

P = [0.,1.]
Q = [0.6,0.4]

print(CE(P,Q))

输出结果为：

0.916290731874155

2.2.1 使用 tensorflow2

主要是因为使用 tensorflow 的时候可能会用到这个函数，所以特地在这里介绍一下计算过程。

注意 这里只适合 Binary 这种情况，也就是说标签只是 0 与 1 两种。具体参考 [3]

这里直接上例子，然后解释计算过程：

import tensorflow as tf

y_true = [0., 1.]
y_pred = [0.6, 0.4]
bce = tf.keras.losses.BinaryCrossentropy()
bce(y_true, y_pred).numpy()

输出内容为：

0.9162905

在官方文档中给出的例子有两组数据，代码如下：

import tensorflow as tf

y_true = [[0., 1.], [0., 1.]]
y_pred = [[0.6, 0.4], [0.4, 0.6]]
# Using 'auto'/'sum_over_batch_size' reduction type.
bce = tf.keras.losses.BinaryCrossentropy()
bce(y_true, y_pred).numpy()  

输出内容为：

0.71355796

这种情况只是分别求两组结果，再进行平均即可。

2.3 当测试数据为全0或全1 的二分类时

上面的公式以及自己编写的代码中，都没有考虑到当测试数据为全0 或全 1 这种情况，接下来在这里讨论，在二分类问题中，应该如何计算结果。

$$CrossEntropy(y,\hat{y})=-(y\ast \log (\hat{y})+(1-y)\ast \log (1-\hat{y}))(3)$$
如 公式3 所示，在 输入数据的 $y$ 为 [0,1] 两种时，使用 公式3,4,5 计算都可以。但是如果输入数据的 $y$ 全部为 0 的时候，公式3 与公式4 则不适用。

这个时候需要使用 公式3 进行计算，并且同样需要做一次求均值，如 公式6 所示。

$$CrossEntropy(y,\hat{y})=-\frac{1}{n}\sum _{i=1}^n(y_i\ast \log ({\hat{y}}_i)+(1-y_i)\ast \log (1-{\hat{y}}_i))(6)$$

对应的代码实现如下：

import math

def CE(p,q):
    return -sum((_p*math.log(_q)+(1-_p)*math.log(1-_q) )for (_p,_q) in zip(p,q) if _q != 0 )/len(p)

P = [0.,0.]
Q = [0.6,0.4]

print(CE(P,Q))

输出结果为：

0.7135581778200728

计算过程：$CE(p,q)=-\frac{1}{2}((0\ast \log 0.6+1\ast \log 0.4)+(0\ast \log 0.4+1\ast \log 0.6))=-\frac{1}{2}\log 0.24=0.71355817782007287419452065403584$

对应的 tensorflow2 代码如下：

import tensorflow as tf

y_true =  [0., 0.]
y_pred = [0.4, 0.6]

bce = tf.keras.losses.BinaryCrossentropy()
bce(y_true, y_pred).numpy()  

输出结果为：

0.71355796

如果测试数据为 [1.,1.] 的时候，输出结果是相同的。

3.1 JS 散度概述

JS 散度 Jensen-Shannon divergence 用于描述两个概率分布的相似程度。和上面的 KL 的描述一致的话，JS 散度是两个概率分布间差异的对称性度量。

JS 散度的求解公式如下：
$$JS(P||Q)=\frac{1}{2}KL(P||\frac{P+Q}{2})+\frac{1}{2}KL(Q||\frac{P+Q}{2})(7)$$

很明显，等式是对称成立的，也就是说 $JS(P||Q)==JS(Q||P)$

3.2 JS散度计算方法的代码实现

公式7 是通过计算 KL 散度来计算 JS 散度的，因此代码实现需要用到前面的 KL 散度，具体实现如下：

实验 1

import math

def KL(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return sum(_p*math.log(_p/_q) for (_p,_q) in zip(p,q) if _p != 0 )

def JS(p,q):
    M = [0.5*(_p +_q) for (_p,_q) in zip(p,q)]
    return 0.5*(KL(p,M)+KL(q,M))

P = [0.,1.]
Q = [0.6,0.4]

print(JS(P,Q))
print(JS(Q,P))

输出内容为：

0.27435846855026524
0.27435846855026524

可以看出 $JS(P,Q)$ 与 $JS(Q,P)$ 相等。

---

实验 2

接下来看一下两个概率分布差异大小在 JS 值上的直观反映：

import math

def KL(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return sum(_p*math.log(_p/_q) for (_p,_q) in zip(p,q) if _p != 0 )

def JS(p,q):
    M = [0.5*(_p +_q) for (_p,_q) in zip(p,q)]
    return 0.5*(KL(p,M)+KL(q,M))

P = [0.,1.]
Q = [0.01,0.99]

print(JS(P,Q))

P = [0.,1.]
Q = [0.1,0.9]

print(JS(P,Q))


P = [0.,1.]
Q = [0.5,0.5]

print(JS(P,Q))

P = [0.,1.]
Q = [0.9,0.1]

print(JS(P,Q))

P = [0.,1.]
Q = [0.99,0.01]

print(JS(P,Q))

输出内容如下：

0.003478298769743019
0.03597375665014844
0.21576155433883565
0.5255973270178643
0.665096412549155

可以看出，最开始的数据两个概率分布是非常接近的，因为 JS 值比较小，接着两个概率分布差异越来越多，JS 值也越来越大。

---

实验 3

接着使用相同的数据，测试一下 KL 值的大小与概率分布的关系，因为 KL 计算是非对称的，因此每次需要输出两个结果。

import math

def KL(p,q):
    # p,q 为两个 list，表示对应取值的概率 且 sum(p) == 1 ，sum(q) == 1
    return sum(_p*math.log(_p/_q) for (_p,_q) in zip(p,q) if _p != 0 )


P = [0.1,0.9]
Q = [0.01,0.99]

print(KL(P,Q),KL(Q,P))

P = [0.1,0.9]
Q = [0.1,0.9]

print(KL(P,Q),KL(Q,P))

P = [0.1,0.9]
Q = [0.5,0.5]

print(KL(P,Q),KL(Q,P))

P = [0.1,0.9]
Q = [0.9,0.1]

print(KL(P,Q),KL(Q,P))

P = [0.1,0.9]
Q = [0.99,0.01]

print(KL(P,Q),KL(Q,P))

输出结果为：

0.14447934747551233 0.07133122707634103
0.0 0.0
0.3680642071684971 0.5108256237659907
1.7577796618689758 1.7577796618689758
3.8205752275831846 2.224611312865836

可以看出，当 P 和 Q 相同分布时，KL 散度为 0；KL 散度随着分布差异的增大而增大，随着分布差异的减小而减小。

---

小结

根据以上实验，可以看出：

• 随着两个概率分布差异的增大，KL 散度与 JS 散度的数值将增大；反之亦然。
• 随着两个概率分布差异的增大，KL 散度的增大时不均匀的，而 JS 散度的增大时均匀的。
• KL 散度的不对称性可能带来一些潜在的问题。

4. 总结

本文总结了 KL 散度、交叉熵以及 JS 散度数学公式以及一些性质，并且通过 python 代码实现。在阅读论文或实际编码中，如果忘记了这方面的内容，可以考虑参考一下。

如有任何疑问，欢迎留言评论！

感谢您的阅读！如果有帮助到您的话，欢迎点赞 + 关注 ！感谢！

Smileyan
2021.3.28 22:15

[1] 《深度学习轻松学》核心算法与视觉实践 冯超著 电子工业出版社 P33
[2] 《相对熵（KL散度）计算过程》
[3] tensorlflow文档 tf.keras.metrics.BinaryCrossentropy
[4] 《熵与信息增益》
[5] 百度百科 相对熵 KL 散度
[6] 百度百科 交叉熵
[7] 熵与信息增益
[8] 二分类、多分类交叉熵的计算
[9] tensorflow BinaryCrossentropy 源码
[10] 知乎 为什么交叉熵（cross-entropy）可以用于计算代价？
[11] 交叉熵、相对熵（KL散度）、JS散度和Wasserstein距离（推土机距离）
[12] tensorflow官网 KL公式

下面用求和符号展开是针对离散分布而言的，对于连续分布，使用积分代替求和。

熵

熵，又称香农熵（Shannon entropy），一个分布$P$的熵记为$H(P)$，计算公式为：

$$H(P)={\mathbb{E}}_{x\sim P(x)}[-logP(x)]=\sum _{i=1}^{n}P(x_i)log\frac{1}{P(x_i)}$$

交叉熵

两个分布$P$和$Q$的交叉熵（Cross entropy）记为$H(P,Q)$，计算公式为：

$$H(P,Q)={\mathbb{E}}_{x\sim P(x)}[-logQ(x)]=\sum _{i=1}^{n}P(x_i)log\frac{1}{Q(x_i)}$$

KL散度

KL散度（Kullback–Leibler divergence）又称相对熵（relative entropy），两个分布$P$和$Q$的KL散度记为 $D_{KL}(P||Q)$，计算公式为：

$$D_{KL}(P||Q)={\mathbb{E}}_{x\sim P(x)}[log\frac{P(x)}{Q(x)}]=\sum _{i=1}^{n}P(x_i)log\frac{P(x_i)}{Q(x_i)}$$

由熵、交叉熵和KL散度的公式我们可得到三者的关系：
$$\begin{array}{rl}{D}_{KL}(P||Q)& =\sum _{i=1}^{n}P(x_i)log\frac{P(x_i)}{Q(x_i)}\\ & =\sum _{i=1}^{n}P(x_i)log\frac{1}{Q(x_i)}-\sum _{i=1}^{n}P(x_i)log\frac{1}{P(x_i)}\\ & =H(P,Q)-H(P)\end{array}$$

因此在机器学习的优化问题中，假设我们的目标分布是$P$。如果$P$在我们的优化过程中是固定的，即$H(P)$不变，那么使用$D_{KL}(P||Q)$和使用$H(P,Q)$是等价的，所以我们可以用计算更加方便的交叉熵而不是KL散度来作为Loss函数。

JS散度

两个分布$P$和$Q$的JS散度（Jensen–Shannon divergence）记为$JSD(P||Q)$，其计算公式为：

$$JSD(P||Q)=\frac{1}{2}{D}_{KL}(P||\frac{P+Q}{2})+\frac{1}{2}{D}_{KL}(Q||\frac{P+Q}{2})$$

对于$n$个分布$P_1,P_2,P_3...,P_n$，其JS散度记为$JS{D}_{{\pi }_1,{\pi }_2,{\pi }_3...,{\pi }_n}(P_1,P_2,P_3...,P_n)$，其中${\pi }_1,{\pi }_2,{\pi }_3...,{\pi }_n$分别是给分布$P_1,P_2,P_3...,P_n$赋予的权重。计算公式为：

$$JS{D}_{{\pi }_1,{\pi }_2,{\pi }_3...,{\pi }_n}(P_1,P_2,P_3...,P_n)=H(\sum _{i=1}^n{\pi }_i{P}_i)-\sum _{i=1}^n{\pi }_{i}H(P_i)$$

实际上，两个分布的JS散度对应了当$n=2$，且取${\pi }_1={\pi }_2=\frac{1}{2}$的情形，即：

$$JSD(P||Q)=H(\frac{P+Q}{2})-\frac{H(P)+H(Q)}{2}$$

上述式子不难验证，将KL散度的计算公式带入JS散度的计算公式，并将每个KL散度展开成交叉熵减去熵的形式，然后再合并就行，如下：
$$\begin{array}{rl}JSD(P||Q)& =\frac{1}{2}{D}_{KL}(P||\frac{P+Q}{2})+\frac{1}{2}{D}_{KL}(Q||\frac{P+Q}{2})\\ & =\frac{1}{2}[\sum _{i=1}^{n}P(x_i)log\frac{1}{\frac{P(x_i)+Q(x_i)}{2}}-\sum _{i=1}^{n}P(x_i)log\frac{1}{P(x_i)}]+\frac{1}{2}[\sum _{i=1}^{n}Q(x_i)log\frac{1}{\frac{P(x_i)+Q(x_i)}{2}}-\sum _{i=1}^{n}Q(x_i)log\frac{1}{Q(x_i)}]\\ & =\frac{1}{2}[\sum _{i=1}^{n}P(x_i)log\frac{1}{\frac{P(x_i)+Q(x_i)}{2}}+\sum _{i=1}^{n}Q(x_i)log\frac{1}{\frac{P(x_i)+Q(x_i)}{2}}]-\frac{1}{2}[\sum _{i=1}^{n}P(x_i)log\frac{1}{P(x_i)}+\sum _{i=1}^{n}Q(x_i)log\frac{1}{Q(x_i)}]\\ & =\sum _{i=1}^n\frac{P(x_i)+Q(x_i)}{2}log\frac{1}{\frac{P(x_i)+Q(x_i)}{2}}-\sum _{i=1}^n\frac{P(x_i)log\frac{1}{P(x_i)}+Q(x_i)log\frac{1}{Q(x_i)}}{2}\\ & =H(\frac{P+Q}{2})-\frac{H(P)+H(Q)}{2}\end{array}$$

互信息

挖坑待填

References

1. https://en.wikipedia.org/wiki/Entropy_(information_theory)
2. https://en.wikipedia.org/wiki/Cross_entropy
3. https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence
4. https://en.wikipedia.org/wiki/Jensen%E2%80%93Shannon_divergence

两者都可以用来衡量两个概率分布之间的差异性。JS散度是KL散度的一种变体形式。

KL散度：

也称相对熵、KL距离。对于两个概率分布P和Q之间的差异性（也可以简单理解成相似性），二者越相似，KL散度越小。

KL散度的性质：

●非负性。即KL散度大于等于零。

●非对称性。即运算时交换P和Q的位置，得到的结果也不一样。（所以这里严格来讲也不能把KL散度称为KL距离，距离一定符合对称性，所以要描述准确的话还是建议用KL散度来表述）

离散分布公式：

连续分布公式：

python代码实现：

#KL_divergence
import numpy as np
import scipy.stats
P=np.array([1/4,1/2,1/4,1/4])
Q=np.array([1/3,1/3,1/6,1/6])
def KL_divergence(P,Q):
    return scipy.stats.entropy(P,Q)
print(KL_divergence(P,Q)) # 0.04369212068196553
print(KL_divergence(P,Q)) # 0.04369212068196553

JS散度：

JS散度是KL散度的一种变体，与KL散度相似，P和Q越相似，JS散度越小。

JS散度的性质：

●JS散度的值域范围是[0,1]，完全相同为0，完全相反为1。相较于KL，对相似度的判别更确切了。

●对称性。通过公式可以看出交换了P和Q的位置计算结果仍然一样。（个人认为这种JS散度的出现就是为了解决KL散度不对称的问题）

python代码实现：

#JS_divergence
import numpy as np
import scipy.stats
P=np.array([1/4,1/2,1/4,1/4])
Q=np.array([1/3,1/3,1/6,1/6])
R=np.array([1/10,3/10,4/10,2/10])
def JS_divergence(P,Q):
    M=(P+Q)/2
    return 0.5*scipy.stats.entropy(P, M)+0.5*scipy.stats.entropy(Q, M)
print(JS_divergence(P,Q))  # 0.011598863066818382
print(JS_divergence(Q,P))  # 0.011598863066818382
print(JS_divergence(R,R)) # 0.0