什么是损失函数？

损失函数是一种掂量模型与数据吻合水平的算法。损失函数测量理论测量值和预测值之间差距的一种形式。损失函数的值越高预测就越谬误，损失函数值越低则预测越靠近实在值。对每个独自的观测(数据点)计算损失函数。将所有损失函数（loss function）的值取平均值的函数称为代价函数（cost function），更简略的了解就是损失函数是针对单个样本的，而代价函数是针对所有样本的。

损失函数与度量指标

一些损失函数也能够被用作评估指标。然而损失函数和度量指标（metrics）有不同的目标。尽管度量指标用于评估最终模型并比拟不同模型的性能，但损失函数在模型构建阶段用作正在创立的模型的优化器。损失函数领导模型如何最小化误差。

也就是说损失函数是晓得模型如何训练的，而度量指标是阐明模型的体现的

为什么要用损失函数?

因为损失函数测量的是预测值和理论值之间的差距，因而在训练模型时能够应用它们来领导模型的改良(通常的梯度降落法)。在构建模型的过程中，如果特色的权重产生了变动失去了更好或更差的预测，就须要利用损失函数来判断模型中特色的权重是否须要扭转，以及扭转的方向。

咱们能够在机器学习中应用各种各样的损失函数，这取决于咱们试图解决的问题的类型、数据品质和散布以及咱们应用的算法，下图为咱们整顿的10个常见的损失函数：

回归问题

1、均方误差(MSE)

均方误差是指所有预测值和实在值之间的平方差，并将其平均值。罕用于回归问题。

 def MSE (y, y_predicted):    sq_error = (y_predicted - y) ** 2    sum_sq_error = np.sum(sq_error)    mse = sum_sq_error/y.size    return mse

2、均匀绝对误差(MAE)

作为预测值和实在值之间的相对差的平均值来计算的。当数据有异样值时，这是比均方误差更好的测量方法。

 def MAE (y, y_predicted):    error = y_predicted - y    absolute_error = np.absolute(error)    total_absolute_error = np.sum(absolute_error)    mae = total_absolute_error/y.size    return mae

3、均方根误差(RMSE)

这个损失函数是均方误差的平方根。如果咱们不想惩办更大的谬误，这是一个现实的办法。

 def RMSE (y, y_predicted):    sq_error = (y_predicted - y) ** 2    total_sq_error = np.sum(sq_error)    mse = total_sq_error/y.size    rmse = math.sqrt(mse)    return rmse

4、平均偏差误差(MBE)

相似于均匀绝对误差但不求绝对值。这个损失函数的毛病是负误差和正误差能够互相对消，所以当钻研人员晓得误差只有一个方向时，利用它会更好。

 def MBE (y, y_predicted):    error = y_predicted -  y    total_error = np.sum(error)    mbe = total_error/y.size    return mbe

5、Huber损失

Huber损失函数联合了均匀绝对误差(MAE)和均方误差(MSE)的长处。这是因为Hubber损失是一个有两个分支的函数。一个分支利用于合乎期望值的MAE，另一个分支利用于异样值。Hubber Loss个别函数为:

这里的

 def hubber_loss (y, y_predicted, delta)    delta = 1.35 * MAE    y_size = y.size    total_error = 0    for i in range (y_size):       erro = np.absolute(y_predicted[i] - y[i])       if error < delta:          hubber_error = (error * error) / 2       else:          hubber_error = (delta * error) / (0.5 * (delta * delta))       total_error += hubber_error    total_hubber_error = total_error/y.size    return total_hubber_error

二元分类

6、最大似然损失(Likelihood Loss/LHL)

该损失函数次要用于二值分类问题。将每一个预测值的概率相乘,失去一个损失值，相干的代价函数是所有观测值的平均值。让咱们用以下二元分类的示例为例，其中类别为[0]或[1]。如果输入概率等于或大于0.5，则预测类为[1]，否则为[0]。输入概率的示例如下:

[0.3 , 0.7 , 0.8 , 0.5 , 0.6 , 0.4]

对应的预测类为:

[0 , 1 , 1 , 1 , 1 , 0]

而理论的类为：

[0 , 1 , 1 , 0 , 1 , 0]

当初将应用实在的类和输入概率来计算损失。如果真类是[1]，咱们应用输入概率，如果真类是[0]，咱们应用1-概率:

((1–0.3)+0.7+0.8+(1–0.5)+0.6+(1–0.4)) / 6 = 0.65

Python代码如下:

 def LHL (y, y_predicted):    likelihood_loss = (y * y_predicted) + ((1-y) * (y_predicted))    total_likelihood_loss = np.sum(likelihood_loss)    lhl = - total_likelihood_loss / y.size    return lhl

7、二元穿插熵(BCE)

这个函数是对数的似然损失的修改。对数列的叠加能够惩办那些十分自信然而却谬误的预测。二元穿插熵损失函数的个别公式为:

— (y . log (p) + (1 — y) . log (1 — p))

让咱们持续应用下面例子的值：

输入概率= [0.3、0.7、0.8、0.5、0.6、0.4]

理论的类= [0，1，1，0，1，0]

— (0 . log (0.3) + (1–0) . log (1–0.3)) = 0.155— (1 . log(0.7) + (1–1) . log (0.3)) = 0.155— (1 . log(0.8) + (1–1) . log (0.2)) = 0.097— (0 . log (0.5) + (1–0) . log (1–0.5)) = 0.301— (1 . log(0.6) + (1–1) . log (0.4)) = 0.222— (0 . log (0.4) + (1–0) . log (1–0.4)) = 0.222

那么代价函数的后果为：

(0.155 + 0.155 + 0.097 + 0.301 + 0.222 + 0.222) / 6 = 0.192

Python的代码如下：

 def BCE (y, y_predicted):    ce_loss = y*(np.log(y_predicted))+(1-y)*(np.log(1-y_predicted))    total_ce = np.sum(ce_loss)    bce = - total_ce/y.size    return bce

8、Hinge Loss 和 Squared Hinge Loss (HL and SHL)

Hinge Loss被翻译成铰链损失或者合页损失，这里还是以英文为准。

Hinge Loss次要用于反对向量机模型的评估。谬误的预测和不太自信的正确预测都会受到惩办。所以个别损失函数是：

l(y) = max (0 , 1 — t . y)

这里的t是实在后果用[1]或[-1]示意。

应用Hinge Loss的类应该是[1]或-1。为了在Hinge loss函数中不被惩办，一个观测不仅须要正确分类而且到超平面的间隔应该大于margin(一个自信的正确预测)。如果咱们想进一步惩办更高的误差，咱们能够用与MSE相似的办法平方Hinge损失,也就是Squared Hinge Loss。

如果你对SVM比拟相熟，应该还记得在SVM中，超平面的边缘（margin）越高，则某一预测就越有信念。如果这块不相熟，则看看这个可视化的例子:

如果一个预测的后果是1.5，并且真正的类是[1]，损失将是0(零)，因为模型是高度自信的。

loss= Max (0,1 - 1* 1.5) = Max (0， -0.5) = 0

如果一个观测后果为0(0)，则示意该观测处于边界(超平面)，实在的类为[-1]。损失为1，模型既不正确也不谬误，可信度很低。

loss = max (0 , 1–(-1) * 0) = max (0 , 1) = 1

如果一次观测后果为2，但分类谬误(乘以[-1])，则间隔为-2。损失是3(十分高)，因为咱们的模型对谬误的决策十分有信念（这个是绝不能容忍的）。

loss = max (0 , 1 — (-1) . 2) = max (0 , 1+2) = max (0 , 3) = 3

python代码如下：

 #Hinge Loss def Hinge (y, y_predicted):    hinge_loss = np.sum(max(0 , 1 - (y_predicted * y)))    return hinge_loss  #Squared Hinge Loss def SqHinge (y, y_predicted):    sq_hinge_loss = max (0 , 1 - (y_predicted * y)) ** 2    total_sq_hinge_loss = np.sum(sq_hinge_loss)    return total_sq_hinge_loss

多分类

9、穿插熵（CE）

在多分类中，咱们应用与二元穿插熵相似的公式，但有一个额定的步骤。首先须要计算每一对[y, y_predicted]的损失，个别公式为:

如果咱们有三个类，其中单个[y, y_predicted]对的输入是:

这里理论的类3（也就是值=1的局部），咱们的模型对真正的类是3的信任度是0.7。计算这损失如下:

Loss = 0 . log (0.1) + 0 . log (0.2) + 1 . log (0.7) = -0.155

为了失去代价函数的值，咱们须要计算所有单个配对的损失，而后将它们相加最初乘以[-1/样本数量]。代价函数由下式给出:

应用下面的例子，如果咱们的第二对:

Loss = 0 . log (0.4) + 1. log (0.4) + 0. log (0.2) = -0.40

那么老本函数计算如下:

应用Python的代码示例能够更容易了解:

 def CCE (y, y_predicted):    cce_class = y * (np.log(y_predicted))    sum_totalpair_cce = np.sum(cce_class)    cce = - sum_totalpair_cce / y.size    return cce

10、Kullback-Leibler 散度 (KLD)

又被简化称为KL散度，它相似于分类穿插熵，但思考了观测值产生的概率。如果咱们的类不均衡，它特地有用。

 def KL (y, y_predicted):    kl = y * (np.log(y / y_predicted))    total_kl = np.sum(kl)    return total_kl

以上就是常见的10个损失函数，心愿对你有所帮忙.

https://avoid.overfit.cn/post/9618c5b7290348c79a2c98eeb3eeff07

作者：Carla Martins