Tensorflow & Keras的loss函数总结

一、二分类与多分类交叉熵损失函数的理解

交叉熵是分类任务中的常用损失函数，在不同的分类任务情况下，交叉熵形式上有很大的差别，

• 二分类任务交叉熵损失函数：

• 多分类任务交叉熵损失函数：

这两个交叉熵损失函数对应神经网络不同的最后一层输出，二分类对应 sigmoid，多分类对应 softmax。它们的交叉熵本质上是一样的：

（1）在信息论中，交叉熵是用来描述两个分布的距离的，函数定义为：

而神经网络训练的目的就是使预测的概率分布 g(x) 逼近真实的概率分布 p(x)。

（2）当 softmax 作为神经网络最后一层时，由于softmax的输出是归一化后的结果，所以可以把输出y作为g(x)，p(x)是one-hot编码的真实标签。

（3）当 sigmoid 作为神经网络最后一层时，由于sigmoid是针对每个元素独立计算的，输出结果相加不等于1，所以不能把它的输出看作一个分布，而应该将最后一层的每个神经元看作一个分布，对应的 yi 服从二项分布 (yi的值代表是这个类的概率)，那么第 i 个神经元的交叉熵为：

用求和符号改写为：

其中，

---

二、Tensorflow & Keras 中loss函数示例

1、Tensorflow接口

(1) tf.losses.sigmoid_cross_entropy(multi_class_labels, logits, ...)

使用tf.nn.sigmoid_cross_entropy_with_logits接口计算交叉熵

import tensorflow as tf
tf.enable_eager_execution()

def my_sigmoid_cross_entropy(labels, logits):
  # z*(-log(sigmoid(x))) + (1 - z)*(-log(1 - sigmoid(x)))
  result = tf.multiply(labels, -tf.log(tf.nn.sigmoid(logits))) \
            + tf.multiply(tf.subtract(1, labels), -tf.log(tf.subtract(1, tf.nn.sigmoid(logits))))
  return tf.reduce_mean(result)

label = tf.constant([0, 1, 1, 0, 1], dtype=tf.int32)
logit = tf.constant([-1.2, 2.3, 4.1, 0.8, 1.4], dtype=tf.float32)

fn_result = tf.losses.sigmoid_cross_entropy(multi_class_labels=label, logits=logit)
print("sigmoid_cross_entropy: {}".format(fn_result))

my_result = my_sigmoid_cross_entropy(labels=tf.cast(label, dtype=tf.float32), logits=logit)
print("my sigmoid_cross_entropy: {}".format(my_result))

输出：

(2) tf.losses.softmax_cross_entropy(onehot_labels, logits, ...)

使用tf.nn.softmax_cross_entropy_with_logits_v2接口计算交叉熵，输入的labels是要经过onehot编码的格式，因为函数内部会计算softmax和cross-entropy，所以输入的logits是不需要经过softmax的值。

tf.nn.softmax_cross_entropy_with_logits_v2函数说明里的一段：

WARNING: This op expects unscaled logits, since it performs a softmaxon logits internally for efficiency. Do not call this op with the output of softmax, as it will produce incorrect results.

意思就是为了效率在函数内部计算了logits的softmax, 不要将softmax的输出作为函数logits输入，否则会导致错误的结果。

import tensorflow as tf
tf.enable_eager_execution()

def my_softmax_cross_entropy(labels, logits):
    logits = tf.nn.softmax(logits)
    result = -tf.reduce_sum(labels * tf.log(logits))
    return result

label = tf.constant(2, dtype=tf.int32)
logit = tf.constant([-1.2, 2.3, 4.1, 3.0, 1.4], dtype=tf.float32)

fn_result = tf.losses.softmax_cross_entropy(onehot_labels=tf.one_hot(label, logit.shape[0]), logits=logit)
print("softmax_cross_entropy: {}".format(fn_result))

my_result = my_softmax_cross_entropy(labels=tf.one_hot(label, logit.shape[0]), logits=logit)
print("my softmax_cross_entropy: {}".format(my_result))

输出：

(3) tf.losses.sparse_softmax_cross_entropy(labels, logits, ...)

使用tf.nn.sparse_softmax_cross_entropy_with_logits接口计算交叉熵，输入的labels是类别，维度是 [batch_size, 1]，函数内部会计算softmax和cross-entropy，所以输入的logits是不需要经过softmax的值。

import tensorflow as tf
tf.enable_eager_execution()

def my_sparse_softmax_cross_entropy(labels, logits):
    x = tf.one_hot(labels, depth=logits.shape[0])
    y = tf.nn.softmax(logits)
    result = -tf.reduce_sum(x * tf.log(y))
    return result

label = tf.constant(2, dtype=tf.int32)
logit = tf.constant([-1.2, 2.3, 4.1, 3.0, 1.4], dtype=tf.float32)

fn_result = tf.losses.sparse_softmax_cross_entropy(labels=label, logits=logit)
print("sparse_softmax_cross_entropy: {}".format(fn_result))

my_result = my_sparse_softmax_cross_entropy(labels=label, logits=logit)
print("my sparse_softmax_cross_entropy: {}".format(my_result))

输出：

2、tf.keras接口

(1) tf.keras.losses.binary_crossentropy(y_true, y_pred)

import tensorflow as tf
tf.enable_eager_execution()

def my_binary_cross_entropy(labels, logits):
  # z*(-log(sigmoid(x))) + (1 - z)*(-log(1 - sigmoid(x)))
  result = tf.multiply(labels, -tf.log(tf.nn.sigmoid(logits))) \
            + tf.multiply(tf.subtract(1, labels), -tf.log(tf.subtract(1, tf.nn.sigmoid(logits))))
  return tf.reduce_mean(result)

label = tf.constant([0, 1, 1, 0, 1], dtype=tf.int32)
logit = tf.constant([1.2, 2.3, 4.1, 0.8, 1.4], dtype=tf.float32)

fn_result = tf.keras.losses.binary_crossentropy(y_true=tf.cast(label, dtype=tf.float32), y_pred=tf.nn.sigmoid(logit))
print("binary_crossentropy: {}".format(fn_result))

my_result = my_binary_cross_entropy(labels=tf.cast(label, dtype=tf.float32), logits=logit)
print("my binary_crossentropy: {}".format(my_result))

输出：

(2) tf.keras.losses.categorical_crossentropy(y_true, y_pred)

import tensorflow as tf
tf.enable_eager_execution()

def my_categorical_cross_entropy(labels, logits):
    logits = tf.nn.softmax(logits)
    result = -tf.reduce_sum(labels * tf.log(logits))
    return result

label = tf.constant(2, dtype=tf.int32)
logit = tf.constant([-1.2, 2.3, 4.1, 3.0, 1.4], dtype=tf.float32)

fn_result = tf.keras.losses.categorical_crossentropy(y_true=tf.one_hot(label, logit.shape[0]), y_pred=tf.nn.softmax(logit))
print("categorical_cross_entropy: {}".format(fn_result))

my_result = my_categorical_cross_entropy(labels=tf.one_hot(label, logit.shape[0]), logits=logit)
print("my categorical_cross_entropy: {}".format(my_result))

输出：

(3) tf.keras.losses.sparse_categorical_crossentropy(y_true, y_pred)

import tensorflow as tf
tf.enable_eager_execution()

def my_sparse_categorical_cross_entropy(labels, logits):
    logits = tf.nn.softmax(logits)
    result = -tf.reduce_sum(labels * tf.log(logits))
    return result

label = tf.constant(2, dtype=tf.int32)
logit = tf.constant([-1.2, 2.3, 4.1, 3.0, 1.4], dtype=tf.float32)

fn_result = tf.keras.losses.sparse_categorical_crossentropy(y_true=label, y_pred=tf.nn.softmax(logit))

print("sparse_categorical_cross_entropy: {}".format(fn_result))

my_result = my_sparse_categorical_cross_entropy(labels=tf.one_hot(label, logit.shape[0]), logits=logit)
print("my sparse_categorical_cross_entropy: {}".format(my_result))

输出：