主要参考 pytorch - Loss functions.

Pytorch == 1.4.0

1. L1Loss

class torch.nn.L1Loss(size_average=None,
                      reduce=None, 
                      reduction='mean')

1.1. 说明

L1 Loss 计算的是,input x 与 target y 间各元素值的平均绝对误差(mean absolute error MAE).

$x_n$ 和 $y_n$ 均是长度为 $n$ 的tensor.

[1] - 未简化版(unreduced,reduction='none'):

$$ \ell(x, y) = L = \{l_1, ..., l_N\}^T, l_n = |x_n - y_n| $$

其中,$N$ - batchsize.

[2] - 简化版(reduced, reduction='mean'reduction='sum'):

$$ \ell(x) = \begin{cases} mean(L) &\text{if reduction='mean' } \\ sum(L) &\text{if reduction = 'sum'} \end{cases} $$

其中,sum 操作仍是对所用元素进行操作,并除以 $n$.

如果设置 reduction='sum' 则不会再除以 $n$.

1.2. 参数

[1] - size_averagereduce 都是待弃用的参数. 不推荐使用.

[2] - reduction: 可选参数:nonemeansum 三种. 默认为 mean.

  • none: 不进行简化(reduction).
  • mean: 对输出求和,并除以元素总数.
  • sum: 对输出求和,但不除以元素总数.

1.3. Shape

[1] - 输入 - input x, $(N, \ast )$.

[2] - 输入 - target y, $(N, \ast )$,与输出保持一致.

[3] - 输出 - 如果 reduce='none', 输出与其输入一致, $(N, \ast)$.

1.4. 示例

import torch 
import torch.nn as nn

loss = nn.L1Loss()
input = torch.randn(2, 3, requires_grad=True)
target = torch.randn(2, 3)
output = loss(input, target)
output.backward()

2. MSELoss

class torch.nn.MSELoss(size_average=None,
                       reduce=None,
                       reduction='mean')

2.1. 说明

MSE Loss 计算的是,input x 和 target y 的 n 个元素间的平方差(mean squard error, squard L2 norm).

[1] - 未简化版(unreduced,reduction='none'):

$$ \ell(x,y) = L = \{l_1, ..., l_N\}^T, l_n = (x_n - y_n)^2 $$

其中,$N$ - batchsize.

[2] - 简化版(reduced, reduction='mean'reduction='sum'):

$$ \ell(x) = \begin{cases} mean(L) &\text{if reduction='mean' } \\ sum(L) &\text{if reduction = 'sum'}\end{cases} $$

其中,sum 操作仍是对所用元素进行操作,并除以 $n$.

如果设置 reduction='sum' 则不会再除以 $n$.

2.2. 参数

1.1. 参数 一致.

2.3. Shape

[1] - 输入 - input x, $(N, \ast )$.

[2] - 输入 - target y, $(N,\ast )$,与输出保持一致.

2.4. 示例

import torch 
import torch.nn as nn

loss = nn.MSELoss()
input = torch.randn(2, 3, requires_grad=True)
target = torch.randn(2, 3)
output = loss(input, target)
output.backward()

3. CrossEntropyLoss

class torch.nn.CrossEntropyLoss(weight=None, 
                                size_average=None, 
                                ignore_index=-100,
                                reduce=None,
                                reduction='mean')

3.1. 说明

CrossEntropyLoss,交叉熵损失函数, 等价于nn.LogSoftmax()nn.NLLloss() 的计算.

其应用于,$C$ 类的分类问题.

如果设置了 weight 参数,则应该是对应每一个类别的权重,1D Tensor. 对于训练集数据不均衡的场景比较有用.

CrossEntropyLoss 的输入是关于每个类别的原始未归一化的值. input 是 $(minibatch, C)$ 或 $(minibatch, C, d_1, d_2, ..., d_K), (K \geq 1)$ Shape 的 Tensor.

CrossEntropyLoss 要求类别索引是 $[0, C-1]$. 如果设置了 ignore_index 参数,该损失函数也会接受该ignore_index类别索引(ignore_index 可以不在 $[0, C-1]$ 范围内.)

[1] - 未设定 weight 参数,不带权重时,

$$ loss(x, class) = -log (\frac{exp(x[class])}{\sum_j exp(x[j])}) = -x[class] + log(\sum_j exp(x[j])) $$

[2] - 设定 weight 参数,带权重时,

$$ loss(x, class) = weight[class](-x[class] + log(\sum_j exp(x[j]))) $$

loss 计算时对每个 minibatch 内的所有样本求均值.

CrossEntropyLoss 也可以用于高维输入,比如,2D 图像,此时其输入shape 为 $(minibatch, C, d_1, d_2, ..., d_K), (K \geq 1)$,其中 $K$ 是维数.

3.2. 参数

[1] - size_averagereduce 都是待弃用的参数. 不推荐使用.

[2] - weight: 关于每个类别的缩放权重,size 为 $C$ 的 Tensor.

[3] - ignore_index: 指定要忽略的 target 值,其不对输入梯度有贡献. 当 size_average='True'时,损失函数值仅对 non-ignored targets 进行求均值.

[4] - reduction: 可选参数:nonemeansum 三种. 默认为 mean.

  • none: 不进行简化(reduction).
  • mean: 对输出求和,并除以元素总数.
  • sum: 对输出求和,但不除以元素总数.

3.3. Shape

[1] - 输入 - input,$(N, C)$,其中,$C$ 是类别数. 或,$(N, C, d_1, d_2, ..., d_K), K\geq 1$.

[2] - 输入 - target,$(N)$,其中,每个值的是 $ 0 \leq target[i] < \leq C-1$. 或,$(N, d_1, d_2, ..., d_K)$.

[3] - 输出 - output,标量值. 如果 reduction='none',则与target 的size一致, $(N)$. 或,$(N, d_1, d_2, ..., d_k)$.

3.4. 示例

loss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.empty(3, dtype=torch.long).random_(5)
output = loss(input, target)
output.backward()

4. NLLLoss

class torch.nn.NLLLoss(weight=None, 
                       size_average=None,
                       ignore_index=-100, 
                       reduce=None,
                       reduction='mean')

4.1. 说明

NLLLoss,负对数似然函数(negative log likelihood). 适用于 $C$ 类的分类任务.

在神经网络中,可以通过在最后一层添加 LogSoftmax 层来得到对数概率(log-probability). 此时,损失函数计算为 LogSoftmax + NLLLoss 的输出. 如果不喜欢新增额外的网络层,可以直接采用 CrossEntropyLoss.

[1] - 未简化版(unreduced,reduction='none'):

$$ \ell (x, y) = L = \lbrace l_1, ..., l_N \rbrace ^T $$

$$ l_n = -w_{y_n} x_{n, y_n} $$

$$ w_c = weight[c] \cdot 1 \lbrace c \neq \text{ignore_index} \rbrace $$

[2] - 简化版(reduced, reduction='mean'reduction='sum'):

$$ \ell(x, y) = \begin{cases} \sum_{n=1}^N \frac{1}{\sum_{n=1}^N} l_n &\text{if reduction='mean' } \\ \sum_{n=1}^N l_n &\text{if reduction = 'sum'} \end{cases} $$

支持高维输入 inputs, 如 2D images, NLLLoss 计算的是对每个像素样本的.

4.2. 参数

3.2. 参数.

4.3. Shape

3.3. Shape.

4.4. 示例

# 1D
import torch 
import torch.nn as nn

logsoft = nn.LogSoftmax()
loss = nn.NLLLoss()
# input, NxC=2x3
input = torch.randn(3, 5, requires_grad=True)
# target, N, 每个值的是 [0, C).
target = torch.tensor([1, 0, 4])
output = loss(logsoft(input), target)
output.backward()
# 2D

N, C = 5, 4
loss = nn.NLLLoss()
# input, N x C x height x width
data = torch.randn(N, 16, 10, 10)
conv = nn.Conv2d(16, C, (3, 3))
m = nn.LogSoftmax(dim=1)
# target
target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
output = loss(m(conv(data)), target)
output.backward()

5. KLDivLoss

class torch.nn.KLDivLoss(size_average=None, 
                         reduce=None, 
                         reduction='mean')

5.1. 说明

KLDivLoss, Kullback-Leibler divergence Loss.

KL 散度适用于连续分布间的距离度量. 往往用于对(离散采样的)连续输出分布的空间进行直接回归.

类似于 NLLLoss,KLDivLoss 的输入也是 log-probabilities,且不严格要求于 2D Tensor. target 也是以概率形式给定的(未取对数).

[1] - 未简化版(unreduced,reduction='none'):

$$ \ell (x, y) = L = \lbrace l_1, ...,l_N \rbrace $$

$$ l_n = y_n \cdot (log \ y_n - x_n) $$

其中,索引 $N$ 贯穿了 input 的所有维度. $L$ 与 input 具有相同的 shape.

[2] - 简化版(reduced, reduction='mean'reduction='sum'):

$$ \ell(x, y) = \begin{cases} mean(L) &\text{if reduction='mean' } \\ sum(L) &\text{if reduction = 'sum'} \end{cases} $$

KLDivLoss 对于每个 minibatch 的样本和维度进行求均值.

5.2. 参数

1.1. 参数 .

下一个 release 版本中,reduction='mean' 会更新为 reduction='batchmean'.

5.3. Shape

1.1. Shape.

6. BCELoss

class torch.nn.BCELoss(weight=None, 
                       size_average=None, 
                       reduce=None, 
                       reduction='mean')

6.1. 说明

BCELoss 计算的是 target 和 output 检测二值交叉熵.

[1] - 未简化版(unreduced,reduction='none'):

$$ \ell(x, y) = L = \lbrace l_1, ..., l_N \rbrace ^T $$

$$ l_n = -w_n [y_n \cdot log \ x_n + (1 - y_n) \cdot log(1 - x_n)] $$

其中,$N$ 为 batchsize.

[2] - 简化版(reduced, reduction='mean'reduction='sum'):

$$ \ell(x) = \begin{cases} mean(L) &\text{if reduction='mean' } \\ sum(L) &\text{if reduction = 'sum'}\end{cases} $$

常用于度量重建误差,例如,auto-encoder.

注, targets $y$ 的值的取值范围为 [0, 1].

6.2. 参数

[1] - size_averagereduce 都是待弃用的参数. 不推荐使用.

[2] - weight: 关于每个类别的缩放权重,size 为 $C$ 的 Tensor.

[3] - reduction: 可选参数:nonemeansum 三种. 默认为 mean.

  • none: 不进行简化(reduction).
  • mean: 对输出求和,并除以元素总数.
  • sum: 对输出求和,但不除以元素总数.

6.3. Shape

[1] - 输入 - input,$(N, \ast)$.

[2] - 输入 - target,$(N, \ast )$.

[3] - 输出 - output,标量值. 如果 reduction='none',则与target 的size一致, $(N, \ast )$.

6.4. 示例

m = nn.Sigmoid()
loss = nn.BCELoss()

input = torch.randn(3, requires_grad=True)
target = torch.empty(3).random_(2)
output = loss(m(input), target)
output.backward()

7. BCEWithLogitsLoss

class torch.nn.BCEWithLogitsLoss(weight=None, 
                                 size_average=None, 
                                 reduce=None, 
                                 reduction='mean',
                                 pos_weight=None)

7.1. 说明

BCEWithLogitsLoss,是将 Sigmoid 层和 BCELoss 层整合.

相比于,采用 Sigmoid + BCELoss,BCEWithLogitsLoss 具有更好的数值稳定性.(主要是利用了 log-sum-exp 技巧来实现数据稳定性).

[1] - 未简化版(unreduced,reduction='none'):

$$ \ell(x, y) = L = \lbrace l_1, ..., l_N \rbrace ^T $$

$$ l_n = -w_n [y_n \cdot log \ \sigma(x_n) + (1 - y_n) \cdot log(1 - \sigma (x_n)] $$

其中,$N$ 为 batchsize.

[2] - 简化版(reduced, reduction='mean'reduction='sum'):

$$ \ell(x) = \begin{cases} mean(L) &\text{if reduction='mean' } \\ sum(L) &\text{if reduction = 'sum'}\end{cases} $$

常用于度量重建误差,例如,auto-encoder.

注,targets $t[i]$ 的取值范围为 [0, 1].

对于BCEWithLogitsLoss,通过增加正样本(positive examples)的 权重,可以实现 recall 和 precision 间的均衡. 对于 multi-label 分类问题:

$$ \ell_c(x, y) = L_c = \lbrace l_{1, c}, ..., l_{N,c} \rbrace ^T $$

$$ l_{n,c} = -w_{n,c} [p_c y_{n,c} \cdot log \ \sigma(x_{n_c}) + (1 - y_{n, c}) \cdot log(1 - \sigma (x_{n, c})] $$

其中,$c$ 为类别数(对于 multi-label 二值分类问题, $c>1$;对于 single-label 二值分类问题,$c=1$).

$n$ 为 batch 内的样本数;

$p_c$ 为对于类别 $c$ ,其正样本的权重. $p_c > 1$ 其提升 recall;$p_c < 1$ 其提升 precision.

例如,对于一个数据集,其包含单个类别(single-class),100 个正样本,300 个负样本,则对于该类别,其$pos\_weight = \frac{300}{100}=3$. 损失函数起作用需要数据集包含 $3 \times 100=300$ 个正样本.

如:

# 64 classes, batch size = 10
target = torch.ones([10, 64], dtype=torch.float32) 
# A prediction (logit)
output = torch.full([10, 64], 0.999)  
# All weights are equal to 1
pos_weight = torch.ones([64])  
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
# -log(sigmoid(0.999))
print(criterion(output, target))
#tensor(0.3135)

7.2. 参数

[1] - size_averagereduce 都是待弃用的参数. 不推荐使用.

[2] - weight: 关于每个类别的缩放权重,size 为 $C$ 的 Tensor.

[3] - reduction: 可选参数:nonemeansum 三种. 默认为 mean.

  • none: 不进行简化(reduction).
  • mean: 对输出求和,并除以元素总数.
  • sum: 对输出求和,但不除以元素总数.

[4] - pos_weight: 正样本的权重. 必须是与类别数长度一致的向量.

7.3. Shape

6.3. Shape.

7.4. 示例

loss = nn.BCEWithLogitsLoss()
input = torch.randn(3, requires_grad=True)
target = torch.empty(3).random_(2)
output = loss(input, target)
output.backward()

8. MarginRankingLoss

class torch.nn.MarginRankingLoss(margin=0.0, 
                                 size_average=None, 
                                 reduce=None, 
                                 reduction='mean')

8.1. 说明

MarginRankingLoss,计算的是,给定输入两个 1D min-batch Tensor $x1$ 和 $x2$ 以及一个 1D mini-batch tensor $y$ (包含1或-1) 的度量.

如果 $y=1$,则假设第一个输入比第二个输入的排名更高(值更大);

如果 $y=-1$,则假设第二个输入比第一个输入的排名更高(值更大).

对于 mini-batch 内的每个样本,

$$ loss(x, y) = max(0, -y \ast (x1-x2) + \text{margin}) $$

8.2. 参数

[1] - margin - 默认值为 0.

其它参数同 1.2. 参数.

8.3. Shape

[1] - 输入 - input,$(N, D)$, $N$ 为 batch-size,$D$ 是样本的维度.

[2] - 输入 - target, $(N)$

[3] - 输出 - 标量,如果 reduction='none',则为 $(N)$.

9. HingeEmbeddingLoss

class torch.nn.HingeEmbeddingLoss(margin=1.0, 
                                  size_average=None,
                                  reduce=None, 
                                  reduction='mean')

9.1. 说明

HingeEmbeddingLoss 计算的是,给定输入 tensor $x$ 和 labels tensor $y$ (包含1和-1) 时的损失函数.

HingeEmbeddingLoss 往往用于度量两个输入是否相似,如采用 L1 成对距离(pairdistance).

HingeEmbeddingLoss 多用于学习非线性嵌入(nonlinear embeddings) 或者半监督学习.

对于 mini-batch 内的第 $n$ 个样本,

$$ l_n = \begin{cases} x_n &\text { if } y_n=1 \\ max\lbrace 0, \Delta - x_n \rbrace &\text { if } y_n = -1 \end{cases} $$

总损失函数为:

$$ L = \{l_1, ..., l_N\}^T $$

$$ \ell(x) = \begin{cases} mean(L) &\text{if reduction='mean' } \\ sum(L) &\text{if reduction = 'sum'}\end{cases} $$

10. MultiLabelMarginLoss

class torch.nn.MultiLabelMarginLoss(size_average=None, 
                                    reduce=None, 
                                    reduction='mean')

10.1. 说明

MultiLabelMarginLoss 度量的是,给定输入2D mini-batch Tensor $x$ 和输出 2D Tensor 目标类别索引 $y$ 时的 multi-class multi-classification hinge loss 函数.

对于 mini-batch 内的每个样本:

$$ loss(x, y) = \sum_{ij} \frac{max(0, 1-(x[y[j]] -x[i]))}{x.size(0)} $$

其中,$x \in \lbrace 0, ..., x.size(0)-1 \rbrace$.

$y \in \lbrace 0, ..., y.size(0)-1 \rbrace$.

$0 \leq y[j] \leq x.size(0)-1$.

对于所有 $i$ 和 $j$,$i \neq y[j]$.

$y$ 和 $x$ size 一致.

MultiLabelMarginLoss 仅针对从上开始的非负 targets 连续块的部分.

MultiLabelMarginLoss 有助于解决不同样本具有不同数量 target 类别的问题.

10.2. 参数

1.2. 参数 .

10.3. Shape

[1] - 输入 - input,$C$ 或 $(N, C)$, $N$ 为 batch-size,$C$ 是类别.

[2] - 输入 - target, $(C)$ 或 $(N, C)$,为了确保与 input shape 一致,target label 会补 -1.

[3] - 输出 - 标量,如果 reduction='none',则为 $(N)$.

10.4. 示例

loss = nn.MultiLabelMarginLoss()
x = torch.FloatTensor([[0.1, 0.2, 0.4, 0.8]])
# for target y, only consider labels 3 and 0, not after label -1
y = torch.LongTensor([[3, 0, -1, 1]])
print(loss(x, y))
# 0.25 * ((1-(0.1-0.2)) + (1-(0.1-0.4)) + (1-(0.8-0.2)) + (1-(0.8-0.4)))
#tensor(0.8500)

11. SmoothL1Loss

class torch.nn.SmoothL1Loss(size_average=None,
                            reduce=None, 
                            reduction='mean')

11.1. 说明

如果每个元素的绝对误差都小于 1,则 SmoothL1Loss 采用平方项;否则采用 L1项.

相比于 MSELoss,SmoothL1Loss 对 outliers 更不敏感,在某些场景下避免梯度爆炸(如,Fast R-CNN 论文里).

SmoothL1Loss,也叫做 Huber loss:

$$ loss(x, y) = \frac{1}{n} \sum_{i} z_i $$

其中,

$$ z_i = \begin{cases} 0.5(x_i - y_i)^2 &\text { if } |x_i - y_i| <1 \\ |x_i - y_i| - 0.5 &\text { otherwise } \end{cases} $$

11.2. 参数

1.2. 参数

11.3. Shape

1.3. Shape.

12. SoftMarginLoss

torch.nn.SoftMarginLoss(size_average=None, 
                        reduce=None, 
                        reduction='mean')

12. 说明

SoftMarginLoss 计算的是,输入 tensor $x$ 和 target tensor $y$ (包含 1 或 -1) 间的二类分类逻辑损失函数(two-class classification logistic loss ).

$$ loss(x,y) = \sum_i \frac{log(1 + exp(-y[i] \ast x[i]))}{x.nelement()} $$

13. MultiLabelSoftMarginLoss

class torch.nn.MultiLabelSoftMarginLoss(weight=None, 
                                        size_average=None, 
                                        reduce=None,
                                        reduction='mean')

13.1. 说明

MultiLabelSoftMarginLoss 计算的是,输入 tensor $x$ 和 target tensor $y$ (size 为 $(N, C)$ 间,基于最大熵(max-entropy)优化 multi-label one-versus-all(一对多)的损失函数.

对于 minibatch 内的每个样本,

$$ loss(x, y) = -\frac{1}{C} \ast \sum_i y[i] \ast log((1 + exp(-x[i]))^{-1}) + (1 - y[i]) \ast log(\frac{exp(-x[i])}{1+exp(-x[i])}) $$

其中,$i \in {0, ..., x/nElement()-1}$, $y[i] \in \lbrace 0, 1 \rbrace$.

14. CosineEmbeddingLoss

class torch.nn.CosineEmbeddingLoss(margin=0.0, 
                                   size_average=None, 
                                   reduce=None, 
                                   reduction='mean')

14.1. 说明

CosineEmbeddingLoss 计算的是,给定输入 tensor $x1$ 和 $x2$,以及 label Tensor $y$ 值为 1 或 -1 时的损失函数.

CosineEmbeddingLoss 用于采用 cosine 距离来度量两个输入是否相似. 往往被用于学习非线性嵌入和半监督学习中.

对于每个样本的损失函数为:

$$ l_n = \begin{cases} 1 - cos(x_1, x_2) &\text { if } y=1 \\ max\lbrace 0, cos(x_1, x_2)- \text{margin} \rbrace &\text { if } y = -1 \end{cases} $$

15. MultiMarginLoss

class torch.nn.MultiMarginLoss(p=1, 
                               margin=1.0, 
                               weight=None, 
                               size_average=None, 
                               reduce=None, 
                               reduction='mean')

15.1. 说明

MultiMarginLoss 计算的是,给定输入 2D mini-batch Tensor $x$ 和输出 target 类别索引的 1D Tensor $y$ ($0 \leq y \leq x.size(1)-1$) 时,multi-class 分类的 hinge loss(margin-based loss) 的优化.

对于每个 mini-batch 样本,关于 1D 输入 $x$ 和 标量输出 $y$ 的损失函数为:

$$ loss(x, y) = \frac{\sum_i max(0, (\text{margin} - x[y] + x[i])^p)}{x.size(0)} $$

其中,$x \in \lbrace 0, ..., x.size(0)-1 \rbrace$ , $x \neq y$.

此外,也可以通过传递 1D weight tensor 参数,设定非负权重:

$$ loss(x, y) = \frac{\sum_i max(0, w[y] \ast (\text{margin} - x[y] + x[i])^p)}{x.size(0)} $$

16. TripletMarginLoss

class torch.nn.TripletMarginLoss(margin=1.0, 
                                 p=2.0, 
                                 eps=1e-06, 
                                 swap=False, 
                                 size_average=None, 
                                 reduce=None, 
                                 reduction='mean')

16.1. 说明

TripletMarginLoss 是三元损失函数度量,给定输入 tensor $x1$, $x2$, $x3$ 以及一个值大于 0 的 margin.

TripletMarginLoss 用于度量样本间的相对相似性.

一个三元组由 $a$、$p$ 和 $n$ 组成(分别表示 anchor, positive example 和 negative example.)

TripletMarginLoss 所有输入 tensors 的 shape 都是 $(N, D)$.

距离 swap 参考论文:Learning shallow convolutional feature descriptors with triplet losses by V. Balntas, E. Riba et al.

对于 mini-batch 内的每个样本,

$$ L(a, p, n) = max \lbrace d(a_i, p_i) - d(a_i, n_i) + \text{margin}, 0 \rbrace $$

其中,

$$ d(x_i, y_i) = ||\mathbf{x}_i - \mathbf{y}_i||_p $$

16.2. 参数

[1] - margin - 默认值为 1.

[2] - p - 成对距离的范围,默认为 2.

[3] - swap - swap 距离.

其它参数同 1.2. 参数.

16.3. Shape

[1] - 输入 - input, $(N, D)$,其中,$D$ 为向量维度.

[2] - 输出 - output, 标量. 如果 reduction='none',则为 $(N)$.

16.4. 示例

triplet_loss = nn.TripletMarginLoss(margin=1.0, p=2)
anchor = torch.randn(100, 128, requires_grad=True)
positive = torch.randn(100, 128, requires_grad=True)
negative = torch.randn(100, 128, requires_grad=True)
output = triplet_loss(anchor, positive, negative)
output.backward()

17. PoissonNLLLoss

class torch.nn.PoissonNLLLoss(log_input=True, 
                              full=False, 
                              size_average=None, 
                              eps=1e-08, 
                              reduce=None, 
                              reduction='mean')

17.1. 说明

PoissonNLLLoss 计算的是,target 服从 Possion 分布的负对数似然函数.

PoissonNLLLoss 可以表述为:

$$ target \sim Poisson(input) $$

$$ loss(input, target) = input - target \ast log(input) + log(target !) $$

最后一项可以忽略,或者采用 Stirling 表达式来逼近. 逼近形式用于 target 值大于1的场景. 对于 target 值小于等于 1时,损失函数加零.

17.2. 参数

[1] - log_input - 如果值为 True,则损失函数计算为: $exp(input) - target \ast input$. 如果值为 False,则损失函数计算为: $input - target \ast log(input + eps)$.

[2] - full - 是否计算完整损失函数,如,添加 Stirling 逼近项:$target \ast log(target) - target + 0.5 \ast log(2 \pi target)$.

其它参数同 1.2. 参数.

17.3. 示例

loss = nn.PoissonNLLLoss()
log_input = torch.randn(5, 2, requires_grad=True)
target = torch.randn(5, 2)
output = loss(log_input, target)
output.backward()

18. CTCLoss

class torch.nn.CTCLoss(blank=0, 
                       reduction='mean', 
                       zero_infinity=False)

18.1. 说明

Connectionist Temporal Classification loss.

时序数据分类的损失函数.

18.2. 示例

T = 50      # Input sequence length
C = 20      # Number of classes (including blank)
N = 16      # Batch size
S = 30      # Target sequence length of longest target in batch
S_min = 10  # Minimum target length, for demonstration purposes

# Initialize random batch of input vectors, for *size = (T,N,C)
input = torch.randn(T, N, C).log_softmax(2).detach().requires_grad_()

# Initialize random batch of targets (0 = blank, 1:C = classes)
target = torch.randint(low=1, high=C, size=(N, S), dtype=torch.long)

input_lengths = torch.full(size=(N,), fill_value=T, dtype=torch.long)
target_lengths = torch.randint(low=S_min, high=S, size=(N,), dtype=torch.long)
ctc_loss = nn.CTCLoss()
loss = ctc_loss(input, target, input_lengths, target_lengths)
loss.backward()
Last modification:February 11th, 2020 at 04:08 pm