Introduction

The error logits and labels must be broadcastable means the loss function received tensors whose shapes do not match what that loss expects. In TensorFlow RNN models, this usually happens because the model predicts one class per time step while the labels are shaped for one class per sequence, or because one-hot labels were paired with a sparse loss, or the reverse.

Start by Asking What the Model Predicts

An RNN can produce two very different kinds of output:

• one prediction for the entire sequence
• one prediction for every time step

Those two tasks imply different output shapes.

If you use return_sequences=True, the logits usually have shape (batch_size, time_steps, num_classes). If the model predicts only one class per sequence, the logits more often have shape (batch_size, num_classes).

Your labels must match that design before the loss can work.

Match the Loss Function to the Label Format

TensorFlow classification losses do not all expect the same label shape.

The common rule is:

• 'SparseCategoricalCrossentropy expects integer class ids'
• 'CategoricalCrossentropy expects one-hot encoded labels'

For a per-time-step sequence classifier, sparse labels usually look like (batch_size, time_steps), while logits look like (batch_size, time_steps, num_classes).

A working sparse example:

1import tensorflow as tf
2
3batch_size = 4
4time_steps = 6
5feature_dim = 8
6num_classes = 3
7
8x = tf.random.normal((batch_size, time_steps, feature_dim))
9y = tf.random.uniform((batch_size, time_steps), maxval=num_classes, dtype=tf.int32)
10
11model = tf.keras.Sequential([
12    tf.keras.layers.SimpleRNN(16, return_sequences=True),
13    tf.keras.layers.Dense(num_classes)
14])
15
16logits = model(x)
17loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
18loss = loss_fn(y, logits)
19print(loss)

Here the labels do not have a class axis because they are integer ids, not one-hot vectors.

One-Hot Labels Need a Different Shape

If your labels are one-hot encoded, they must include the class axis and you must use CategoricalCrossentropy instead.

1import tensorflow as tf
2
3batch_size = 2
4time_steps = 5
5num_classes = 4
6
7logits = tf.random.normal((batch_size, time_steps, num_classes))
8labels = tf.one_hot([[0, 1, 2, 1, 0], [1, 2, 3, 0, 1]], depth=num_classes)
9
10loss_fn = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
11loss = loss_fn(labels, logits)
12print(loss)

If you feed those one-hot labels into a sparse loss, TensorFlow reports a shape mismatch or a broadcast problem because the loss is reading the wrong label format.

Sequence-Level and Step-Level Tasks Cannot Share Labels Blindly

Another common bug is preparing labels shaped (batch_size,) or (batch_size, 1) while the RNN outputs (batch_size, time_steps, num_classes). That means your labels describe one class per sequence, but your model is predicting one class per time step.

If the task is sequence-level classification, use an architecture that collapses the time dimension before the final dense layer:

1model = tf.keras.Sequential([
2    tf.keras.layers.SimpleRNN(16, return_sequences=False),
3    tf.keras.layers.Dense(num_classes)
4])

Now the logits have shape (batch_size, num_classes), which matches a label tensor shaped (batch_size,) for sparse classification.

Print Shapes Before Computing Loss

This is the fastest debugging step and it should happen before you change optimizers, datasets, or model depth.

print("logits:", logits.shape)
print("labels:", y.shape)

Once you see those shapes, most broadcastability errors become mechanical to fix. The mystery usually disappears as soon as you verify whether the model is sequence-level or step-level and whether the labels are sparse or one-hot.

Common Pitfalls

The most common mistake is mixing a per-time-step model with per-sequence labels. The shapes can no longer align.

Another mistake is using one-hot labels with SparseCategoricalCrossentropy, or integer labels with CategoricalCrossentropy. The loss function and label representation must agree.

Developers also forget that return_sequences=True adds a time axis to the logits. That single configuration flag often explains the entire error.

Summary

• The broadcastable error means logits and labels have incompatible shapes for the chosen loss.
• First decide whether the RNN predicts one label per sequence or one per time step.
• Match sparse labels with sparse loss, and one-hot labels with categorical loss.
• Print tensor shapes before the loss call to confirm the contract.
• Most fixes come from aligning model output shape, label shape, and loss semantics.