Attention-Based Encoder-Decoder Models

While Connectionist Temporal Classification (CTC) provides an elegant way to handle variable-length audio inputs without needing explicit alignments during training, it makes a strong conditional independence assumption: the prediction at each time step is independent of other predictions, given the input audio. This can limit its ability to model the inherent dependencies within the output text sequence.

Sequence-to-sequence (Seq2Seq) models, particularly those enhanced with attention mechanisms, offer an alternative approach that directly addresses this limitation. Originally popularized in machine translation, these models have proven highly effective for ASR, directly mapping an input sequence of acoustic features $X = (x_1, ..., x_T)$ to an output sequence of characters or phonemes $Y = (y_1, ..., y_U)$.

The Encoder-Decoder Framework

An attention-based Seq2Seq model for ASR consists of two main components: an Encoder and a Decoder, linked by an Attention mechanism.

Basic architecture of an Attention-Based Encoder-Decoder model for ASR. The encoder processes the input audio features, the attention mechanism calculates a context vector based on encoder outputs and the current decoder state, and the decoder generates the output sequence token by token.

1. Encoder: This component processes the entire input sequence of acoustic features ($x_1, ..., x_T$). Typically, it's implemented using recurrent neural networks like LSTMs or GRUs (often bidirectional to capture context from both past and future frames) or even stacked convolutional layers followed by RNNs. The encoder's role is to transform the input features into a sequence of higher-level representations, often called hidden states or annotations ($h_1, ..., h_T$). Each $h_t$ ideally summarizes the relevant information around time step $t$ in the input audio.

   $$h_t = \text{Encoder}(x_1, ..., x_T)_t$$

2. Decoder: This component generates the output text sequence ($y_1, ..., y_U$) one token at a time. It's usually an autoregressive RNN (LSTM/GRU). At each output step $u$, the decoder receives the previously generated token $y_{u-1}$ and its own previous hidden state $s_{u-1}$ as input. Crucially, it also receives a context vector $c_u$, which is provided by the attention mechanism. Based on these inputs, it updates its hidden state $s_u$ and predicts the probability distribution for the next output token $y_u$ over the vocabulary (e.g., characters, subwords).

   $$s_u = \text{DecoderRNN}(s_{u-1}, y_{u-1}, c_u)$$ $$P(y_u | y_{<u}, X) = \text{softmax}(\text{OutputLayer}(s_u, c_u))$$

The Attention Mechanism: Focusing on Relevant Audio

The fixed-length context vector limitation of early Seq2Seq models (where the encoder summarized the entire input into a single vector) is problematic for long sequences like speech. The attention mechanism overcomes this by allowing the decoder to dynamically focus on different parts of the entire encoded input sequence ($h_1, ..., h_T$) when generating each output token $y_u$.

At each decoder step $u$, the attention mechanism calculates a context vector $c_u$ as a weighted sum of the encoder hidden states $h_t$:

$$c_u = \sum_{t=1}^{T} \alpha_{ut} h_t$$

The weights $\alpha_{ut}$ are called attention weights. They determine how much "attention" the decoder should pay to the encoder state $h_t$ when predicting the output token $y_u$. These weights are calculated based on the similarity or alignment between the current decoder state $s_{u-1}$ (acting as a "query") and each encoder hidden state $h_t$ (acting as "keys").

1. Calculate Alignment Scores: An alignment model $e_{ut}$ scores how well the input around time $t$ matches the output at position $u$. A common choice is additive attention (Bahdanau-style):

   $$e_{ut} = v_a^T \tanh(W_a s_{u-1} + V_a h_t + b_a)$$

   Here, $v_a$, $W_a$, $V_a$, and $b_a$ are learnable weight matrices and biases of the attention mechanism. Another popular option is dot-product attention (Luong-style), which is computationally simpler if the dimensions match:

   $$e_{ut} = s_{u-1}^T W_a h_t$$

   Or simply $e_{ut} = s_{u-1}^T h_t$ if dimensions allow direct dot products.

2. Normalize Scores to Weights: The scores $e_{ut}$ are normalized using a softmax function across all input time steps to obtain the attention weights $\alpha_{ut}$. These weights sum to 1.

   $$\alpha_{ut} = \frac{\exp(e_{ut})}{\sum_{k=1}^{T} \exp(e_{uk})}$$

3. Compute Context Vector: The context vector $c_u$ is computed as the weighted sum shown earlier. This vector provides a summary of the input audio specifically relevant for generating the output token $y_u$.

This dynamic weighting allows the model to, for instance, focus on the audio segment corresponding to the phoneme /k/ when predicting the character 'c', then shift its focus to the /æ/ segment for 'a', and finally the /t/ segment for 't' when transcribing the word "cat".

Training and Inference

Training: Attention-based models are typically trained end-to-end using maximum likelihood estimation. The objective is to maximize the probability of the correct output sequence given the input audio. The loss function is usually the sum or average of the cross-entropy losses at each decoder step:

$$\mathcal{L} = - \sum_{u=1}^{U} \log P(y_u^* | y_{<u}^*, X)$$

where $y^*$ is the ground truth sequence. During training, a technique called teacher forcing is commonly used. Instead of feeding the decoder's own prediction from the previous step ($y_{u-1}$) as input for the current step, the ground truth token ($y_{u-1}^*$) is provided. This stabilizes training and speeds up convergence, though it can lead to a mismatch between training and inference conditions (known as exposure bias).

Inference (Decoding): Generating the output sequence at test time requires producing one token at a time. Since the ground truth is unavailable, the decoder uses its own previously predicted token as input for the next step. Finding the most likely sequence $Y$ requires searching through the space of possible output sequences.

• Greedy Search: At each step $u$, simply select the token $y_u$ with the highest probability according to the model's output distribution. This is fast but often suboptimal.
• Beam Search: A more effective approach is beam search. It maintains a fixed number ($k$, the beam width) of most probable partial hypotheses (sequences) at each step. For each hypothesis, it explores possible next tokens, calculates the probabilities of the extended sequences, and keeps only the top $k$ overall sequences for the next step. This explores a larger part of the search space than greedy search and generally yields better results, at the cost of increased computation.

Advantages and Disadvantages

Advantages:

• Flexibility: Can model complex, non-monotonic alignments between audio and text.
• Context Modeling: Explicitly models dependencies in the output sequence through the autoregressive decoder.
• End-to-End Training: Learns all components jointly, potentially leading to better overall optimization.
• State-of-the-Art Performance: Achieves excellent results on many ASR benchmarks.

Disadvantages:

• Computational Cost: Attention calculation adds overhead, especially for long sequences.
• Sequential Inference: The autoregressive nature of the decoder means inference cannot be parallelized over output tokens, making it slower than non-autoregressive models like CTC for real-time applications.
• Alignment Issues: Can sometimes fail to learn meaningful alignments, especially with limited data or very long sequences. Attention mechanisms might focus too broadly or sharply, or lose track.
• Exposure Bias: The discrepancy between teacher forcing during training and autoregressive generation during inference can degrade performance.

Attention-based encoder-decoder models represent a significant step in acoustic modeling, moving away from frame-wise classification with strong independence assumptions towards generating output sequences conditioned on the entire input history and relevant parts of the audio input. While subsequent architectures like the RNN Transducer (discussed next) and Transformers offer improvements, particularly for streaming and parallelization, understanding the attention mechanism is fundamental to modern ASR.