Introduction

TensorFlow and PyTorch both implement Connectionist Temporal Classification, but the two APIs are not drop-in replacements. The big differences are how they expect logits to be shaped, what label format they accept, and whether they expect raw logits or log-probabilities. If you keep those three points straight, the mathematical loss is the same idea in both frameworks.

The Shared Goal of CTC

CTC is used when the input sequence length is larger than the target sequence length and the alignment between them is unknown. Speech recognition, handwriting recognition, and some OCR systems are standard examples.

Both TensorFlow and PyTorch compute the probability of all valid alignments that collapse to the target label sequence. The loss itself is conceptually the same. Most migration bugs come from API mismatches, not from a different underlying objective.

TensorFlow Usually Takes Logits

In TensorFlow, tf.nn.ctc_loss is typically called with raw logits plus explicit label and sequence-length tensors. A simple example with explicit shapes looks like this:

1import tensorflow as tf
2
3logits = tf.random.normal([2, 5, 4])  # batch, time, classes
4labels = tf.ragged.constant([[1, 2], [1]])
5label_length = tf.constant([2, 1], dtype=tf.int32)
6logit_length = tf.constant([5, 5], dtype=tf.int32)
7
8loss = tf.nn.ctc_loss(
9    labels=labels,
10    logits=logits,
11    label_length=label_length,
12    logit_length=logit_length,
13    logits_time_major=False,
14    blank_index=0,
15)
16
17print(loss.numpy())

The important detail is that TensorFlow applies the internal CTC computation starting from logits. You should set logits_time_major explicitly so shape expectations are obvious.

PyTorch Usually Takes Log-Probabilities

PyTorch’s nn.CTCLoss is commonly used with log-probabilities, not raw logits. That means you normally apply log_softmax yourself before calling the loss.

1import torch
2import torch.nn as nn
3
4logits = torch.randn(5, 2, 4)  # time, batch, classes
5log_probs = logits.log_softmax(2)
6
7targets = torch.tensor([1, 2, 1], dtype=torch.long)
8input_lengths = torch.tensor([5, 5], dtype=torch.long)
9target_lengths = torch.tensor([2, 1], dtype=torch.long)
10
11criterion = nn.CTCLoss(blank=0, reduction="mean", zero_infinity=True)
12loss = criterion(log_probs, targets, input_lengths, target_lengths)
13print(loss.item())

That is one of the biggest practical differences when porting code. If you forget the log_softmax step in PyTorch, the numbers will be wrong even though the shapes may look correct.

Shape Conventions Are Easy to Mix Up

Another common source of bugs is tensor layout.

A safe rule is:

• in TensorFlow, pass the layout you intend and set logits_time_major explicitly
• in PyTorch, CTCLoss expects (time, batch, classes) for the input tensor

That means a model output may need a transpose when moving from one framework to the other. Always print shapes before blaming the loss function.

Label Representation Also Differs

PyTorch usually flattens the targets into one long one-dimensional tensor plus target_lengths. TensorFlow is often used with ragged labels or another explicit per-example label structure.

The blank symbol is another place where silent mismatches happen. Even if both libraries support a configurable blank index, do not rely on remembered defaults. Set the blank index explicitly in both frameworks so the label vocabulary stays aligned.

Reduction and Infinity Handling

Both frameworks support reduction choices such as mean or sum, but training behavior can still diverge if you normalize differently or if one implementation is configured to zero out infinite losses while the other is not. When comparing results across frameworks, make the reduction rule and blank index explicit before deciding the loss functions disagree.

Common Pitfalls

• Passing raw logits into PyTorch CTCLoss without applying log_softmax first.
• Forgetting to specify whether TensorFlow logits are batch-major or time-major.
• Flattening labels incorrectly when moving from TensorFlow to PyTorch.
• Relying on remembered blank-symbol defaults instead of setting the blank index explicitly.
• Comparing loss values across frameworks while using different reductions or length tensors.

Summary

• TensorFlow and PyTorch implement the same CTC idea, but their APIs differ.
• TensorFlow is commonly called with logits; PyTorch is commonly called with log-probabilities.
• Shape conventions are a major migration trap, so set them explicitly.
• Label encoding and blank-index handling must match across frameworks.
• Most apparent differences come from API usage details rather than different mathematics.