The attention mechanism intuition

WHY attention solves the bottleneck: Fixed-length context vectors lose information for long sequences. Attention creates a dynamic, weighted summary of the input for each decoder step.

What Is Attention?

WHAT it does functionally:

1. At decoder timestep $t$, compute an alignment score between the previous decoder state $s_{t-1}$ and each encoder hidden state $h_i$
2. Convert scores to attention weights via softmax (they sum to 1)
3. Compute context vector $c_t$ as weighted sum: $c_t = \sum_i \alpha_{ti} h_i$
4. Use $c_t$ alongside $s_t$ to predict output

HOW it differs from vanilla seq2seq: Vanilla uses only the last encoder state $h_n$. Attention uses all $h_1, h_2, \ldots, h_n$ with learned weights.

Deriving Attention from First Principles

Step 1: The Alignment Function

WHY we need alignment: Before updating the decoder at step $t$, we have the previous decoder state $s_{t-1}$. We want to know "which input positions are relevant now?" We measure relevance by a score function using $s_{t-1}$.

WHY use $s_{t-1}$ not $s_t$: In the standard Bahdanau ordering, the context $c_t$ is needed to compute $s_t$. So we can't use $s_t$ (it doesn't exist yet)—we align using the previous state $s_{t-1}$, then form $c_t$, then update to $s_t$.

WHY this formula: We need a single scalar score. Concatenating/adding $s_{t-1}$ and $h_i$ directly fails if dimensions differ. The tanh layer learns a nonlinear alignment space. The final dot product with $v_a$ reduces to a scalar.

Alternative (Multiplicative/Luong): $e_{ti} = s_t^T W_a h_i$ — simpler, used when $d_s = d_h$ (Luong applies it after computing $s_t$).

Step 2: Attention Weights via Softmax

WHY softmax: Scores $e_{ti}$ are unbounded and don't sum to 1. We want a probability distribution over input positions.

WHY this step is crucial: $\alpha_{ti} \in [0,1]$ and $\sum_i \alpha_{ti} = 1$. This makes attention interpretable: "41% focus on word 3, 28% on word 5, etc."

Step 3: Context Vector

WHY weighted sum: Each $h_i$ encodes information about position $i$. The context $c_t$ is a custom-built summary: high-$\alpha$ positions contribute more. This is a soft lookup (vs. hard selection).

Step 4: Decoder Update

The context vector $c_t$ is fed into the decoder RNN alongside the previous hidden state and embedding:

where $f$ is RNN update (GRU/LSTM), $g$ is output projection (often $\text{softmax}(W[s_t; c_t])$).

WHY include $c_t$ twice: Once to update state (what information to store), once to generate output (what to emit). Empirically improves performance.

Worked Example 1: Translation Attention

Task: Translate "Je suis étudiant" → "I am a student"

Setup:

• Encoder produces $h_1, h_2, h_3$ for "Je", "suis", "étudiant"
• Decoder at $t=1$ generates "I", at $t=2$ generates "am", etc.

At $t=2$ (generating "am"):

• Previous decoder state $s_1$ (after emitting "I")
• Compute scores: $e_{21} = v^T \tanh(W s_1 + U h_1)$, $e_{22}$, $e_{23}$
• Say $e_{21} = 0.3$, $e_{22} = 2.1$, $e_{23} = 0.5$
• Denominator: $\exp(0.3) + \exp(2.1) + \exp(0.5) = 1.350 + 8.166 + 1.649 = 11.165$
• Softmax: $\alpha_{21} = \frac{\exp(0.3)}{11.165} = \frac{1.350}{11.165} = 0.12$
• $\alpha_{22} = \frac{\exp(2.1)}{11.165} = \frac{8.166}{11.165} = 0.73$, $\alpha_{23} = \frac{\exp(0.5)}{11.165} = \frac{1.649}{11.165} = 0.15$
• Context: $c_2 = 0.12\, h_1 + 0.73\, h_2 + 0.15\, h_3$ ← 73% focus on "suis"
• WHY this makes sense: "am" translates "suis", so attention correctly identifies the source word

At $t=4$ (generating "student"):

• $s_3$ now carries context of "I am a"
• Scores favor $h_3$ ("étudiant"): $\alpha_{43} \approx 0.85$
• Context $c_4$ is mostly $h_3$
• Decoder uses $c_4$ to generate "student"

WHY this works: Attention learned the alignment "student ↔ étudiant" from data, without explicit word-to-word labels.

Worked Example 2: Attention for Long Sequences

Problem: Translate a 50-word sentence. Fixed context vector loses details.

With Attention:

• Encoder produces $h_1, \ldots, h_{50}$
• At decoder step $t=30$, attention might give:
  • $\alpha_{30,25} = 0.6$ (word 25 is relevant)
  • $\alpha_{30,26} = 0.3$ (word 26 is relevant)
  • $\alpha_{30,i} \approx 0$ for $i \notin \{25,26\}$
• WHY this scales: Information isn't squeezed through a bottleneck. Each decoder step gets a fresh, focused view of the input.

Computational cost: $O(T_x \times T_y)$ attention scores. For $T_x=50$, $T_y=50$, that's 2500 scores—manageable. (Later: sparse attention for $T_x=1000+$.)

Common Mistakes

Reality: Attention augments the encoder-decoder. The RNN encoder still processes the input sequentially to build $h_i$ (which capture context). Attention is a lookup mechanism over those representations. Without the RNN, $h_i$ would just be embeddings—no temporal context.

The fix: Think of attention as "which encoder states to use" not "how to encode."

Reality: Attention is correlation-based. High $\alpha$ means the model found $h_i$ useful for predicting $y_t$, but it could be:

• Syntactic agreement (gender/number)
• Co-occurrence (idioms)
• Spurious correlation (the model cheating)

The fix: Attention is interpretability, not causality. Always validate attention patterns against linguistic/domain knowledge.

Reality: If all scores $e_{ti}$ are similar, softmax gives uniform $\alpha_{ti} \approx 1/T_x$ (no focus). The model can learn to attend broadly or sharply depending on the task. For some tasks (e.g., summarization), diffuse attention is correct.

The fix: Examine attention entropy: $H = -\sum_i \alpha_{ti} \log \alpha_{ti}$. Low entropy = focused, high = diffuse. Both can be correct.

Visualizing Attention

Attention heatmap: Rows = decoder steps, columns = encoder steps, color = $\alpha_{ti}$.

• Diagonal pattern → monotonic alignment (speech recognition, OCR)
• Scattered pattern → reordering (English-Japanese translation)
• Vertical bands → many-to-one (compound words)

Example: Translating "neural machine translation" → "traduction automatique neuronale" (French). Attention might show:

• "traduction" attends to "translation" (word 3)
• "automatique" attends to "machine" (word 2)
• "neuronale" attends to "neural" (word 1)
• Order reversed: English (1,2,3) → French (3,2,1)

Mathematical Properties

Property 1: Permutation Invariance of Encoder (Almost) If you permute encoder outputs $h_i$, attention weights $\alpha_{ti}$ permute identically. The context $c_t$ is the same. Caveat: RNN encoders aren't permutation invariant (they process sequentially), but the attention mechanism itself is.

Property 2: Context Vector is Convex Combination $c_t = \sum_i \alpha_{ti} h_i$ with $\alpha_{ti} \geq 0$, $\sum_i \alpha_{ti} = 1$ means $c_t$ lies in the convex hull of $\{h_i\}$. It's an interpolation, not extrapolation.

Property 3: Gradient Flow Every $h_i$ receives gradient from the loss at every decoder step $t$ (weighted by $\alpha_{ti}$). This mitigates vanishing gradients for long sequences—encoder position 1 still gets strong signal if it's attended to at step 50.

Connections to Other Concepts

To RNN and LSTM fundamentals: Attention addresses the long-term dependency problem from a different angle. LSTMs use gating to control information flow over time. Attention uses weighted aggregation over space (sequence positions).

To Encoder-decoder architecture: Attention modifies the decoder to accept a dynamic context vector $c_t$ instead of a single fixed vector $c$.

To Transformers and self-attention: Attention generalizes to self-attention (query=key=value from same sequence) and multi-head attention (multiple attention functions in parallel). The core "weighted sum over representations" is identical.

To Seq2seq models: Seq2seq + attention is the dominant architecture pre-Transformer. Attention was the breakthrough that made seq2seq viable for long sequences.

To Information bottleneck: Attention removes the bottleneck by giving the decoder access to the full encoder state history, not a compressed fixed vector.

Connections

• RNN and LSTM fundamentals
• Encoder-decoder architecture
• Seq2seq models
• Transformers and self-attention
• Information bottleneck
• Gradient flow in deep networks
• Neural machine translation

#flashcards/ai-ml

What problem does attention solve in sequence-to-sequence models? :: Attention solves the information bottleneck problem where a fixed-length context vector fails to capture long input sequences. It allows the decoder to selectively focus on relevant input positions at each decoding step.

What is the computational complexity of attention for sequences of length $T_x$ and $T_y$? :: $O(T_x \times T_y)$ because we compute $T_x$ scores for each of $T_y$ decoder steps. For a 50-word input and 50-word output, that's 2,500 score computations per sample.

Concept Map

Hinglish (regional understanding)

Hinglish (regional understanding)