When working with Recurrent Neural Networks in deep learning frameworks, one of the most common sources of error is providing data with incorrect tensor shapes. RNN layers are designed to process sequences, and they expect input data structured in a specific 3D format. Getting this right is fundamental to building and training your models correctly.

Let's break down the typical input shape expected by most RNN layers (like SimpleRNN, LSTM, or GRU) in frameworks like TensorFlow/Keras and PyTorch (when using batch_first=True). The standard input is a 3D tensor with the dimensions:

(batch_size, time_steps, features)

Understanding the Input Tensor Dimensions

batch_size: This dimension represents the number of independent sequences you process simultaneously in one forward/backward pass. Training in batches is standard practice in deep learning for computational efficiency and gradient stability. For instance, if you are processing 128 different text reviews at once, your batch_size would be 128. If you are processing a single sequence for prediction, the batch_size would be 1.
time_steps (Sequence Length): This is the length of each sequence in the batch. For text data, it could be the number of words (or characters) in a sentence after padding or truncation. For time series data, it could be the number of observations in a specific time window. Crucially, within a single batch, all sequences typically need to have the same length. Techniques like padding are used to achieve this uniform length, as we'll cover in Chapter 8. If your sequences have 50 time steps, this dimension will be 50.
features (Input Dimensionality): This dimension specifies the number of features available at each time step within a sequence.
- For simple univariate time series (like predicting a single stock price), this might be 1.
- For multivariate time series (e.g., weather data with temperature, humidity, pressure), this would be the number of measured variables (e.g., 3).
- For text data that has been converted to word embeddings (a common technique discussed later), this would be the dimensionality of the embedding vector (e.g., 100, 300).

Think of the input tensor as a collection (batch_size) of matrices, where each matrix has time_steps rows and features columns.

Here's a small diagram illustrating the input tensor structure for a batch of 2 sequences, each with 3 time steps and 4 features:

A conceptual representation of an RNN input tensor with shape (2, 3, 4), showing two sequences, each with three time steps and four features per step.

Understanding RNN Layer Output Shapes

The shape of the tensor output by an RNN layer depends on a configuration parameter, often called return_sequences (in Keras/TensorFlow) or implicitly by how you use the outputs (in PyTorch). Let $N$ be the batch_size, $T$ be the time_steps, $F$ be the number of input features, and $H$ be the number of hidden units (or neurons) specified when creating the RNN layer.

Returning the Full Sequence of Outputs: If you configure the layer to return the hidden state for every time step (e.g., return_sequences=True), the output tensor shape will be: (batch_size, time_steps, hidden_units) or $(N, T, H)$

This is necessary when you want to:
- Stack multiple RNN layers (the next RNN layer needs the full sequence output of the previous one).
- Apply operations that act on each time step's output (e.g., a TimeDistributed wrapper around a Dense layer in Keras, or certain types of attention mechanisms).
- Perform sequence-to-sequence tasks where an output is needed for each input time step.
Returning Only the Final Output: If you configure the layer to return only the hidden state from the last time step (e.g., return_sequences=False, the default in Keras), the output tensor shape will be: (batch_size, hidden_units) or $(N, H)$

This is commonly used when:
- The RNN layer is the final recurrent layer in your model.
- You need a single vector representation of the entire sequence to feed into a subsequent Dense layer for classification or regression (e.g., sentiment analysis of a sentence).

The number of hidden_units ( $H$ ) is a hyperparameter you choose when defining the RNN layer. It determines the dimensionality of the internal hidden state and, consequently, the output vectors.

Practical Considerations

Framework Defaults: Always check the documentation for your specific deep learning framework (TensorFlow, PyTorch, etc.). While the (batch_size, time_steps, features) input convention is common, defaults for output shapes (return_sequences) and batch dimension placement (batch_first) can vary. PyTorch's RNN layers, for instance, default to batch_first=False, expecting (time_steps, batch_size, features), unless you specify batch_first=True. Keras layers generally default to (batch_size, time_steps, features) input and return_sequences=False output.
Data Preparation: Ensure your data loading and preprocessing pipeline (covered in Chapter 8) correctly shapes your raw sequence data into these 3D tensors, including handling variable lengths via padding or other methods.
Debugging: Shape mismatches are frequent errors. When encountering runtime errors, carefully print and inspect the .shape attribute of your input tensors and the expected input shape of the RNN layer.

Understanding and correctly managing these tensor shapes is a practical necessity for implementing RNNs. As you proceed to build models in the upcoming sections and chapters, keep this (batch_size, time_steps, features) structure in mind for inputs, and be mindful of whether you need the full sequence or just the final output from your recurrent layers.