The attention mechanism intuition

3.5.9 · AI-ML › Sequence Models

WHY attention bottleneck solve karta hai: Fixed-length context vectors lambi sequences ke liye information kho dete hain. Attention har decoder step ke liye input ka ek dynamic, weighted summary banata hai.

What Is Attention?

WHAT it does functionally:

1. Decoder timestep $t$ pe, previous decoder state $s_{t-1}$ aur har encoder hidden state $h_i$ ke beech ek alignment score compute karo
2. Scores ko softmax ke zariye attention weights mein convert karo (unka sum 1 hota hai)
3. Context vector $c_t$ weighted sum ke roop mein compute karo: $c_t={\sum }_i{\alpha }_{ti}{h}_i$
4. Output predict karne ke liye $c_t$ ko $s_t$ ke saath use karo

HOW it differs from vanilla seq2seq: Vanilla sirf last encoder state $h_n$ use karta hai. Attention saare $h_1,h_2,\dots ,h_n$ ko learned weights ke saath use karta hai.

Deriving Attention from First Principles

Step 1: The Alignment Function

WHY we need alignment: Step $t$ pe decoder update karne se pehle, hamare paas previous decoder state $s_{t-1}$ hai. Hum jaanna chahte hain "ab kaun si input positions relevant hain?" Hum relevance ko $s_{t-1}$ use karke ek score function se measure karte hain.

WHY $s_{t-1}$ use karein $s_t$ ki jagah: Standard Bahdanau ordering mein, context $c_t$ ko $s_t$ compute karne ke liye chahiye. Toh hum $s_t$ use nahi kar sakte (woh abhi exist nahi karta)—hum previous state $s_{t-1}$ se align karte hain, phir $c_t$ banate hain, phir $s_t$ pe update karte hain.

WHY this formula: Humein ek single scalar score chahiye. $s_{t-1}$ aur $h_i$ ko directly concatenate/add karna fail ho jaata hai agar dimensions alag hoon. tanh layer ek nonlinear alignment space seekhti hai. $v_a$ ke saath final dot product scalar tak reduce karta hai.

Alternative (Multiplicative/Luong): $e_{ti}=s_t^T{W}_a{h}_i$ — simpler, tab use hota hai jab $d_s=d_h$ ho (Luong ise $s_t$ compute karne ke baad apply karta hai).

Step 2: Attention Weights via Softmax

WHY softmax: Scores $e_{ti}$ unbounded hain aur 1 tak sum nahi karte. Hum input positions pe ek probability distribution chahte hain.

WHY this step is crucial: ${\alpha }_{ti}\in [0,1]$ aur ${\sum }_i{\alpha }_{ti}=1$. Isse attention interpretable banta hai: "word 3 pe 41% focus, word 5 pe 28%, etc."

Step 3: Context Vector

WHY weighted sum: Har $h_i$ position $i$ ke baare mein information encode karta hai. Context $c_t$ ek custom-built summary hai: high-$\alpha$ positions zyada contribute karte hain. Yeh ek soft lookup hai (hard selection ke ulta).

Step 4: Decoder Update

Context vector $c_t$ ko decoder RNN mein previous hidden state aur embedding ke saath feed kiya jaata hai:

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

WHY include $c_t$ twice: Ek baar state update karne ke liye (kaun si information store karni hai), ek baar output generate karne ke liye (kya emit karna hai). Empirically performance improve hoti hai.

Worked Example 1: Translation Attention

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

Setup:

• Encoder "Je", "suis", "étudiant" ke liye $h_1,h_2,h_3$ produce karta hai
• Decoder $t=1$ pe "I" generate karta hai, $t=2$ pe "am" generate karta hai, etc.

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

• Previous decoder state $s_1$ ("I" emit karne ke baad)
• Scores compute karo: $e_{21}=v^T\tanh (W{s}_1+U{h}_1)$, $e_{22}$, $e_{23}$
• Maano $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.12h_1+0.73h_2+0.15h_3$ ← 73% focus "suis" pe
• WHY this makes sense: "am" "suis" ka translation hai, toh attention sahi source word identify karta hai

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

• $s_3$ ab "I am a" ka context carry karta hai
• Scores $h_3$ ("étudiant") ko favor karte hain: ${\alpha }_{43}\approx 0.85$
• Context $c_4$ zyaadatar $h_3$ hai
• Decoder "student" generate karne ke liye $c_4$ use karta hai

WHY this works: Attention ne data se "student ↔ étudiant" alignment seekha, bina explicit word-to-word labels ke.

Worked Example 2: Attention for Long Sequences

Problem: 50-word sentence translate karo. Fixed context vector details kho deta hai.

With Attention:

• Encoder $h_1,\dots ,h_{50}$ produce karta hai
• Decoder step $t=30$ pe, attention dे sakta hai:
  • ${\alpha }_{30,25}=0.6$ (word 25 relevant hai)
  • ${\alpha }_{30,26}=0.3$ (word 26 relevant hai)
  • ${\alpha }_{30,i}\approx 0$ for $i\notin \{25,26\}$
• WHY this scales: Information ek bottleneck se squeeze nahi hoti. Har decoder step ko input ka ek fresh, focused view milta hai.

Computational cost: $O(T_x\times T_y)$ attention scores. $T_x=50$, $T_y=50$ ke liye, woh 2500 scores hain—manageable. (Baad mein: sparse attention for $T_x=1000+$.)

Common Mistakes

Reality: Attention encoder-decoder ko augment karta hai. RNN encoder abhi bhi $h_i$ build karne ke liye input sequentially process karta hai (jo context capture karte hain). Attention un representations pe ek lookup mechanism hai. RNN ke bina, $h_i$ sirf embeddings hote—koi temporal context nahi.

The fix: Attention ko "which encoder states to use" socho, na ki "how to encode."

Reality: Attention correlation-based hai. High $\alpha$ matlab model ne $h_i$ ko $y_t$ predict karne ke liye useful paaya, lekin yeh ho sakta hai:

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

The fix: Attention interpretability hai, causality nahi. Attention patterns ko hamesha linguistic/domain knowledge se validate karo.

Reality: Agar saare scores $e_{ti}$ similar hain, toh softmax uniform ${\alpha }_{ti}\approx 1/T_x$ deta hai (koi focus nahi). Model task ke hisaab se broadly ya sharply attend karna seekh sakta hai. Kuch tasks ke liye (jaise summarization), diffuse attention sahi hai.

The fix: Attention entropy examine karo: $H=-{\sum }_i{\alpha }_{ti}\log {\alpha }_{ti}$. Low entropy = focused, high = diffuse. Dono sahi ho sakte hain.

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: "neural machine translation" → "traduction automatique neuronale" (French) translate karna. Attention dikha sakta hai:

• "traduction" "translation" (word 3) pe attend karta hai
• "automatique" "machine" (word 2) pe attend karta hai
• "neuronale" "neural" (word 1) pe attend karta hai
• Order reversed: English (1,2,3) → French (3,2,1)

Mathematical Properties

Property 1: Permutation Invariance of Encoder (Almost) Agar tum encoder outputs $h_i$ ko permute karo, toh attention weights ${\alpha }_{ti}$ identically permute ho jaate hain. Context $c_t$ same rehta hai. Caveat: RNN encoders permutation invariant nahi hain (woh sequentially process karte hain), lekin attention mechanism khud invariant hai.

Property 2: Context Vector is Convex Combination $c_t={\sum }_i{\alpha }_{ti}{h}_i$ jahan ${\alpha }_{ti}\ge 0$, ${\sum }_i{\alpha }_{ti}=1$ matlab $c_t$ $\{h_i\}$ ke convex hull mein hota hai. Yeh ek interpolation hai, extrapolation nahi.

Property 3: Gradient Flow Har $h_i$ ko har decoder step $t$ se loss ka gradient milta hai (${\alpha }_{ti}$ se weighted). Yeh lambi sequences ke liye vanishing gradients ko mitigate karta hai—encoder position 1 ko abhi bhi strong signal milta hai agar step 50 pe usse attend kiya jaaye.

Connections to Other Concepts

To RNN and LSTM fundamentals: Attention long-term dependency problem ko ek alag angle se address karta hai. LSTMs time ke saath information flow control karne ke liye gating use karte hain. Attention space (sequence positions) pe weighted aggregation use karta hai.

To Encoder-decoder architecture: Attention decoder ko modify karta hai taaki woh ek single fixed vector $c$ ki jagah ek dynamic context vector $c_t$ accept kare.

To Transformers and self-attention: Attention self-attention tak generalize hota hai (query=key=value same sequence se) aur multi-head attention tak (parallel mein multiple attention functions). Core "weighted sum over representations" identical hai.

To Seq2seq models: Seq2seq + attention pre-Transformer dominant architecture tha. Attention woh breakthrough tha jisne seq2seq ko lambi sequences ke liye viable banaya.

To Information bottleneck: Attention bottleneck hata deta hai decoder ko full encoder state history ka access dekar, compressed fixed vector ki jagah.

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

Sequence-to-sequence models mein attention kaun si problem solve karta hai? :: Attention information bottleneck problem solve karta hai jahan ek fixed-length context vector lambi input sequences ko capture karne mein fail hota hai. Yeh decoder ko har decoding step pe relevant input positions pe selectively focus karne deta hai.

$T_x$ aur $T_y$ length ki sequences ke liye attention ki computational complexity kya hai? :: $O(T_x\times T_y)$ kyunki hum $T_y$ decoder steps mein se har ek ke liye $T_x$ scores compute karte hain. 50-word input aur 50-word output ke liye, woh har sample ke liye 2,500 score computations hain.

Concept Map