还有一件事我肯定想强调，因为logit只是一个原始输出，通常是最后一层的输出。这也可以是负值。如果我们使用它作为“交叉熵”评估，如下所述:

-tf.reduce_sum(y_true * tf.log(logits))

那就没用了。因为log (-ve)没有定义。 因此使用softmax激活，将克服这个问题。

这是我的理解，如果错了请指正。

以上答案对所问问题有足够的描述。

除此之外，Tensorflow还优化了应用激活函数，然后使用自己的激活和代价函数计算代价的操作。因此，使用tf.nn.softmax_cross_entropy() over tf.nn.softmax()是一个很好的实践;tf.nn.cross_entropy ()

在资源密集型模型中，你可以发现它们之间的显著差异。

短版:

假设您有两个张量，其中y_hat包含每个类的计算分数(例如，从y = W*x +b开始)，y_true包含单热编码的true标签。

y_hat  = ... # Predicted label, e.g. y = tf.matmul(X, W) + b
y_true = ... # True label, one-hot encoded

如果将y_hat中的分数解释为非标准化的对数概率，那么它们就是对数。

此外，总交叉熵损失计算如下:

y_hat_softmax = tf.nn.softmax(y_hat)
total_loss = tf.reduce_mean(-tf.reduce_sum(y_true * tf.log(y_hat_softmax), [1]))

本质上等同于用函数softmax_cross_entropy_with_logits()计算的总交叉熵损失:

total_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true))

长版:

在神经网络的输出层，你可能会计算一个数组，其中包含每个训练实例的类分数，例如从计算y_hat = W*x + b。作为一个例子，下面我创建了一个2 x 3的y_hat数组，其中行对应训练实例，列对应类。这里有2个训练实例和3个类。

import tensorflow as tf
import numpy as np

sess = tf.Session()

# Create example y_hat.
y_hat = tf.convert_to_tensor(np.array([[0.5, 1.5, 0.1],[2.2, 1.3, 1.7]]))
sess.run(y_hat)
# array([[ 0.5,  1.5,  0.1],
#        [ 2.2,  1.3,  1.7]])

注意，这些值不是归一化的(即行加起来不等于1)。为了将它们归一化，我们可以应用softmax函数，它将输入解释为非归一化的对数概率(又名logits)，并将输出解释为归一化的线性概率。

y_hat_softmax = tf.nn.softmax(y_hat)
sess.run(y_hat_softmax)
# array([[ 0.227863  ,  0.61939586,  0.15274114],
#        [ 0.49674623,  0.20196195,  0.30129182]])

充分理解softmax输出的含义是很重要的。下面我展示了一个更清楚地表示上面输出的表。可以看出，例如，训练实例1为“Class 2”的概率为0.619。每个训练实例的类概率是标准化的，所以每一行的和是1.0。

                      Pr(Class 1)  Pr(Class 2)  Pr(Class 3)
                    ,--------------------------------------
Training instance 1 | 0.227863   | 0.61939586 | 0.15274114
Training instance 2 | 0.49674623 | 0.20196195 | 0.30129182

现在我们有了每个训练实例的类概率，我们可以使用每行的argmax()来生成最终的分类。从上面，我们可以生成训练实例1属于“类2”，训练实例2属于“类1”。

这些分类正确吗?我们需要与训练集中的真实标签进行比较。您将需要一个单热编码的y_true数组，其中的行是训练实例，列是类。下面我创建了一个示例y_true单热数组，其中训练实例1的真标签是“Class 2”，训练实例2的真标签是“Class 3”。

y_true = tf.convert_to_tensor(np.array([[0.0, 1.0, 0.0],[0.0, 0.0, 1.0]]))
sess.run(y_true)
# array([[ 0.,  1.,  0.],
#        [ 0.,  0.,  1.]])

y_hat_softmax中的概率分布是否接近y_true中的概率分布?我们可以用交叉熵损失来测量误差。

We can compute the cross-entropy loss on a row-wise basis and see the results. Below we can see that training instance 1 has a loss of 0.479, while training instance 2 has a higher loss of 1.200. This result makes sense because in our example above, y_hat_softmax showed that training instance 1's highest probability was for "Class 2", which matches training instance 1 in y_true; however, the prediction for training instance 2 showed a highest probability for "Class 1", which does not match the true class "Class 3".

loss_per_instance_1 = -tf.reduce_sum(y_true * tf.log(y_hat_softmax), reduction_indices=[1])
sess.run(loss_per_instance_1)
# array([ 0.4790107 ,  1.19967598])

我们真正想要的是所有训练实例的总损失。所以我们可以计算:

total_loss_1 = tf.reduce_mean(-tf.reduce_sum(y_true * tf.log(y_hat_softmax), reduction_indices=[1]))
sess.run(total_loss_1)
# 0.83934333897877944

使用softmax_cross_entropy_with_logits ()

我们可以使用tf.nn.softmax_cross_entropy_with_logits()函数来计算总交叉熵损失，如下所示。

loss_per_instance_2 = tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true)
sess.run(loss_per_instance_2)
# array([ 0.4790107 ,  1.19967598])

total_loss_2 = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true))
sess.run(total_loss_2)
# 0.83934333897877922

请注意，total_loss_1和total_loss_2产生的结果本质上是相同的，只是在最后的数字上有一些微小的差异。但是，您也可以使用第二种方法:它只需要少一行代码，积累的数值错误也更少，因为softmax是在softmax_cross_entropy_with_logits()中为您完成的。

softmax计算通过softmax层的前向传播。当您计算模型输出的概率时，您可以在模型的评估过程中使用它。

tf.nn。Softmax_cross_entropy_with_logits计算一个softmax层的开销。它只在训练时使用。

对数是输出模型的非归一化对数概率(在应用softmax归一化之前输出的值)。

softmax+logits仅仅意味着该函数对早期层的未缩放输出进行操作，并且理解单位的相对缩放是线性的。这意味着，特别是输入的总和可能不等于1，这些值不是概率(你可能有一个5的输入)。在内部，它首先对未缩放的输出应用softmax，然后再计算这些值的交叉熵与标签所定义的“应该”值的交叉熵。

softmax产生将softmax函数应用于输入张量的结果。softmax“压缩”输入，使sum(输入)= 1，它通过将输入解释为对数概率(logits)，然后将它们转换回0到1之间的原始概率来进行映射。softmax的输出形状与输入相同:

a = tf.constant(np.array([[.1, .3, .5, .9]]))
print s.run(tf.nn.softmax(a))
[[ 0.16838508  0.205666    0.25120102  0.37474789]]

有关为什么softmax被广泛用于dnn的更多信息，请参阅这个答案。

tf.nn。Softmax_cross_entropy_with_logits将softmax步骤与应用softmax函数后的交叉熵损失计算结合在一起，但它以一种更精确的数学方式将它们结合在一起。它的结果类似于:

sm = tf.nn.softmax(x)
ce = cross_entropy(sm)

交叉熵是一种汇总度量:它对元素进行汇总。tf.nn的输出。形状[2,5]张量上的Softmax_cross_entropy_with_logits的形状为[2,1](第一个维度被视为批处理)。

如果你想做优化来最小化交叉熵，并且在最后一层之后进行软最大化，你应该使用tf.nn。Softmax_cross_entropy_with_logits而不是自己做，因为它以数学正确的方式涵盖了数值不稳定的角落情况。否则，你就会在这里和那里加上小的。

编辑2016-02-07: 如果您有单个类标签，其中一个对象只能属于一个类，那么您现在可以考虑使用tf.nn。Sparse_softmax_cross_entropy_with_logits，这样您就不必将标签转换为密集的单热数组。该功能是在0.6.0版之后添加的。

Tensorflow 2.0兼容答案:dga和stackoverflowuser2010的解释非常详细地介绍了Logits和相关的函数。

当在Tensorflow 1中使用这些函数时。X可以正常工作，但是如果您从1迁移代码。X(1.14, 1.15，等等)到2。X(2.0, 2.1，等等)，使用这些函数会导致错误。

因此，如果我们从1迁移，则为上面讨论的所有函数指定2.0兼容调用。X到2。X，为了社区的利益。

1.x中的函数:

tf.nn.softmax tf.nn.softmax_cross_entropy_with_logits tf.nn.sparse_softmax_cross_entropy_with_logits

从1迁移时各自的函数。X到2.x:

tf.compat.v2.nn.softmax tf.compat.v2.nn.softmax_cross_entropy_with_logits tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits

有关从1迁移的更多信息。X到2。x，请参考本迁移指南。