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\sum|x_i-y_i|
$$
- 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\sum(x_i-y_i)^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可以表述为以下形式:
$$ \begin{aligned} loss(x, class) &= -\text{log}\frac{exp(x[class])}{\sum_j exp(x[j]))}\ &= -x[class] + log(\sum_j exp(x[j])) \end{aligned}
$$ 当weight参数被指定的时候,loss的计算公式变为:
$$ loss(x, class) = weights[class] * (-x[class] + log(\sum_j exp(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)=\frac{1}{n}\sum_i(target_i*(log(target_i)-x_i))
$$ 默认情况下,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]))
$$ 如果weight被指定 :
$$ loss(o,t)=-\frac{1}{n}\sum_iweights[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$,$x2$两个1-D mini-batch Tensor's,和一个$y$(1-D mini-batch tensor) ,$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$(2-D mini-batch tensor)和对应的 标签 $y$ (1-D tensor,1,-1),此函数用来计算之间的损失值。这个loss通常用来测量两个输入是否相似,即:使用L1 成对距离。典型是用在学习非线性 embedding或者半监督学习中:
$$ loss(x,y)=\frac{1}{n}\sum_i \begin{cases} x_i, &\text if~y_i==1 \ max(0, margin-x_i), &if ~y_i==-1 \end{cases}
$$ $x$和$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) = \frac{1}{x.size(0)}\sum_{i=0,j=0}^{I,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]$
x 和 y 必须具有同样的 size。
这个标准仅考虑了第一个非零 y[j] targets 此标准允许了,对于每个样本来说,可以有多个类别。
class torch.nn.SmoothL1Loss(size_average=True)[source]
平滑版L1 loss。
loss的公式如下:
$$ loss(x, y) = \frac{1}{n}\sum_i \begin{cases} 0.5*(x_i-y_i)^2, & if~|x_i - y_i| < 1\ |x_i - y_i| - 0.5, & otherwise\end{cases}
$$ 此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) = \frac{1}{x.nelement()}\sum_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) = - \frac{1}{x.nElement()}\sum_{i=0}^I y[i]\text{log}\frac{exp(x[i])}{(1 + exp(x[i])}
- (1-y[i])\text{log}\frac{1}{1+exp(x[i])}
$$ 其中 I=x.nElement()-1, $y[i] \in {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) = \begin{cases} 1 - cos(x1, x2), &if~y == 1 \ max(0, cos(x1, x2) - margin), &if~y == -1 \end{cases}
$$ 如果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) = \frac{1}{x.size(0)}\sum_{i=0}^I(max(0, margin - x[y] + x[i])^p)
$$ 其中 I=x.size(0) $i\neq y$。 可选择的,如果您不想所有的类拥有同样的权重的话,您可以通过在构造函数中传入weights参数来解决这个问题,weights是一个1D权重Tensor。
传入weights后,loss函数变为:
$$ loss(x, y) = \frac{1}{x.size(0)}\sum_imax(0, w[y] * (margin - x[y] - x[i]))^p
$$ 默认情况下,求出的loss会对mini-batch取平均,可以通过设置size_average=False来取消取平均操作。