【深度学习所有损失函数】在 NumPy、TensorFlow 和 PyTorch 中实现（2/2）_稀疏分类交叉损失函数

 一、说明

在本文中，讨论了深度学习中使用的所有常见损失函数，并在NumPy，PyTorch和TensorFlow中实现了它们。

(二-五)见

六、稀疏分类交叉熵损失

        稀疏分类交叉熵损失类似于分类交叉熵损失，但在真实标签作为整数而不是独热编码提供时使用。它通常用作多类分类问题中的损失函数。

稀疏分类交叉熵损失的公式为：

L = -1/N * sum(log(Y_hat_i))

        其中 是每个样本的真实类标签的预测概率，是样本数。Y_hat_iiN

        换句话说，该公式计算每个样本的真实类标签的预测概率的负对数，然后对所有样本的这些值求平均值。

        与对真实标签使用独热编码的分类交叉熵损失不同，稀疏分类交叉熵损失直接使用整数标签。每个样本的真实标签表示为 0 到 之间的单个整数值，其中 是类的数量。iC-1C

6.1 在 NumPy 中的实现

import numpy as np
 
def sparse_categorical_crossentropy(y_true, y_pred):
    # convert true labels to one-hot encoding
    y_true_onehot = np.zeros_like(y_pred)
    y_true_onehot[np.arange(len(y_true)), y_true] = 1
 
    # calculate loss
    loss = -np.mean(np.sum(y_true_onehot * np.log(y_pred), axis=-1))
 
    return loss

        在此实现中， 是整数标签数组，是每个样本的预测概率数组。该函数首先使用 NumPy 的高级索引功能将真实标签转换为独热编码格式，以创建一个形状数组，其中是样本数和类数，每行对应于单个样本的真实标签分布。y_truey_pred(N, C)NC

然后，该函数使用上一个答案中描述的公式计算损失：。这是使用 NumPy 的广播实现的，其中创建一个形状数组，其中每个元素表示 和 中相应元素的乘积。然后，该函数用于对维度求和，并用于对维度求平均值。-1/N * sum(log(Y_hat_i))y_true_onehot * np.log(y_pred)(N, C)y_true_onehotnp.log(y_pred)sumCmeanN

下面是如何使用该函数的示例：

# define true labels as integers and predicted probabilities as an array
y_true = np.array([1, 2, 0])
y_pred = np.array([[0.1, 0.8, 0.1], [0.3, 0.2, 0.5], [0.4, 0.3, 0.3]])
 
# calculate the loss
loss = sparse_categorical_crossentropy(y_true, y_pred)
 
# print the loss
print(loss)

        这将输出给定输入的稀疏分类交叉熵损失的值。

6.2 TensorFlow 中的实现

import tensorflow as tf
 
def sparse_categorical_crossentropy(y_true, y_pred):
    loss = tf.keras.losses.sparse_categorical_crossentropy(y_true, y_pred, from_logits=False)
    return loss
 
# define true labels as integers and predicted probabilities as a tensor
y_true = tf.constant([1, 2, 0])
y_pred = tf.constant([[0.1, 0.8, 0.1], [0.3, 0.2, 0.5], [0.4, 0.3, 0.3]])
 
# calculate the loss
loss = sparse_categorical_crossentropy(y_true, y_pred)
 
# print the loss
print(loss.numpy())

在此实现中， 是整数标签数组，是每个样本的预测概率数组。该函数使用 TensorFlow 提供的函数来计算损失。设置该参数以确保 表示概率而不是对数值。y_truey_predtf.keras.losses.sparse_categorical_crossentropyfrom_logitsFalsey_pred

6.3 在 PyTorch 中的实现

import torch.nn.functional as F
import torch
 
def sparse_categorical_crossentropy(y_true, y_pred):
    loss = F.cross_entropy(y_pred, y_true)
    return loss
 
# define true labels as integers and predicted logits as a tensor
y_true = torch.tensor([1, 2, 0])
y_pred = torch.tensor([[0.1, 0.8, 0.1], [0.3, 0.2, 0.5], [0.4, 0.3, 0.3]])
 
# calculate the loss
loss = sparse_categorical_crossentropy(y_true, y_pred)
 
# print the loss
print(loss.item())

        在此实现中， 是一个整数标签数组，并且是每个样本的预测对数数组。该函数使用 PyTorch 的函数来计算损失。张量应该具有形状，其中是样本的数量，是类的数量。y_truey_predF.cross_entropyy_pred(N, C)NC

七、骰子损失

        骰子损失，也称为索伦森-骰子系数或 F1 分数，是图像分割任务中使用的损失函数，用于测量预测分割与地面实况之间的重叠。骰子损失范围从 0 到 1，其中 0 表示没有重叠，1 表示完全重叠。

骰子损失定义为：

Dice Loss = 1 - (2 * intersection + smooth) / (sum of squares of prediction + sum of squares of ground truth + smooth)

        其中 是预测和地面真实掩码的元素乘积，是一个平滑常数（通常是一个较小的值，例如 1e-5），以防止除以零，并且总和将覆盖掩码的所有元素。intersectionsmooth

        骰子损失可以在各种深度学习框架中实现，如TensorFlow，PyTorch和NumPy。该实现涉及使用框架中可用的逐元素乘积和求和运算计算交集和平方和。

7.1 在 NumPy 中的实现

import numpy as np
 
def dice_loss(y_true, y_pred, smooth=1e-5):
    intersection = np.sum(y_true * y_pred, axis=(1,2,3))
    sum_of_squares_pred = np.sum(np.square(y_pred), axis=(1,2,3))
    sum_of_squares_true = np.sum(np.square(y_true), axis=(1,2,3))
    dice = 1 - (2 * intersection + smooth) / (sum_of_squares_pred + sum_of_squares_true + smooth)
    return dice

        在此实现中，分别是基本事实和预测掩码。该参数用于防止被零除。和函数分别用于计算交集和平方和。最后，使用上一个答案中描述的公式计算骰子损失。y_truey_predsmoothsumsquare

        请注意，此实现假定 和 是具有维度的 4D 数组。如果您的掩码具有不同的形状，则可能需要相应地修改实现。y_truey_pred(batch_size, height, width, num_classes)

7.2 TensorFlow 中的实现

import tensorflow as tf
 
def dice_loss(y_true, y_pred, smooth=1e-5):
    intersection = tf.reduce_sum(y_true * y_pred, axis=(1,2,3))
    sum_of_squares_pred = tf.reduce_sum(tf.square(y_pred), axis=(1,2,3))
    sum_of_squares_true = tf.reduce_sum(tf.square(y_true), axis=(1,2,3))
    dice = 1 - (2 * intersection + smooth) / (sum_of_squares_pred + sum_of_squares_true + smooth)
    return dice

        在此实现中，和 是 TensorFlow 张量分别表示地面真相和预测掩码。该参数用于防止被零除。和函数分别用于计算交集和平方和。最后，使用上一个答案中描述的公式计算骰子损失。y_truey_predsmoothreduce_sumsquare

请注意，此实现假定 和 是具有维度的 4D 张量。如果您的掩码具有不同的形状，则可能需要相应地修改实现。y_truey_pred(batch_size, height, width, num_classes)

7.3 在 PyTorch 中的实现

import torch
 
def dice_loss(y_true, y_pred, smooth=1e-5):
    intersection = torch.sum(y_true * y_pred, dim=(1,2,3))
    sum_of_squares_pred = torch.sum(torch.square(y_pred), dim=(1,2,3))
    sum_of_squares_true = torch.sum(torch.square(y_true), dim=(1,2,3))
    dice = 1 - (2 * intersection + smooth) / (sum_of_squares_pred + sum_of_squares_true + smooth)
    return dice

        在此实现中，和 是 PyTorch 张量分别表示基本事实和预测掩码。该参数用于防止被零除。和函数分别用于计算交集和平方和。最后，使用上一个答案中描述的公式计算骰子损失。y_truey_predsmoothsumsquare

请注意，此实现假定 和 是具有维度的 4D 张量。如果您的掩码具有不同的形状，则可能需要相应地修改实现。y_truey_pred(batch_size, num_classes, height, width)

八、KL散度损失

        KL（Kullback-Leibler）散度损失是两个概率分布彼此差异程度的度量。在机器学习的上下文中，它通常用作损失函数来训练从给定分布生成新样本的模型。

        两个概率分布 p 和 q 之间的 KL 散度定义为：

        KL（p||q） = sum（p（x） * log（p（x） / q（x）））

        在机器学习的上下文中，p 表示真实分布，q 表示预测分布。KL 散度损失衡量预测分布与真实分布的匹配程度。

        KL 散度损失可用于各种任务，例如图像生成、文本生成和强化学习。但是，由于它具有非凸形式，因此可能很难优化。

        在实践中，KL散度损失通常与其他损失函数（如交叉熵损失）结合使用。通过将KL散度损失添加到交叉熵损失中，鼓励模型生成不仅与目标分布匹配，而且与训练数据具有相似分布的样本。

8.1 在 NumPy 中的实现

import numpy as np
 
def kl_divergence_loss(p, q):
    return np.sum(p * np.log(p / q))

在此实现中，和 是分别表示真实分布和预测分布的 numpy 数组。KL 背离损失使用上述公式计算。pq

请注意，此实现假定并具有相同的形状。如果它们具有不同的形状，则可能需要相应地修改实现。pq

8.2 TensorFlow 中的实现

   tf.keras.losses.KLDivergence()是 TensorFlow 中的一个内置函数，用于计算两个概率分布之间的 KL 背离损失。它可以用作各种机器学习任务中的损失函数，例如图像生成、文本生成和强化学习。

        下面是一个用法示例：tf.keras.losses.KLDivergence()

import tensorflow as tf
 
# define true distribution and predicted distribution
p = tf.constant([0.2, 0.3, 0.5])
q = tf.constant([0.4, 0.3, 0.3])
 
# compute KL divergence loss
kl_loss = tf.keras.losses.KLDivergence()(p, q)
 
print(kl_loss.numpy())

        在此示例中，和 是 TensorFlow 张量分别表示真实分布和预测分布。该函数用于计算 和 之间的 KL 散度损失。结果是一个表示损失值的标量张量。pqtf.keras.losses.KLDivergence()pq

        请注意，通过将 和 具有不同形状的情况广播到通用形状，自动处理这些情况。此外，您还可以通过设置函数的参数来调整 KL 散度损失相对于模型中其他损失的权重，该参数控制损失的聚合方式。tf.keras.losses.KLDivergence()pqreduction

8.3 在 PyTorch 中的实现

        在 PyTorch 中，KL 散度损失可以使用模块计算。下面是一个示例实现：torch.nn.KLDivLoss

import torch
 
def kl_divergence_loss(p, q):
    criterion = torch.nn.KLDivLoss(reduction='batchmean')
    loss = criterion(torch.log(p), q)
    return lossIn this implementation, p and q are PyTorch tensors representing the true distribution and predicted distribution, respectively. The torch.nn.KLDivLoss module is used to compute the KL divergence loss between p and q. The reduction parameter is set to 'batchmean' to compute the mean loss over the batch.

        请注意，和 应该是概率，沿最后一个维度的总和为 1。该函数用于在将 的对数传递给模块之前获取对数。这是因为模块期望输入是对数概率。pqtorch.logptorch.nn.KLDivLoss

九、平均绝对误差 （MAE） 损耗 / L1 损耗

        L1 损失，也称为平均绝对误差 （MAE） 损失，是深度学习中用于回归任务的常见损失函数。它测量目标变量的预测值和真实值之间的绝对差异。

        L1损失的公式为：

        L1 LOSS = 1/n * Σ|y_pred — y_true|

        其中 n 是样本数，y_pred 是预测值，y_true 是真实值。

        简单来说，L1 损失是预测值和真实值之间绝对差值的平均值。它对异常值的敏感度低于均方误差 （MSE） 损失，因此对于可能受异常值影响的模型来说，它是一个不错的选择。

9.1 在 Numpy 中的实现

import numpy as np
 
def l1_loss(y_pred, y_true):
    loss = np.mean(np.abs(y_pred - y_true))
    return loss

L1 损失的 NumPy 实现与公式非常相似，其中您从真实值中减去预测值并取绝对值。然后，取所有样本中这些绝对差异的平均值，以获得平均 L1 损失。

9.2 TensorFlow 中的实现

import tensorflow as tf
 
def l1_loss(y_pred, y_true):
    loss = tf.reduce_mean(tf.abs(y_pred - y_true))
    return loss

在 TensorFlow 中，您可以使用该函数计算所有样本中预测值和真实值之间的绝对差值的平均值。tf.reduce_mean()

9.3 在 PyTorch 中的实现

import torch
 
def l1_loss(y_pred, y_true):
    loss = torch.mean(torch.abs(y_pred - y_true))
    return loss

在 PyTorch 中，您可以使用该函数计算所有样本中预测值和真实值之间的绝对差值的平均值。torch.mean()

十、Huber 胡贝尔损失

        Huber 损失是回归任务中使用的损失函数，它对异常值的敏感度低于均方误差 （MSE） 损失。它被定义为MSE损失和平均绝对误差（MAE）损失的组合，其中损失函数是MSE表示小误差，MAE表示较大误差。这使得Huber损失比MSE损失对异常值更稳健。

        Huber 损失函数定义如下：

L(y_pred, y_true) = 1/n * sum(0.5 * (y_pred - y_true)^2)   if |y_pred - y_true| <= delta
                    1/n * sum(delta * |y_pred - y_true| - 0.5 * delta^2)   otherwise

        其中 是样本数，是预测值，是真实值，并且是确定在 MSE 和 MAE 损失之间切换的阈值的超参数。ny_predy_truedelta

        当 ，损失函数是 MSE 损失。当 时，损失函数是斜率为 的 MAE 损失。|y_pred - y_true| <= delta|y_pred - y_true| > deltadelta

        在实践中，通常设置为平衡 MSE 和 MAE 损耗的值，例如 。delta1.0

10.1 在 Numpy 中的实现

import numpy as np
 
def huber_loss(y_pred, y_true, delta=1.0):
    error = y_pred - y_true
    abs_error = np.abs(error)
    quadratic = np.minimum(abs_error, delta)
    linear = (abs_error - quadratic)
    return np.mean(0.5 * quadratic ** 2 + delta * linear)

        此函数将预测值、真值和超参数作为输入，并返回 Huber 损失。y_predy_truedelta

        该函数首先计算预测值和真值之间的绝对误差，然后根据超参数将误差拆分为两个分量。二次分量是 时的 MSE 损耗，线性分量是 时的 MAE 损耗。最后，该函数返回所有样本的平均Huber损失。deltaabs_error <= deltaabs_error > delta

        您可以在基于 numpy 的回归任务中使用此函数，方法是使用预测值和真实值以及所需值调用它。delta

10.2 TensorFlow 中的实现

import tensorflow as tf
 
def huber_loss(y_pred, y_true, delta=1.0):
    error = y_pred - y_true
    abs_error = tf.abs(error)
    quadratic = tf.minimum(abs_error, delta)
    linear = (abs_error - quadratic)
    return tf.reduce_mean(0.5 * quadratic ** 2 + delta * linear)

此函数将预测值、真值和超参数作为输入，并返回 Huber 损失。y_predy_truedelta

该函数首先使用该函数计算预测值和真值之间的绝对误差，然后使用 and 运算符根据超参数将误差拆分为两个分量。二次分量是 时的 MSE 损耗，线性分量是 时的 MAE 损耗。最后，该函数使用该函数返回所有样本的平均Huber损失。tf.absdeltatf.minimum-abs_error <= deltaabs_error > deltatf.reduce_mean

您可以在基于 TensorFlow 的回归任务中使用此函数，方法是使用预测值和真实值以及所需值调用它。delta

10.3 在 PyTorch 中的实现

import torch.nn.functional as F
 
def huber_loss(y_pred, y_true, delta=1.0):
    error = y_pred - y_true
    abs_error = torch.abs(error)
    quadratic = torch.min(abs_error, delta)
    linear = (abs_error - quadratic)
    return 0.5 * quadratic ** 2 + delta * linear

        此函数将预测值、真值和超参数作为输入，并返回 Huber 损失。y_predy_truedelta

        该函数首先使用该函数计算预测值和真值之间的绝对误差，然后使用 and 运算符根据超参数将误差拆分为两个分量。二次分量是 时的 MSE 损耗，线性分量是 时的 MAE 损耗。最后，该函数使用公式返回 Huber 损失。torch.absdeltatorch.min-abs_error <= deltaabs_error > delta0.5 * quadratic ** 2 + delta * linear

        您可以在基于 PyTorch 的回归任务中使用此函数，方法是使用预测值和真实值以及所需值调用它。delta