As we discussed earlier, recurrent models like RNNs, LSTMs, and GRUs process sequences step-by-step. This sequential nature, while intuitive for modeling time-series or language, imposes a fundamental constraint on computational parallelization, particularly during the training phase.

The Sequential Dependency Bottleneck

The core operation in any RNN involves computing the hidden state $h_t$ at timestep $t$ based on the input $x_t$ at that timestep and the hidden state $h_{t-1}$ from the previous timestep. This relationship is typically expressed as:

h_t = f(h_{t-1}, x_t)

where $f$ represents the transformation performed by the RNN cell (which could be a simple RNN update, an LSTM cell, or a GRU cell). This equation highlights the inherent sequential dependency: calculating $h_t$ requires the result of $h_{t-1}$ , which in turn required $h_{t-2}$ , and so forth, all the way back to the initial state $h_0$ .

The calculation of the hidden state $h_t$ depends sequentially on the previous state $h_{t-1}$ . This dependency prevents parallel computation across time steps within a single sequence.

This temporal dependency creates a bottleneck. Modern hardware accelerators like GPUs and TPUs excel at performing massive matrix operations in parallel. However, within a single sequence processed by an RNN, the computation for timestep $t$ cannot begin until the computation for timestep $t-1$ is complete. The operations within a single timestep (e.g., matrix multiplications inside the LSTM gates) can be parallelized, but the computation across timesteps remains sequential.

Impact on Training Efficiency

This constraint significantly limits the acceleration achievable during training. While you can parallelize RNN training across different sequences in a mini-batch (data parallelism), the processing of each individual sequence remains bound by its length due to the sequential forward pass.

Furthermore, the backward pass through the network, known as Backpropagation Through Time (BPTT), suffers from the same sequential constraint. To compute the gradient of the loss with respect to parameters used at timestep $t$ , BPTT requires propagating gradients backward through the sequence, step-by-step. The gradient calculation at timestep $t$ depends on the gradient calculation from timestep $t+1$ . This mirrors the forward pass dependency, preventing parallelization of the gradient computations across time.

The practical consequence is that training RNNs on very long sequences becomes computationally expensive and slow. Increasing the sequence length leads to a roughly linear increase in computation time for that sequence, and the inability to fully leverage parallel hardware means GPUs might be underutilized during parts of the computation.

This limitation is a significant factor motivating the development of architectures like the Transformer, which aims to capture sequence dependencies without relying on sequential recurrence, thereby enabling much greater parallelization during training.