Pytorch Loss funtion介绍

Loss functions

基本用法：

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

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

class torch.nn.L1Loss(size_average=True)[source]

创建一个衡量输入x(模型预测输出)和目标y之间差的绝对值的平均值的标准。

loss(x,y)=1/n∑|xi−yi|

x 和 y 可以是任意形状，每个包含n个元素。
对n个元素对应的差值的绝对值求和，得出来的结果除以n。
如果在创建L1Loss实例的时候在构造函数中传入size_average=False，那么求出来的绝对值的和将不会除以n

class torch.nn.MSELoss(size_average=True)[source]

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

loss(x,y)=1/n∑(xi−yi)2

x 和 y 可以是任意形状，每个包含n个元素。
对n个元素对应的差值的绝对值求和，得出来的结果除以n。
如果在创建MSELoss实例的时候在构造函数中传入size_average=False，那么求出来的平方和将不会除以n

class torch.nn.CrossEntropyLoss(weight=None, size_average=True)[source]

此标准将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可以表述为以下形式：

loss(x,class)=−logexp(x[class])∑jexp(x[j]))
=−x[class]+log(∑jexp(x[j]))

当weight参数被指定的时候，loss的计算公式变为：

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 <= targets[i] <= C-1

class torch.nn.NLLLoss(weight=None, size_average=True)[source]

负的log likelihood loss损失。用于训练一个n类分类器。

如果提供的话，weight参数应该是一个1-Dtensor，里面的值对应类别的权重。当你的训练集样本不均衡的话，使用这个参数是非常有用的。

输入是一个包含类别log-probabilities的2-D tensor，形状是（mini-batch， n）

可以通过在最后一层加LogSoftmax来获得类别的log-probabilities。

如果您不想增加一个额外层的话，您可以使用CrossEntropyLoss。

此loss期望的target是类别的索引 (0 to N-1, where N = number of classes)

此loss可以被表示如下：

loss(x,class)=−x[class]

如果weights参数被指定的话，loss可以表示如下：

loss(x,class)=−weights[class]∗x[class]

参数说明：

weight (Tensor, optional) – 手动指定每个类别的权重。如果给定的话，必须是长度为nclasses

size_average (bool, optional) – 默认情况下，会计算mini-batch``loss的平均值。然而，如果size_average=False那么将会把mini-batch中所有样本的loss累加起来。

形状:

Input: (N,C) , C是类别的个数

Target: (N) ， target中每个值的大小满足 0 <= targets[i] <= C-1

例子:

 m = nn.LogSoftmax()
 loss = nn.NLLLoss()
 # input is of size nBatch x nClasses = 3 x 5
 input = autograd.Variable(torch.randn(3, 5), requires_grad=True)
 # each element in target has to have 0 <= value < nclasses
 target = autograd.Variable(torch.LongTensor([1, 0, 4]))
 output = loss(m(input), target)
 output.backward()

class torch.nn.NLLLoss2d(weight=None, size_average=True)[source]

对于图片的 negative log likehood loss。计算每个像素的 NLL loss。

参数说明：

weight (Tensor, optional) – 用来作为每类的权重，如果提供的话，必须为1-Dtensor，大小为C：类别的个数。

size_average – 默认情况下，会计算 mini-batch loss均值。如果设置为 False 的话，将会累加mini-batch中所有样本的loss值。默认值：True。

形状：

Input: (N,C,H,W) C 类的数量

Target: (N,H,W) where each value is 0 <= targets[i] <= C-1

例子：

  m = nn.Conv2d(16, 32, (3, 3)).float()
     loss = nn.NLLLoss2d()
     # input is of size nBatch x nClasses x height x width
     input = autograd.Variable(torch.randn(3, 16, 10, 10))
     # each element in target has to have 0 <= value < nclasses
     target = autograd.Variable(torch.LongTensor(3, 8, 8).random_(0, 4))
     output = loss(m(input), target)
     output.backward()

class torch.nn.KLDivLoss(weight=None, size_average=True)[source]

计算 KL 散度损失。

KL散度常用来描述两个分布的距离，并在输出分布的空间上执行直接回归是有用的。

与NLLLoss一样，给定的输入应该是log-probabilities。然而。和NLLLoss不同的是，input不限于2-D tensor，因为此标准是基于element的。

target 应该和 input的形状相同。

此loss可以表示为：

loss(x,target)=1n∑i(targeti∗(log(targeti)−xi))

默认情况下，loss会基于element求平均。如果 size_average=False loss 会被累加起来。

class torch.nn.BCELoss(weight=None, size_average=True)[source]

计算 target 与 output 之间的二进制交叉熵。 $loss(o,t)=-\frac{1}{n}\sum_i(t[i] log(o[i])+(1-t[i]) log(1-o[i]))$loss(o,t)=−n1​i∑​(t[i]log(o[i])+(1−t[i])log(1−o[i])) 如果weight被指定 ： $loss(o,t)=-\frac{1}{n}\sum_iweights[i] (t[i] log(o[i])+(1-t[i])* log(1-o[i]))$loss(o,t)=−n1​i∑​weights[i](t[i]log(o[i])+(1−t[i])∗log(1−o[i]))

这个用于计算 auto-encoder 的 reconstruction error。注意 0<=target[i]<=1。

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

class torch.nn.MarginRankingLoss(margin=0, size_average=True)[source]

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

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

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

loss(x,y)=max(0,−y∗(x1−x2)+margin)

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

class torch.nn.HingeEmbeddingLoss(size_average=True)[source]

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

loss(x,y)=1n∑i{xi,if yi ==1 max(0,margin−xi),if yi==−1

$x$x和$y$y可以是任意形状，且都有n的元素，loss的求和操作作用在所有的元素上，然后除以n。如果您不想除以n的话，可以通过设置size_average=False。

margin的默认值为1,可以通过构造函数来设置。
~~

class torch.nn.MultiLabelMarginLoss(size_average=True)[source]

~~

计算多标签分类的 hinge loss(margin-based loss) ，计算loss时需要两个输入： input x(2-D mini-batch Tensor)，和 output y(2-D tensor表示mini-batch中样本类别的索引)。

`loss(x,y)=1x.size(0)∑i=0,j=0I,J(max(0,1−(x[y[j]]−x[i])))`

其中 I=x.size(0),J=y.size(0)。对于所有的 i和 j，满足 $y[j]\neq0, i \neq y[j]$y[j]̸​=0,i̸​=y[j]

x 和 y 必须具有同样的 size。

这个标准仅考虑了第一个非零 y[j] targets 此标准允许了，对于每个样本来说，可以有多个类别。

class torch.nn.SmoothL1Loss(size_average=True)[source]

平滑版L1 loss。

loss的公式如下：

loss(x,y)=1n∑i{0.5∗(xi−yi)2,if |xi−yi|<1 |xi−yi|−0.5,otherwise

此loss对于异常点的敏感性不如MSELoss，而且，在某些情况下防止了梯度爆炸，(参照 Fast R-CNN)。这个loss有时也被称为 Huber loss。

x 和 y 可以是任何包含n个元素的tensor。默认情况下，求出来的loss会除以n，可以通过设置size_average=True使loss累加。

class torch.nn.SoftMarginLoss(size_average=True)[source]

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

loss(x,y)=1x.nelement()∑i(log(1+exp(−y[i]∗x[i])))

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

class torch.nn.MultiLabelSoftMarginLoss(weight=None, size_average=True)[source]

创建一个标准，基于输入x和目标y的 max-entropy，优化多标签 one-versus-all 的损失。x:2-D mini-batch Tensor;y:binary 2D Tensor。对每个mini-batch中的样本，对应的loss为：

loss(x,y)=−1x.nElement()∑i=0Iy[i]logexp(x[i])(1+exp(x[i])+(1−y[i])log11+exp(x[i])

其中 I=x.nElement()-1, $y[i] \in {0,1}$y[i]∈0,1，y 和 x必须要有同样size。
class torch.nn.CosineEmbeddingLoss(margin=0, size_average=True)[source]

给定 输入 Tensors，x1, x2 和一个标签Tensor y(元素的值为1或-1)。此标准使用cosine距离测量两个输入是否相似，一般用来用来学习非线性embedding或者半监督学习。

margin应该是-1到1之间的值，建议使用0到0.5。如果没有传入margin实参，默认值为0。

每个样本的loss是：

loss(x,y)={1−cos(x1,x2), if y1 max(0,cos(x1,x2)−margin),if y−1

如果size_average=True 求出的loss会对batch求均值，如果size_average=False的话，则会累加loss。默认情况size_average=True。

class torch.nn.MultiMarginLoss(p=1, margin=1, weight=None, size_average=True)[source]

用来计算multi-class classification的hinge loss（magin-based loss）。输入是 x(2D mini-batch Tensor), y(1D Tensor)包含类别的索引， 0 <= y <= x.size(1))。

对每个mini-batch样本：

loss(x,y)=1x.size(0)∑i=0I(max(0,margin−x[y]+x[i])p)

其中 I=x.size(0) $i\neq y$i̸​=y。 可选择的，如果您不想所有的类拥有同样的权重的话，您可以通过在构造函数中传入weights参数来解决这个问题，weights是一个1D权重Tensor。

传入weights后，loss函数变为：

loss(x,y)=1x.size(0)∑imax(0,w[y]∗(margin−x[y]−x[i]))p

默认情况下，求出的loss会对mini-batch取平均，可以通过设置size_average=False来取消取平均操作。