Keras 3 API 文档 / 损失函数 / 概率损失

概率损失

[源代码]

BinaryCrossentropy

keras.losses.BinaryCrossentropy(
    from_logits=False,
    label_smoothing=0.0,
    axis=-1,
    reduction="sum_over_batch_size",
    name="binary_crossentropy",
    dtype=None,
)

计算真实标签和预测标签之间的交叉熵损失。

将此交叉熵损失用于二元(0 或 1)分类应用。损失函数需要以下输入

  • y_true(真实标签):可以是 0 或 1。
  • y_pred(预测值):这是模型的预测,即一个浮点值,表示 logit(当 from_logits=True 时,值在 [-inf, inf] 范围内)或概率(当 from_logits=False 时,值在 [0., 1.] 范围内)。

参数

  • from_logits:是否将 y_pred 解释为 logit 值的张量。默认情况下,我们假设 y_pred 是概率(即 [0, 1] 范围内的值)。
  • label_smoothing:[0, 1] 范围内的浮点数。当为 0 时,不进行平滑。当 > 0 时,我们计算预测标签和真实标签的平滑版本之间的损失,其中平滑将标签压缩到 0.5。label_smoothing 的值越大,平滑程度越高。
  • axis:计算交叉熵的轴(特征轴)。默认为 -1
  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

示例

推荐用法:(设置 from_logits=True

使用 compile() API

model.compile(
    loss=keras.losses.BinaryCrossentropy(from_logits=True),
    ...
)

作为独立函数

>>> # Example 1: (batch_size = 1, number of samples = 4)
>>> y_true = np.array([0, 1, 0, 0])
>>> y_pred = np.array([-18.6, 0.51, 2.94, -12.8])
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True)
>>> bce(y_true, y_pred)
0.8654
>>> # Example 2: (batch_size = 2, number of samples = 4)
>>> y_true = np.array([[0, 1], [0, 0]])
>>> y_pred = np.array([[-18.6, 0.51], [2.94, -12.8]])
>>> # Using default 'auto'/'sum_over_batch_size' reduction type.
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True)
>>> bce(y_true, y_pred)
0.8654
>>> # Using 'sample_weight' attribute
>>> bce(y_true, y_pred, sample_weight=[0.8, 0.2])
0.243
>>> # Using 'sum' reduction` type.
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True,
...     reduction="sum")
>>> bce(y_true, y_pred)
1.730
>>> # Using 'none' reduction type.
>>> bce = keras.losses.BinaryCrossentropy(from_logits=True,
...     reduction=None)
>>> bce(y_true, y_pred)
array([0.235, 1.496], dtype=float32)

默认用法:(设置 from_logits=False

>>> # Make the following updates to the above "Recommended Usage" section
>>> # 1. Set `from_logits=False`
>>> keras.losses.BinaryCrossentropy() # OR ...('from_logits=False')
>>> # 2. Update `y_pred` to use probabilities instead of logits
>>> y_pred = [0.6, 0.3, 0.2, 0.8] # OR [[0.6, 0.3], [0.2, 0.8]]

[源代码]

BinaryFocalCrossentropy

keras.losses.BinaryFocalCrossentropy(
    apply_class_balancing=False,
    alpha=0.25,
    gamma=2.0,
    from_logits=False,
    label_smoothing=0.0,
    axis=-1,
    reduction="sum_over_batch_size",
    name="binary_focal_crossentropy",
    dtype=None,
)

计算真实标签和预测之间的焦点交叉熵损失。

二元交叉熵损失常用于二元(0 或 1)分类任务。损失函数需要以下输入

  • y_true(真实标签):可以是 0 或 1。
  • y_pred(预测值):这是模型的预测,即一个浮点值,表示 logit(当 from_logits=True 时,值在 [-inf, inf] 范围内)或概率(当 from_logits=False 时,值在 [0., 1.] 范围内)。

根据 Lin 等人,2018,应用“焦点因子”有助于降低简单示例的权重,并将更多注意力集中在困难示例上。默认情况下,焦点张量计算如下

对于类别 1,focal_factor = (1 - output) ** gamma;对于类别 0,focal_factor = output ** gamma,其中 gamma 是聚焦参数。当 gamma=0 时,此函数等效于二元交叉熵损失。

参数

  • apply_class_balancing:布尔值,是否对二元类别 0 和 1 应用权重平衡。
  • alpha:类别 1 的权重平衡因子,默认为 0.25,如参考文献 Lin 等人,2018 中所述。类别 0 的权重为 1.0 - alpha
  • gamma:用于计算焦点因子的聚焦参数,默认为 2.0,如参考文献 Lin 等人,2018 中所述。
  • from_logits:是否将 y_pred 解释为 logit 值的张量。默认情况下,我们假设 y_pred 是概率(即 [0, 1] 范围内的值)。
  • label_smoothing[0, 1] 范围内的浮点数。当为 0 时,不进行平滑。当 > 0 时,我们计算预测标签和真实标签的平滑版本之间的损失,其中平滑将标签压缩到 0.5label_smoothing 的值越大,平滑程度越高。
  • axis:计算交叉熵的轴(特征轴)。默认为 -1
  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

示例

使用 compile() API

model.compile(
    loss=keras.losses.BinaryFocalCrossentropy(
        gamma=2.0, from_logits=True),
    ...
)

作为独立函数

>>> # Example 1: (batch_size = 1, number of samples = 4)
>>> y_true = np.array([0, 1, 0, 0])
>>> y_pred = np.array([-18.6, 0.51, 2.94, -12.8])
>>> loss = keras.losses.BinaryFocalCrossentropy(
...    gamma=2, from_logits=True)
>>> loss(y_true, y_pred)
0.691
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     apply_class_balancing=True, gamma=2, from_logits=True)
>>> loss(y_true, y_pred)
0.51
>>> # Example 2: (batch_size = 2, number of samples = 4)
>>> y_true = np.array([[0, 1], [0, 0]])
>>> y_pred = np.array([[-18.6, 0.51], [2.94, -12.8]])
>>> # Using default 'auto'/'sum_over_batch_size' reduction type.
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     gamma=3, from_logits=True)
>>> loss(y_true, y_pred)
0.647
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
...      apply_class_balancing=True, gamma=3, from_logits=True)
>>> loss(y_true, y_pred)
0.482
>>> # Using 'sample_weight' attribute with focal effect
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     gamma=3, from_logits=True)
>>> loss(y_true, y_pred, sample_weight=[0.8, 0.2])
0.133
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
...      apply_class_balancing=True, gamma=3, from_logits=True)
>>> loss(y_true, y_pred, sample_weight=[0.8, 0.2])
0.097
>>> # Using 'sum' reduction` type.
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     gamma=4, from_logits=True,
...     reduction="sum")
>>> loss(y_true, y_pred)
1.222
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     apply_class_balancing=True, gamma=4, from_logits=True,
...     reduction="sum")
>>> loss(y_true, y_pred)
0.914
>>> # Using 'none' reduction type.
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     gamma=5, from_logits=True,
...     reduction=None)
>>> loss(y_true, y_pred)
array([0.0017 1.1561], dtype=float32)
>>> # Apply class weight
>>> loss = keras.losses.BinaryFocalCrossentropy(
...     apply_class_balancing=True, gamma=5, from_logits=True,
...     reduction=None)
>>> loss(y_true, y_pred)
array([0.0004 0.8670], dtype=float32)

[源代码]

CategoricalCrossentropy

keras.losses.CategoricalCrossentropy(
    from_logits=False,
    label_smoothing=0.0,
    axis=-1,
    reduction="sum_over_batch_size",
    name="categorical_crossentropy",
    dtype=None,
)

计算标签和预测之间的交叉熵损失。

当有两个或更多标签类别时,使用此交叉熵损失函数。我们期望标签以 one_hot 表示形式提供。如果要将标签作为整数提供,请使用 SparseCategoricalCrossentropy 损失。每个特征应有 num_classes 个浮点值,即 y_predy_true 的形状均为 [batch_size, num_classes]

参数

  • from_logits:是否期望 y_pred 是 logits 张量。默认情况下,我们假设 y_pred 编码概率分布。
  • label_smoothing:[0, 1] 范围内的浮点数。当 > 0 时,标签值将被平滑,这意味着标签值上的置信度将被放松。例如,如果为 0.1,则对于非目标标签使用 0.1 / num_classes,对于目标标签使用 0.9 + 0.1 / num_classes
  • axis:计算交叉熵的轴(特征轴)。默认为 -1
  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

示例

独立用法

>>> y_true = np.array([[0, 1, 0], [0, 0, 1]])
>>> y_pred = np.array([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> cce = keras.losses.CategoricalCrossentropy()
>>> cce(y_true, y_pred)
1.177
>>> # Calling with 'sample_weight'.
>>> cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.814
>>> # Using 'sum' reduction type.
>>> cce = keras.losses.CategoricalCrossentropy(
...     reduction="sum")
>>> cce(y_true, y_pred)
2.354
>>> # Using 'none' reduction type.
>>> cce = keras.losses.CategoricalCrossentropy(
...     reduction=None)
>>> cce(y_true, y_pred)
array([0.0513, 2.303], dtype=float32)

使用 compile() API

model.compile(optimizer='sgd',
              loss=keras.losses.CategoricalCrossentropy())

[源代码]

CategoricalFocalCrossentropy

keras.losses.CategoricalFocalCrossentropy(
    alpha=0.25,
    gamma=2.0,
    from_logits=False,
    label_smoothing=0.0,
    axis=-1,
    reduction="sum_over_batch_size",
    name="categorical_focal_crossentropy",
    dtype=None,
)

计算 alpha 平衡的焦点交叉熵损失。

当有两个或更多标签类别并且想要处理类别不平衡(无需使用 class_weights)时,使用此交叉熵损失函数。我们期望标签以 one_hot 表示形式提供。

根据 Lin 等人,2018,应用焦点因子有助于降低简单示例的权重,并将更多注意力集中在困难示例上。焦点损失 (FL) 的通用公式如下

FL(p_t) = (1 - p_t) ** gamma * log(p_t)

其中 p_t 定义如下:p_t = output if y_true == 1, else 1 - output

(1 - p_t) ** gammamodulating_factor,其中 gamma 是聚焦参数。当 gamma = 0 时,交叉熵没有焦点效应。gamma 以平滑的方式降低赋予简单示例的重要性。

作者在论文中使用了焦点损失 (FL) 的 alpha 平衡变体:FL(p_t) = -alpha * (1 - p_t) ** gamma * log(p_t)

其中 alpha 是类别的权重因子。如果 alpha = 1,则损失将无法正确处理类别不平衡,因为所有类别将具有相同的权重。这可以是常数或常数列表。如果 alpha 是列表,则其长度必须与类别数相同。

以上公式可以推广为:FL(p_t) = alpha * (1 - p_t) ** gamma * CrossEntropy(y_true, y_pred)

其中减号来自 CrossEntropy(y_true, y_pred) (CE)。

将其扩展到多类情况非常简单:FL(p_t) = alpha * (1 - p_t) ** gamma * CategoricalCE(y_true, y_pred)

在下面的代码片段中,每个示例有 num_classes 个浮点值。y_predy_true 的形状均为 (batch_size, num_classes)

参数

  • alpha:所有类别的权重平衡因子,默认为 0.25,如参考文献中所述。它可以是浮点数列表或标量。在多类情况下,alpha 可以通过使用 sklearn.utils 中的 compute_class_weight 根据逆类别频率设置。
  • gamma:聚焦参数,默认为 2.0,如参考文献中所述。它有助于以平滑的方式逐渐降低赋予简单(容易)示例的重要性。
  • from_logits:是否期望 output 是 logits 张量。默认情况下,我们认为 output 编码概率分布。
  • label_smoothing:[0, 1] 范围内的浮点数。当 > 0 时,标签值将被平滑,这意味着标签值上的置信度将被放松。例如,如果为 0.1,则对于非目标标签使用 0.1 / num_classes,对于目标标签使用 0.9 + 0.1 / num_classes
  • axis:计算交叉熵的轴(特征轴)。默认为 -1
  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

示例

独立用法

>>> y_true = [[0., 1., 0.], [0., 0., 1.]]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> cce = keras.losses.CategoricalFocalCrossentropy()
>>> cce(y_true, y_pred)
0.23315276
>>> # Calling with 'sample_weight'.
>>> cce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.1632
>>> # Using 'sum' reduction type.
>>> cce = keras.losses.CategoricalFocalCrossentropy(
...     reduction="sum")
>>> cce(y_true, y_pred)
0.46631
>>> # Using 'none' reduction type.
>>> cce = keras.losses.CategoricalFocalCrossentropy(
...     reduction=None)
>>> cce(y_true, y_pred)
array([3.2058331e-05, 4.6627346e-01], dtype=float32)

使用 compile() API

model.compile(optimizer='adam',
              loss=keras.losses.CategoricalFocalCrossentropy())

[源代码]

SparseCategoricalCrossentropy

keras.losses.SparseCategoricalCrossentropy(
    from_logits=False,
    ignore_class=None,
    reduction="sum_over_batch_size",
    name="sparse_categorical_crossentropy",
    dtype=None,
)

计算标签和预测之间的交叉熵损失。

当有两个或更多标签类别时,使用此交叉熵损失函数。我们期望标签以整数形式提供。如果要使用 one-hot 表示形式提供标签,请使用 CategoricalCrossentropy 损失。对于 y_pred,每个特征应有 # 类别 个浮点值,对于 y_true,每个特征应有单个浮点值。

在下面的代码片段中,对于 y_true,每个示例有单个浮点值,对于 y_pred,每个示例有 num_classes 个浮点值。y_true 的形状为 [batch_size]y_pred 的形状为 [batch_size, num_classes]

参数

  • from_logits:是否期望 y_pred 是 logits 张量。默认情况下,我们假设 y_pred 编码概率分布。
  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

示例

>>> y_true = [1, 2]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> scce = keras.losses.SparseCategoricalCrossentropy()
>>> scce(y_true, y_pred)
1.177
>>> # Calling with 'sample_weight'.
>>> scce(y_true, y_pred, sample_weight=np.array([0.3, 0.7]))
0.814
>>> # Using 'sum' reduction type.
>>> scce = keras.losses.SparseCategoricalCrossentropy(
...     reduction="sum")
>>> scce(y_true, y_pred)
2.354
>>> # Using 'none' reduction type.
>>> scce = keras.losses.SparseCategoricalCrossentropy(
...     reduction=None)
>>> scce(y_true, y_pred)
array([0.0513, 2.303], dtype=float32)

使用 compile() API

model.compile(optimizer='sgd',
              loss=keras.losses.SparseCategoricalCrossentropy())

[源代码]

Poisson

keras.losses.Poisson(reduction="sum_over_batch_size", name="poisson", dtype=None)

计算 y_truey_pred 之间的泊松损失。

公式

loss = y_pred - y_true * log(y_pred)

参数

  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

[源代码]

CTC

keras.losses.CTC(reduction="sum_over_batch_size", name="ctc", dtype=None)

CTC(连接时序分类)损失。

参数

  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

[源代码]

KLDivergence

keras.losses.KLDivergence(
    reduction="sum_over_batch_size", name="kl_divergence", dtype=None
)

计算 y_truey_pred 之间的 Kullback-Leibler 散度损失。

公式

loss = y_true * log(y_true / y_pred)

y_truey_pred 预期为概率分布,其值介于 0 和 1 之间。它们将被裁剪到 [0, 1] 范围内。

参数

  • reduction:应用于损失的缩减类型。在几乎所有情况下,这都应该是 "sum_over_batch_size"。支持的选项包括 "sum""sum_over_batch_size""mean""mean_with_sample_weight"None"sum" 对损失求和,"sum_over_batch_size""mean" 对损失求和并除以样本大小,"mean_with_sample_weight" 对损失求和并除以样本权重的总和。"none"None 不执行聚合。默认为 "sum_over_batch_size"
  • name:损失实例的可选名称。
  • dtype:损失计算的数据类型。默认为 None,这意味着使用 keras.backend.floatx()keras.backend.floatx()"float32",除非设置为其他值(通过 keras.backend.set_floatx())。如果提供了 keras.DTypePolicy,则将使用 compute_dtype

[源代码]

binary_crossentropy 函数

keras.losses.binary_crossentropy(
    y_true, y_pred, from_logits=False, label_smoothing=0.0, axis=-1
)

计算二元交叉熵损失。

参数

  • y_true:真实值。形状 = [batch_size, d0, .. dN]
  • y_pred:预测值。形状 = [batch_size, d0, .. dN]
  • from_logits:是否期望 y_pred 是 logits 张量。默认情况下,我们假设 y_pred 编码概率分布。
  • label_smoothing[0, 1] 范围内的浮点数。如果 > 0,则通过将标签压缩到 0.5 来平滑标签,即,对于目标类别使用 1. - 0.5 * label_smoothing,对于非目标类别使用 0.5 * label_smoothing
  • axis:计算均值的轴。默认为 -1

返回值

二元交叉熵损失值。形状 = [batch_size, d0, .. dN-1]

示例

>>> y_true = [[0, 1], [0, 0]]
>>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
>>> loss = keras.losses.binary_crossentropy(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.916 , 0.714], dtype=float32)

[源代码]

categorical_crossentropy 函数

keras.losses.categorical_crossentropy(
    y_true, y_pred, from_logits=False, label_smoothing=0.0, axis=-1
)

计算分类交叉熵损失。

参数

  • y_true:表示one-hot编码的真实目标张量。
  • y_pred:表示预测目标的张量。
  • from_logits:是否期望 y_pred 是 logits 张量。默认情况下,我们假设 y_pred 编码概率分布。
  • label_smoothing:介于[0, 1]之间的浮点数。如果大于0,则对标签进行平滑处理。例如,如果为0.1,则非目标标签使用0.1 / num_classes,目标标签使用0.9 + 0.1 / num_classes
  • axis:默认为-1。计算熵的维度。

返回值

类别交叉熵损失值。

示例

>>> y_true = [[0, 1, 0], [0, 0, 1]]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> loss = keras.losses.categorical_crossentropy(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.0513, 2.303], dtype=float32)

[源代码]

sparse_categorical_crossentropy 函数

keras.losses.sparse_categorical_crossentropy(
    y_true, y_pred, from_logits=False, ignore_class=None, axis=-1
)

计算稀疏类别交叉熵损失。

参数

  • y_true:真实值。
  • y_pred:预测值。
  • from_logits:是否期望 y_pred 是 logits 张量。默认情况下,我们假设 y_pred 编码概率分布。
  • ignore_class:可选整数。在损失计算期间要忽略的类的ID。例如,在分割问题中,分割图中存在“空洞”类(通常为-1或255)时,这很有用。默认情况下(ignore_class=None),考虑所有类。
  • axis:默认为-1。计算熵的维度。

返回值

稀疏类别交叉熵损失值。

示例

>>> y_true = [1, 2]
>>> y_pred = [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]
>>> loss = keras.losses.sparse_categorical_crossentropy(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.0513, 2.303], dtype=float32)

[源代码]

poisson 函数

keras.losses.poisson(y_true, y_pred)

计算y_true和y_pred之间的泊松损失。

公式

loss = y_pred - y_true * log(y_pred)

参数

  • y_true:真实值。形状 = [batch_size, d0, .. dN]
  • y_pred:预测值。形状 = [batch_size, d0, .. dN]

返回值

形状为[batch_size, d0, .. dN-1]的泊松损失值。

示例

>>> y_true = np.random.randint(0, 2, size=(2, 3))
>>> y_pred = np.random.random(size=(2, 3))
>>> loss = keras.losses.poisson(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> y_pred = y_pred + 1e-7
>>> assert np.allclose(
...     loss, np.mean(y_pred - y_true * np.log(y_pred), axis=-1),
...     atol=1e-5)

[源代码]

ctc 函数

keras.losses.ctc(y_true, y_pred)

CTC(连接时序分类)损失。

参数

  • y_true:形状为(batch_size, max_length)的张量,包含整数格式的真实标签。0始终表示空白/掩码索引,不应用于类。
  • y_pred:形状为(batch_size, max_length, num_classes)的张量,包含 logits(模型的输出)。它们不应通过softmax进行归一化。

[源代码]

kl_divergence 函数

keras.losses.kl_divergence(y_true, y_pred)

计算 y_truey_pred 之间的 Kullback-Leibler 散度损失。

公式

loss = y_true * log(y_true / y_pred)

y_truey_pred 预期为概率分布,其值介于 0 和 1 之间。它们将被裁剪到 [0, 1] 范围内。

参数

  • y_true:表示真实目标的张量。
  • y_pred:表示预测目标的张量。

返回值

形状为[batch_size, d0, .. dN-1]的KL散度损失值。

示例

>>> y_true = np.random.randint(0, 2, size=(2, 3)).astype(np.float32)
>>> y_pred = np.random.random(size=(2, 3))
>>> loss = keras.losses.kl_divergence(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> y_true = ops.clip(y_true, 1e-7, 1)
>>> y_pred = ops.clip(y_pred, 1e-7, 1)
>>> assert np.array_equal(
...     loss, np.sum(y_true * np.log(y_true / y_pred), axis=-1))