精华内容
下载资源
问答
  • JS散度 万次阅读
    2018-12-23 22:54:10

    前面我们介绍了相对熵(KL散度)的概念,知道了它可以用来表示两个概率分布之间的差异,但有个不大好的地方是它并不是对称的,因此有时用它来训练神经网络会有顺序不同造成不一样的训练结果的情况(其实个人觉得也就是训练时间差异罢了,也没那么严重)。为了克服这个问题,有人就提出了一个新的衡量公式,叫做 J S JS JS散度,式子如下:
    J S ( P 1 ∥ P 2 ) = 1 2 K L ( P 1 ∥ P 1 + P 2 2 ) + 1 2 K L ( P 2 ∥ P 1 + P 2 2 ) J S \left( P _ { 1 } \| P _ { 2 } \right) = \frac { 1 } { 2 } K L \left( P _ { 1 } \| \frac { P _ { 1 } + P _ { 2 } } { 2 } \right) + \frac { 1 } { 2 } K L \left( P _ { 2 } \| \frac { P _ { 1 } + P _ { 2 } } { 2 } \right) JS(P1P2)=21KL(P12P1+P2)+21KL(P22P1+P2)
    如果有一点数学功底的人可以轻易看出这个公式对于 P 1 P _ { 1 } P1 P 2 P _ { 2 } P2是对称的,而且因为是两个 K L KL KL的叠加,由相对熵的文章我们知道 K L KL KL的值一定是大于等于0的,因此这个公式也一定大于等于0。

    现在只剩下一个关键问题,就是什么时候等于0的问题了。同样参考相对熵的文章我们知道当两个分布相同的时候等于0,那么换到这里,也就是:
    P 1 = P 1 + P 2 2   且 P 2 = P 1 + P 2 2 P _ { 1 }=\frac { P _ { 1 } + P _ { 2 } }{ 2 }\ \qquad 且 \qquad P _ { 2 }=\frac { P _ { 1 } + P _ { 2 } } { 2 } P1=2P1+P2 P2=2P1+P2
    的时候。可以轻易看出来, J S JS JS散度等于0的时候跟 K L KL KL散度一样,就是 P 1 P _ { 1 } P1 P 2 P _ { 2 } P2完全一样的时候。那么推到这里,用 J S JS JS散度来表达两个概率分布的差异就问题不大了。

    其实本人在看相对熵和 J S JS JS散度的时候一直有疑问,就是当两个概率分布不一样的时候,它们的值是不是会随着距离的变大而变大,也就是说这两个公式跟概率分布的距离到底是不是一个单调的关系,但我没有看到别人在说这件事情。我自己想了半天之后得出的结论是不一定,可能随着概率分布的表达式不一样而有所变化。

    当然因为没有人讲这件事我至今也不知道这样想是不是对的,因此有老哥想明白了麻烦留个言告诉我。

    更多相关内容
  • 该算法基于每个项目基分值概率分布使用 KL 散度计算项目之间的显性反馈相似度,再融合隐 狄利克雷主题分配模型,得到每个项目属于 T 个主题的概率分布,使用 JS 散度计算出项目之间隐性 反馈相似度,将两个相似度...
  • [nlp] KL散度JS散度

    2021-01-07 03:12:00
    1.KL散度 KL散度( Kullback–Leibler divergence) (最大类间散度) 是描述两个概率分布差异的一种测度。对于两个概率分布P、Q,二者越相似,KL散度越小。 KL散度的性质:P:真实分布,Q:P的拟合分布 非负性:KL(P||Q...
  • KL散度JS散度数学公式以及代码例子 1.1 KL 散度概述 KL 散度 是概率论和信息论中十分重要的一个概念。它描述两个概念分布 PPP 和 QQQ 差异的一种方法。 离散概率分布的 KL 散度 计算公式为: KL(p∣∣q)=∑p(x)...

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

    1.1 KL 散度概述

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

    对离散概率分布的 KL 散度 计算公式为:
    K L ( p ∣ ∣ q ) = ∑ p ( x ) log ⁡ p ( x ) q ( x )            ( 1 ) KL(p||q)=\sum p(x)\log{{p(x)}\over{q(x)}} \ \ \ \ \ \ \ \ \ \ (1) KL(pq)=p(x)logq(x)p(x)          (1)

    对连续概率分布的 KL 散度 计算公式为:
    K L ( p ∣ ∣ q ) = ∫ p ( x ) log ⁡ p ( x ) q ( x ) d x           ( 2 ) KL(p||q)=\int p(x)\log {{p(x)}\over{q(x)}}dx \ \ \ \ \ \ \ \ \ (2) KL(pq)=p(x)logq(x)p(x)dx         (2)

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

    KL 散度 的重要性质:

    • KL 散度 的结果是非负的。
    • KL 散度 是非对称的,即 K L ( p ∣ ∣ q )   ! =   K L ( q ∣ ∣ p ) KL(p||q) \ !=\ KL(q||p) KL(pq) != KL(qp)

    具体内容参考 [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
    

    计算过程 K L ( P , Q ) = 0.2 ∗ log ⁡ 0.2 0.4 + 0.4 ∗ log ⁡ 0.4 0.2 + 0.4 ∗ log ⁡ 0.4 0.4 = 0.13862943611198905 KL(P,Q) = 0.2*\log{{0.2}\over{0.4}}+0.4*\log{{0.4}\over{0.2}}+0.4*\log{{0.4}\over{0.4}}=0.13862943611198905 KL(P,Q)=0.2log0.40.2+0.4log0.20.4+0.4log0.40.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 信息论中一个重要概念,主要用于度量两个概率分布间的差异性信息。

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

    C r o s s E n t r o p y   ( y , y ^ ) = − ( y ∗ log ⁡ ( y ^ ) + ( 1 − y ) ∗ log ⁡ ( 1 − y ^ ) )           ( 3 ) Cross Entropy\ (y, {\hat y}) = -(y*\log(\hat y)+(1-y)*\log(1-\hat y)) \ \ \ \ \ \ \ \ \ (3) CrossEntropy (y,y^)=(ylog(y^)+(1y)log(1y^))         (3)
    其中, y y y 可以理解为数据集中的 label,也就是接下来例子中的 y t r u e y_{true} ytrue;而 y ^ \hat y y^ 可以理解与模型的预测标签,也就是接下来的例子中的 y p r e d y_{pred} ypred

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

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

    C r o s s E n t r o p y   ( y , y ^ ) = ∑ y ∗ log ⁡ ( 1 y ^ )              ( 4 ) Cross Entropy\ (y, {\hat y}) = \sum y*\log ({{1}\over{\hat y}}) \ \ \ \ \ \ \ \ \ \ \ \ (4) CrossEntropy (y,y^)=ylog(y^1)            (4)
    公式 4 可以写成如下格式:

    C r o s s E n t r o p y   ( y , y ^ ) = − ∑ y ∗ log ⁡ ( y ^ )              ( 5 ) Cross Entropy\ (y, {\hat y}) = -\sum y*\log ({\hat y}) \ \ \ \ \ \ \ \ \ \ \ \ (5) CrossEntropy (y,y^)=ylog(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))
    

    计算过程 C E ( P , Q ) = 0 ∗ log ⁡ ( 1 0.6 ) + 1 ∗ log ⁡ ( 1 0.4 ) = log ⁡ ( 2.5 ) = 0.91629073187415506518352721176801 CE(P, Q)=0*\log({{1}\over{0.6}})+1*\log({{1}\over{0.4}})=\log(2.5)=0.91629073187415506518352721176801 CE(P,Q)=0log(0.61)+1log(0.41)=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 这种情况,接下来在这里讨论,在二分类问题中,应该如何计算结果。

    C r o s s E n t r o p y   ( y , y ^ ) = − ( y ∗ log ⁡ ( y ^ ) + ( 1 − y ) ∗ log ⁡ ( 1 − y ^ ) )           ( 3 ) Cross Entropy\ (y, {\hat y}) = -(y*\log(\hat y)+(1-y)*\log(1-\hat y)) \ \ \ \ \ \ \ \ \ (3) CrossEntropy (y,y^)=(ylog(y^)+(1y)log(1y^))         (3)
    公式3 所示,在 输入数据的 y y y 为 [0,1] 两种时,使用 公式3,4,5 计算都可以。但是如果输入数据的 y y y 全部为 0 的时候,公式3 与公式4 则不适用。

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

    C r o s s E n t r o p y   ( y , y ^ ) = − 1 n ∑ i = 1 n ( y i ∗ log ⁡ ( y ^ i ) + ( 1 − y i ) ∗ log ⁡ ( 1 − y ^ i ) )           ( 6 ) Cross Entropy\ (y, {\hat y}) = -{{1}\over{n}}\sum_{i=1}^n(y_i*\log(\hat y_i)+(1-y_i)*\log(1-\hat y_i)) \ \ \ \ \ \ \ \ \ (6) CrossEntropy (y,y^)=n1i=1n(yilog(y^i)+(1yi)log(1y^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
    

    计算过程 C E ( p , q ) = − 1 2 ( ( 0 ∗ log ⁡ 0.6 + 1 ∗ log ⁡ 0.4 ) + ( 0 ∗ log ⁡ 0.4 + 1 ∗ log ⁡ 0.6 ) ) = − 1 2 log ⁡ 0.24 = 0.71355817782007287419452065403584 CE(p,q)=-{{1}\over{2}}((0*\log 0.6 + 1*\log 0.4)+(0*\log 0.4+1*\log0.6))=-{{1}\over{2}}\log0.24=0.71355817782007287419452065403584 CE(p,q)=21((0log0.6+1log0.4)+(0log0.4+1log0.6))=21log0.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 散度的求解公式如下:
    J S ( P   ∣ ∣   Q ) = 1 2 K L ( P   ∣ ∣   P + Q 2 ) + 1 2 K L ( Q   ∣ ∣   P + Q 2 )            ( 7 ) JS(P \ ||\ Q ) = {{1}\over{2}}KL(P\ ||\ {{P+Q}\over{2}})+{{1}\over{2}}KL(Q \ ||\ {{P+Q}\over{2}}) \ \ \ \ \ \ \ \ \ \ (7) JS(P  Q)=21KL(P  2P+Q)+21KL(Q  2P+Q)          (7)

    很明显,等式是对称成立的,也就是说 J S ( P   ∣ ∣   Q ) = = J S ( Q   ∣ ∣   P ) JS(P \ || \ Q) == JS(Q\ ||\ P) 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
    

    可以看出 J S ( P , Q ) JS(P,Q) JS(P,Q) J S ( Q , P ) JS(Q,P) 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公式

    展开全文
  • 上述式子不难验证,将KL散度的计算公式带入JS散度的计算公式,并将每个KL散度展开成交叉熵减去熵的形式,然后再合并就行,如下: J S D ( P ∣ ∣ Q ) = 1 2 D K L ( P ∣ ∣ P + Q 2 ) + 1 2 D K L ( Q ∣ ∣ P +...

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

    熵,又称香农熵(Shannon entropy),一个分布 P P P的熵记为 H ( P ) H(P) H(P),计算公式为:

    H ( P ) = E x ∼ P ( x ) [ − l o g P ( x ) ] = ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) H(P)=\mathbb E_{ x \sim P(x)} [ -logP(x)]=\sum_{i=1}^n P(x_i)log\frac{1}{P(x_i)} H(P)=ExP(x)[logP(x)]=i=1nP(xi)logP(xi)1

    交叉熵

    两个分布 P P P Q Q Q的交叉熵(Cross entropy)记为 H ( P , Q ) H(P,Q) H(P,Q),计算公式为:

    H ( P , Q ) = E x ∼ P ( x ) [ − l o g Q ( x ) ] = ∑ i = 1 n P ( x i ) l o g 1 Q ( x i ) H(P,Q)=\mathbb E_{x \sim P(x)} [-logQ(x)]=\sum_{i=1}^n P(x_i)log\frac{1}{Q(x_i)} H(P,Q)=ExP(x)[logQ(x)]=i=1nP(xi)logQ(xi)1

    KL散度

    KL散度(Kullback–Leibler divergence)又称相对熵(relative entropy),两个分布 P P P Q Q Q的KL散度记为 D K L ( P ∣ ∣ Q ) D_{KL}(P||Q) DKL(PQ),计算公式为:

    D K L ( P ∣ ∣ Q ) = E x ∼ P ( x ) [ l o g P ( x ) Q ( x ) ] = ∑ i = 1 n P ( x i ) l o g P ( x i ) Q ( x i ) 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)} DKL(PQ)=ExP(x)[logQ(x)P(x)]=i=1nP(xi)logQ(xi)P(xi)

    由熵、交叉熵和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 1 Q ( x i ) − ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) = H ( P , Q ) − H ( P ) \begin{aligned} 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{aligned} DKL(PQ)=i=1nP(xi)logQ(xi)P(xi)=i=1nP(xi)logQ(xi)1i=1nP(xi)logP(xi)1=H(P,Q)H(P)

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

    JS散度

    两个分布 P P P Q Q Q的JS散度(Jensen–Shannon divergence)记为 J S D ( P ∣ ∣ Q ) JSD(P||Q) JSD(PQ),其计算公式为:

    J S D ( P ∣ ∣ Q ) = 1 2 D K L ( P ∣ ∣ P + Q 2 ) + 1 2 D K L ( Q ∣ ∣ P + Q 2 ) JSD(P||Q)=\frac 12 D_{KL}(P||\frac {P+Q}{2})+\frac 12 D_{KL}(Q||\frac {P+Q}{2}) JSD(PQ)=21DKL(P2P+Q)+21DKL(Q2P+Q)

    对于 n n n个分布 P 1 , P 2 , P 3 . . . , P n P_1, P_2, P_3 ..., P_n P1,P2,P3...,Pn,其JS散度记为 J S D π 1 , π 2 , π 3 . . . , π n ( P 1 , P 2 , P 3 . . . , P n ) JSD_{\pi _1, \pi_2, \pi_3 ..., \pi_n}(P_1, P_2, P_3 ..., P_n) JSDπ1,π2,π3...,πn(P1,P2,P3...,Pn),其中 π 1 , π 2 , π 3 . . . , π n \pi _1, \pi_2, \pi_3 ..., \pi_n π1,π2,π3...,πn分别是给分布 P 1 , P 2 , P 3 . . . , P n P_1, P_2, P_3 ..., P_n P1,P2,P3...,Pn赋予的权重。计算公式为:

    J S D π 1 , π 2 , π 3 . . . , π n ( P 1 , P 2 , P 3 . . . , P n ) = H ( ∑ i = 1 n π i P i ) − ∑ i = 1 n π i H ( P i ) JSD_{\pi _1, \pi_2, \pi_3 ..., \pi_n}(P_1, P_2, P_3 ..., P_n)=H(\sum_{i=1}^n\pi_iP_i)-\sum_{i=1}^n\pi_iH(P_i) JSDπ1,π2,π3...,πn(P1,P2,P3...,Pn)=H(i=1nπiPi)i=1nπiH(Pi)

    实际上,两个分布的JS散度对应了当 n = 2 n=2 n=2,且取 π 1 = π 2 = 1 2 \pi_1=\pi_2=\frac12 π1=π2=21的情形,即:

    J S D ( P ∣ ∣ Q ) = H ( P + Q 2 ) − H ( P ) + H ( Q ) 2 JSD(P||Q)=H(\frac{P+Q}{2})-\frac{H(P)+H(Q)}{2} JSD(PQ)=H(2P+Q)2H(P)+H(Q)

    上述式子不难验证,将KL散度的计算公式带入JS散度的计算公式,并将每个KL散度展开成交叉熵减去熵的形式,然后再合并就行,如下:
    J S D ( P ∣ ∣ Q ) = 1 2 D K L ( P ∣ ∣ P + Q 2 ) + 1 2 D K L ( Q ∣ ∣ P + Q 2 ) = 1 2 [ ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) + Q ( x i ) 2 − ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) ] + 1 2 [ ∑ i = 1 n Q ( x i ) l o g 1 P ( x i ) + Q ( x i ) 2 − ∑ i = 1 n Q ( x i ) l o g 1 Q ( x i ) ] = 1 2 [ ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) + Q ( x i ) 2 + ∑ i = 1 n Q ( x i ) l o g 1 P ( x i ) + Q ( x i ) 2 ] − 1 2 [ ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) + ∑ i = 1 n Q ( x i ) l o g 1 Q ( x i ) ] = ∑ i = 1 n P ( x i ) + Q ( x i ) 2 l o g 1 P ( x i ) + Q ( x i ) 2 − ∑ i = 1 n P ( x i ) l o g 1 P ( x i ) + Q ( x i ) l o g 1 Q ( x i ) 2 = H ( P + Q 2 ) − H ( P ) + H ( Q ) 2 \begin{aligned} JSD(P||Q) &=\frac 12 D_{KL}(P||\frac {P+Q}{2})+\frac 12 D_{KL}(Q||\frac {P+Q}{2}) \\ &=\frac12[\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)}]+\frac12[\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)}] \\ &=\frac12[\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}}]-\frac12[\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{aligned} JSD(PQ)=21DKL(P2P+Q)+21DKL(Q2P+Q)=21[i=1nP(xi)log2P(xi)+Q(xi)1i=1nP(xi)logP(xi)1]+21[i=1nQ(xi)log2P(xi)+Q(xi)1i=1nQ(xi)logQ(xi)1]=21[i=1nP(xi)log2P(xi)+Q(xi)1+i=1nQ(xi)log2P(xi)+Q(xi)1]21[i=1nP(xi)logP(xi)1+i=1nQ(xi)logQ(xi)1]=i=1n2P(xi)+Q(xi)log2P(xi)+Q(xi)1i=1n2P(xi)logP(xi)1+Q(xi)logQ(xi)1=H(2P+Q)2H(P)+H(Q)

    互信息

    挖坑待填

    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
    展开全文
  • KL散度(距离)和JS散度(距离)

    千次阅读 2021-09-29 13:26:22
    JS散度是KL散度的一种变体形式。 KL散度: 也称相对熵、KL距离。对于两个概率分布P和Q之间的差异性(也可以简单理解成相似性),二者越相似,KL散度越小。 KL散度的性质: ●非负性。即KL散度大于等于零。 ●非...

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

    KL散度:

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

    KL散度的性质:

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

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

    离散分布公式:

    D_{K L}(P \mid Q)=\sum_{i} P(i) \log \frac{P(i)}{Q(i)}

    连续分布公式:

    D_{K L}(P \mid Q)=\int_{-\infty}^{\infty} P(x) \log \frac{P(x)}{Q(x)} d x

    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散度不对称的问题)

    D_{J S}(P \mid Q)=\frac{1}{2} D_{K L}\left(P \mid \frac{P+Q}{2}\right)+\frac{1}{2} D_{K L}\left(Q \mid \frac{P+Q}{2}\right)

    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

    展开全文
  • KL散度JS散度

    千次阅读 2018-10-23 20:07:31
    KL散度JS散度KL散度(Kullback-Leibler divergence)KL散度的计算公式KL散度的基本性质JS散度(Jensen-Shannon divergence)JS散度的数学公式不同于KL的主要两方面 KL散度(Kullback-Leibler divergence) 又称KL距离,...
  • 数据集相似度度量之KL&JS散度

    千次阅读 2020-12-29 09:20:02
    JS散度一、KL散度1、什么是KL散度KL散度又叫相对熵,是描述两个概率分布差异的一种方法,有人将KL散度称为KL距离,但实际上它不满足距离概念中的两个条件,a、对称性,即D(P||Q)=D(Q||P); b、三角不等式;2、有什么...
  • KL散度 KL-divergence,KL散度,KL距离,又叫相对熵(relative entropy),衡量两个概率分布...JS散度基于KL散度,同样是二者越相似,JS散度越小。 JS散度的取值范围在0-1之间,完全相同时为0 JS散度是对称的 ...
  • 对于连续型随机变量,假设P为随机变量X的概率分布,则p(x)...KL散度 KL散度(Kullback–Leibler divergence)又称KL距离,相对熵。D(P∣∣Q)=∫−∞∞P(x)logP(x)Q(x)D(P||Q)=\int_{-\infty}^\infty P(x)log\frac{P...
  • JS散度度量了两个概率分布的相似度,是KL散度的变体,JS散度解决了KL散度非对称的问题。一般地,JS散度是对称的,其取值是0到1之间: JS(p,q)=12KL(p∣∣p+qq)+12KL(q∣∣p+qq)\text{JS}(p,q)=\frac{1}{2}\text{KL}...
  • 散度KL散度定义特性公式离散连续机器学习JS散度出现的原因公式特性问题交叉熵(Cross Entropy)定义公式和KL散度的关系 KL散度 定义 KL(Kullback-Leibler divergence)散度用来描述两个概率分布P和Q的差异的一种方法...
  • 作者 KevinCK编辑 极市平台 侵删来源 https://zhuanlan.zhihu.com/p/74075915目录:信息量熵相对熵(KL散度)交叉熵JS散度推土机理论Wasse...
  • JS散度全称Jensen-Shannon散度,我们这里简称JS散度。在概率统计中,JS散度也与前面提到的KL散度一样具备了测量两个概率分布相似程度的能力,它的计算方法基于KL散度,继承了KL散度的非负性等,担有一点重要的不同,...
  • KL散度JS散度、Wasserstein距离

    万次阅读 多人点赞 2018-08-03 15:31:13
    1. KL散度 KL散度又称为相对熵,信息散度,信息增益。KL散度是是两个概率分布P和Q 差别的非对称性的度量。 KL散度是用来 度量使用基于Q的编码来编码来自P的样本平均所需的额外的位元数。 典型情况下,P表示数据的...
  • GAN的理论基础之KL散度JS散度

    千次阅读 2019-01-23 10:31:18
    在介绍KL散度JS散度之前,我们需要了解什么是信息熵,什么是交叉熵。 香农信息量、信息熵 香农信息量用于刻画消除随机变量X在x处的不确定性所需的信息量的大小 当对数的底数为2时,香农信息量的单位为比特 ...
  • KL散度JS散度以及交叉熵对比

    万次阅读 多人点赞 2018-06-07 21:18:10
    在看论文《Detecting Regions of Maximal Divergence for ...KL散度JS散度和交叉熵 三者都是用来衡量两个概率分布之间的差异性的指标。不同之处在于它们的数学表达。 对于概率分布P(x)和Q(x) 1)KL散度(K...
  • GAN:两者分布不重合JS散度为log2的数学证明

    千次阅读 多人点赞 2019-03-30 19:05:43
    在开始介绍JS散度之前,必须首先引入KL散度,因为JS散度是在KL散度的基础上而来的,其公式为 K L ( P ∣ ∣ Q ) = ∑ p ( x ) log ⁡ p ( x ) q ( x ) KL(P||Q)=\sum p(x)\log \frac{p(x)}{q(x)} K L ( P ∣ ∣ Q )...
  • 请问,JS散度衡量的是两个分布的相似性,互信息衡量的是两个分部相互包含 的成都,能否理解JS散度越小互信息越大呢???
  • 1.8.2 JS散度 JS散度在KL散度的基础上进行了一次变换,使两个概率分布(p、q)间的差异度量具有对称性: 1.8.3 JS散度的特性 与KL散度相比,JS散废更适合在神经网络中应用。它具有以下特性。 对称性:可以衡量两种...
  • JS散度(Jensen-Shannon)

    千次阅读 2020-10-23 17:01:40
    JS散度(Jensen-Shannon) JS散度度量了两个概率分布的相似度,基于KL散度的变体,解决了KL散度非对称的问题。一般地,JS散度是对称的,其取值是0到1之间。 定义如下: KL散度JS散度度量的时候有一个问题: 如果...
  • 第6章—6.3KL散度JS散度.pptx
  • 理解JS散度(Jensen–Shannon divergence)

    万次阅读 多人点赞 2020-05-01 15:49:04
    文章目录1.KL散度1.1 KL散度的性质1.2 KL散度的问题即JS散度的引出2. JS散度为什么会出现两个分布没有重叠的现象参考文献 1.KL散度 用来衡量两个分布之间的差异,等于一个交叉熵减去一个信息熵(交叉熵损失函数的...
  • 本文将先建立一下距离和度量的概念,然后引出f散度的概念,利用共轭函数和神经网络来计算f散度,最后将简述KL散度JS散度的问题。 1 分布间的距离 最初提出的GAN是基于博弈论角度的,它包括一个判别器和一个生成...
  • JS散度度量了两个概率分布的相似度,是基于KL散度的变体,解决了KL散度非对称的问题。一般地,JS散度是对称的,其取值是0到1之间。定义如下: KL散度JS散度度量的时候有一个问题: 当两个分布P,Q离得很远,完全...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,981
精华内容 792
关键字:

JS散度