点击上方,选择星标或置顶,每天给你送干货!
阅读大概需要23分钟
跟随小博主,每天进步一丢丢
来自:AI蜗牛车
前言
对于一个深度学习的训练过程,可以将它描述为让网络输出值和实际值越来越接近的过程。我们通过训练优化器来完成这个过程,还需要一个评估函数来为我们的优化器指明方向。这个评估函数用来估量模型的预测值和真实值的不一致程度,也就是所谓的损失函数。Loss函数有很多,并且在很多的深度学习任务中,有时候是需要我们自行去根据任务相关来设计Loss函数的。
1. 回归任务中的损失函数
1.1 MAE loss(L1)
L1 Loss 是一个衡量输入x(模型预测输出)和目标y之间差的绝对值的平均值,也叫MAE Loss。由于L1 Loss 具有稀疏性,为了惩罚较大的值,因此常常将其作为正则项添加到其他Loss中作为约束。L1 Loss的最大问题是梯度在0点不平滑,导致会跳过极小值。在Pytorch中,L1 Loss的实例化类为:
class torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')
其中N为一个batch的样本数,参数reduction控制batch的loss取每个样本L1 loss的均值还是总和,缺省为mean。
1.2 MSE loss(L2)
L2 Loss是输入x(模型预测输出)和目标y之间均方误差,所以也叫做MSE Loss:同样,L2 Loss也常常作为正则项。当y和f(x)也就是真实值和预测值的差值大于1时,会放大误差;而当差值小于1时,则会缩小误差,这是平方运算决定的。MSE对于较大的误差(>1)给予较大的惩罚,较小的误差(<1)给予较小的惩罚。也就是说,对离群点比较敏感,受其影响较大。如果样本中存在离群点,MSE会给离群点更高的权重,这就会牺牲其他正常点数据的预测效果,最终降低整体的模型性能。在Pytorch中,L2 Loss的实例化类为:
class torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')
同样,N为一个batch的样本数,参数reduction控制batch的loss取每个样本L2 loss的均值还是总和,缺省为mean。
1.3 选MSE还是MAE?
L1 Loss作为损失函数更稳定,并且对离群值不敏感,而且 L1 Loss 在0处不可导,大部分情况下梯度都是相等的,这意味着即使对于小的损失值,其梯度也是大的。这不利于函数的收敛和模型的学习。另外,在深度学习中,收敛较慢。
L2 Loss导数求解速度高,但是其对离群值敏感,不过可以将离群值的导数设为0(导数值大于某个阈值)来避免这种情况。
在实际的应用中,这两种损失函数的选择要视情况而定:从计算机求解梯度的复杂度来说,MSE 要优于 MAE,而且梯度也是动态变化的,能较快准确达到收敛。但是从离群点角度来看,如果离群点是实际数据或重要数据,而且是应该被检测到的异常值,那么我们应该使用MSE。另一方面,离群点仅仅代表数据损坏或者错误采样,无须给予过多关注,那么我们应该选择MAE作为损失。
1.4 Huber loss 和 Smooth L1 loss
Huber loss结合了MSE和MAE,定义如下:Huber Loss 包含了一个超参数 δ。δ 值的大小决定了 Huber Loss 对 MSE 和 MAE 的侧重性,当 |y−f(x)| ≤ δ 时,变为 MSE;当 |y−f(x)| > δ 时,则变成类似于 MAE,因此 Huber Loss 同时具备了 MSE 和 MAE 的优点,减小了对离群点的敏感度问题,实现了处处可导的功能。Smooth L1 loss就是Huber loss的参数δ取值为1时的形式。在Faster R-CNN以及SSD中对边框的回归使用的损失函数都是Smooth L1 loss。Smooth L1 Loss 能从两个方面限制梯度:
1.当预测框与 ground truth 差别过大时,梯度值不至于过大
2.当预测框与 ground truth 差别很小时,梯度值足够小
从上面可以看出,Smooth L1 loss函数实际上就是一个分段函数,在[-1,1]之间实际上就是L2损失,这样解决了L1的不光滑问题,在[-1,1]区间外,实际上就是L1损失,这样就解决了离群点梯度爆炸的问题。
在Pytorch中,Smooth L1 Loss的实例化类为:
class torch.nn.SmoothL1Loss(size_average=None, reduce=None, reduction='mean')
2. 分类任务中的损失函数
2.1 交叉熵损失
2.1.1 什么是交叉熵损失?(举例)
在一个多分类任务中,交叉熵损失函数是非常常见的,其定义如下:其中:
[ ] ——类别的数量;
[ ] ——指示变量(0或1),如果该类别和样本的类别相同就是1,否则是0;
[ ] ——对于观测样本属于类别 [c] 的预测概率。
交叉熵,实际上就是真实标签和预测标签两个分布的交叉熵。举个例子: 假设一个5分类问题,然后一个样本I的标签 =[0,0,0,1,0],也就是说样本I的真实标签是4:
假设模型预测的结果概率 =[0.1,0.15,0.05,0.6,0.1],可以看出这个预测是对的,也就是类别4,那么对应的损失值为 。
假设 =[0.15,0.2,0.4,0.1,0.15],这个预测结果就很离谱了,因为真实标签是4,而你觉得这个样本是4的概率只有0.1(远不如其他概率高,如果是在测试阶段,那么模型就会预测该样本属于类别3),对应损失值L=-log(0.1)。
假设 =[0.05,0.15,0.4,0.3,0.1],这个预测结果虽然也错了,但是没有前面那个那么离谱,对应的损失L=-log(0.3)。根据log函数的性质,有-log(0.6) < -log(0.3) < -log(0.1)。可以看出预测错比预测对的损失要大,预测错得离谱比预测错得轻微的损失要大。
2.1.2 softmax loss
对于网络层中常用的softmax loss,其实,在交叉熵损失的公式里面,如果预测概率 是由softmax函数(softmax函数输出向量为样本在N个类别中,属于每个类别的概率)得到的。那么此时的softmax loss就是交叉熵loss。
2.1.3 Pytorch中的二分类交叉熵损失
在Pytorch中,交叉熵 Loss有几个函数,其中,二分类的交叉熵为:
1. class torch.nn.BCELoss(weight=None, size_average=None, reduce=None, reduction='mean')
2. class torch.nn.BCEWithLogitsLoss(weight=None, size_average=None, reduce=None, reduction='mean', pos_weight=None)
对于BCELoss,由于二分类样本的输出只有两维,所以有:其中参数reduction表示一个batch样本loss的统计方式,默认为均值统计。API提供权重参数weight来调整loss值,weight是和分类维度一样的tensor,一般weight默认即可。
BCEWithLogitsLoss相当于在BCELoss的基础上加了sigmoid层:这样做的好处是可以使用一个tricks:log_sum_exp ,使得数值结果更加稳定,实际任务时,二分类交叉熵损失建议使用BCEWithLogitsLoss。
2.1.4 Pytorch中的多分类交叉熵损失
多分类任务的交叉熵loss为:
class torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')
Pytorch的CrossEntropyLoss实际上做了这么几件事情:
1.计算了一层softmax:
softmax函数会返回样本分类成每一个类别的概率分数,值在0~1之间。
2.将Softmax之后的结果取log,将乘法改成加法减少计算量,同时保障函数的单调性 .
3.上面的输出与Label对应的那个值拿出来,乘以权重weight(用于数据样本分布不均衡的调整),去掉负号,再求均值(reduction缺省为mean)。
Pytorch中也提供了两个函数:
1. class torch.nn.LogSoftmax(dim=None)
2. class torch.nn.NLLLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')
而nn.CrossEntropyLoss的作用就相当于nn.LogSoftmax + nn.NLLLoss。
nn.LogSoftmax完成上面的步骤1-2:
nn.NLLLoss完成上面的步骤3(取出label对应的值):
这里一个需要注意的点是nn.CrossEntropyLoss已经做了一次softmax,所以它的input在之前不需要再在网络中添加一个softmax层了。
2.2 铰链损失(Hinge loss)
铰链损失的出名应用是作为SVM的损失函数,其名字来自于Hinge loss的图像:其中, 是预测值,为一概率分数, 是标签值。与0-1损失相比,Hinge loss的图像如下:同样对于多分类问题,Pytorch提供如下函数表示多分类hinge loss:
class torch.nn.MultiMarginLoss(p=1, margin=1.0, weight=None, size_average=None, reduce=None, reduction='mean')
其中次数p一般缺省为1。
weight为根据样本类别分布而设置的权重,可选择性设置。margin为hinge的阈值,就像图像表示的函数,1也是margin值。 为该样本错误预测的得分, 为正确预测的得分。两者的差值可用来表示两种预测结果的相似关系,margin是一个由自己指定的安全系数。
我们希望正确预测的得分高于错误预测的得分,且高出一个边界值 margin,换句话说, 越高越好, 越低越好,( – )越大越好,( – )越小越好,但二者得分之差最多为margin就足够了,差距更大并不会有任何奖励。这样设计的目的在于,对单个样本正确分类只要有margin的把握就足够了,更大的把握则不必要,过分注重单个样本的分类效果反而有可能使整体的分类效果变坏。分类器应该更加专注于整体的分类误差。
2.3 KL散度
KL散度也被称为相对熵,常被用于生成模型,比如GAN。在信息论中,关于熵有如下表述:
熵:可以表示一个事件P包含多少信息。
KL散度:可以表述事件P和事件P的拟合事件Q有多大不同
交叉熵:可以表述从事件P的角度如何去描述P的拟合事件Q。
前面说到的交叉熵,便是表达了预测事件和真实事件的相关程度,同样,KL散度也同样能描述两个时间分布的关系,并作为损失函数使用。上面公式是描述连续型事件分布的KL散度公式,不难发现,第一项便是之前说到的交叉熵的连续型,而后一项则是熵本身的定义,反映了事件P的信息量大小,所以,对于真实事件P和预测事件Q,熵,相对熵(KL散度),交叉熵有如下关系:*** P与Q的交叉熵 = P与Q的KL散度 - P的熵*** Pytorch中提供KLDivLoss函数来表述离散型KL散度损失:
class torch.nn.KLDivLoss(size_average=None, reduce=None, reduction='mean')
对于一个N个样本的batch,KL散度损失做如下计算:参数reduction控制batch的loss取每个样本loss的均值还是总和,缺省为mean。
2.4 Triplet loss
Triplet loss用于训练差异性较小的样本,最初出现在FaceNet的论文中:FaceNet: A Unified Embedding for Face Recognition and Clustering (https://arxiv.org/pdf/1503.03832.pdf),可以学到较好的人脸的embedding。Triplet loss的输入是一个三元组:(anchor,positive, negative),其中,从训练数据集中随机选一个样本,该样本称为anchor,然后随机选取和anchor同类的样本positive和不同类的样本negative。下图是人脸embedding产生的Triplet loss:训练模型使得Triplet loss最小就是拉近同类(anchor,positive)距离,拉远异类(anchor,negative)距离,如下图:Triplet loss的公式如下:在训练的时候会得到很多的三元组(a,p,n),他们可以分为以下几类:
easy triplets:loss = 0,d(a, p) + margin < d(a, n),ap对的距离远远小于an对的距离。即,类内距离很小,类间很大距离,这种情况不需要优化。
hard triplets:d(a, n) < d(a, p) ,ap对的距离大于于an对的距离,即类内距离大于类间距离。这种情况比较难优化。
semi-hard triplets:d(a, p) < d(a, n) < d(a, p) + margin。ap对的距离和an对的距离比较高近。即,<a, p>和<a, n>很近,但都在一个margin内。比较容易优化。
一般在训练的时候是随机选取semi-hard triplets 进行训练的,但早期为了网络loss平稳,一般选择easy triplets进行优化,后期为了优化训练关键是要选择hard triplets,他们是活跃的,因此可以帮助改进模型。Triplet loss有两种训练方法,
OFFLINE将训练集所有数据经过计算得到对应的 embeddings, 然后再计算 triplet loss,这种方式的效率不高,因为要遍历所有的数据得到三元组。
ONLINE在ReID的论文:In Defense of the Triplet Loss for Person Re-Identification中使用了这样的方式。在训练时,分为Batch All和Batch Hard。Batch All计算了一个batch中所有val的的hard triplet 和 semi-hard triplet, 然后取平均得到Triplet loss。而Batch Hard则是对于每一个anchor,都选择距离最大的d(a, p) 和距离最大的d(a, n)。论文中选择Batchhard,随机抽取P个人,每个人K张图片形成一个batch,每个人的K张图片之间形成K*(K-1)个ap对,再在剩下其他人里取一个与该ap距离最近的negative,组成apn组并将apn组按照下面式子中的公式取模型里进行训练,使得下面的式子最小化。
Pytorch中提供TripletMarginLoss函数来实现Triplet loss,其中p为距离范数,默认为2,即2-范数:
class torch.nn.TripletMarginLoss(margin=1.0, p=2.0,size_average=None, reduce=None, reduction='mean')
3. PyTorch 如何自定义损失函数
关于PyTorch 如何自定义损失函数?总的来说,大体有三种方法:
3.1 调用torch.Tensor的原生接口
和一般的自定义函数一样只需要在__init__()里面定义好超参数,再在forward里写好计算过程就可以了。因为继承了nn.Module,所以这个loss类在实例化之后可以直接运行__call__()方法。这里以center loss为例(center loss来自于ECCV 2016 的一篇论文,被使用在ReID任务中,论文地址)
import torch as t
import torch.nn as nn
import torch.nn.functional as F
class CenterLoss(nn.Module):
def __init__(self,cls_num,featur_num):
super().__init__()
self.cls_num = cls_num
self.featur_num=featur_num
self.center = nn.Parameter(t.rand(cls_num,featur_num))
def forward(self, xs,ys):
self.center_exp = self.center.index_select(dim=0,index=ys.long())
count = t.histc(ys,bins=self.cls_num,min=0,max=self.cls_num-1)
self.count_dis = count.index_select(dim=0,index=ys.long())+1
loss = t.sum(t.sum((xs-self.center_exp)**2,dim=1)/2.0/self.count_dis.float())
return loss
3.2 Pytorch使用numpy/scipy扩展
原生接口提供了torch.nn.functional模块来代替一些函数操作,当该模块功能不能满足自定义函数的功能实现要求时,我们可以先将tensor转换为numpy,再使用numpy/scipy来实现函数功能,最后再返回tensor。下面是Pytorch官网给出的使用numpy/scipy扩展自定义快速傅里叶变换的案例:
import torch
from torch.autograd import Function
from numpy.fft import rfft2, irfft2
class BadFFTFunction(Function):
@staticmethod
def forward(ctx, input):
numpy_input = input.detach().numpy() #先转换成Numpy
result = abs(rfft2(numpy_input))
return input.new(result)
@staticmethod
def backward(ctx, grad_output):
numpy_go = grad_output.numpy()
result = irfft2(numpy_go)
return grad_output.new(result)
def incorrect_fft(input):
return BadFFTFunction.apply(input)
input = torch.randn(8, 8, requires_grad=True)
result = incorrect_fft(input)
print(result)
result.backward(torch.randn(result.size())) #返回tensor
print(input)
'''
运算结果:
tensor([[ 5.9226, 6.3469, 4.8813, 8.1814, 3.2829],
[ 7.1644, 6.0789, 3.7858, 6.2823, 2.3036],
[ 2.1042, 5.3961, 1.2794, 13.0508, 7.8831],
[11.0937, 6.8053, 4.2092, 2.3636, 4.6894],
[11.4806, 9.2691, 2.2958, 4.5882, 15.1742],
[11.0937, 12.0654, 7.2496, 4.1519, 4.6894],
[ 2.1042, 5.0917, 4.5153, 12.4071, 7.8831],
[ 7.1644, 4.8029, 7.4481, 1.6412, 2.3036]],
grad_fn=<BadFFTFunctionBackward>)
tensor([[ 0.6201, 1.2492, 0.1847, 0.1239, 0.0867, 0.1096, 1.1102, 0.8024],
[-1.7598, 0.3906, 1.2448, -0.1645, -0.7275, -1.7156, -0.7443, -1.5144],
[-0.3217, 0.1188, 0.1551, -0.9676, -0.8834, 0.8660, 0.2944, 2.7816],
[-0.0698, 0.3642, -1.0339, -0.1114, 0.0208, -1.3441, 0.0184, 0.1927],
[ 0.1153, 1.5583, -0.9675, 0.3124, -0.2498, -0.5960, 1.4346, -0.5523],
[ 0.6704, -0.1076, 0.6561, 0.4233, 1.0294, -0.4443, 0.2737, 0.7467],
[-0.1177, 0.6641, 0.8596, 0.5245, -0.4537, 0.8934, -2.1302, 1.0770],
[-0.5317, 0.0276, 0.5124, -0.3272, 0.8176, -0.0871, 1.2068, -0.6912]],
requires_grad=True)
'''
参考:
[1].https://www.cnblogs.com/wangguchangqing/p/12021638.html
[2].https://blog.csdn.net/wonengguwozai/article/details/74066157
[3].https://msd.misuland.com/pd/2884250171976192486
[4].https://mp.weixin.qq.com/s/Xbi5iOh3xoBIK5kVmqbKYA
[5].https://blog.csdn.net/weixin_40671425/article/details/98068190
[6].https://blog.csdn.net/weixin_45191152/article/details/97762005
投稿或交流学习,备注:昵称-学校(公司)-方向,进入DL&NLP交流群。
方向有很多:机器学习、深度学习,python,情感分析、意见挖掘、句法分析、机器翻译、人机对话、知识图谱、语音识别等。记得备注呦让更多的人知道你“在看”