MeanSquaredError
类keras.losses.MeanSquaredError(
reduction="sum_over_batch_size", name="mean_squared_error", dtype=None
)
计算标签和预测之间的误差平方均值。
公式
loss = mean(square(y_true - y_pred))
参数
"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"
。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))
参数
"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"
。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))
参数
"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"
。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)))
参数
"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"
。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))
参数
-1
。"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"
。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 损失。
参数
"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"
。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
。
参数
"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"
。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", dtype=None
)
计算 y_true
和 y_pred
之间的 Tversky 损失值。
此损失函数由惩罚误报和漏报的 alpha 和 beta 系数加权。
当 alpha=0.5
和 beta=0.5
时,损失值等效于 Dice 损失。
参数
0.5
。0.5
。"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"
。None
,这意味着使用 keras.backend.floatx()
。keras.backend.floatx()
为 "float32"
,除非设置为不同的值(通过 keras.backend.set_floatx()
)。如果提供了 keras.DTypePolicy
,则将使用 compute_dtype
。返回值
Tversky 损失值。
参考文献
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))
参数
"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"
。None
。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(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)
>>> 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)
参数
[batch_size, d0, .. dN]
的真实值。[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)
参数
[batch_size, d0, .. dN]
的真实值。[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
)。
参数
[batch_size, d0, .. dN]
的真实值。[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
)。
参数
[batch_size, d0, .. dN]
的真实值。[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))
请注意,它是一个介于 -1 和 1 之间的数字。当它是一个介于 -1 和 0 之间的负数时,0 表示正交,更接近 -1 的值表示更大的相似性。这使得它可以用作损失函数,在您尝试最大化预测和目标之间的接近度的设置中。如果 y_true
或 y_pred
是零向量,则无论预测和目标之间的接近度如何,余弦相似度都将为 0。
参数
-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 损失。
示例
>>> 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
参数
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
参数
[batch_size, d0, .. dN]
的真实值。[batch_size, d0, .. dN]
的预测值。返回值
形状为 [batch_size, d0, .. dN-1]
的 Logcosh 误差值。
tversky
函数keras.losses.tversky(y_true, y_pred, alpha=0.5, beta=0.5)
计算 y_true
和 y_pred
之间的 Tversky 损失值。
此损失函数由惩罚误报和漏报的 alpha 和 beta 系数加权。
当 alpha=0.5
和 beta=0.5
时,损失值等效于 Dice 损失。
参数
返回值
Tversky 损失值。
参考文献
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))
参数
返回值
Dice 损失值。