交叉熵损失函数和focal loss_大话交叉熵损失函数

使用keras进行二分类时,常使用binary_crossentropy作为损失函数。那么它的原理是什么,跟categorical_crossentropy、sparse_categorical_crossentropy有什么区别?在进行文本分类时,如何选择损失函数,有哪些优化损失函数的方式?本文将从原理到实现进行一一介绍。

参考: https:// towardsdatascience.com/ understanding-binary-cross-entropy-log-loss-a-visual-explanation-a3ac6025181a

binary_crossentropy

原理

假设我们想做一个二分类,输入有10个点:

x = [-2.2, -1.4, -0.8, 0.2, 0.4, 0.8, 1.2, 2.2, 2.9, 4.6]

输出有两类,分别为红色、绿色:

5ad8dc08dd447fc12f60c2f28c203165.png

我们可以将问题描述成“这个点是绿色的吗?”,或者“这个点是绿色的概率是多少?”。理想情况下,绿点的概率是1.0,而红点的(是绿色的)概率是0.0。从而,绿色就是正样本,红色就是负样本。

如果我们拟合一个模型来执行这种分类,它将预测我们每个点的绿色概率。那么我们如何评估预测概率的好坏呢?这就是损失函数的意义,

Binary CrossEntorpy的计算如下:

9a0c9b7f2bf65d8552569f69da4ceae2.png

其中y是标签(1代表绿色点,0代表红色点),p(y)是所有N个点都是绿色的预测概率。看到这个计算式,发现对于每一个绿点(y=1)它增加了log(p(y))的损失(概率越大,增加的越小),也就是它是绿色的概率。下面我们可视化地看一下这个损失函数。

假设我们训练一个逻辑回归模型来进行分类,那么训练出的函数趋近于一个sigmoid曲线,曲线上每个点表示对于每个x是绿色点的概率:

c29297fb0abef232e1a366d47fa74ba5.png

那么对于这些绿色的点,他们预测为绿色的概率是多少呢?实际下面图片中绿色的bar:

4bdae9ba6992b26bb142d8c7ea4e73d7.png

那么红色点预测为红色的概率是多少呢?实际就是下面图片中红色的bar:

4f26a61ef73eea1bcead91a82e942000.png

我们把图片绘制得更好看一下,如下图:

48284ca15ce2e539acc760541d9d4bcd.png

因为我们要计算损失,我们需要惩罚错误的预测。如果与正例相关的概率是1.0,我们需要它的损失为零。相反,如果概率很低,比如0.01,我们需要它的损失是巨大的!取概率的(负)对数非常适合我们的目的(由于0.0和1.0之间的值的对数是负的,我们取负对数来获得正的损失值)。下面这个图展示了当正例的概率逐渐趋近于0时loss的变化:

1302c307ec2836c9005e209ee56e93dc.png

下面这个图表示了,我们使用负对数时每个点的损失,我们计算其平均值,就是binary cross entropy了!

46abea47d232a940b415d32ffd437052.png

keras实现

tf2.1的bce用法如下:

bce = tf.keras.losses.BinaryCrossentropy()
loss = bce([0., 0., 1., 1.], [1., 1., 1., 0.])
print('Loss: ', loss.numpy())  # Loss: 11.522857

或者:

model = tf.keras.Model(inputs, outputs)
model.compile('sgd', loss=tf.keras.losses.BinaryCrossentropy())

具体实现如下(tensorflow.python.keras/losses):

class BinaryCrossentropy(LossFunctionWrapper):
    def __init__(self, from_logits=False,
                  label_smoothing=0,
                  reduction=losses_utils.ReductionV2.AUTO,
                  name='binary_crossentropy'):
        super(BinaryCrossentropy, self).__init__(
              binary_crossentropy,
              name=name,
              reduction=reduction,
              from_logits=from_logits,
              label_smoothing=label_smoothing)
        self.from_logits = from_logits


def binary_crossentropy(y_true, y_pred, from_logits=False, label_smoothing=0):
    y_pred = ops.convert_to_tensor_v2(y_pred)
    y_true = math_ops.cast(y_true, y_pred.dtype)
    label_smoothing = ops.convert_to_tensor_v2(label_smoothing, dtype=K.floatx())
    
    def _smooth_labels():
      return y_true * (1.0 - label_smoothing) + 0.5 * label_smoothing
    
    y_true = smart_cond.smart_cond(label_smoothing, _smooth_labels, lambda: y_true)
    return K.mean(K.binary_crossentropy(y_true, y_pred, from_logits=from_logits), axis=-1)

在上面代码中,如果from_logits=True,则认为y_predit是tensor(可以认为是[0,1]之间的概率值),使用from_logits=True可以更稳定一些。label_smoothing在[0,1]之间。reduction的默认值是AUTO,表示根据上下文确定;如果是SUM_OVER_BATCH_SIZE表示整个batch的结果相加。

其中K.binary_crossentropy实现如下:

def binary_crossentropy(target, output, from_logits=False):
  if from_logits:
    return nn.sigmoid_cross_entropy_with_logits(labels=target, logits=output)


  if not isinstance(output, (ops.EagerTensor, variables_module.Variable)):
    output = _backtrack_identity(output)
    if output.op.type == 'Sigmoid':
      assert len(output.op.inputs) == 1
      output = output.op.inputs[0]
      return nn.sigmoid_cross_entropy_with_logits(labels=target, logits=output)


  epsilon_ = _constant_to_tensor(epsilon(), output.dtype.base_dtype)
  output = clip_ops.clip_by_value(output, epsilon_, 1. - epsilon_)


  bce = target * math_ops.log(output + epsilon())
  bce += (1 - target) * math_ops.log(1 - output + epsilon())
  return -b

sigmoid_cross_entropy_with_logits实现如下:(该函数适用于不同类标签之间相互独立的情况,例如一个图片可以既包含大象也包含狗)

def sigmoid_cross_entropy_with_logits(_sentinel=None, labels=None, logits=None, name=None):
    zeros = array_ops.zeros_like(logits, dtype=logits.dtype)
    cond = (logits >= zeros)
    relu_logits = array_ops.where(cond, logits, zeros)
    neg_abs_logits = array_ops.where(cond, -logits, logits)
    return math_ops.add(relu_logits - logits * labels, math_ops.log1p(math_ops.exp(neg_abs_logits)), name=name)

对于上面代码,解释如下:

对于x=logits, z=labels,logistic损失定义为

z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
= z * -log(1 / (1 + exp(-x))) + (1 - z) * -log(exp(-x) / (1 + exp(-x)))
= z * log(1 + exp(-x)) + (1 - z) * (-log(exp(-x)) + log(1 + exp(-x)))
= z * log(1 + exp(-x)) + (1 - z) * (x + log(1 + exp(-x))
= (1 - z) * x + log(1 + exp(-x))
= x - x * z + log(1 + exp(-x))

对于x<0,为了防止exp(-x)溢出:

x - x * z + log(1 + exp(-x))
= log(exp(x)) - x * z + log(1 + exp(-x))
= - x * z + log(1 + exp(x))

为了保证稳定和不溢出,在实现过程中使用了如下等式:

max(x, 0) - x * z + log(1 + exp(-abs(x)))

categorical_crossentropy

原理

CrossEntropy可用于多分类任务,且label且one-hot形式。它的计算式如下:

a0ddab7f42bae1441a0d4227448d5a04.png

keras实现

tf2.1的ce用法如下:

y_true = [[0, 1, 0], [0, 0, 1]]
y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
cce = tf.keras.losses.CategoricalCrossentropy()
# Using 'auto'/'sum_over_batch_size' reduction type.
cce(y_true, y_pred).numpy()
# Calling with 'sample_weight'.
cce(y_true, y_pred, sample_weight=tf.constant([0.3, 0.7])).numpy()
# Using 'sum' reduction type.
cce = tf.keras.losses.CategoricalCrossentropy(reduction=tf.keras.losses.Reduction.NONE)
cce(y_true, y_pred).numpy()
# Usage with the `compile` API
model = tf.keras.Model(inputs, outputs)
model.compile('sgd', loss=tf.keras.losses.CategoricalCrossentropy())

具体实现如下(tensorflow.python.keras/losses):

class CategoricalCrossentropy(LossFunctionWrapper):
    def __init__(self,
                   from_logits=False,
                   label_smoothing=0,
                   reduction=losses_utils.ReductionV2.AUTO,
                   name='categorical_crossentropy'):
        super(CategoricalCrossentropy, self).__init__(
                categorical_crossentropy,
                name=name,
                reduction=reduction,
                from_logits=from_logits,
                label_smoothing=label_smoothing)


    def categorical_crossentropy(y_true,
                                 y_pred,
                                 from_logits=False,
                                 label_smoothing=0):
        y_pred = ops.convert_to_tensor_v2(y_pred)
        y_true = math_ops.cast(y_true, y_pred.dtype)
        label_smoothing = ops.convert_to_tensor_v2(label_smoothing, dtype=K.floatx())
        def _smooth_labels():
            num_classes = math_ops.cast(array_ops.shape(y_true)[1], y_pred.dtype)
            return y_true * (1.0 - label_smoothing) + (label_smoothing / num_classes)
        y_true = smart_cond.smart_cond(label_smoothing, _smooth_labels, lambda: y_true)
        return K.categorical_crossentropy(y_true, y_pred, from_logits=from_logits)

其中K.categorical_crossentropy实现如下:

def categorical_crossentropy(target, output, from_logits=False, axis=-1):
    if from_logits:
        return nn.softmax_cross_entropy_with_logits_v2(
            labels=target, logits=output, axis=axis)
    if not isinstance(output, (ops.EagerTensor, variables_module.Variable)):
        output = _backtrack_identity(output)
        if output.op.type == 'Softmax':
            output = output.op.inputs[0]
            return nn.softmax_cross_entropy_with_logits_v2(
                labels=target, logits=output, axis=axis)
    # scale preds so that the class probas of each sample sum to 1
    output = output / math_ops.reduce_sum(output, axis, True)
    # Compute cross entropy from probabilities.
    epsilon_ = _constant_to_tensor(epsilon(), output.dtype.base_dtype)
    output = clip_ops.clip_by_value(output, epsilon_, 1. - epsilon_)
    return -math_ops.reduce_sum(target * math_ops.log(output), axis)

sparse_categorical_crossentropy

原理

跟categorical_crossentropy的区别是其标签不是one-hot,而是integer。比如在categorical_crossentropy是[1,0,0],在sparse_categorical_crossentropy中是3.

keras实现

tf2.1中使用方法如下:

y_true = [1, 2]
y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
loss = tf.keras.losses.sparse_categorical_crossentropy(y_true, y_pred)

其他技巧

focal loss

参考: https:// ldzhangyx.github.io/201 8/11/16/focal-loss/

Focal Loss的出现是为了解决训练集正负样本极度不平衡的情况,通过reshape标准交叉熵损失解决类别不均衡(Class Imbalance),这样它就能降低容易分类的样例的比重(Well-classified Examples)。这个方法专注训练在Hard Examples的稀疏集合上,能够防止大量的Easy Negatives在训练中压倒训练器。其公式为:

921a681239eeb6af29579736a308b542.png

其中参数为0的时候,Focal Loss退化为交叉熵CE。当这个参数不同时,对loss的影响如下:

0a3edd5f31ec657d28e2bd766d59c703.png

p_t越大,FL越小,其对总体loss所做的贡献就越小;反过来说,p_t越小(小于0.5的情况也就是被误分类),越能反映在总体loss上。

Focal Loss的tensorflow api:https://www.tensorflow.org/addons/api_docs/python/tfa/losses/SigmoidFocalCrossEntropy

label smooth

参考: https:// towardsdatascience.com/ what-is-label-smoothing-108debd7ef06

在使用深度学习模型进行分类任务时,我们通常会遇到以下问题:overfit和over confidence。Overfit问题得到了很好的研究,可以通过earlystop、dropout、正则化等方法来解决。另一方面,我们over confidence的工具较少。标签平滑是一种正则化技术,解决了这两个问题。

Label Smooth将y_hot和均匀分布的混合来代替一个hot编码的标签向量y_hot:

10a41df41ffeb6fb03e4c17f56202357.png

K是标签类的数目,α是一个决定平滑的超参数。如果α= 0,我们获得最初的一个原始的y_hot编码。如果α= 1,我们得到均匀分布。

当损失函数为交叉熵时,使用标签平滑,模型将softmax函数应用于倒数第二层的logit向量z,计算其输出概率p。在这种情况下,交叉熵损失函数相对于logit的梯度为:

f2a2294a070c3b0ef5881aba3b23ff8f.png

其中y是标签分布,并且:

  • 梯度下降会使p尽可能接近y
  • 梯度在-1和1之间有界

一个标准的ont-hot希望有更大的logit gaps输入到里面。直观地说,较大的logit gap加上有界的梯度会使模型的自适应性降低,并且对其预测过于自信。相反,平滑的标签鼓励小的logit差距,可以得到更好的模型校准,并防止过度自信的预测。

下面我们使用一个例子说明:假设我们有K = 3类,我们的标签属于第一类。令[a, b, c]为logit向量。如果我们不使用标签平滑,那么标签向量就是一个one-hot向量[1,0,0]。我们的模型将a≫b和a≫c。例如,应用softmax分对数向量(10,0,0)给(0.9999,0,0)的4位小数。

如果我们使用标签的平滑与α= 0.1,平滑标签向量≈(0.9333,0.0333,0.0333)。logit向量[3.3322,0,0]在softmax之后将经过平滑处理的标签向量近似为小数点后4位,并且它的差距更小。这就是为什么我们称平滑标签为一种正则化技术,因为它可以防止最大的logit变得比其他的更大。

更形象地说,对于label_smoothing=0.2,则意味着标签0的概率是0.1,标签1的概率是0.9

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值