অ্যাটেনশন মেকানিজম

সমস্যা — bottleneck

Encoder-Decoder RNN-এ পুরো source sequence একটিমাত্র vector-এ চাপা হয়। দীর্ঘ বাক্যে তথ্য হারিয়ে যায়। Attention প্রতিটি decoder step-এ সব encoder state-এ access দেয়।

Scaled Dot-Product Attention

Attention(Q, K, V) = softmax(Q · Kᵀ / √d_k) · V

• Query (Q): "আমি কী খুঁজছি?"
• Key (K): প্রতিটি item-এর "label"।
• Value (V): প্রকৃত তথ্য।
• √d_k দিয়ে scale — gradient stable রাখে।

NumPy-তে scratch implementation

import numpy as np

def softmax(x, axis=-1):
    e = np.exp(x - x.max(axis=axis, keepdims=True))
    return e / e.sum(axis=axis, keepdims=True)

def attention(Q, K, V):
    d_k = Q.shape[-1]
    scores = Q @ K.T / np.sqrt(d_k)
    weights = softmax(scores)
    return weights @ V, weights

Self-Attention

Self-attention-এ Q, K, V — সব একই sequence থেকে আসে। প্রতিটি token sequence-এর প্রতিটি token-এর সাথে সম্পর্ক হিসেব করে। এটি Transformer-এর কোর।

class SelfAttention(nn.Module):
    def __init__(self, d):
        super().__init__()
        self.q = nn.Linear(d, d)
        self.k = nn.Linear(d, d)
        self.v = nn.Linear(d, d)
    def forward(self, x):
        Q, K, V = self.q(x), self.k(x), self.v(x)
        s = (Q @ K.transpose(-2,-1)) / (Q.size(-1)**0.5)
        a = s.softmax(-1)
        return a @ V

Multi-Head Attention

একাধিক "head" সমান্তরালে আলাদা subspace-এ attention করে — কেউ syntactic relation, কেউ semantic similarity। ফলাফল concatenate করে একটি linear projection।

mha = nn.MultiheadAttention(embed_dim=512, num_heads=8, batch_first=True)
out, weights = mha(query=x, key=x, value=x)

Attention প্রকারভেদ

• Additive (Bahdanau): MLP-based, পুরোনো।
• Dot-product (Luong): দ্রুত।
• Scaled dot-product: আধুনিক স্ট্যান্ডার্ড।
• Masked self-attention: ভবিষ্যত token দেখতে দেয় না (GPT)।
• Cross-attention: decoder encoder-এর দিকে তাকায়।

Visualization

import matplotlib.pyplot as plt
plt.imshow(attn_weights[0].cpu(), cmap="viridis")
plt.xticks(range(len(tokens)), tokens, rotation=90)
plt.yticks(range(len(tokens)), tokens)

অনুশীলন

সারসংক্ষেপ