概率损失

`BinaryCrossentropy` 类

tf_keras.losses.BinaryCrossentropy(
    from_logits=False,
    label_smoothing=0.0,
    axis=-1,
    reduction="auto",
    name="binary_crossentropy",
)

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

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

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

推荐用法：（设置 from_logits=True）

使用 tf.keras API

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

作为独立函数

>>> # Example 1: (batch_size = 1, number of samples = 4)
>>> y_true = [0, 1, 0, 0]
>>> y_pred = [-18.6, 0.51, 2.94, -12.8]
>>> bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)
>>> bce(y_true, y_pred).numpy()
0.865

>>> # Example 2: (batch_size = 2, number of samples = 4)
>>> y_true = [[0, 1], [0, 0]]
>>> y_pred = [[-18.6, 0.51], [2.94, -12.8]]
>>> # Using default 'auto'/'sum_over_batch_size' reduction type.
>>> bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)
>>> bce(y_true, y_pred).numpy()
0.865
>>> # Using 'sample_weight' attribute
>>> bce(y_true, y_pred, sample_weight=[0.8, 0.2]).numpy()
0.243
>>> # Using 'sum' reduction` type.
>>> bce = tf.keras.losses.BinaryCrossentropy(from_logits=True,
...     reduction=tf.keras.losses.Reduction.SUM)
>>> bce(y_true, y_pred).numpy()
1.730
>>> # Using 'none' reduction type.
>>> bce = tf.keras.losses.BinaryCrossentropy(from_logits=True,
...     reduction=tf.keras.losses.Reduction.NONE)
>>> bce(y_true, y_pred).numpy()
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`
>>> tf.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]]

[源代码]

`CategoricalCrossentropy` 类

tf_keras.losses.CategoricalCrossentropy(
    from_logits=False,
    label_smoothing=0.0,
    axis=-1,
    reduction="auto",
    name="categorical_crossentropy",
)

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

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

在下面的代码片段中，每个示例有 # 类别 个浮点值。y_pred 和 y_true 的形状均为 [batch_size, num_classes]。

独立用法

>>> 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 = tf.keras.losses.CategoricalCrossentropy()
>>> cce(y_true, y_pred).numpy()
1.177

>>> # Calling with 'sample_weight'.
>>> cce(y_true, y_pred, sample_weight=tf.constant([0.3, 0.7])).numpy()
0.814

>>> # Using 'sum' reduction type.
>>> cce = tf.keras.losses.CategoricalCrossentropy(
...     reduction=tf.keras.losses.Reduction.SUM)
>>> cce(y_true, y_pred).numpy()
2.354

>>> # Using 'none' reduction type.
>>> cce = tf.keras.losses.CategoricalCrossentropy(
...     reduction=tf.keras.losses.Reduction.NONE)
>>> cce(y_true, y_pred).numpy()
array([0.0513, 2.303], dtype=float32)

使用 compile() API

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

[源代码]

`SparseCategoricalCrossentropy` 类

tf_keras.losses.SparseCategoricalCrossentropy(
    from_logits=False,
    ignore_class=None,
    reduction="auto",
    name="sparse_categorical_crossentropy",
)

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

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

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

独立用法

>>> 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 = tf.keras.losses.SparseCategoricalCrossentropy()
>>> scce(y_true, y_pred).numpy()
1.177

>>> # Calling with 'sample_weight'.
>>> scce(y_true, y_pred, sample_weight=tf.constant([0.3, 0.7])).numpy()
0.814

>>> # Using 'sum' reduction type.
>>> scce = tf.keras.losses.SparseCategoricalCrossentropy(
...     reduction=tf.keras.losses.Reduction.SUM)
>>> scce(y_true, y_pred).numpy()
2.354

>>> # Using 'none' reduction type.
>>> scce = tf.keras.losses.SparseCategoricalCrossentropy(
...     reduction=tf.keras.losses.Reduction.NONE)
>>> scce(y_true, y_pred).numpy()
array([0.0513, 2.303], dtype=float32)

使用 compile() API

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

[源代码]

`Poisson` 类

tf_keras.losses.Poisson(reduction="auto", name="poisson")

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

loss = y_pred - y_true * log(y_pred)

独立用法

>>> y_true = [[0., 1.], [0., 0.]]
>>> y_pred = [[1., 1.], [0., 0.]]
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> p = tf.keras.losses.Poisson()
>>> p(y_true, y_pred).numpy()
0.5

>>> # Calling with 'sample_weight'.
>>> p(y_true, y_pred, sample_weight=[0.8, 0.2]).numpy()
0.4

>>> # Using 'sum' reduction type.
>>> p = tf.keras.losses.Poisson(
...     reduction=tf.keras.losses.Reduction.SUM)
>>> p(y_true, y_pred).numpy()
0.999

>>> # Using 'none' reduction type.
>>> p = tf.keras.losses.Poisson(
...     reduction=tf.keras.losses.Reduction.NONE)
>>> p(y_true, y_pred).numpy()
array([0.999, 0.], dtype=float32)

使用 compile() API

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

[源代码]

`binary_crossentropy` 函数

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

计算二元交叉熵损失。

独立用法

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

参数

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]。

[源代码]

`categorical_crossentropy` 函数

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

计算分类交叉熵损失。

独立用法

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

参数

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。计算熵的维度。

返回值

分类交叉熵损失值。

[源代码]

`sparse_categorical_crossentropy` 函数

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

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

独立用法

>>> 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)
>>> assert loss.shape == (2,)
>>> loss.numpy()
array([0.0513, 2.303], dtype=float32)

>>> y_true = [[[ 0,  2],
...            [-1, -1]],
...           [[ 0,  2],
...            [-1, -1]]]
>>> y_pred = [[[[1.0, 0.0, 0.0], [0.0, 0.0, 1.0]],
...             [[0.2, 0.5, 0.3], [0.0, 1.0, 0.0]]],
...           [[[1.0, 0.0, 0.0], [0.0, 0.5, 0.5]],
...            [[0.2, 0.5, 0.3], [0.0, 1.0, 0.0]]]]
>>> loss = tf.keras.losses.sparse_categorical_crossentropy(
...   y_true, y_pred, ignore_class=-1)
>>> loss.numpy()
array([[[2.3841855e-07, 2.3841855e-07],
        [0.0000000e+00, 0.0000000e+00]],
       [[2.3841855e-07, 6.9314730e-01],
        [0.0000000e+00, 0.0000000e+00]]], dtype=float32)

参数

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

返回值

稀疏分类交叉熵损失值。

[源代码]

`poisson` 函数

tf_keras.losses.poisson(y_true, y_pred)

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

泊松损失是 Tensor y_pred - y_true * log(y_pred) 的元素的平均值。

独立用法

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

参数

y_true：真实值。形状为 [batch_size, d0, .. dN]。
y_pred：预测值。形状为 [batch_size, d0, .. dN]。

返回值

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

引发

InvalidArgumentError：如果 y_true 和 y_pred 的形状不兼容。

[源代码]

`KLDivergence` 类

tf_keras.losses.KLDivergence(reduction="auto", name="kl_divergence")

计算 y_true 和 y_pred 之间的 Kullback-Leibler 散度损失。

loss = y_true * log(y_true / y_pred)

参见：https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence

独立用法

>>> y_true = [[0, 1], [0, 0]]
>>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
>>> # Using 'auto'/'sum_over_batch_size' reduction type.
>>> kl = tf.keras.losses.KLDivergence()
>>> kl(y_true, y_pred).numpy()
0.458

>>> # Calling with 'sample_weight'.
>>> kl(y_true, y_pred, sample_weight=[0.8, 0.2]).numpy()
0.366

>>> # Using 'sum' reduction type.
>>> kl = tf.keras.losses.KLDivergence(
...     reduction=tf.keras.losses.Reduction.SUM)
>>> kl(y_true, y_pred).numpy()
0.916

>>> # Using 'none' reduction type.
>>> kl = tf.keras.losses.KLDivergence(
...     reduction=tf.keras.losses.Reduction.NONE)
>>> kl(y_true, y_pred).numpy()
array([0.916, -3.08e-06], dtype=float32)

使用 compile() API

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

[源代码]

`kl_divergence` 函数

tf_keras.losses.kl_divergence(y_true, y_pred)

计算 y_true 和 y_pred 之间的 Kullback-Leibler 散度损失。

loss = y_true * log(y_true / y_pred)

参见：https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence

独立用法

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

参数

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

返回值

包含损失的 Tensor。

引发

TypeError：如果 y_true 无法转换为 y_pred.dtype。

概率损失

BinaryCrossentropy 类

CategoricalCrossentropy 类

SparseCategoricalCrossentropy 类

Poisson 类

binary_crossentropy 函数

categorical_crossentropy 函数

sparse_categorical_crossentropy 函数

poisson 函数

KLDivergence 类

kl_divergence 函数

概率损失

BinaryCrossentropy 类

CategoricalCrossentropy 类

SparseCategoricalCrossentropy 类

Poisson 类

binary_crossentropy 函数

categorical_crossentropy 函数

sparse_categorical_crossentropy 函数

poisson 函数

KLDivergence 类

kl_divergence 函数

`BinaryCrossentropy` 类

`CategoricalCrossentropy` 类

`SparseCategoricalCrossentropy` 类

`Poisson` 类

`binary_crossentropy` 函数

`categorical_crossentropy` 函数

`sparse_categorical_crossentropy` 函数

`poisson` 函数

`KLDivergence` 类

`kl_divergence` 函数