损失函数总结（四）：NLLLoss、CTCLoss

本文主要是介绍损失函数总结（四）：NLLLoss、CTCLoss，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

损失函数总结（四）：NLLLoss、CTCLoss

1 引言
2 损失函数
- 2.1 NLLLoss
- 2.2 CTCLoss
3 总结

1 引言

在前面的文章中已经介绍了介绍了一系列损失函数 (L1Loss、MSELoss、BCELoss、CrossEntropyLoss)。在这篇文章中，会接着上文提到的众多损失函数继续进行介绍，给大家带来更多不常见的损失函数的介绍。这里放一张损失函数的机理图：
在这里插入图片描述

2 损失函数

2.1 NLLLoss

NLLLoss（Negative Log Likelihood Loss，负对数似然损失）通常用于训练分类模型，尤其是在多类别分类任务中。它是一种用于度量模型的类别概率分布与实际类别分布之间的差距的损失函数。NLLLoss 的数学表达式如下：
$L_{\text{NLL}}(Y, Y') = -\frac{1}{n} \sum_{i=1}^{n} \sum_{j=1}^{C} y_{ij} \log(y_{ij}')$

其中：

$L_{\text{CE}}(Y, Y')$ 是整个数据集上的交叉熵损失。
$n$ 是样本数量。
$C$ 是类别数量。
$y_{ij}$ 是第 $i$ 个样本的实际类别分布，通常是一个独热编码（one-hot encoding）向量，表示实际类别。
$y_{ij}'$ 是第 $i$ 个样本的模型预测的类别概率分布，通常是一个概率向量，表示模型对每个类别的预测概率。

注意：上面的公式和 CrossEntropyLoss 公式相同，但实际上是不同的。实际关系为：
NLLLoss + LogSoftmax = CrossEntropyLoss

代码实现（Pytorch）：

m = nn.LogSoftmax(dim=1)
loss = nn.NLLLoss()
# input is of size N x C = 3 x 5
input = torch.randn(3, 5, requires_grad=True)
# each element in target has to have 0 <= value < C
target = torch.tensor([1, 0, 4])
output = loss(m(input), target)
output.backward()
# 2D loss example (used, for example, with image inputs)
N, C = 5, 4
loss = nn.NLLLoss()
# input is of size 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)
# each element in target has to have 0 <= value < C
target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
output = loss(m(conv(data)), target)
output.backward()

NLLLoss 通常用于分类任务，特别是当模型输出的是类别概率分布时。NLLLoss 和 CrossEntropyLoss 是等价的，可以相互替换。。。

2.2 CTCLoss

论文链接：Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks

CTC Loss（Connectionist Temporal Classification Loss，连接时序分类损失）通常用于训练序列到序列（sequence-to-sequence）模型，尤其是在语音识别和自然语言处理中的任务，其中输出序列的长度与输入序列的长度不一致。CTC Loss 的主要目标是将模型的输出与目标序列对齐，以度量它们之间的相似度。CTCLoss 的数学表达式如下：
$L_{\text{CTC}}(S) = -\ln \sum_{(x,z) \in S} p(z|x) = -\sum_{(x,z) \in S} lnp(z|x)$

其中：

$S$ 表示训练集
$L_{\text{CTC}}(S)$ 表示给定标签序列和输入，最终输出正确序列的概率

代码实现（Pytorch）：

# Target are to be padded
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 (padding length)
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()
# Target are to be un-padded
T = 50      # Input sequence length
C = 20      # Number of classes (including blank)
N = 16      # Batch size
# Initialize random batch of input vectors, for *size = (T,N,C)
input = torch.randn(T, N, C).log_softmax(2).detach().requires_grad_()
input_lengths = torch.full(size=(N,), fill_value=T, dtype=torch.long)
# Initialize random batch of targets (0 = blank, 1:C = classes)
target_lengths = torch.randint(low=1, high=T, size=(N,), dtype=torch.long)
target = torch.randint(low=1, high=C, size=(sum(target_lengths),), dtype=torch.long)
ctc_loss = nn.CTCLoss()
loss = ctc_loss(input, target, input_lengths, target_lengths)
loss.backward()
# Target are to be un-padded and unbatched (effectively N=1)
T = 50      # Input sequence length
C = 20      # Number of classes (including blank)
# Initialize random batch of input vectors, for *size = (T,C)
input = torch.randn(T, C).log_softmax(2).detach().requires_grad_()
input_lengths = torch.tensor(T, dtype=torch.long)
# Initialize random batch of targets (0 = blank, 1:C = classes)
target_lengths = torch.randint(low=1, high=T, size=(), dtype=torch.long)
target = torch.randint(low=1, high=C, size=(target_lengths,), dtype=torch.long)
ctc_loss = nn.CTCLoss()
loss = ctc_loss(input, target, input_lengths, target_lengths)
loss.backward()