回归损失函数

[source]

MeanSquaredError class

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" 或 None. name: 损失实例的可选名称. dtype: 损失计算的数据类型.默认为 None,这意味着使用 keras.backend.floatx().keras.backend.floatx() 是 "float32",除非设置为不同值 （通过 keras.backend.set_floatx()）.如果提供了 keras.DTypePolicy,则将使用 compute_dtype.

[source]

MeanAbsoluteError class

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" 或 None. name: 损失实例的可选名称. dtype: 损失计算的数据类型.默认为 None,这意味着使用 keras.backend.floatx().keras.backend.floatx() 是 "float32",除非设置为不同值 （通过 keras.backend.set_floatx()）.如果提供了 keras.DTypePolicy,则将使用 compute_dtype.

[source]

MeanAbsolutePercentageError class

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" 或 None. name: 损失实例的可选名称. dtype: 损失计算的数据类型.默认为 None,这意味着使用 keras.backend.floatx().keras.backend.floatx() 是 "float32",除非设置为不同的值 （通过 keras.backend.set_floatx()）.如果提供了 keras.DTypePolicy,则将使用 compute_dtype.

[source]

MeanSquaredLogarithmicError class

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" 或 None. name: 损失实例的可选名称. dtype: 损失计算的数据类型.默认为 None,这意味着使用 keras.backend.floatx().keras.backend.floatx() 是 "float32",除非设置为不同的值 （通过 keras.backend.set_floatx()）.如果提供了 keras.DTypePolicy,则将使用 compute_dtype.

[source]

CosineSimilarity class

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"或None. name: 损失实例的可选名称. dtype: 损失计算的数据类型.默认为None,这意味着使用keras.backend.floatx().keras.backend.floatx()是"float32",除非设置为不同的值 （通过keras.backend.set_floatx()）.如果提供了keras.DTypePolicy,则将使用compute_dtype.

[source]

mean_squared_error function

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

[source]

mean_absolute_error function

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)

[source]

mean_absolute_percentage_error function

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)

[source]

mean_squared_logarithmic_error function

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)

[source]

cosine_similarity function

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.

参数: 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]

[source]

Huber class

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"、"sum_over_batch_size" 或 None.默认为 "sum_over_batch_size". name: 实例的可选名称. dtype: 损失计算的数据类型.默认为 None,表示使用 keras.backend.floatx().keras.backend.floatx() 是 "float32",除非设置为不同值（通过 keras.backend.set_floatx()）.如果提供了 keras.DTypePolicy,则将使用 compute_dtype.

[source]

huber function

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.

返回: 每个样本包含一个标量损失值的张量.

[source]

LogCosh class

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

计算预测误差的 hyperbolic cosine 的对数.

公式:

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

其中 x 是误差 y_pred - y_true.

参数: reduction: 应用于损失的减少类型.选项有 "sum"、 "sum_over_batch_size" 或 None.默认为 "sum_over_batch_size". name: 实例的可选名称. dtype: 损失计算的 dtype.默认为 None,这意味着使用 keras.backend.floatx().keras.backend.floatx() 是 "float32",除非设置为不同值 （通过 keras.backend.set_floatx()）.如果提供了 keras.DTypePolicy,则将使用 compute_dtype.

[source]

log_cosh function

keras.losses.log_cosh(y_true, y_pred)

对预测误差的 hyperbolic cosine 取对数.

公式:

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

注意 log(cosh(x)) 对于小的 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].