Is there a difference between “torch.nn.CTCLoss” supported by PYTORCH and “CTCLoss” supported by torch_baidu_ctc?

439327bcc62cd8e45e96: <p>Is there a difference between “torch.nn.CTCLoss” supported by PYTORCH and “CTCLoss” supported by torch_baidu_ctc?</p>
<p>i think, I didn’t notice any difference when I compared the tutorial code.</p>
<p>Does anyone know the true?</p>
<p>Tutorial code is located below.</p>
<pre><code class="lang-auto">import torch
from torch_baidu_ctc import ctc_loss, CTCLoss

# Activations. Shape T x N x D.
# T -&gt; max number of frames/timesteps
# N -&gt; minibatch size
# D -&gt; number of output labels (including the CTC blank)
x = torch.rand(10, 3, 6)
# Target labels
y = torch.tensor([
# 1st sample
1, 1, 2, 5, 2,
# 2nd
1, 5, 2,
# 3rd
4, 4, 2, 3,
],
dtype=torch.int,
)
# Activations lengths
xs = torch.tensor([10, 6, 9], dtype=torch.int)
# Target lengths
ys = torch.tensor([5, 3, 4], dtype=torch.int)

# By default, the costs (negative log-likelihood) of all samples are 
summed.
# This is equivalent to:
#   ctc_loss(x, y, xs, ys, average_frames=False, reduction="sum")
loss1 = ctc_loss(x, y, xs, ys)

# You can also average the cost of each sample among the number of 
frames.
# The averaged costs are then summed.
loss2 = ctc_loss(x, y, xs, ys, average_frames=True)

# Instead of summing the costs of each sample, you can perform
# other `reductions`: "none", "sum", or "mean"
#
# Return an array with the loss of each individual sample
losses = ctc_loss(x, y, xs, ys, reduction="none")
#
# Compute the mean of the individual losses
loss3 = ctc_loss(x, y, xs, ys, reduction="mean")
#
# First, normalize loss by number of frames, later average losses
loss4 = ctc_loss(x, y, xs, ys, average_frames=True, reduction="mean")


# Finally, there's also a nn.Module to use this loss.
ctc = CTCLoss(average_frames=True, reduction="mean", blank=0)
loss4_2 = ctc(x, y, xs, ys)

# Note: the `blank` option is also available for `ctc_loss`.
# By default it is 0.
</code></pre>
<p>torch.nn.CTCLoss</p>
<pre><code class="lang-auto">T = 50      # Input sequence length
C = 20      # Number of classes (excluding 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+1 = classes)
target = torch.randint(low=1, high=C+1, 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()
</code></pre>
<p>I am Korean. English is not my first language. So I’m not good at English. If there’s anything that hasn’t been delivered well, please leave a comment. I’ll change the sentence as soon as possible.</p>

tom: <p>It might not be exactly a drop in replacement (and my implementation follows a GTC presentation of the CuDNN developers more than what Baidu did), but they implement the same loss.</p>
<p>Two caveats</p>
<ul>
<li>You need PyTorch 1.1’s <code>zero_infinity=True</code> flag if you wish to zero losses and gradients of “impossible” samples (where the probability of producing the target using the input is 0 because the target is too long).</li>
<li>There still is a bug that you won’t get gradients for 0 length targets on the GPU.</li>
</ul>
<p>Most people who do the first correctly seem to get their training to work.</p>
<p>Best regards</p>
<p>Thomas</p>