概率损失函数

`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,
)

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

二元交叉熵损失通常用于二元（0或1）分类任务。该损失函数需要以下输入：

y_true（真实标签）：为0或1。
y_pred（预测值）：这是模型的预测，即一个单一的浮点值，它表示一个logit（即，当from_logits=True时，值为[-inf, inf]）或一个概率（即，当from_logits=False时，值为[0., 1.]）。

根据Lin等人，2018，应用“focal因子”可以降低简单样本的权重，更关注困难样本。默认情况下，focal因子计算如下：

对于类别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：用于计算focal因子的聚焦参数，默认值为2.0，如参考文献Lin等人，2018中所述。
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。

示例

与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_pred和y_true的形状均为[batch_size, num_classes]。

参数

from_logits：是否期望y_pred是logits张量。默认情况下，我们假定y_pred编码了一个概率分布。
label_smoothing：范围在[0, 1]内的浮点数。当大于0时，标签会被平滑，即非目标标签使用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平衡的focal交叉熵损失。

当存在两个或更多标签类别，并且您希望在不使用class_weights的情况下处理类别不平衡时，请使用此交叉熵损失函数。我们期望标签以one_hot表示形式提供。

根据Lin等人，2018，应用focal因子可以降低简单样本的权重，更关注困难样本。focal损失（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) ** gamma是modulating_factor，其中gamma是聚焦参数。当gamma=0时，对交叉熵没有focal效果。gamma以平滑的方式减小了对简单样本的重视程度。

作者在论文中使用了focal损失（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_pred和y_true的形状均为(batch_size, num_classes)。

参数

alpha：所有类别的权重平衡因子，默认值为0.25，如参考文献所述。它可以是浮点数列表或标量。在多类别情况下，可以使用sklearn.utils中的compute_class_weight来按反类别频率设置alpha。
gamma：聚焦参数，默认值为2.0，如参考文献所述。它有助于以平滑的方式逐渐减小对简单（易）样本的重视程度。
from_logits：是否期望output是logits张量。默认情况下，我们认为output编码了一个概率分布。
label_smoothing：范围在[0, 1]内的浮点数。当大于0时，标签会被平滑，即非目标标签使用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",
    axis=-1,
    name="sparse_categorical_crossentropy",
    dtype=None,
)

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

当存在两个或更多标签类别时，请使用此交叉熵损失函数。我们期望标签以整数形式提供。如果您想以one-hot表示形式提供标签，请使用CategoricalCrossentropy损失。对于y_pred，每项特征应有# classes个浮点值，对于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"。
axis：计算交叉熵的轴（特征轴）。默认为-1。
name: 损失实例的可选名称。
dtype：损失计算的数据类型。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非将其设置为不同值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则将使用 compute_dtype。

示例

>>> y_true = np.array([1, 2])
>>> y_pred = np.array([[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_true与y_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（Connectionist Temporal Classification）损失。

参数

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_true与y_pred之间的Kullback-Leibler散度损失。

公式

loss = y_true * log(y_true / y_pred)

y_true和y_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（Connectionist Temporal Classification）损失。

参数

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_true与y_pred之间的Kullback-Leibler散度损失。

公式

loss = y_true * log(y_true / y_pred)

y_true和y_pred应为概率分布，值在0到1之间。它们将被裁剪到[0, 1]的范围。

参数

y_true：真实目标的张量。
y_pred：预测目标的张量。

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

示例

>>> 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))