56

当尝试使用 sigmoid 激活函数获得交叉熵时，两者之间存在差异

  1. loss1 = -tf.reduce_sum(p*tf.log(q), 1)
  2. loss2 = tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(labels=p, logits=logit_q),1)

但是在使用 softmax 激活函数时它们是相同的。

以下是示例代码：

import tensorflow as tf

sess2 = tf.InteractiveSession()
p = tf.placeholder(tf.float32, shape=[None, 5])
logit_q = tf.placeholder(tf.float32, shape=[None, 5])
q = tf.nn.sigmoid(logit_q)
sess.run(tf.global_variables_initializer())

feed_dict = {p: [[0, 0, 0, 1, 0], [1,0,0,0,0]], logit_q: [[0.2, 0.2, 0.2, 0.2, 0.2], [0.3, 0.3, 0.2, 0.1, 0.1]]}
loss1 = -tf.reduce_sum(p*tf.log(q),1).eval(feed_dict)
loss2 = tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(labels=p, logits=logit_q),1).eval(feed_dict)

print(p.eval(feed_dict), "\n", q.eval(feed_dict))
print("\n",loss1, "\n", loss2)
4

2 回答 2

86

您混淆了二元和多类问题的交叉熵。

多类交叉熵

您使用的公式是正确的，它直接对应于tf.nn.softmax_cross_entropy_with_logits：

-tf.reduce_sum(p * tf.log(q), axis=1)

p并且q预计是 N 个类别的概率分布。特别是，N 可以是 2，如下例所示：

p = tf.placeholder(tf.float32, shape=[None, 2])
logit_q = tf.placeholder(tf.float32, shape=[None, 2])
q = tf.nn.softmax(logit_q)

feed_dict = {
  p: [[0, 1],
      [1, 0],
      [1, 0]],
  logit_q: [[0.2, 0.8],
            [0.7, 0.3],
            [0.5, 0.5]]
}

prob1 = -tf.reduce_sum(p * tf.log(q), axis=1)
prob2 = tf.nn.softmax_cross_entropy_with_logits(labels=p, logits=logit_q)
print(prob1.eval(feed_dict))  # [ 0.43748799  0.51301527  0.69314718]
print(prob2.eval(feed_dict))  # [ 0.43748799  0.51301527  0.69314718]

注意q是计算tf.nn.softmax，即输出一个概率分布。所以它仍然是多类交叉熵公式，仅适用于 N = 2。

二元交叉熵

这次正确的公式是

p * -tf.log(q) + (1 - p) * -tf.log(1 - q)

虽然在数学上它是多类情况的部分情况，但和的含义是不同的。在最简单的情况下，每个和都是一个数字，对应于 A 类的概率。pqpq

重要提示：不要对共同p * -tf.log(q)部分和总和感到困惑。以前p是单热向量，现在是数字，零或一。同样q- 这是一个概率分布，现在是一个数字（概率）。

如果p是一个向量，则每个单独的组件都被认为是一个独立的二元分类。请参阅此答案，该答案概述了 tensorflow 中 softmax 和 sigmoid 函数之间的区别。所以定义p = [0, 0, 0, 1, 0]并不意味着一个单一的向量，而是 5 个不同的特征，其中 4 个关闭，1 个打开。该定义q = [0.2, 0.2, 0.2, 0.2, 0.2]意味着 5 个特征中的每一个都以 20% 的概率开启。

这解释了sigmoid在交叉熵之前使用函数：它的目标是将 logit 压缩到[0, 1]区间。

上面的公式仍然适用于多个独立的特征，而这正是tf.nn.sigmoid_cross_entropy_with_logits计算的：

p = tf.placeholder(tf.float32, shape=[None, 5])
logit_q = tf.placeholder(tf.float32, shape=[None, 5])
q = tf.nn.sigmoid(logit_q)

feed_dict = {
  p: [[0, 0, 0, 1, 0],
      [1, 0, 0, 0, 0]],
  logit_q: [[0.2, 0.2, 0.2, 0.2, 0.2],
            [0.3, 0.3, 0.2, 0.1, 0.1]]
}

prob1 = -p * tf.log(q)
prob2 = p * -tf.log(q) + (1 - p) * -tf.log(1 - q)
prob3 = p * -tf.log(tf.sigmoid(logit_q)) + (1-p) * -tf.log(1-tf.sigmoid(logit_q))
prob4 = tf.nn.sigmoid_cross_entropy_with_logits(labels=p, logits=logit_q)
print(prob1.eval(feed_dict))
print(prob2.eval(feed_dict))
print(prob3.eval(feed_dict))
print(prob4.eval(feed_dict))

你应该看到最后三个张量是相等的，而prob1只是交叉熵的一部分，所以它只有在pis时才包含正确的值1：

[[ 0.          0.          0.          0.59813893  0.        ]
 [ 0.55435514  0.          0.          0.          0.        ]]
[[ 0.79813886  0.79813886  0.79813886  0.59813887  0.79813886]
 [ 0.5543552   0.85435522  0.79813886  0.74439669  0.74439669]]
[[ 0.7981388   0.7981388   0.7981388   0.59813893  0.7981388 ]
 [ 0.55435514  0.85435534  0.7981388   0.74439663  0.74439663]]
[[ 0.7981388   0.7981388   0.7981388   0.59813893  0.7981388 ]
 [ 0.55435514  0.85435534  0.7981388   0.74439663  0.74439663]]

现在应该清楚的是，在这种情况下取​​ a 的总和是-p * tf.log(q)没有axis=1意义的，尽管它在多类情况下是一个有效的公式。

于 2017-11-11T13:08:56.663 回答
0

您可以通过以下方式了解 softmax 和 sigmoid 交叉熵之间的区别：

  1. 对于 softmax 交叉熵，它实际上有一个概率分布
  2. 对于 sigmoid 交叉熵，它实际上有多个独立的二元概率分布，每个二元概率分布可以看作是两类概率分布

所以无论如何交叉熵是：

   p * -tf.log(q)

对于 softmax 交叉熵，它看起来和上面的公式完全一样，</p>

但是对于 sigmoid，它看起来有点不同，因为它对于每个二进制概率分布都有多个二进制概率分布，它是

p * -tf.log(q)+(1-p) * -tf.log(1-q)

p 和 (1-p) 您可以将其视为每个二元概率分布中的两类概率

于 2020-11-21T03:59:45.967 回答