损失函数 订阅
损失函数(loss function)或代价函数(cost function)是将随机事件或其有关随机变量的取值映射为非负实数以表示该随机事件的“风险”或“损失”的函数。在应用中,损失函数通常作为学习准则与优化问题相联系,即通过最小化损失函数求解和评估模型。例如在统计学和机器学习中被用于模型的参数估计(parameteric estimation) [1]  ,在宏观经济学中被用于风险管理(risk mangement)和决策 [2]  ,在控制理论中被应用于最优控制理论(optimal control theory) [3]  。 展开全文
损失函数(loss function)或代价函数(cost function)是将随机事件或其有关随机变量的取值映射为非负实数以表示该随机事件的“风险”或“损失”的函数。在应用中,损失函数通常作为学习准则与优化问题相联系,即通过最小化损失函数求解和评估模型。例如在统计学和机器学习中被用于模型的参数估计(parameteric estimation) [1]  ,在宏观经济学中被用于风险管理(risk mangement)和决策 [2]  ,在控制理论中被应用于最优控制理论(optimal control theory) [3]  。
信息
外文名
loss function
类    型
函数
应用学科
统计学
中文名
损失函数
应用领域
机器学习,经济学,控制理论
损失函数函数定义
在样本空间 内有可测状态 和随机变量 根据法则 所做的决策 ,此时若在乘积空间 上有函数 满足: ,即对任意的 , 是非负可测函数,则 被称为损失函数,表示状态 下采取决策 所对应的损失或风险 [4]  。机器学习中,给定独立同分布(independent and identically distributed,iid)的学习样本 ,和模型 ,损失函数是模型输出和观测结果间概率分布差异的量化 [1]  : 式中 表示模型参数,上式右侧具体的量化方法视问题和模型而定,但要求满足损失函数的一般定义,即样本空间的非负可测函数。
收起全文
精华内容
下载资源
问答
  • 交叉熵损失函数原理详解 万次阅读 多人点赞
    2019-08-30 10:28:42

    交叉熵损失函数原理详解

    之前在代码中经常看见交叉熵损失函数(CrossEntropy Loss),只知道它是分类问题中经常使用的一种损失函数,对于其内部的原理总是模模糊糊,而且一般使用交叉熵作为损失函数时,在模型的输出层总会接一个softmax函数,至于为什么要怎么做也是不懂,所以专门花了一些时间打算从原理入手,搞懂它,故在此写一篇博客进行总结,以便以后翻阅。


    交叉熵简介

    交叉熵是信息论中的一个重要概念,主要用于度量两个概率分布间的差异性,要理解交叉熵,需要先了解下面几个概念。


    信息量

    信息奠基人香农(Shannon)认为“信息是用来消除随机不确定性的东西”,也就是说衡量信息量的大小就是看这个信息消除不确定性的程度。

    “太阳从东边升起”,这条信息并没有减少不确定性,因为太阳肯定是从东边升起的,这是一句废话,信息量为0。

    ”2018年中国队成功进入世界杯“,从直觉上来看,这句话具有很大的信息量。因为中国队进入世界杯的不确定性因素很大,而这句话消除了进入世界杯的不确定性,所以按照定义,这句话的信息量很大。

    根据上述可总结如下:信息量的大小与信息发生的概率成反比。概率越大,信息量越小。概率越小,信息量越大。

    设某一事件发生的概率为P(x),其信息量表示为:
    I ( x ) = − log ⁡ ( P ( x ) ) I\left ( x \right ) = -\log\left ( P\left ( x \right ) \right ) I(x)=log(P(x))
    其中 I ( x ) I\left ( x \right ) I(x)表示信息量,这里 log ⁡ \log log表示以e为底的自然对数。


    信息熵

    信息熵也被称为熵,用来表示所有信息量的期望。

    期望是试验中每次可能结果的概率乘以其结果的总和。

    所以信息量的熵可表示为:(这里的 X X X是一个离散型随机变量)
    H ( X ) = − ∑ i = 1 n P ( x i ) log ⁡ ( P ( x i ) ) ) ( X = x 1 , x 2 , x 3 . . . , x n ) H\left ( \mathbf{X} \right ) = -\sum \limits_{i=1}^n P(x_{i}) \log \left ( P \left ( x_{i} \right ))) \qquad ( \mathbf{X}= x_{1},x_{2},x_{3}...,x_{n} \right) H(X)=i=1nP(xi)log(P(xi)))(X=x1,x2,x3...,xn)
    使用明天的天气概率来计算其信息熵:

    序号事件概率P信息量
    1明天是晴天0.5 − log ⁡ ( 0.5 ) -\log \left ( 0.5 \right ) log(0.5)
    2明天出雨天0.2 − log ⁡ ( 0.2 ) -\log \left ( 0.2 \right ) log(0.2)
    3多云0.3 − log ⁡ ( 0.3 ) -\log \left ( 0.3 \right ) log(0.3)

    H ( X ) = − ( 0.5 ∗ log ⁡ ( 0.5 ) + 0.2 ∗ log ⁡ ( 0.2 ) + 0.3 ∗ log ⁡ ( 0.3 ) ) H\left ( \mathbf{X} \right ) = -\left ( 0.5 * \log \left ( 0.5 \right ) + 0.2 * \log \left ( 0.2 \right ) + 0.3 * \log \left ( 0.3 \right ) \right) H(X)=(0.5log(0.5)+0.2log(0.2)+0.3log(0.3))

    对于0-1分布的问题,由于其结果只用两种情况,是或不是,设某一件事情发生的概率为 P ( x ) P\left ( x \right ) P(x),则另一件事情发生的概率为 1 − P ( x ) 1-P\left ( x \right ) 1P(x),所以对于0-1分布的问题,计算熵的公式可以简化如下:
    H ( X ) = − ∑ n = 1 n P ( x i log ⁡ ( P ( x i ) ) ) = − [ P ( x ) log ⁡ ( P ( x ) ) + ( 1 − P ( x ) ) log ⁡ ( 1 − P ( x ) ) ] = − P ( x ) log ⁡ ( P ( x ) ) − ( 1 − P ( x ) ) log ⁡ ( 1 − P ( x ) ) H\left ( \mathbf{X} \right ) = -\sum \limits_{n=1}^n P(x_{i}\log \left ( P \left ( x_{i} \right )) \right) \\ = -\left [ P\left ( x \right) \log \left ( P\left ( x \right ) \right ) + \left ( 1 - P\left ( x \right ) \right) \log \left ( 1-P\left ( x \right ) \right ) \right] \\ = -P\left ( x \right) \log \left ( P\left ( x \right ) \right ) - \left ( 1 - P\left ( x \right ) \right) \log \left ( 1-P\left ( x \right ) \right) H(X)=n=1nP(xilog(P(xi)))=[P(x)log(P(x))+(1P(x))log(1P(x))]=P(x)log(P(x))(1P(x))log(1P(x))


    相对熵(KL散度)

    如果对于同一个随机变量 X X X有两个单独的概率分布 P ( x ) P\left(x\right) P(x) Q ( x ) Q\left(x\right) Q(x),则我们可以使用KL散度来衡量这两个概率分布之间的差异

    下面直接列出公式,再举例子加以说明。
    D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) log ⁡ ( p ( x i ) q ( x i ) ) D_{KL}\left ( p || q \right) = \sum \limits_{i=1}^n p\left ( x_{i}\right ) \log \left ( \frac{p\left ( x_{i} \right )}{q\left ( x_{i} \right )} \right ) DKL(pq)=i=1np(xi)log(q(xi)p(xi))
    在机器学习中,常常使用 P ( x ) P\left(x\right) P(x)来表示样本的真实分布, Q ( x ) Q \left(x\right) Q(x)来表示模型所预测的分布,比如在一个三分类任务中(例如,猫狗马分类器), x 1 , x 2 , x 3 x_{1}, x_{2}, x_{3} x1,x2,x3分别代表猫,狗,马,例如一张猫的图片真实分布 P ( X ) = [ 1 , 0 , 0 ] P\left(X\right) = [1, 0, 0] P(X)=[1,0,0], 预测分布 Q ( X ) = [ 0.7 , 0.2 , 0.1 ] Q\left(X\right) = [0.7, 0.2, 0.1] Q(X)=[0.7,0.2,0.1],计算KL散度:
    D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) log ⁡ ( p ( x i ) q ( x i ) ) = p ( x 1 ) log ⁡ ( p ( x 1 ) q ( x 1 ) ) + p ( x 2 ) log ⁡ ( p ( x 2 ) q ( x 2 ) ) + p ( x 3 ) log ⁡ ( p ( x 3 ) q ( x 3 ) ) = 1 ∗ log ⁡ ( 1 0.7 ) = 0.36 D_{KL}\left ( p || q \right) = \sum \limits_{i=1}^n p\left ( x_{i}\right ) \log \left ( \frac{p\left ( x_{i} \right )}{q\left ( x_{i} \right )} \right ) \\ = p\left ( x_{1}\right ) \log \left ( \frac{p\left ( x_{1} \right )}{q\left ( x_{1} \right )} \right ) + p\left ( x_{2}\right ) \log \left ( \frac{p\left ( x_{2} \right )}{q\left ( x_{2} \right )} \right ) + p\left ( x_{3}\right ) \log \left ( \frac{p\left ( x_{3} \right )}{q\left ( x_{3} \right )} \right ) \\ = 1 * \log \left ( \frac{1}{0.7} \right ) = 0.36 DKL(pq)=i=1np(xi)log(q(xi)p(xi))=p(x1)log(q(x1)p(x1))+p(x2)log(q(x2)p(x2))+p(x3)log(q(x3)p(x3))=1log(0.71)=0.36
    KL散度越小,表示 P ( x ) P\left(x\right) P(x) Q ( x ) Q\left(x\right) Q(x)的分布更加接近,可以通过反复训练 Q ( x ) Q\left(x \right) Q(x)来使 Q ( x ) Q\left(x \right) Q(x)的分布逼近 P ( x ) P\left(x \right) P(x)


    交叉熵

    首先将KL散度公式拆开:
    D K L ( p ∣ ∣ q ) = ∑ i = 1 n p ( x i ) log ⁡ ( p ( x i ) q ( x i ) ) = ∑ i = 1 n p ( x i ) l o g ( p ( x i ) ) − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) = − H ( p ( x ) ) + [ − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) ] D_{KL}\left ( p || q \right) = \sum \limits_{i=1}^n p\left ( x_{i}\right ) \log \left ( \frac{p\left ( x_{i} \right )}{q\left ( x_{i} \right )} \right ) \\ = \sum \limits_{i=1}^n p \left (x_{i}\right) log \left(p \left (x_{i}\right)\right) - \sum \limits_{i=1}^n p \left (x_{i}\right) log \left(q \left (x_{i}\right)\right) \\ = -H \left (p \left(x \right) \right) + \left [-\sum \limits_{i=1}^n p \left (x_{i}\right) log \left(q \left (x_{i}\right)\right) \right] DKL(pq)=i=1np(xi)log(q(xi)p(xi))=i=1np(xi)log(p(xi))i=1np(xi)log(q(xi))=H(p(x))+[i=1np(xi)log(q(xi))]
    前者 H ( p ( x ) ) H \left (p \left (x \right)\right) H(p(x))表示信息熵,后者即为交叉熵,KL散度 = 交叉熵 - 信息熵

    交叉熵公式表示为:
    H ( p , q ) = − ∑ i = 1 n p ( x i ) l o g ( q ( x i ) ) H \left (p, q\right) = -\sum \limits_{i=1}^n p \left (x_{i}\right) log \left(q \left (x_{i}\right)\right) H(p,q)=i=1np(xi)log(q(xi))
    在机器学习训练网络时,输入数据与标签常常已经确定,那么真实概率分布 P ( x ) P\left(x \right) P(x)也就确定下来了,所以信息熵在这里就是一个常量。由于KL散度的值表示真实概率分布 P ( x ) P\left(x\right) P(x)与预测概率分布 Q ( x ) Q \left(x\right) Q(x)之间的差异,值越小表示预测的结果越好,所以需要最小化KL散度,而交叉熵等于KL散度加上一个常量(信息熵),且公式相比KL散度更加容易计算,所以在机器学习中常常使用交叉熵损失函数来计算loss就行了。


    交叉熵在单分类问题中的应用

    在线性回归问题中,常常使用MSE(Mean Squared Error)作为loss函数,而在分类问题中常常使用交叉熵作为loss函数。

    下面通过一个例子来说明如何计算交叉熵损失值。

    假设我们输入一张狗的图片,标签与预测值如下:

    *
    Label010
    Pred0.20.70.1

    那么loss
    l o s s = − ( 0 ∗ log ⁡ ( 0.2 ) + 1 ∗ log ⁡ ( 0.7 ) + 0 ∗ log ⁡ ( 0.1 ) ) = 0.36 loss = -\left ( 0 * \log \left ( 0.2 \right ) + 1 * \log \left ( 0.7 \right ) + 0 * \log \left ( 0.1 \right )\right) = 0.36 loss=(0log(0.2)+1log(0.7)+0log(0.1))=0.36
    一个batch的loss为
    l o s s = − 1 m ∑ i = 1 m ∑ j = 1 n p ( x i j ) l o g ( q ( x i j ) ) loss = -\frac{1}{m}\sum \limits_{i=1}^m \sum \limits_{j=1}^n p \left (x_{ij}\right) log \left(q \left (x_{ij}\right)\right) loss=m1i=1mj=1np(xij)log(q(xij))
    其中m表示样本个数。


    总结:

    • 交叉熵能够衡量同一个随机变量中的两个不同概率分布的差异程度,在机器学习中就表示为真实概率分布与预测概率分布之间的差异。交叉熵的值越小,模型预测效果就越好。

    • 交叉熵在分类问题中常常与softmax是标配,softmax将输出的结果进行处理,使其多个分类的预测值和为1,再通过交叉熵来计算损失。


    参考:

    https://blog.csdn.net/tsyccnh/article/details/79163834


    THE END

    更多相关内容
  • 损失函数5.1 什么是损失函数5.2 常见的损失函数5.3 逻辑回归为什么使用对数损失函数5.4 对数损失函数是如何度量损失的 在本文中着重介绍机器学习中的目标函数(代价函数,Cost Function)以及损失函数(Loss Fu
  • 损失函数一般分为4种,平方损失函数,对数损失函数,HingeLoss 0-1 损失函数,绝对值损失函数。 我们先定义两个二维数组,然后用不同的损失函数计算其损失值。 import torch from torch.autograd import Variable ...
  • 损失函数(loss function)或代价函数(cost function)是将随机事件或其有关随机变量的取值映射为非负实数以表示该随机事件的“风险”或“损失”的函数。在应用中,损失函数通常作为学习准则与优化问题相联系,即...
  • 应该是目前为止互联网上能找到的关于yolo v1目标检测开源算法损失函数的最详尽的代码注释了吧!对于初学人工智能的朋友们应该有所帮助。
  • RetinaNet深入理解(损失函数详解),RetinaNet深入理解(损失函数详解)
  • 损失函数

    千次阅读 2018-10-23 10:27:22
    1. 损失函数的定义 机器学习模型关于单个样本的预测值与真实值的差称为损失。损失越小,模型越好,如果预测值与真实值相等,就是没有损失。 用于计算损失的函数称为损失函数。模型每一次预测的好坏用损失函数来...

    1. 损失函数的定义

    机器学习模型关于单个样本的预测值与真实值的差称为损失。损失越小,模型越好,如果预测值与真实值相等,就是没有损失。 
    用于计算损失的函数称为损失函数。模型每一次预测的好坏用损失函数来度量。

    2. 损失函数

    损失函数大致可分为两类:分类问题的损失函数和回归问题的损失函数。在这篇文章中,我将着重介绍回归损失。

    本文出现的代码和图表我们都妥妥保存在这儿了:

    https://nbviewer.jupyter.org/github/groverpr/Machine-Learning/blob/master/notebooks/05_Loss_Functions.ipynb

    分类、回归问题损失函数对比

    均方误差

    均方误差(MSE)是最常用的回归损失函数,计算方法是求预测值与真实值之间距离的平方和,公式如图。

    下图是MSE函数的图像,其中目标值是100,预测值的范围从-10000到10000,Y轴代表的MSE取值范围是从0到正无穷,并且在预测值为100处达到最小。

    MSE损失(Y轴)-预测值(X轴)

    平均绝对值误差(也称L1损失)

    平均绝对误差(MAE)是另一种用于回归模型的损失函数。MAE是目标值和预测值之差的绝对值之和。其只衡量了预测值误差的平均模长,而不考虑方向,取值范围也是从0到正无穷(如果考虑方向,则是残差/误差的总和——平均偏差(MBE))。

    MAE损失(Y轴)-预测值(X轴)

    MSE(L2损失)与MAE(L1损失)的比较

    简单来说,MSE计算简便,但MAE对异常点有更好的鲁棒性。下面就来介绍导致二者差异的原因。

    训练一个机器学习模型时,我们的目标就是找到损失函数达到极小值的点。当预测值等于真实值时,这两种函数都能达到最小。

    下面让我们观察MAE和RMSE(即MSE的平方根,同MAE在同一量级中)在两个例子中的计算结果。第一个例子中,预测值和真实值很接近,而且误差的方差也较小。第二个例子中,因为存在一个异常点,而导致误差非常大。

     

    左图:误差比较接近 右图:有一个误差远大于其他误差

    从图中可以知道什么?应当如何选择损失函数?

    MSE对误差取了平方(令e=真实值-预测值),因此若e>1,则MSE会进一步增大误差。如果数据中存在异常点,那么e值就会很大,而e则会远大于|e|。

    因此,相对于使用MAE计算损失,使用MSE的模型会赋予异常点更大的权重。在第二个例子中,用RMSE计算损失的模型会以牺牲了其他样本的误差为代价,朝着减小异常点误差的方向更新。然而这就会降低模型的整体性能。

    如果训练数据被异常点所污染,那么MAE损失就更好用(比如,在训练数据中存在大量错误的反例和正例标记,但是在测试集中没有这个问题)。

    直观上可以这样理解:如果我们最小化MSE来对所有的样本点只给出一个预测值,那么这个值一定是所有目标值的平均值。但如果是最小化MAE,那么这个值,则会是所有样本点目标值的中位数。众所周知,对异常值而言,中位数比均值更加鲁棒,因此MAE对于异常值也比MSE更稳定。

    然而MAE存在一个严重的问题(特别是对于神经网络):更新的梯度始终相同,也就是说,即使对于很小的损失值,梯度也很大。这样不利于模型的学习。为了解决这个缺陷,我们可以使用变化的学习率,在损失接近最小值时降低学习率。

    而MSE在这种情况下的表现就很好,即便使用固定的学习率也可以有效收敛。MSE损失的梯度随损失增大而增大,而损失趋于0时则会减小。这使得在训练结束时,使用MSE模型的结果会更精确。

     

     

    根据不同情况选择损失函数

    如果异常点代表在商业中很重要的异常情况,并且需要被检测出来,则应选用MSE损失函数。相反,如果只把异常值当作受损数据,则应选用MAE损失函数。

    推荐大家读一下这篇文章,文中比较了分别使用L1、L2损失的回归模型在有无异常值时的表现。

    文章网址:

    http://rishy.github.io/ml/2015/07/28/l1-vs-l2-loss/

    这里L1损失和L2损失只是MAE和MSE的别称。

    总而言之,处理异常点时,L1损失函数更稳定,但它的导数不连续,因此求解效率较低。L2损失函数对异常点更敏感,但通过令其导数为0,可以得到更稳定的封闭解。

    二者兼有的问题是:在某些情况下,上述两种损失函数都不能满足需求。例如,若数据中90%的样本对应的目标值为150,剩下10%在0到30之间。那么使用MAE作为损失函数的模型可能会忽视10%的异常点,而对所有样本的预测值都为150。

    这是因为模型会按中位数来预测。而使用MSE的模型则会给出很多介于0到30的预测值,因为模型会向异常点偏移。上述两种结果在许多商业场景中都是不可取的。

    这些情况下应该怎么办呢?最简单的办法是对目标变量进行变换。而另一种办法则是换一个损失函数,这就引出了下面要讲的第三种损失函数,即Huber损失函数。

    Huber损失,平滑的平均绝对误差

    Huber损失对数据中的异常点没有平方误差损失那么敏感。它在0也可微分。本质上,Huber损失是绝对误差,只是在误差很小时,就变为平方误差。误差降到多小时变为二次误差由超参数δ(delta)来控制。当Huber损失在[0-δ,0+δ]之间时,等价为MSE,而在[-∞,δ]和[δ,+∞]时为MAE。

    Huber损失(Y轴)与预测值(X轴)图示。真值取0

    这里超参数delta的选择非常重要,因为这决定了你对与异常点的定义。当残差大于delta,应当采用L1(对较大的异常值不那么敏感)来最小化,而残差小于超参数,则用L2来最小化。

    为何要使用Huber损失?

    使用MAE训练神经网络最大的一个问题就是不变的大梯度,这可能导致在使用梯度下降快要结束时,错过了最小点。而对于MSE,梯度会随着损失的减小而减小,使结果更加精确。

    在这种情况下,Huber损失就非常有用。它会由于梯度的减小而落在最小值附近。比起MSE,它对异常点更加鲁棒。因此,Huber损失结合了MSE和MAE的优点。但是,Huber损失的问题是我们可能需要不断调整超参数delta。

    Log-Cosh损失

    Log-cosh是另一种应用于回归问题中的,且比L2更平滑的的损失函数。它的计算方式是预测误差的双曲余弦的对数。

    Log-cosh损失(Y轴)与预测值(X轴)图示。真值取0

    优点:对于较小的x,log(cosh(x))近似等于(x^2)/2,对于较大的x,近似等于abs(x)-log(2)。这意味着‘logcosh’基本类似于均方误差,但不易受到异常点的影响。它具有Huber损失所有的优点,但不同于Huber损失的是,Log-cosh二阶处处可微。

    为什么需要二阶导数?许多机器学习模型如XGBoost,就是采用牛顿法来寻找最优点。而牛顿法就需要求解二阶导数(Hessian)。因此对于诸如XGBoost这类机器学习框架,损失函数的二阶可微是很有必要的。

    XgBoost中使用的目标函数。注意对一阶和二阶导数的依赖性

    但Log-cosh损失也并非完美,其仍存在某些问题。比如误差很大的话,一阶梯度和Hessian会变成定值,这就导致XGBoost出现缺少分裂点的情况。

    分位数损失

    在大多数现实世界预测问题中,我们通常希望了解预测中的不确定性。清楚预测的范围而非仅是估计点,对许多商业问题的决策很有帮助。

    当我们更关注区间预测而不仅是点预测时,分位数损失函数就很有用。使用最小二乘回归进行区间预测,基于的假设是残差(y-y_hat)是独立变量,且方差保持不变。

    一旦违背了这条假设,那么线性回归模型就不成立。但是我们也不能因此就认为使用非线性函数或基于树的模型更好,而放弃将线性回归模型作为基线方法。这时,分位数损失和分位数回归就派上用场了,因为即便对于具有变化方差或非正态分布的残差,基于分位数损失的回归也能给出合理的预测区间。

    下面让我们看一个实际的例子,以便更好地理解基于分位数损失的回归是如何对异方差数据起作用的。

    分位数回归与最小二乘回归

    左:b/wX1和Y为线性关系。具有恒定的残差方差。右:b/wX2和Y为线性关系,但Y的方差随着X2增加。(异方差)

     

    橙线表示两种情况下OLS的估值

    分位数回归。虚线表示基于0.05和0.95分位数损失函数的回归

    附上图中所示分位数回归的代码:

    https://github.com/groverpr/Machine-Learning/blob/master/notebooks/09_Quantile_Regression.ipynb

    理解分位数损失函数

    如何选取合适的分位值取决于我们对正误差和反误差的重视程度。损失函数通过分位值(γ)对高估和低估给予不同的惩罚。例如,当分位数损失函数γ=0.25时,对高估的惩罚更大,使得预测值略低于中值。

     

    γ是所需的分位数,其值介于0和1之间。

    分位数损失(Y轴)与预测值(X轴)图示。Y的真值为0

    这个损失函数也可以在神经网络或基于树的模型中计算预测区间。以下是用Sklearn实现梯度提升树回归模型的示例。

    使用分位数损失(梯度提升回归器)预测区间

    上图表明:在sklearn库的梯度提升回归中使用分位数损失可以得到90%的预测区间。其中上限为γ=0.95,下限为γ=0.05。

    对比研究

    为了证明上述所有损失函数的特点,让我们来一起看一个对比研究。首先,我们建立了一个从sinc(x)函数中采样得到的数据集,并引入了两项人为噪声:高斯噪声分量εN(0,σ2)和脉冲噪声分量ξBern(p)。

    加入脉冲噪声是为了说明模型的鲁棒效果。以下是使用不同损失函数拟合GBM回归器的结果。

     

    连续损失函数:(A)MSE损失函数;(B)MAE损失函数;(C)Huber损失函数;(D)分位数损失函数。将一个平滑的GBM拟合成有噪声的sinc(x)数据的示例:(E)原始sinc(x)函数;(F)具有MSE和MAE损失的平滑GBM;(G)具有Huber损失的平滑GBM,且δ={4,2,1};(H)具有分位数损失的平滑的GBM,且α={0.5,0.1,0.9}。

    仿真对比的一些观察结果:

    MAE损失模型的预测结果受脉冲噪声的影响较小,而MSE损失函数的预测结果受此影响略有偏移。Huber损失模型预测结果对所选超参数不敏感。分位数损失模型在合适的置信水平下能给出很好的估计。

    最后,让我们将所有损失函数都放进一张图,我们就得到了下面这张漂亮的图片!它们的区别是不是一目了然了呢~

    对数损失函数 


    对数损失函数 
    对于预测值是概率的情况,取对数损失。因为概率范围[0, 1] 所以对数值是(-∞, 0) ,为了让损失 > 0 所以取对数的负值。上面的公式里面有个负号。看图像,一目了然哈哈: 
    对数曲线

    tensorflow-深度学习之损失函数总结

    1 以回归为主:MSE-均方根误差

    2 以分类为主:SOFTMAX-交叉熵

    3 根据特定场景:自定义损失函数

    接下来我们具体来通过代码讲解每种具体的实例:

    首先我们看一下均方根误差-MSE

    import tensorflow as tf
    session = tf.InteractiveSession()

    y_ = tf.constant([1,2,3],dtype=tf.float32,shape=[3,1])
    y1 = tf.constant([1,2,3],dtype=tf.float32,shape=[3,1])
    y2 = tf.constant([3,5,5],dtype=tf.float32,shape=[3,1])

    #先求差的平方,然后再求平均
    mes = tf.reduce_mean(tf.square(y2-y_))

    # reduce_sum 使用它的目的 如果当求差的平法之后是一个向量,需要先用这个函数求和
    mes1 = tf.reduce_mean(tf.reduce_sum(tf.square(y2-y_)))

    print(session.run(mes))
    print(session.run(mes1))
    关于交叉熵有两种使用方法,一种是自定义交叉熵,一种是使用tensorflow自带的几种,接下来分别来讲解

    & 自定义交叉熵

    import tensorflow as tf
    session = tf.InteractiveSession()

    y_ = tf.constant([[1.0, 0, 0]]) # 正确标签
    y1 = tf.constant([[0.9, 0.06, 0.04]]) # 预测结果1
    y2 = tf.constant([[0.5, 0.3, 0.2]]) # 预测结果2
    # 自定义交叉熵
    cross_entropy = -tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y1, 1e-10, 1.0)))
    print('cross_entropy',cross_entropy)
    clib_by_value为了防止出现log0这种情况,还有不要忘记前面的'-',实际使用中建议使用tf自带的损失函数

    & tensorflow自带实现的交叉熵

    # -*- coding: utf-8 -*-
    import tensorflow as tf
    session = tf.InteractiveSession()

    y_ = tf.constant([[1.0, 0, 0]]) # 正确标签
    y3 = tf.constant([[10.0, 3.0, 2.0]])
    y4 = tf.constant([[5.0, 3.0, 1.0]])

    # 该操作应该施加在未经过Softmax处理的logits上,否则会产生错误结果
    # labels为期望输出,且必须采用labels=y_, logits=y的形式将参数传入
    cross_entropy_v2_1 = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y3)
    cross_entropy_v2_2 = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y4)

    print('v2_1', cross_entropy_v2_1.eval())
    print('v2_2',cross_entropy_v2_2.eval())
    我们举了其中的一个实现方法讲解,其实它提供了几大类,分别对应不同的场景实现:

    # 基于单标签多分类
    tf.nn.softmax_cross_entropy_with_logits()
    #基于单标签单分类
    tf.nn.sparse_softmax_cross_entropy_with_logits()
    #基于多标签多分类
    tf.nn.sigmoid_cross_entropy_with_logits()
    # 基于权重的损失函数
    tf.nn.weighted_cross_entropy_with_logits()
    # 基于词向量的NCE
    tf.nn.nce_loss()

    注意:前4个函数,返回的不是一个具体的数值,而是一个向量,所以如果要求交叉熵需要使用tf.reduce_sum()进行求和,如果还想求解最终的loss,需要再使用tf.reduce_mean()....

    & 自定义损失函数:这个根据业务场景可以很简单也可以很复杂,接下来我们看一个比较简单的使用场景

    # -*- coding: utf-8 -*-

    import tensorflow as tf
    from numpy.random import RandomState

    batch_size=8

    # 定义两个输入节点
    x=tf.placeholder(tf.float32,shape=(None,2),name='x-input')
    # 回归问题一般只有一个输出节点
    y_=tf.placeholder(tf.float32,shape=(None,1),name='y-input')

    # 定义一个单层的神经网络
    w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
    y=tf.matmul(x,w1)


    #自己定义损失函数
    # 如果y>y_ 取(y-y_)* 1
    # 如果y<=y_ 取(y_-y)*10
    # 根据loss结果可以自动调节这个计算方式和系数的值
    loss=tf.reduce_sum(tf.where(tf.greater(y,y_),(y-y_)*1,(y_-y)*10))

    train_step=tf.train.AdamOptimizer(0.001).minimize(loss)

    # 随机生成一个模拟数据集
    rdm=RandomState(1)
    dataset_size=128
    X=rdm.rand(dataset_size,2)
    # 设置随机噪声,范围在-0.05~0.05
    Y = [[x1+x2+rdm.rand()/10.0-0.05] for (x1,x2) in X]

    # 训练神经网路
    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)
        STEPS=5000
        for i in range(STEPS):
            start=(i*batch_size) % dataset_size
            end = min(start+batch_size,dataset_size)
            sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]})
        print(sess.run(w1))
    通过上面自定义的损失函数可以发现,最后的输出结果的参数会略大于1,而我们在定义实际的输出结果是x1+x2+随机数,参数值应该都为1。因为,我们在使用损失函数的时候,指定了当预测少的损失更大,所以预测值会比实际值要大一些。如果,我们指定损失函数的时候,指定预测多的损失更大,那么所求得的参数值将会略小于1。通过自定义损失函数,来更好的满足我们实际的模型需要,从中可以发现,损失函数对一个模型的重要性。
    --------------------- 
    作者:qq_18603599 
    来源:CSDN 
    原文:https://blog.csdn.net/qq_18603599/article/details/80595905 
    版权声明:本文为博主原创文章,转载请附上博文链接!

     

     交叉熵代价函数(Cross-entropy cost function)是用来衡量人工神经网络(ANN)的预测值与实际值的一种方式。与二次代价函数相比,它能更有效地促进ANN的训练。在介绍交叉熵代价函数之前,本文先简要介绍二次代价函数,以及其存在的不足。

    1. 二次代价函数的不足

            ANN的设计目的之一是为了使机器可以像人一样学习知识。人在学习分析新事物时,当发现自己犯的错误越大时,改正的力度就越大。比如投篮:当运动员发现自己的投篮方向离正确方向越远,那么他调整的投篮角度就应该越大,篮球就更容易投进篮筐。同理,我们希望:ANN在训练时,如果预测值与实际值的误差越大,那么在反向传播训练的过程中,各种参数调整的幅度就要更大,从而使训练更快收敛。然而,如果使用二次代价函数训练ANN,看到的实际效果是,如果误差越大,参数调整的幅度可能更小,训练更缓慢。

            以一个神经元的二类分类训练为例,进行两次实验(ANN常用的激活函数为sigmoid函数,该实验也采用该函数):输入一个相同的样本数据x=1.0(该样本对应的实际分类y=0);两次实验各自随机初始化参数,从而在各自的第一次前向传播后得到不同的输出值,形成不同的代价(误差):

    实验1:第一次输出值为0.82

    实验2:第一次输出值为0.98

            在实验1中,随机初始化参数,使得第一次输出值为0.82(该样本对应的实际值为0);经过300次迭代训练后,输出值由0.82降到0.09,逼近实际值。而在实验2中,第一次输出值为0.98,同样经过300迭代训练,输出值只降到了0.20。

            从两次实验的代价曲线中可以看出:实验1的代价随着训练次数增加而快速降低,但实验2的代价在一开始下降得非常缓慢;直观上看,初始的误差越大,收敛得越缓慢。

            其实,误差大导致训练缓慢的原因在于使用了二次代价函数。二次代价函数的公式如下:

            其中,C表示代价,x表示样本,y表示实际值,a表示输出值,n表示样本的总数。为简单起见,同样一个样本为例进行说明,此时二次代价函数为:

            目前训练ANN最有效的算法是反向传播算法。简而言之,训练ANN就是通过反向传播代价,以减少代价为导向,调整参数。参数主要有:神经元之间的连接权重w,以及每个神经元本身的偏置b。调参的方式是采用梯度下降算法(Gradient descent),沿着梯度方向调整参数大小。w和b的梯度推导如下:

            其中,z表示神经元的输入,表示激活函数。从以上公式可以看出,w和b的梯度跟激活函数的梯度成正比,激活函数的梯度越大,w和b的大小调整得越快,训练收敛得就越快。而神经网络常用的激活函数为sigmoid函数,该函数的曲线如下所示:

            如图所示,实验2的初始输出值(0.98)对应的梯度明显小于实验1的输出值(0.82),因此实验2的参数梯度下降得比实验1慢。这就是初始的代价(误差)越大,导致训练越慢的原因。与我们的期望不符,即:不能像人一样,错误越大,改正的幅度越大,从而学习得越快。

            可能有人会说,那就选择一个梯度不变化或变化不明显的激活函数不就解决问题了吗?图样图森破,那样虽然简单粗暴地解决了这个问题,但可能会引起其他更多更麻烦的问题。而且,类似sigmoid这样的函数(比如tanh函数)有很多优点,非常适合用来做激活函数,具体请自行google之。

    2. 交叉熵代价函数

            换个思路,我们不换激活函数,而是换掉二次代价函数,改用交叉熵代价函数:

            其中,x表示样本,n表示样本的总数。那么,重新计算参数w的梯度:

            其中(具体证明见附录):

            因此,w的梯度公式中原来的被消掉了;另外,该梯度公式中的表示输出值与实际值之间的误差。所以,当误差越大,梯度就越大,参数w调整得越快,训练速度也就越快。同理可得,b的梯度为:

            实际情况证明,交叉熵代价函数带来的训练效果往往比二次代价函数要好。

    3. 交叉熵代价函数是如何产生的?

            以偏置b的梯度计算为例,推导出交叉熵代价函数:

            在第1小节中,由二次代价函数推导出来的b的梯度公式为:

            为了消掉该公式中的,我们想找到一个代价函数使得:

            即:

            对两侧求积分,可得:

            而这就是前面介绍的交叉熵代价函数。

    附录:

            sigmoid函数为:

            可证:


    --------------------- 
    作者:__鸿 
    来源:CSDN 
    原文:https://blog.csdn.net/u014313009/article/details/51043064 
    版权声明:本文为博主原创文章,转载请附上博文链接!

     

    展开全文
  • 机器学习中的常见问题——损失函数
  • 损失函数主要介绍0-1损失函数、 平方损失函数、绝对值损失函数、对数损失函数、Hinge损失函数;风险函数包括期望风险、经验风险、结构风险;代价函数包括均方误差、均方根误差、平均绝对误差、交叉嫡代价函数、Huber...

    1 损失函数、代价函数和目标函数

            本部分参考自——机器学习中的目标函数、损失函数、代价函数有什么区别?

    • 损失函数(Loss Function )是定义在单个样本上的,算的是一个样本的误差。
    • 代价函数(Cost Function )是定义在整个训练集上的,是所有样本误差的平均,也就是损失函数的平均。(也被称作经验风险)
    • 目标函数(Object Function)定义为:最终需要优化的函数。等于经验风险+结构风险(也就是代价函数 + 正则化项)。代价函数最小化,降低经验风险,正则化项最小化降低。

    1.1 损失函数与代价函数

    The loss function computes the error for a single training example; the cost function is the average of the loss funcitons of the entire training set. — — Andrew NG

            根据NG的解释可以得出结论:损失函数(loss function)是单个样本的训练误差,而代价函数(cost function)是所有样本损失函数的期望。

    1.2 常见的损失函数

            损失函数是一个非负实数函数,用来量化模型预测和真实标签之间的差异。下面介绍几种常用的损失函数。

    1. 0-1 损失函数(0-1 Loss Function)
            最直观的损失函数是模型在训练集上的错误率,即0-1 损失函数:
    L ( y , f ( x ) ) = { 1 , y ≠ f ( x ) 0 , y = f ( x ) = I ( y ≠ f ( x ) ) (1-1) \begin{aligned} L(y, f(x)) &= \begin{cases} 1, & {y \neq f(x) } \\ 0, & {y = f(x)} \end{cases} \\&= I(y\not=f(x)) \end{aligned}\tag{1-1} L(y,f(x))={1,0,y=f(x)y=f(x)=I(y=f(x))(1-1)
            其中 I ( ⋅ ) I(\cdot) I()指示函数即当预测错误时,损失函数为1,当预测正确时,损失函数值为0。该损失函数不考虑预测值和真实值的误差程度。只要错误,就是1。

            虽然 0-1 损失函数能够客观地评价模型的好坏,但其缺点是数学性质不是很好:不连续且导数为0,难以优化.。因此经常用连续可微的损失函数替代。

    2. 平方损失函数(Quadratic Loss Function)
            平方损失函数经常用在预测标签 𝑦 𝑦 y 为实数值的任务中,定义为
    L ( y , f ( x ) ) = ( y − f ( x ) ) 2 (1-2) L(y, f(x)) = (y - f(x))^2 \tag{1-2} L(y,f(x))=(yf(x))2(1-2)
            是指预测值与实际值差的平方。

            平方损失函数一般不适用于分类问题。

    3. 绝对值损失函数(Absolute Loss Function)
    L ( y , f ( x ) ) = ∣ y − f ( x ) ∣ (1-3) L(y, f(x)) = | y -f(x) | \tag{1-3} L(y,f(x))=yf(x)(1-3)
            该损失函数的意义和上面差不多,只不过是取了绝对值而不是求绝对值,差距不会被平方放大。

    4. 对数损失函数(logarithmic loss function)
    L ( y , p ( y ∣ x ) ) = − log ⁡ p ( y ∣ x ) (1-4) L(y, p(y|x)) = - \log p(y|x) \tag{1-4} L(y,p(yx))=logp(yx)(1-4)
            这个损失函数就比较难理解了。事实上,该损失函数用到了极大似然估计的思想。 P ( Y ∣ X ) P(Y|X) P(YX) 通俗的解释就是:在当前模型的基础上,对于样本 X X X,其预测值为 Y Y Y,也就是预测正确的概率。由于概率之间的同时满足需要使用乘法,为了将其转化为加法,我们将其取对数。最后由于是损失函数,所以预测正确的概率越高,其损失值应该是越小,因此再加个负号取个反。

    5. Hinge损失函数(Hinge Loss Function)
            Hinge loss一般分类算法中的损失函数,尤其是SVM,其定义为:
    L ( w , b ) = m a x { 0 , 1 − y f ( x ) } (1-5) L(w,b) = max \{0, 1-yf(x) \} \tag{1-5} L(w,b)=max{0,1yf(x)}(1-5)

            其中 y = + 1 y=+1 y=+1 y = − 1 y=−1 y=1 f ( x ) = w x + b f(x)=wx+b f(x)=wx+b,当为SVM的线性核时。

            了解更多,请阅读:机器学习中的损失函数 (着重比较:hinge loss vs softmax loss)损失函数 、代价函数、目标函数


    2 风险函数

            这部分内容参考自——西伯尔——机器学习,评估——风险函数Traco——经验风险VS风险函数

    2.1 定义

            风险函数(risk function)= 期望风险(Expected Risk)= 期望损失(Expected Loss),可以认为是平均意义下的损失。

            风险函数有两种,不考虑正则项的是经验风险(Empirical Risk),考虑过拟合问题,加上正则项的是结构风险(Structural Risk)。

            监督学习的两种基本策略:经验风险最小化(ERM)和结构风险最小化(SRM)。

            这样,监督学习问题就变成了经验风险或结构风险函数的最优化问题,即经验或结构风险函数是最优化的目标函数。

    2.2 三种风险的关系

            期望风险是理想,是白月光,是可望不可求的,只能用经验风险去近似,而结构风险是经验风险的升级版。

            为什么可以用经验风险估计期望风险呢?

            根据大数定律,当样本容量 N N N 趋于无穷时,经验风险 R e m p ( f ) R_{emp}(f) Remp(f) 趋于期望风险 R e x p ( f ) R_{exp}(f) Rexp(f)。所以一个很自然的想法是用经验风险估计期望风险,即局部最优代替全局最优。

            但是,由于现实中的训练样本数目有限,甚至很小,所以用经验风险估计期望风险常常并不理想,要对经验风险进行一定的矫正。这就关系到监督学习的两个基本策略:经验风险最小化和结构风险最小化。

    1. 期望风险(Expected Risk)【全局,理想】

            期望风险对所有样本预测错误程度的均值,基于所有样本点损失函数最小化。期望风险是全局最优,是理想化的不可求的。

            期望风险、期望损失、风险函数三者是等价的,也就是损失 L ( Y , f ( X ) ) L(Y,f(X)) L(Y,f(X)) 的数学期望,在理论上,可以代入期望公式 E X = ∑ x i ⋅ P i = ∫ x ⋅ f ( x ) d x EX=\sum x_i\cdot P_i=\int x\cdot f(x)dx EX=xiPi=xf(x)dx,也就是
    R e x p = E p [ L ( Y , f ( X ) ] = ∬ L ( y , f ( x ) ) ⋅ f ( x , y ) d x d y (2-1) R_{exp} = E_p[L(Y, f(X)] = \iint L(y, f(x))\cdot f(x, y) dxdy\tag{2-1} Rexp=Ep[L(Y,f(X)]=L(y,f(x))f(x,y)dxdy(2-1)
            但是由于联合概率密度函数 f ( x , y ) f(x,y) f(x,y) 不知道,所以此路不通,只能另寻他路,也就是根据经验找近似。

    2. 经验风险(Empirical Risk)【局部,现实】

            经验风险(Empirical Risk)也称为经验错误(Empirical Error),损失函数度量了单个样本的预测结果,要想衡量整个训练集的预测值与真实值的差异,将整个训练集所有记录均进行一次预测,求取损失函数,将所有值累加,即为经验风险。经验风险是局部最优,是现实的可求的。

            就是已知的数据按照现有的模型,测试预测值和真实值偏离的程度叫经验风险。

            经验风险越小说明模型 f ( x ) f(x) f(x) 对训练集的拟合程度越好。

            经验风险 = 经验损失 = 代价函数

            给定一个数据集,模型 f ( x ) f(x) f(x) 关于训练集的平均损失被称为经验风险(empirical risk)或经验损失(empirical loss)。
    R e m p ( f ) = 1 N 1 N ∑ i = 1 N L ( y i , f ( x i ) ) (2-2) R_{emp}(f) = \frac{1}{N}\frac{1}{N}\sum_{i=1}^{N}L(y_i, f(x_i)) \tag{2-2} Remp(f)=N1N1i=1NL(yi,f(xi))(2-2)
            这个公式的用意很明显,就是模型关于训练集的平均损失(每个样本的损失加起来,然后平均一下)。在实际中用的时候,我们也就很自然的这么用了。

    3. 结构风险(Structural Risk)
            结构风险,就是在经验风险上加上一个正则化项(regularizer)或者叫做罚项(penalty term),即
    R s r m ( f ) = 1 N 1 N ∑ i = 1 N L ( y i , f ( x i ) ) + λ J ( f ) (2-3) R_{srm}(f) = \frac{1}{N}\frac{1}{N}\sum_{i=1}^{N}L(y_i, f(x_i)) + \lambda J(f) \tag{2-3} Rsrm(f)=N1N1i=1NL(yi,f(xi))+λJ(f)(2-3)

    经验风险 vs 期望风险∶

    • 期望风险是模型对全局(所有数据集)的效果;经验风险是模型对局部(训练集)的效果
    • 期望风险往往无法计算,即联合分布 f ( X , Y ) f(X, Y) f(X,Y) 通常是未知的;而经验风险可以计算
    • 当训练集足够大时,经验风险可以替代期望风险,即局部最优代替全局最优

    2.3 经验风险最小化和结构风险最小化

    1. 经验风险最小化&结构风险最小化
            经验风险最小化(empirical risk minimization,ERM),就是认为经验风险最小的模型是最优的模型,用公式表示:
    min ⁡ f ∈ F 1 N ∑ i = 1 N L ( y i , f ( x i ) ) (2-4) \min_{f\in\mathcal{F}}\frac{1}{N}\sum_{i=1}^{N}L(y_i, f(x_i)) \tag{2-4} fFminN1i=1NL(yi,f(xi))(2-4)

            这个理论很符合人的直观理解。因为在训练集上面的经验风险最小,也就是平均损失越小,意味着模型得到结果和“真实值”尽可能接近,表明模型越好。
            当样本容量不大的时候,经验风险最小化模型容易产生“过拟合”的问题。为了“减缓”过拟合问题,就提出了结构风险最小的理论。

            结构风险最小化(structural risk minimization,SRM),就是认为,结构风险最小的模型是最优模型,公式表示
    min ⁡ f ∈ F 1 N ∑ i = 1 N L ( y i , f ( x i ) ) + λ J ( f ) (2-5) \min_{f\in\mathcal{F}}\frac{1}{N}\sum_{i=1}^{N}L(y_i, f(x_i)) + \lambda J(f) \tag{2-5} fFminN1i=1NL(yi,f(xi))+λJ(f)(2-5)

    2. 经验风险最小化的例子:极大似然估计(maximum likelihood estimation)

    • 模型——条件概率分布;
    • 损失函数——对数损失函数;
    • 经验风险最小化等价于极大似然估计。

    3. 结构风险最小化的例子:贝叶斯最大后验概率估计

    • 模型——条件概率分布;
    • 损失函数——对数损失函数;
    • 模型复杂度——由先验概率表示;
    • 结构风险=经验风险+正则项=后验概率+先验概率;
    • 先验概率不变,结构风险最小化,等价于最大后验概率估计。

    结构风险 vs 经验风险︰

    • 经验风险越小,模型决策函数越复杂,其包含的参数越多
    • 当经验风险函数小到一定程度就出现了过拟合现象
    • 防止过拟合现象的方式,就要降低决策函数的复杂度,让惩罚项 J ( f ) J(f) J(f) 最小化
    • 需要同时保证经验风险函数和模型决策函数的复杂度都达到最小化
    • 把两个式子融合成一个式子得到结构风险函数然后对这个结构风险函数进行最小化

    2.4 风险函数与对数损失函数


    3 常用的代价函数

            这部分内容参考自——【机器学习】代价函数(cost function)

    3.1.1 均方误差(Mean Squared Error)

    M S E = 1 N ∑ i = 1 N ( y i − y ^ ) 2 (2-6) MSE={\frac{1}{N}{\sum_{i=1}^N(y_i-\widehat{y})^2} } \tag{2-6} MSE=N1i=1N(yiy )2(2-6)

            均方误差是指参数估计值与参数真值之差平方的期望值; MSE可以评价数据的变化程度,MSE的值越小,说明预测模型描述实验数据具有更好的精确度。( i i i 表示第 i i i 个样本, N N N 表示样本总数)
    通常用来做回归问题的代价函数。

    3.1.2 均方根误差(RMSE)

    R M S E = M S E RMSE=\sqrt{MSE} RMSE=MSE
            均方根误差是均方误差的算术平方根,能够直观观测预测值与实际值的离散程度。
    通常用来作为回归算法的性能指标。

    3.1.3 平均绝对误差(Mean Absolute Error)

    M A E = ∑ i = 1 n ∣ y i − y ^ ∣ n (2-7) MAE={{\sum_{i=1}^n|y_i-\widehat{y}|} \over n}\tag{2-7} MAE=ni=1nyiy (2-7)

            平均绝对误差是绝对误差的平均值 ,平均绝对误差能更好地反映预测值误差的实际情况。
            MSE误差函数对噪声点比较敏感,因为噪声的误差一般比较大,经过平方后放大的倍数会影响模型的效果,此时可以选择对噪声不是非常敏感的’MAE’损失函数。

    3.1.4 交叉熵代价函数(Cross Entry)

    H ( p , q ) = − ∑ i = 1 N p ( x ( i ) ) log ⁡ q ( x ( − i ) ) (2-8) H(p,q) = - \sum_{i=1}^{N} p(x^{(i)}) \log {q(x^{(-i)})} \tag{2-8} H(p,q)=i=1Np(x(i))logq(x(i))(2-8)

            交叉熵是用来评估当前训练得到的概率分布与真实分布的差异情况,减少交叉熵损失就是在提高模型的预测准确率。其中 p ( x ) p(x) p(x) 是指真实分布的概率, q ( x ) q(x) q(x) 是模型通过数据计算出来的概率估计。通常用做分类问题的代价函数。对于二分类模型的交叉熵代价函数(可参考下一小节——逻辑回归)。

    3.1.5 Huber损失函数

    L δ ( y , y ^ ) = { 1 2 ( y − y ^ ) 2 ∣ y − y ^ ∣ ≤ δ δ ∣ y − y ^ ∣ − 1 2 δ 2 o t h e r w i s e (2-9) L_\delta(y,\widehat{y})=\begin{cases} {1\over2}(y-\widehat{y})^2 & |y-\widehat{y}|\le \delta \\ \delta|y-\widehat{y}|-{1 \over2}\delta^2 & otherwise \end{cases}\tag{2-9} Lδ(y,y )={21(yy )2δyy 21δ2yy δotherwise(2-9)

    • δ \delta δ 是超参数,可调
    • δ \delta δ 接近于0时,Huber loss接近MAE δ \delta δ 接近于
    • ∞ \infty 时,Huber loss接近MSE

    3.1.6 Log-Cosh Loss

    L ( y , y ^ ) = ∑ i = 1 n l o g ( c o s h ( y − y ^ ) ) (2-10) L(y,\widehat{y})=\sum_{i=1}^nlog(cosh(y-\widehat{y})) \tag{2-10} L(y,y )=i=1nlog(cosh(yy ))(2-10)

    3.1.7 分位数损失函数

            基于Quantile回归的目的是,在给定预测变量的某些值时,估计因变量的条件“分位数”。Quantile Loss实际上只是MAE的扩展形式(当分位数是第50个百分位时,Quantile Loss退化为MAE)。

    3.2 各常见代价函数的优缺点

    • 使用平方误差更容易求解, 但使用绝对误差对离群点更加鲁棒;
    • 当数据存在离群点时,以MSE为损失的模型会赋予更高的权重给离群点;
    • MAE损失适用于训练数据被离群点损坏的时候(即,在训练数据而非测试数据中,我们错误地获得了不切实际的过大正值或负值);
    • 对所有的观测数据,如果我们只给一个预测结果来最小化MSE,那么该预测值应该是所有目标值的均值。但是如果我们试图最小化MAE,那么这个预测就是所有目标值的中位数。我们知道中位数对于离群点比平均值更鲁棒,这使得MAEMSE更加鲁棒;
    • 使用MAE损失(特别是对于神经网络)的一个大问题是它的梯度始终是相同的,这意味着即使对于小的损失值,其梯度也是大的。这对模型的学习可不好。为了解决这个问题,我们可以使用随着接近最小值而减小的动态学习率。MSE在这种情况下的表现很好, 即使采用固定的学习率也会收敛。 MSE损失的梯度在损失值较高时会比较大, 随着损失接近0时而下降,从而使其在训练结束时更加精确。
    • 如果离群点是会影响业务、而且是应该被检测到的异常值,那么我们应该使用MSE。如果我们认为离群点仅仅代表数据损坏,那么我们应该选择MAE作为损失。
    • L1损失对异常值更加稳健,但其导数并不连续,因此求解效率很低。L2损失对异常值敏感,但给出了更稳定的闭式解(closed form solution)(通过将其导数设置为0);
    • 两种损失函数的问题:可能会出现这样的情况,即任何一种损失函数都不能给出理想的预测。例如,如果我们数据中90%的观测数据的真实目标值是150,其余10%的真实目标值在0-30之间。那么,一个以MAE为损失的模型可能对所有观测数据都预测为150,而忽略10%的离群情况,因为它会尝试去接近中值。同样地,以MSE为损失的模型会给出许多范围在0到30的预测,因为它被离群点弄糊涂了。这两种结果在许多业务中都是不可取的。
    • Huber Loss对数据离群点的敏感度低于平方误差损失。它在0处也可导。基本上它是绝对误差,当误差很小时,误差是二次形式的。误差何时需要变成二次形式取决于一个超参数,该超参数可以进行微调。 δ \delta δ 的选择非常重要,因为它决定了你认为什么数据是离群点。
    • 使用MAE训练神经网络的一个大问题是经常会遇到很大的梯度,使用梯度下降时可能导致训练结束时错过最小值。对于MSE,梯度会随着损失接近最小值而降低,从而使其更加精确。在这种情况下,Huber Loss可能会非常有用,因为它会使最小值附近弯曲,从而降低梯度。另外它比MSE对异常值更鲁棒。因此,它结合了MSEMAE的优良特性。但是,Huber Loss的问题是我们可能需要迭代地训练超参数 δ \delta δ
    • 优点:log(cosh(x))对于小的 x x x 来说,其大约等于 ( x ∗ ∗ 2 ) / 2 (x**2)/2 (x2)/2,而对于大的 x x x 来说,其大约等于 a b s ( x ) − l o g ( 2 ) abs(x) - log(2) abs(x)log(2)。这意味着log(cosh(x))的作用大部分与均方误差一样,但不会受到偶尔出现的极端不正确预测的强烈影响。它具有Huber Loss的所有优点,和Huber Loss不同之处在于,其处处二次可导。

    4 各种算法的损失函数

            这部分内容参考自——机器学习-损失函数课程总结04 - 损失函数、代价函数与目标函数 的整理。

    4.1 逻辑回归模型

            虽然名字里包含“回归”,但是实际上却是一种分类学习方法。
    优点:

    1. 直接对分类可能性进行建模,无需事先假设数据分布,避免了假设分布不准确的问题;
    2. 不是仅预测出“类别”,而是得到近似概率预测,对于需要利用概率辅助预测的任务很有用;
    3. 对率函数任意阶可到的凸函数,很多数值化优化算法都可以直接用于求解最优解。

    4.1.1 代价函数

    4.1.2 模型参数求解

            模型参数的求解方法之一:采用最大似然估计的对数形式(对数是单调函数,求解参数的最大值,函数的对数和函数求出的最大值是一样的)构建函数,再利用梯度下降来求解:

    4.1.3 逻辑回归多分类模型

    4.2 决策树

    4.2.1 决策树-整体损失函数

    4.2.2 CART二叉树-最小二乘回归树

    4.3 朴素贝叶斯

    4.3.1 朴素贝叶斯代价函数

    4.3.2 朴素贝叶斯参数估计-极大似然估计

    4.4 KNN损失函数

    4.5 SVM损失函数-hinge损失

    4.6 提升方法损失函数

    4.6.1 Adaboost

    4.6.2 GBDT-梯度提升树模型


            以上就是对机器学习中损失函数、风险函数、代价函数、目标函数的整理,由于水平有限,可能部分地方有误,欢迎大家指出,后续也会随着学习继续完善,祝学习愉快!


    参考

    展开全文
  • 目录0. 前言1.损失函数(Loss Function)1.1 损失项1.2 正则化项2....今天在学习cs231n的时候看到了关于交叉熵损失函数的讲解,发现之前虽然经常用到这个损失函数,但却对里面的细节很模糊,学完之后更清晰了一

    0. 前言

    有段时间没写博客了,前段时间主要是在精读一些计算机视觉的论文(比如yolov1),以及学cs231n这门AI和计算机视觉领域的经典课程。我发现很多事情不能着急,质变需要量变的积累,违背事物发展的客观规律,往往适得其反。

    今天在学习cs231n的时候看到了关于交叉熵损失函数的讲解,发现之前虽然经常用到这个损失函数,但却对里面的细节很模糊,学完之后更清晰了一些,所以做个总结笔记,方便以后快速回顾。学习就是不断重复的过程。

    1.损失函数(Loss Function)

    损失函数作用是:衡量真实值和模型预测值之间的差异

    为什么要有损失函数呢?

    以分类任务为例,在神经网络中,模型前向传播求出每一类别的得分(score),然后将score带入损失函数中,求出Loss。再使用梯度下降法,反向传播,通过降低损失值(Loss)对模型的参数进行优化。

    损失函数通常由损失项正则化项组成。

    1.1 损失项

    损失项的目的就是之前说的,为了衡量真实值和模型预测值之间的差异

    1.2 正则化项

    正则化项的目的是对高次项的特征进行惩罚,减轻过拟合的程度,进而可以提高模型的泛化能力。

    常用的正则化有L1正则化和L2正则化。假如现在要训练一个线性模型,y = Wx + b,其中W就是我们要训练的参数(由w1,w2,…wn n个参数组成),b是偏置项。

    则L1正则化就是

    在这里插入图片描述

    L2正则化为:

    在这里插入图片描述

    2. 交叉熵损失函数

    交叉熵损失函数是多分类问题中很常用的损失函数,而交叉熵损失函数又离不开softmax函数。因为在多分类问题中,神经网络最后一层全连接层的原始输出只是每一类的得分(score)向量。比如以MINIST手写数字识别为例,我们构建的神经网络的最后一层肯定只有10个神经元(每个神经元输出0-9数字的得分)。

    注意,这里10个神经元输出的只是得分,而非该图片属于该数字的概率。那要输出概率该怎么办呢?这就要用到sofrmax处理了。

    2.1 softmax

    softmax函数定义为:

    在这里插入图片描述

    比如对于一个猫cat,狗dog,马horse的三分类问题,我们的神经网络最后一层给出每类得分为[10,9, 8],那softmax应该这么求:

    在这里插入图片描述

    表示的含义是:模型推测该图片是猫的概率为67%,狗的概率为24%,马的概率为9%

    用ex求出的值恒为正,可以表示概率。

    在这里插入图片描述
    另外,从上面的例子也可以看出softmax可以把得分差距拉的更大:最后的全链接层得分输出为:[10,9,8],相差其实不大。而经过softmax之后输出为:[0.67,0.24,0.09],相对而言差距更大了。

    2.2 交叉熵

    终于说到交叉熵了,前面说了,交叉熵损失函数离不开softmax,应该先经过softmax求出每类的概率,再求交叉熵,可是为什么要这样呢?

    这得从信息论中交叉熵的定义说起。交叉熵H(p,q)的定义为:

    在这里插入图片描述
    注意,这里的log是以e为底的!

    其中p为真实概率分布,而q为预测的概率分布。既然是概率,那肯定得满足:每个值在0-1之间,且所有值的和为1。

    说到这里,我们再拐回去看softmax函数的定义:

    在这里插入图片描述

    可以经过softmax层后的输出的每个值在0-1之间,且所有值的和为1。

    这就是为什么在交叉熵损失函数中需要先进行softmax处理了,因为这是交叉熵本身的定义决定的(输入必须为概率)。

    再来看交叉熵损失函数:
    在这里插入图片描述
    在机器学习中,真实概率分布p(xi)就是训练集的标签,预测的概率分布q(xi)就是我们模型预测的结果。再以刚刚的猫、狗、马三分类为例,我们提供一张猫的照片,则真实概率分布p(xi)的向量为[1, 0, 0],而我们模型预测的概率分布q(xi)的向量为:[0.67, 0.24, 0.09]。

    则对于该预测结果的交叉熵损失函数为:

    在这里插入图片描述

    -log(x)函数

    在这里插入图片描述
    因为是-log(q(x)),而q(x)是概率,在0-1之间,所以我们只看0-1之间的函数样子。

    不难看出:

    (1)当预测结果正确时,该正确类别的概率越大(q(x)越接近1),交叉熵损失函数越小。

    (2)当预测结果正确,但正确类别的概率不够大时(q(x)较小),交叉熵损失函数较大。

    (3)当预测结果错误时,交叉熵损失函数也很大。

    END:)

    参考

    交叉熵损失函数原理详解

    展开全文
  • 常见损失函数综述及区别

    千次阅读 2022-03-23 17:04:57
    损失函数和风险函数 首先引入损失函数与风险函数的概念。损失函数度量模型一次预测的好坏,风险函数度量平均意义下模型预测的好坏。 监督学习问题是在假设空间F\Bbb FF中选取模型fff作为决策函数,对于给定的输入XXX...
  • 常用的损失函数

    千次阅读 2022-04-19 19:41:06
    pytorch的源码:torch.nn — ...一、回归损失函数 1.1 MSE[均方误差Mean Square Error,二次损失Quadratic Loss,L2损失L2 Loss] 1.2 MAE[平均绝对误差Mean Absolute Error,L1损失L1 Loss] 1.3 Huber Loss...
  • 损失函数简介

    千次阅读 2022-02-25 08:29:36
    损失函数的作用:衡量模型预测的好坏。 简单来说就是,损失函数就是用来表现预测与真实数据的差距程度。 令 真实值 为Y,预测值为 f(x),损失函数为L( Y , f(x)),关系如下: 损失函数(loss funtion)是...
  • 阅读大概需要7分钟跟随小博主,每天进步一丢丢机器学习算法与自然语言处理出品@公众号原创专栏作者yyHaker单位 |哈工大SCIR实验室损失函数用来评价模型的预测值和真实值不一样的程度,损失函数越好,通常模型的性能...
  • 【深度学习理论】(1) 损失函数

    千次阅读 2022-03-13 17:57:54
    构造损失函数之后,我们的目标就是将损失函数的值最小化,使用梯度下降的方法求得损失函数对于每个权重的偏导数。 损失函数公式如下,f 代表一张图像属于每个类别的分数;yi 代表真实的标签;Li
  • 损失函数整理(分类和回归)

    千次阅读 2021-03-18 16:35:09
    0-1损失函数(zero-one loss)、绝对值损失、指数损失、Hinge 损失、感知损失、交叉熵损失(CE)、权重交叉熵损失(WCE)、Focal Loss 均方差、平均绝对误差、Huber Loss(Smooth L1 Loss)、分位数回归损失、IoU ...
  • 在深度学习领域中,损失函数定义了模型的预测与目标值之间的距离。因此我们必须正确地选择它,只有这样所有的参数才会根据其值进行更新。损失函数的选择取决于模型的设计。 在这篇文章中,我们主要讨论两种常见的的...
  • 损失函数设计

    千次阅读 2020-05-27 15:14:06
    1.常见损失函数 1.1 平方损失函数 1.2 绝对值损失函数 1.3 Huber损失函数 1.4 Hinge损失函数 1.5 交叉熵损失函数 1.6 指数损失函数 2.不对称损失函数设计 3.面向容错的损失函数设计 4.评测指标不可导时的...
  • Pyotorch自定义损失函数

    千次阅读 2022-02-28 20:42:01
    本篇包含深度学习损失函数总结及如何使用Pytorch自定义损失函数(Loss Function),使用torch.Tensor提供的接口实现:继承nn.Module类在__init__函数中定义所需要的超参数,在foward函数中定义loss的计算方法。
  • 平方损失函数与交叉熵损失函数

    万次阅读 2018-05-07 15:21:43
    对于机器学习中常见的损失函数有:平方损失函数与交叉熵损失函数。在本文中将讲述两者含义与响应的运用区别。 2. 平方损失函数 平方损失函数较为容易理解,它直接测量机器学习模型的输出与实际结果之间的距离。...
  • 语义分割损失函数总结

    千次阅读 多人点赞 2020-12-15 21:07:44
    图像分割中最常用的损失函数是逐像素交叉熵损失。该损失函数分别检查每个像素,将类预测(softmax or sigmoid)与目标向量(one hot)进行比较。 1.1 理论指导 二分类: 二分类最终模型采用sigmoid激活函数,最后一层...
  • 前言: 本专栏在保证内容完整性的基础上,力求简洁,旨在让初学...损失函数包括两种: 一种是默认的内置损失函数,可以直接调用的,适合初学者; 还有一种,就是自定义损失函数,需要自行构建,这是进阶者必须掌握的。
  • 【深度学习】激活函数和损失函数

    千次阅读 2022-03-26 08:37:14
    4.3 激活函数 作用: 当神经网络中上一层的输出直接作为下一层的输入时,每层之间的关系是线性关系,即相当于f(x)=x,此时神经网络的拟合能力较弱。为了使得神经网络有更好的拟合能力,在每一层网络之间加入了激活...
  • 机器学习中,我们需要一定的准则来评估不同机器学习模型的好坏,这里引入损失函数与风险函数的概念。 损失函数:评估模型单次预测的好坏 风险函数:度量平均意义下模型的好坏 损失函数与风险函数 损失函数的定义 ...
  • 史上最全交叉熵损失函数详解

    千次阅读 多人点赞 2022-01-02 09:57:10
    在我们自学神经网络神经网络的损失函数的时候会发现有一个思路就是交叉熵损失函数,交叉熵的概念源于信息论,一般用来求目标与预测值之间的差距。比如说我们在人脑中有一个模型,在神经网络中还有一个模型,我们需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 304,842
精华内容 121,936
关键字:

损失函数