Pytorch 常用损失函数

基本用法:

criterion = LossCriterion() 		# 构造函数有自己的参数
loss 	  = criterion(x, y) 		# 调用标准时也有参数

计算出来的结果已经对mini-batch取了平均

分类和回归的区别:在于输出变量的类型。
定量输出称为回归,或者说是连续变量预测;
定性输出称为分类,或者说是离散变量预测。


1、nn.L1Loss()

nn.L1Loss(size_average=True)

创建一个衡量输入x(模型预测输出) 和 目标y之间差的绝对值的平均值的标准。
l o s s ( x , y ) = 1 n ∑ ∣ x i − y i ∣ loss(x,y)=\frac {1}{n} \sum|x_i−y_i| loss(x,y)=n1xiyi

x 和 y 可以是任意形状,每个包含n个元素。

对n个元素对应的差值的绝对值求和,得出来的结果除以n。

如果在创建L1Loss实例的时候在构造函数中传入size_average=False,那么求出来的绝对值的和将不会除以n。


2、nn.MSELoss()

nn.MSELoss(size_average=True)

创建一个衡量输入x(模型预测输出)和目标y之间均方误差标准。

l o s s ( x , y ) = 1 n ∑ ( x i − y i ) 2 loss(x,y)=\frac {1}{n}\sum(xi−yi)2 loss(x,y)=n1(xiyi)2

x 和 y 可以是任意形状,每个包含n个元素。

对n个元素对应的差值的绝对值求和,得出来的结果除以n。

如果在创建MSELoss实例的时候在构造函数中传入size_average=False,那么求出来的平方和将不会除以n。


3、nn.CrossEntropyLoss()

nn.CrossEntropyLoss(weight=None, size_average=True)

此标准将LogSoftMax和NLLLoss集成到一个类中。当训练一个多类分类器的时候,这个方法是十分有用的。

  • weight(tensor): 1-D tensor,n个元素,分别代表n类的权重,如果你的训练样本很不均衡的话,是非常有用的。默认值为None。

调用时参数:

  • input : 包含每个类的得分,2-D tensor,shape为 batch*n
  • target: 大小为 n 的 1-D tensor,包含类别的索引(0到 n-1)。

Loss可以表述为以下形式:

l o s s ( x , c l a s s ) = − l o g e x p ( x [ c l a s s ] ) ∑ j e x p ( x [ j ] ) ) = − x [ c l a s s ] + l o g ( ∑ j e x p ( x [ j ] ) ) loss(x,class)=−log \frac {exp(x[class])}{\sum_j exp(x[j]))} =−x[class]+log(\sum_j exp(x[j])) loss(x,class)=logjexp(x[j]))exp(x[class])=x[class]+log(jexp(x[j]))

w e i g h t weight weight 参数被指定的时候, l o s s loss loss 的计算公式变为:

l o s s ( x , c l a s s ) = w e i g h t s [ c l a s s ] ∗ ( − x [ c l a s s ] + l o g ( ∑ j e x p ( x [ j ] ) ) ) loss(x,class)=weights[class]∗(−x[class]+log(\sum_j exp(x[j]))) loss(x,class)=weights[class](x[class]+log(jexp(x[j])))

计算出的loss对mini-batch的大小取了平均。

形状(shape):

  • Input:(N,C) C 是类别的数量
  • Target: (N) :N是mini-batch的大小, 0 ⩽ t a r g e t s [ i ] ⩽ C − 1 0 \leqslant targets[i] \leqslant C-1 0targets[i]C1

4、nn.BCELoss()

nn.BCELoss(weight=None, size_average=True)

计算 target 与 output 之间的二分类交叉熵。

l o s s ( o , t ) = − 1 n ∑ i ( t [ i ] l o g ( o [ i ] ) + ( 1 − t [ i ] ) l o g ( 1 − o [ i ] ) ) loss(o,t)=-\frac{1}{n}\sum_i(t[i] log(o[i])+(1-t[i]) log(1-o[i])) loss(o,t)=n1i(t[i]log(o[i])+(1t[i])log(1o[i]))

如果weight被指定 :

l o s s ( o , t ) = − 1 n ∑ i w e i g h t s [ i ] ∗ ( t [ i ] l o g ( o [ i ] ) + ( 1 − t [ i ] ) ∗ l o g ( 1 − o [ i ] ) ) loss(o,t)=-\frac{1}{n}\sum_iweights[i] \ast (t[i] log(o[i])+(1-t[i])* log(1-o[i])) loss(o,t)=n1iweights[i](t[i]log(o[i])+(1t[i])log(1o[i]))

这个用于计算 auto-encoder 的 reconstruction error。注意 0 ⩽ t a r g e t [ i ] ⩽ 1 0\leqslant target[i] \leqslant1 0target[i]1

默认情况下,loss会基于element平均,如果size_average=False的话,loss会被累加。


5、nn.MarginRankingLoss()

nn.MarginRankingLoss(margin=0, size_average=True)

创建一个标准,给定输入 x 1 x1 x1, x 2 x2 x2 两个1-D mini-batch Tensor’s,和一个 y y y(1-D mini-batch tensor) , y y y 里面的值只能是-1或1。

如果 y=1,代表第一个输入的值应该大于第二个输入的值,如果y=-1的话,则相反。

mini-batch中每个样本的loss的计算公式如下:

l o s s ( x , y ) = m a x ( 0 , − y ∗ ( x 1 − x 2 ) + m a r g i n ) loss(x,y)=max(0,−y∗(x1−x2)+margin) loss(x,y)=max(0,y(x1x2)+margin)

如果size_average=True,那么求出的loss将会对mini-batch求平均;
反之,求出的loss会累加。默认情况下,size_average=True。


6、nn.HingeEmbeddingLoss()

nn.HingeEmbeddingLoss(size_average=True)

给定一个输入 x x x (2-D mini-batch tensor)和对应的 标签 y y y (1-D tensor,1,-1),此函数用来计算之间的损失值。这个loss通常用来测量两个输入是否相似,即:使用L1 成对距离。典型是用在学习非线性 embedding或者半监督学习中:

第n次小批量样品的损失函数为

l n = { x n if:  y n = 1 m a x ( 0 , Δ − x n ) if:  y n = − 1 l_n = \begin{cases} x_n & \text{if: }y_n=1 \\ max(0, \Delta - x_n) & \text{if: } y_n=-1 \end{cases} ln={xnmax(0,Δxn)if: yn=1if: yn=1

总损失函数是:

ℓ ( x , y ) = { m e a n ( L ) if: reduction= ’mean’ s u m ( L ) if: reduction=’sum’  ℓ(x,y)=\begin{cases}mean(L) & \text{if: reduction= 'mean'} \\ sum(L) & \text{if: reduction='sum' } \end{cases} (x,y)={mean(L)sum(L)if: reduction= ’mean’if: reduction=’sum’ 

x x x y y y 可以是任意形状,且都有n的元素,loss的求和操作作用在所有的元素上,然后除以n。如果您不想除以n的话,可以通过设置size_average=False。margin的默认值为1,可以通过构造函数来设置。


7、nn.MultiLabelMarginLoss()

nn.MultiLabelMarginLoss(size_average=True)

计算多标签分类的 hinge loss(margin-based loss) ,计算loss时需要两个输入:

  • input x:2-D mini-batch Tensor
  • output y: 2-D tensor表示mini-batch中样本类别的索引

l o s s ( x , y ) = 1 x . s i z e ( 0 ) ∑ i = 0 , j = 0 I , J m a x ( 0 , 1 − ( x [ y [ j ] ] − x [ i ] ) ) loss(x,y)=\frac{1}{x.size(0)} \sum_{i=0,j=0}^{I,J}max(0,1−(x[y[j]]−x[i])) loss(x,y)=x.size(0)1i=0,j=0I,Jmax(0,1(x[y[j]]x[i]))

其中 I = x . s i z e ( 0 ) , J = y . s i z e ( 0 ) I=x.size(0),J=y.size(0) I=x.size(0),J=y.size(0)。对于所有的 i i i j j j,满足 y [ j ] ≠ 0 , i ≠ y [ j ] y[j]\neq0, i \neq y[j] y[j]=0,i=y[j]

x x x y y y 必须具有同样的 size。这个标准仅考虑了第一个非零 y [ j ] t a r g e t s y[j] targets y[j]targets 此标准允许了,对于每个样本来说,可以有多个类别。


8、nn.SmoothL1Loss

nn.SmoothL1Loss(size_average=True)

平滑版L1 loss,loss 的公式如下:

l o s s ( x , y ) = ∑ z i n loss(x,y)= \frac {\sum z_i} n loss(x,y)=nzi

z i = { 0.5 ( x i − y i 2 ) / b e t a  if ∣x i −y i ∣<beta ∣ x i − y i ∣ − 0.5 × b e a t otherwise z_i= \begin{cases} 0.5 ({x_i - y_i}^2) / {beta} & \text{ if ∣x i −y i ∣<beta} \\ \vert x_i - y_i \vert - 0.5 \times beat & \text{otherwise} \end{cases} zi={0.5(xiyi2)/betaxiyi0.5×beat if ∣x i −y i ∣<betaotherwise

此loss对于异常点的敏感性不如MSELoss,而且,在某些情况下防止了梯度爆炸,(参照 Fast R-CNN)。这个loss有时也被称为 Huber loss。x 和 y 可以是任何包含n个元素的tensor。默认情况下,求出来的loss会除以n,可以通过设置size_average=True 使 loss累加。


9、nn.SoftMarginLoss

nn.SoftMarginLoss(size_average=True)

创建一个标准,用来优化2分类的 logistic loss。输入为 x(一个 2-D mini-batch Tensor)和 目标y(一个包含1或 -1的Tensor)。

l o s s ( x , y ) = 1 x . n e l e m e n t ∑ i l o g ( 1 + e x p ( − y [ i ] ∗ x [ i ] ) ) loss(x,y)=\frac{1}{x.nelement} \sum_i log(1+exp(−y[i]∗x[i])) loss(x,y)=x.nelement1ilog(1+exp(y[i]x[i]))

如果求出的loss不想被平均可以通过设置 size_average=False。

ViatorSun CSDN认证博客专家 深度学习 计算机视觉
研究生在读、Github开源世界贡献者,深度学习 & 计算机视觉分享者;
主要研究【深度学习 & 计算机视觉】相关领域,欢迎感兴趣的小伙伴一起交流、探讨~
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 岁月 设计师:pinMode 返回首页