回归损失

`MeanSquaredError` 类

keras.losses.MeanSquaredError(
    reduction="sum_over_batch_size", name="mean_squared_error", dtype=None
)

计算标签和预测值之间的误差平方的平均值。

公式

loss = mean(square(y_true - 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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`MeanAbsoluteError` 类

keras.losses.MeanAbsoluteError(
    reduction="sum_over_batch_size", name="mean_absolute_error", dtype=None
)

计算标签和预测值之间绝对差的平均值。

公式

loss = mean(abs(y_true - 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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`MeanAbsolutePercentageError` 类

keras.losses.MeanAbsolutePercentageError(
    reduction="sum_over_batch_size", name="mean_absolute_percentage_error", dtype=None
)

计算 y_true & y_pred 之间的平均绝对百分比误差。

公式

loss = 100 * mean(abs((y_true - y_pred) / y_true))

参数

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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`MeanSquaredLogarithmicError` 类

keras.losses.MeanSquaredLogarithmicError(
    reduction="sum_over_batch_size", name="mean_squared_logarithmic_error", dtype=None
)

计算 y_true & y_pred 之间的平均平方对数误差。

公式

loss = mean(square(log(y_true + 1) - log(y_pred + 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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`CosineSimilarity` 类

keras.losses.CosineSimilarity(
    axis=-1, reduction="sum_over_batch_size", name="cosine_similarity", dtype=None
)

计算 y_true & y_pred 之间的余弦相似度。

请注意，这是一个介于 -1 和 1 之间的数字。当它是一个介于 -1 和 0 之间的负数时，0 表示正交性，值越接近 -1 表示相似度越高。这使得它可以在尝试最大化预测值和目标值接近度的场景中用作损失函数。如果 y_true 或 y_pred 是零向量，则无论预测值和目标值的接近程度如何，余弦相似度都将为 0。

公式

loss = -sum(l2_norm(y_true) * l2_norm(y_pred))

参数

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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`Huber` 类

keras.losses.Huber(
    delta=1.0, reduction="sum_over_batch_size", name="huber_loss", dtype=None
)

计算 y_true & y_pred 之间的 Huber 损失。

公式

for x in error:
    if abs(x) <= delta:
        loss.append(0.5 * x^2)
    elif abs(x) > delta:
        loss.append(delta * abs(x) - 0.5 * delta^2)

loss = mean(loss, axis=-1)

参见：Huber loss。

参数

delta: 一个浮点数，Huber 损失函数从二次变为线性的点。
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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`LogCosh` 类

keras.losses.LogCosh(reduction="sum_over_batch_size", name="log_cosh", dtype=None)

计算预测误差的双曲余弦的对数。

公式

error = y_pred - y_true
logcosh = mean(log((exp(error) + exp(-error))/2), axis=-1)`

其中 x 是误差 y_pred - y_true。

参数

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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

[源]

`Tversky` 类

keras.losses.Tversky(
    alpha=0.5,
    beta=0.5,
    reduction="sum_over_batch_size",
    name="tversky",
    axis=None,
    dtype=None,
)

计算 y_true 和 y_pred 之间的 Tversky 损失值。

此损失函数由 alpha 和 beta 系数加权，用于惩罚假阳性和假阴性。

使用 alpha=0.5 和 beta=0.5，损失值等同于 Dice Loss。

参数

alpha: 控制假阳性发生率的系数。默认为 0.5。
beta: 控制假阴性发生率的系数。默认为 0.5。
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: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

返回值

Tversky 损失值。

参考文献

Salehi et al., 2017

[源]

`Dice` 类

keras.losses.Dice(
    reduction="sum_over_batch_size", name="dice", axis=None, dtype=None
)

计算 y_true 和 y_pred 之间的 Dice 损失值。

公式

loss = 1 - (2 * sum(y_true * y_pred)) / (sum(y_true) + sum(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: 损失实例的可选名称。
axis: 计算损失所沿着的维度元组。默认为 None。
dtype: 损失计算的数据类型 (DType)。默认为 None，这意味着使用 keras.backend.floatx()。keras.backend.floatx() 是 "float32"，除非设置为不同的值（通过 keras.backend.set_floatx()）。如果提供了 keras.DTypePolicy，则会使用 compute_dtype。

返回值

Dice 损失值。

示例

>>> y_true = [[[[1.0], [1.0]], [[0.0], [0.0]]],
...           [[[1.0], [1.0]], [[0.0], [0.0]]]]
>>> y_pred = [[[[0.0], [1.0]], [[0.0], [1.0]]],
...           [[[0.4], [0.0]], [[0.0], [0.9]]]]
>>> axis = (1, 2, 3)
>>> loss = keras.losses.Dice(axis=axis, reduction=None)(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.5, 0.75757575], shape=(2,), dtype=float32)

>>> loss = keras.losses.Dice()(y_true, y_pred)
>>> assert loss.shape == ()
>>> loss
array(0.6164384, shape=(), dtype=float32)

>>> y_true = np.array(y_true)
>>> y_pred = np.array(y_pred)
>>> loss = keras.losses.Dice(axis=axis, reduction=None)(y_true, y_pred)
>>> assert loss.shape == (2,)
>>> loss
array([0.5, 0.75757575], shape=(2,), dtype=float32)

[源]

`mean_squared_error` 函数

keras.losses.mean_squared_error(y_true, y_pred)

计算标签和预测值之间的均方误差。

公式

loss = mean(square(y_true - y_pred), axis=-1)

示例

>>> y_true = np.random.randint(0, 2, size=(2, 3))
>>> y_pred = np.random.random(size=(2, 3))
>>> loss = keras.losses.mean_squared_error(y_true, y_pred)

参数

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

返回值

均方误差值，形状为 [batch_size, d0, .. dN-1]。

[源]

`mean_absolute_error` 函数

keras.losses.mean_absolute_error(y_true, y_pred)

计算标签和预测值之间的平均绝对误差。

loss = mean(abs(y_true - y_pred), axis=-1)

参数

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.mean_absolute_error(y_true, y_pred)

[源]

`mean_absolute_percentage_error` 函数

keras.losses.mean_absolute_percentage_error(y_true, y_pred)

计算 y_true & y_pred 之间的平均绝对百分比误差。

公式

loss = 100 * mean(abs((y_true - y_pred) / y_true), axis=-1)

通过除以 maximum(y_true, epsilon) 来防止除以零，其中 epsilon = keras.backend.epsilon() （默认为 1e-7）。

参数

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

返回值

平均绝对百分比误差值，形状为 [batch_size, d0, .. dN-1]。

示例

>>> y_true = np.random.random(size=(2, 3))
>>> y_pred = np.random.random(size=(2, 3))
>>> loss = keras.losses.mean_absolute_percentage_error(y_true, y_pred)

[源]

`mean_squared_logarithmic_error` 函数

keras.losses.mean_squared_logarithmic_error(y_true, y_pred)

计算 y_true & y_pred 之间的平均平方对数误差。

公式

loss = mean(square(log(y_true + 1) - log(y_pred + 1)), axis=-1)

注意，y_pred 和 y_true 不能小于或等于 0。负值和 0 值将被替换为 keras.backend.epsilon() （默认为 1e-7）。

参数

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.mean_squared_logarithmic_error(y_true, y_pred)

[源]

`cosine_similarity` 函数

keras.losses.cosine_similarity(y_true, y_pred, axis=-1)

计算标签和预测值之间的余弦相似度。

公式

loss = -sum(l2_norm(y_true) * l2_norm(y_pred))

参数

y_true: 真实目标的张量。
y_pred: 预测目标的张量。
axis: 用于确定相似度的轴。默认为 -1。

返回值

余弦相似度张量。

示例

>>> y_true = [[0., 1.], [1., 1.], [1., 1.]]
>>> y_pred = [[1., 0.], [1., 1.], [-1., -1.]]
>>> loss = keras.losses.cosine_similarity(y_true, y_pred, axis=-1)
[-0., -0.99999994, 0.99999994]

[源]

`huber` 函数

keras.losses.huber(y_true, y_pred, delta=1.0)

计算 Huber 损失值。

公式

for x in error:
    if abs(x) <= delta:
        loss.append(0.5 * x^2)
    elif abs(x) > delta:
        loss.append(delta * abs(x) - 0.5 * delta^2)

loss = mean(loss, axis=-1)

参见：Huber loss。

示例

>>> y_true = [[0, 1], [0, 0]]
>>> y_pred = [[0.6, 0.4], [0.4, 0.6]]
>>> loss = keras.losses.huber(y_true, y_pred)
0.155

参数

y_true: 真实目标的张量。
y_pred: 预测目标的张量。
delta: 一个浮点数，Huber 损失函数从二次变为线性的点。默认为 1.0。

返回值

每个样本一个标量损失项的张量。

[源]

`log_cosh` 函数

keras.losses.log_cosh(y_true, y_pred)

预测误差的双曲余弦的对数。

公式

loss = mean(log(cosh(y_pred - y_true)), axis=-1)

注意，对于小的 x，log(cosh(x)) 大约等于 (x ** 2) / 2；对于大的 x，大约等于 abs(x) - log(2)。这意味着 'logcosh' 的作用类似于均方误差，但不会受到偶尔出现的极端错误预测的强烈影响。

示例

>>> y_true = [[0., 1.], [0., 0.]]
>>> y_pred = [[1., 1.], [0., 0.]]
>>> loss = keras.losses.log_cosh(y_true, y_pred)
0.108

参数

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

返回值

Logcosh 误差值，形状为 [batch_size, d0, .. dN-1]。

[源]

`tversky` 函数

keras.losses.tversky(y_true, y_pred, alpha=0.5, beta=0.5, axis=None)

计算 y_true 和 y_pred 之间的 Tversky 损失值。

此损失函数由 alpha 和 beta 系数加权，用于惩罚假阳性和假阴性。

使用 alpha=0.5 和 beta=0.5，损失值等同于 Dice Loss。

参数

y_true: 真实目标的张量。
y_pred: 预测目标的张量。
alpha: 控制假阳性发生率的系数。
beta: 控制假阴性发生率的系数。
axis: 计算损失所沿着的维度元组。

返回值

Tversky 损失值。

参考文献

Salehi et al., 2017

[源]

`dice` 函数

keras.losses.dice(y_true, y_pred, axis=None)

计算 y_true 和 y_pred 之间的 Dice 损失值。

公式

loss = 1 - (2 * sum(y_true * y_pred)) / (sum(y_true) + sum(y_pred))

参数

y_true: 真实目标的张量。
y_pred: 预测目标的张量。
axis: 计算损失所沿着的维度元组

返回值

Dice 损失值。

示例

>>> y_true = [[[[1.0], [1.0]], [[0.0], [0.0]]],
...           [[[1.0], [1.0]], [[0.0], [0.0]]]]
>>> y_pred = [[[[0.0], [1.0]], [[0.0], [1.0]]],
...           [[[0.4], [0.0]], [[0.0], [0.9]]]]
>>> axis = (1, 2, 3)
>>> loss = keras.losses.dice(y_true, y_pred, axis=axis)
>>> assert loss.shape == (2,)
>>> loss
array([0.5, 0.75757575], shape=(2,), dtype=float32)

>>> loss = keras.losses.dice(y_true, y_pred)
>>> assert loss.shape == ()
>>> loss
array(0.6164384, shape=(), dtype=float32)

回归损失

MeanSquaredError 类

MeanAbsoluteError 类

MeanAbsolutePercentageError 类

MeanSquaredLogarithmicError 类

CosineSimilarity 类

Huber 类

LogCosh 类

Tversky 类

Dice 类

mean_squared_error 函数

mean_absolute_error 函数

mean_absolute_percentage_error 函数

mean_squared_logarithmic_error 函数

cosine_similarity 函数

huber 函数

log_cosh 函数

tversky 函数

dice 函数

回归损失

MeanSquaredError 类

MeanAbsoluteError 类

MeanAbsolutePercentageError 类

MeanSquaredLogarithmicError 类

CosineSimilarity 类

Huber 类

LogCosh 类

Tversky 类

Dice 类

mean_squared_error 函数

mean_absolute_error 函数

mean_absolute_percentage_error 函数

mean_squared_logarithmic_error 函数

cosine_similarity 函数

huber 函数

log_cosh 函数

tversky 函数

dice 函数

`MeanSquaredError` 类

`MeanAbsoluteError` 类

`MeanAbsolutePercentageError` 类

`MeanSquaredLogarithmicError` 类

`CosineSimilarity` 类

`Huber` 类

`LogCosh` 类

`Tversky` 类

`Dice` 类

`mean_squared_error` 函数

`mean_absolute_error` 函数

`mean_absolute_percentage_error` 函数

`mean_squared_logarithmic_error` 函数

`cosine_similarity` 函数

`huber` 函数

`log_cosh` 函数

`tversky` 函数

`dice` 函数