Attention — query, key, value আর alignment

পর্ব ৩০-এ দেখেছেন, একটি context vector দিয়ে সব তথ্য পার করলে লম্বা input ভেঙে পড়ে। Padding আর attention mask এসেছে পর্ব ১১-এ, স্থিতিশীল softmax পর্ব ৩-এ। Dot product-এর জ্যামিতিক অর্থ AI-এর ভিত্তি কোর্সের পর্ব ৩৩-এ, embedding দিয়ে অর্থ ধরে খোঁজা পর্ব ৬৯-এ, আর query, key, value-র প্রথম পরিচয় পর্ব ৭০-এ। সেখানে হিসাবটি একবার দেখেছেন; এবার ভেতরে ঢুকে মেপে দেখব।

১ · একটি চিরকুট থেকে পুরো খাতা — attention কেন

এই “দরকারি পাতা খোলা”-ই attention. Encoder-এর শেষ state-এর বদলে আমরা তার সব state জমা রাখি: h₁, …, h_T. Decoder-এর প্রতিটি ধাপ t নিজের একটি context c_t পায়:

e_tj = score(s_t−1, h_j)  ·  a_tj = softmax_j(e_t)  ·  c_t = Σ_j a_tj h_j

এখানে s_t−1 decoder-এর আগের state, h_j j-তম input token-এর encoder state, e_tj তাদের alignment score, a_tj সেই ঘরের attention weight, আর c_t এই ধাপের context. Weight-গুলো ধনাত্মক, যোগফল ১, প্রতি ধাপে নতুন করে হিসাব হয়। লক্ষ্য করুন: c_t-এর আকার এখনো (B, H), কিন্তু তাকে আর একবারে সব তথ্য বহন করতে হয় না। প্রতি ধাপে শুধু সেই ধাপের দরকারি অংশ বহন করলেই চলে।

২ · Query, key, value — নরম খোঁজার তিন ধাপ

Python-এর dict একটি শক্ত খোঁজা: d["ডাল"] হয় হুবহু মেলে, নয় error. এতে gradient চলে না, কারণ বাছাইটি লাফিয়ে বদলায়। Soft lookup সব key-এর সঙ্গেই মিল মাপে, আর সব value মেশায় মিলের অনুপাতে। হিসাবটি মসৃণ, তাই backpropagation চলে।

• Query (q): এই মুহূর্তে কী খুঁজছি। Seq2seq-এ decoder-এর আগের state.
• Key (k_j): প্রতিটি ঘরের লেবেল, যার সঙ্গে query মেলানো হয়।
• Value (v_j): ঘরটি বেছে নিলে যা পাওয়া যায়।

এই পর্বের GRU model-এ key আর value একই জিনিস: h_j. নামগুলো আলাদা রাখার কারণ, পরের পর্বে Transformer-এ এরা আলাদা হবে। নিচে পুরো পথটি দেখুন।

এবার একটি হিসাব হাতে। ৩টি token, key দুই মাপের, value একটি সংখ্যা। এই ধরনের অঙ্ক পরীক্ষায়ও আসতে পারে, তাই প্রতিটি ধাপ খাতায় মিলিয়ে নিন।

একই কাজ NumPy-তে, ৪টি token নিয়ে। বাজারঘরের চারটি পণ্য; key বানানো লেবেল, value হলো দাম আর মজুত। শেষ অংশে query-কে বড় করে দেখব বাছাই কড়া হয় কি না।

import numpy as np
np.set_printoptions(precision=3, suppress=True, linewidth=60)
items = ["চাল", "ডাল", "তেল", "লবণ"]         # ৪টি token
K = np.array([[1.0, 0.0, 0.5],               # keys: লেবেল, (4, 3)
              [0.8, 0.6, 0.0],
              [0.0, 1.0, 0.2],
              [-0.5, 0.0, 1.0]])
V = np.array([[70.0, 12.0],                  # values: দাম আর মজুত, (4, 2)
              [120.0, 5.0],
              [180.0, 8.0],
              [40.0, 30.0]])
q = np.array([1.0, 0.5, 0.0])                # query, (3,)

def softmax(z):
    e = np.exp(z - z.max())                  # পর্ব ৩-এর স্থিতিশীল রূপ
    return e / e.sum()

def attend(q, K, V):
    scores = K @ q                           # dot product, (4,)
    weights = softmax(scores)                # যোগফল 1, (4,)
    return scores, weights, weights @ V      # weighted sum, (2,)

s, a, c = attend(q, K, V)
print("shape: q", q.shape, "K", K.shape, "V", V.shape)
for name, si, ai in zip(items, s, a):
    print(f"{name}: score {si:5.2f}  weight {ai:.3f}")
print("weight-এর যোগফল:", round(float(a.sum()), 6))
print("context c =", c, "shape", c.shape)
for beta in (1, 3, 10):                      # query যত বড়, বাছাই তত কড়া
    _, a2, c2 = attend(beta * q, K, V)
    print(f"query × {beta:2d}: weight {a2}  c {c2}")

shape: q (3,) K (4, 3) V (4, 2)
চাল: score  1.00  weight 0.341
ডাল: score  1.10  weight 0.377
তেল: score  0.50  weight 0.207
লবণ: score -0.50  weight 0.076
weight-এর যোগফল: 1.0
context c = [109.281   9.906] shape (2,)
query ×  1: weight [0.341 0.377 0.207 0.076]  c [109.281   9.906]
query ×  3: weight [0.387 0.522 0.086 0.004]  c [105.488   8.075]
query × 10: weight [0.268 0.73  0.002 0.   ]  c [106.686   6.885]

৩ · Score দুই রকম — dot-product আর additive

Softmax আর weighted sum সব attention-এ প্রায় একই; আলাদা হয় score. দুটি সূত্র সবচেয়ে পরিচিত:

dot: e = s^Th  ·  additive: e = v^T tanh(W_qs + W_kh)

Dot-product attention-এ শেখার কিছু নেই: query আর key-এর dot product. Additive attention-এ W_q, W_k matrix আর v একটি vector, যা শেখা হয়; এটিই একটি লুকানো স্তরের ছোট network. এই ধরনের score Bahdanau-র প্রবন্ধে ছিল, আর Luong-রা dot-সহ কয়েকটি সরল রূপ তুলনা করেন।

নিচের কোডে দুটি score একই vector-এর ওপর। Additive-এর parameter এলোমেলো, না-শেখা, তাই তার সংখ্যার কোনো “অর্থ” খুঁজবেন না; দেখার বিষয় আকার, সীমা আর একটি বড় key-এর প্রভাব।

import numpy as np
np.set_printoptions(precision=3, suppress=True, linewidth=60)
rng = np.random.default_rng(42)
K = np.array([[1.0, 0.0, 0.5], [0.8, 0.6, 0.0],
              [0.0, 1.0, 0.2], [-0.5, 0.0, 1.0]])
q = np.array([1.0, 0.5, 0.0])
d, da = 3, 4                                 # key-এর মাপ, additive-এর ভেতরের মাপ
Wq = rng.normal(size=(da, d)) * 0.5          # না-শেখা, এলোমেলো parameter
Wk = rng.normal(size=(da, d)) * 0.5
v = rng.normal(size=da) * 0.5

def softmax(z):
    e = np.exp(z - z.max()); return e / e.sum()
def dot(q, K):
    return K @ q
def additive(q, K):
    return np.tanh(Wq @ q + K @ Wk.T) @ v    # (4, da) @ (da,) → (4,)

print("dot      score", dot(q, K), "weight", softmax(dot(q, K)))
print("additive score", additive(q, K), "weight", softmax(additive(q, K)))
print("dot-এর parameter: 0")
print("additive-এর parameter:", Wq.size + Wk.size + v.size)
K2 = K.copy(); K2[3] = K2[3] * -10           # লবণের key উল্টে ১০ গুণ বড়
print("\nএকটি key ১০ গুণ বড় করলে:")
print("dot      score", dot(q, K2), "weight", softmax(dot(q, K2)))
print("additive score", additive(q, K2), "weight", softmax(additive(q, K2)))
print("additive score-এর সীমা: ±", round(float(np.abs(v).sum()), 3))
cos = K2 @ q / (np.linalg.norm(K2, axis=1) * np.linalg.norm(q))
print("cosine (দৈর্ঘ্য বাদ) ", cos)

dot      score [ 1.   1.1  0.5 -0.5] weight [0.341 0.377 0.207 0.076]
additive score [ 0.096  0.052 -0.06  -0.08 ] weight [0.274 0.262 0.234 0.23 ]
dot-এর parameter: 0
additive-এর parameter: 28

একটি key ১০ গুণ বড় করলে:
dot      score [1.  1.1 0.5 5. ] weight [0.017 0.019 0.011 0.953]
additive score [ 0.096  0.052 -0.06   0.152] weight [0.258 0.247 0.221 0.273]
additive score-এর সীমা: ± 0.839
cosine (দৈর্ঘ্য বাদ)  [0.8   0.984 0.439 0.4  ]

৪ · Mask — pad-কে ঠিক শূন্য weight দেওয়া

একটি batch-এ ৪ অঙ্ক আর ২ অঙ্কের নম্বর একসঙ্গে থাকলে ছোটটিতে pad বসে (পর্ব ১১). Pad ডেটা নয়, তাই attention যেন সেখানে না তাকায়। এটিই padding mask-এর কাজ। আর একটি জিনিস প্রায়ই ভুল হয়: pad ঘরের state শূন্য হলে score-ও শূন্য, কিন্তু শূন্য score মানে শূন্য weight নয়।

এবার batch আকারে, এমন সংখ্যায় যেখানে pad-এর শূন্য score আসল score-এর চেয়েও বড়।

import numpy as np
np.set_printoptions(precision=3, suppress=True, linewidth=60)
PAD = 0
src = np.array([[5, 7, 6, 9],                # ৪ অঙ্ক
                [8, 3, PAD, PAD]])           # ২ অঙ্ক + ২ pad
H = np.zeros((2, 4, 2))                      # encoder states, (B, T, d)
H[0, :4] = [[1, 0], [0, 1], [-1, 1], [1, 1]]
H[1, :2] = [[-1, 0.5], [-0.5, -1]]           # pad ঘরে শূন্য vector
s = np.array([[1.0, 0.5], [1.0, 0.5]])       # query, (B, d)
mask = src != PAD                            # True = আসল token

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

scores = (H @ s[..., None])[..., 0]          # (B, T)
print("mask:\n", mask.astype(int))
print("scores:\n", scores)
print("১. mask নেই:\n", softmax(scores))
print("২. score × mask (ভুল পথ), সারি ২:", softmax(scores * mask)[1])
masked = np.where(mask, scores, -np.inf)     # softmax-এর আগে −inf
w = softmax(masked)
print("৩. −inf:\n", w)
print("প্রতি সারির যোগফল:", w.sum(-1))
c = (w[..., None] * H).sum(1)                # context, (B, d)
print("batch-এ context, সারি ২:", c[1])
one = softmax(H[1, :2] @ s[1])               # pad ছাড়া একা চালালে
print("একা context:", one @ H[1, :2])
print("সব ঘর mask হলে:", softmax(np.full((1, 3), -np.inf)))

mask:
 [[1 1 1 1]
 [1 1 0 0]]
scores:
 [[ 1.    0.5  -0.5   1.5 ]
 [-0.75 -1.    0.    0.  ]]
১. mask নেই:
 [[0.287 0.174 0.064 0.474]
 [0.166 0.13  0.352 0.352]]
২. score × mask (ভুল পথ), সারি ২: [0.166 0.13  0.352 0.352]
৩. −inf:
 [[0.287 0.174 0.064 0.474]
 [0.562 0.438 0.    0.   ]]
প্রতি সারির যোগফল: [1. 1.]
batch-এ context, সারি ২: [-0.781 -0.157]
একা context: [-0.781 -0.157]
সব ঘর mask হলে: [[nan nan nan]]

৫ · Decoder-এ attention বসানো — shape ধরে

পর্ব ৩০-এর GRU model-এ তিনটি বদল। Encoder এখন সব state ফেরত দেয়। Decoder-এর ইনপুটে আগের token-এর embedding-এর পাশে context যোগ হয়। আর output layer পড়ে নতুন state আর context, দুটিই। নকশাটি Bahdanau ধরনের (আগের state হলো query), তবে encoder একমুখী, আর দুই score-ই পরীক্ষা করা যায়। নিচে আসল class-এর মূল অংশ, সংক্ষেপে; greedy আর constructor-এর বাকি অংশ বাদ, packing আগের মতোই।

class AttnSeq2Seq(nn.Module):
    # self.dec = nn.GRUCell(emb + hid, hid); self.out = nn.Linear(2 * hid, n_tgt)
    def encode(self, src, lens):
        packed = nn.utils.rnn.pack_padded_sequence(
            self.src_emb(src), lens.cpu(), batch_first=True, enforce_sorted=False)
        H, h_n = self.enc(packed)
        H, _ = nn.utils.rnn.pad_packed_sequence(H, batch_first=True)
        return H, h_n[0]                           # H: (B, T, hid), keys ও values

    def attend(self, s, H, mask):                  # s: (B, hid) হলো query
        if self.score == "dot":
            e = (H @ s.unsqueeze(-1)).squeeze(-1)  # (B, T)
        else:
            e = self.v(torch.tanh(self.Wq(s).unsqueeze(1) + self.Wk(H))).squeeze(-1)
        e = e.masked_fill(~mask, float("-inf"))
        a = e.softmax(-1)                          # (B, T), প্রতি সারির যোগফল 1
        c = (a.unsqueeze(1) @ H).squeeze(1)        # (B, hid)
        return c, a

    def step(self, inp, s, H, mask):
        c, a = self.attend(s, H, mask)
        s = self.dec(torch.cat([self.tgt_emb(inp), c], -1), s)
        return self.out(torch.cat([s, c], -1)), s, a

Shape পড়ুন, B = ১২৮, T = ৪০, hid = ১২৮ ধরে। H (128, 40, 128); s.unsqueeze(-1) (128, 128, 1); গুণফল (128, 40, 1), squeeze করে (128, 40). a.unsqueeze(1) (128, 1, 40), তার সঙ্গে H গুণ করলে (128, 1, 128), squeeze করে context (128, 128). masked_fill ঘরগুলোকে −inf বসায়, আর সেই ঘর থেকে gradient আসে না। Batched matmul এসেছে পর্ব ৭-এ।

Parameter গুনি। পর্ব ৩০-এর h = ১২৮ model-এ ১,২৮,২৩৯. GRUCell-এর ইনপুট ৩২ থেকে ১৬০ হওয়ায় বাড়ে ৩ × ১২৮ × ১২৮ = ৪৯,১৫২. Output layer-এ বাড়ে ১২৮ × ১৫ = ১,৯২০. Dot-এর মোট ১,৭৯,৩১১, attention-এর নিজের কোনো parameter ছাড়াই। Additive-এ আরও ২ × ১২৮ × ১২৮ + ১২৮ = ৩২,৮৯৬, মোট ২,১২,২০৭. PyTorch-এর গোনার সঙ্গে সংখ্যাগুলো মেলে।

৬ · সত্যিকারের run — পর্ব ৩০-এর একই কাজ, attention সহ আর ছাড়া

কাজ পর্ব ৩০-এর: এলোমেলো বাংলা অঙ্কের অর্ডার নম্বর, দৈর্ঘ্য ১ থেকে ৪০, output ইংরেজি অঙ্কে। একই ২০,০০০ train জোড়া, একই seed-এর ৪০০টি করে test প্রতিটি দৈর্ঘ্যের ভাগে, batch ১২৮, ২০ epoch, teacher forcing ratio ১.০, Adam ০.০০২, মূল্যায়ন greedy. সত্যিকারের run, CPU-তে; torch 2.15.0, Python 3.14.4. আগে attention ছাড়া model আবার চালিয়ে নিলাম, পর্ব ৩০-এর সংখ্যা ফিরে আসে কি না দেখতে:

~/bazarghar-dl$ uv run python run_attn.py none 128 0
none hid 128 seed 0 parameters 128239
epoch  1 train loss 2.1908 | L=36-40 exact 0.000 | 12s
epoch  5 train loss 1.3105 | L=36-40 exact 0.000 | 65s
epoch 20 train loss 0.8449 | L=36-40 exact 0.000 | 335s
L= 1- 5 exact 1.000 CER 0.0000
L= 6-10 exact 0.792 CER 0.0679
L=11-15 exact 0.223 CER 0.2437
L=16-20 exact 0.007 CER 0.3658
…
L=36-40 exact 0.000 CER 0.5789

~/bazarghar-dl$ uv run python run_attn.py dot 128 0
dot hid 128 seed 0 parameters 179311
epoch  1 train loss 1.5400 | L=36-40 exact 0.013 | 25s
epoch  3 train loss 0.1260 | L=36-40 exact 0.393 | 82s
epoch  5 train loss 0.0291 | L=36-40 exact 0.897 | 147s
epoch 10 train loss 0.0170 | L=36-40 exact 0.950 | 338s
epoch 20 train loss 0.0215 | L=36-40 exact 0.850 | 677s
L= 1- 5 exact 0.998 CER 0.0008
L= 6-10 exact 0.993 CER 0.0019
L=11-15 exact 0.975 CER 0.0031
L=16-20 exact 0.980 CER 0.0032
L=21-25 exact 0.973 CER 0.0035
L=26-30 exact 0.945 CER 0.0048
L=31-35 exact 0.920 CER 0.0140
L=36-40 exact 0.850 CER 0.0181

প্রথম লগের প্রতিটি সংখ্যা পর্ব ৩০-এর সঙ্গে হুবহু মেলে (train loss ০.৮৪৪৯; ৬–১০ আর ১১–১৫ অঙ্কে exact ০.৭৯২, ০.২২৩), তাই তুলনাটি সত্যিই একই ডেটায়। সেকেন্ডের সংখ্যায় ভরসা করবেন না: কয়েকটি run একসঙ্গে চলছিল; সময় আলাদা করে মেপেছি নিচে। সব মিলিয়ে, প্রতিটি ঘরে exact-match / CER:

প্রতিটি attention কলাম seed ০ আর ১-এর গড়; attention ছাড়া কলাম দুটি পর্ব ৩০-এর টেবিল থেকে (h = ১২৮ দুই seed, h = ৫১২ এক seed). পড়ার সময় চারটি কথা মনে রাখুন।

• পতন প্রায় নেই. h = ১২৮-এ ১৬–২০ অঙ্কে ০.০০৭ থেকে ০.৯৮৯, ৩৬–৪০ অঙ্কে ০.০০০ থেকে ০.৯২২. পর্ব ৩০-এর পাশে-পাশে নিয়ন্ত্রণের ১.০০০-এর খুব কাছে।
• বড় model লাগেনি. h = ৬৪-এর attention model h = ৫১২-এর attention-ছাড়া model-এর প্রায় ৩১ ভাগের এক ভাগ parameter নিয়েও ৩৬–৪০ অঙ্কে ০.৯৫১ পায়, যেখানে অন্যটি ০.০০০.
• Dot h = ৬৪ কি h = ১২৮-এর চেয়ে ভালো? এই টেবিল তা বলে না। Dot h = ১২৮, seed ০-এর লগে ৩৬–৪০ অঙ্কে ১০ম epoch-এ ০.৯৫০, ২০তম-তে ০.৮৫০; একই model-এর seed ১ পেল ০.৯৯৩. Learning rate স্থির, তাই শেষ epoch-এর ফল ওঠানামা করে। দুই seed দিয়ে এই ফাঁকের রায় দেওয়া যায় না।
• Additive এখানে স্থির. দুই seed-এই ৩৬–৪০ অঙ্কে ০.৯৯৫ আর ০.৯৯৮. এটি এই কাজের একটি স্থানীয় পরীক্ষা, “additive সবসময় ভালো” নয়।

দামও মাপা দরকার। আলাদা করে, পরপর, CPU-তে ২০টি train batch আর ৪০ অঙ্কের একটি greedy decode (৫০ বারের গড়); দ্বিতীয় রাউন্ডেও প্রায় একই:

~/bazarghar-dl$ uv run python run_extra.py
run 0 none     : ২০ train batch 0.99 s | ৪০ অঙ্কের greedy 3.4 ms
run 0 dot      : ২০ train batch 1.89 s | ৪০ অঙ্কের greedy 5.6 ms
run 0 additive : ২০ train batch 4.84 s | ৪০ অঙ্কের greedy 7.1 ms

Dot-এ training প্রায় দ্বিগুণ, additive-এ প্রায় পাঁচ গুণ সময় নিল, এই কোডে। কারণ decoder-এর প্রতি ধাপে T-টি ঘর দেখতে হয়: output-এর দৈর্ঘ্য T′ হলে মোট কাজ T·T′-এর সমানুপাতিক। Additive-এর দামের একটি অংশ আমাদের কোডেরই: সে প্রতি ধাপে W_kh আবার হিসাব করে, যা আগে থেকে রেখে দেওয়া যেত। তবে একই বাজেটে ফলের ফারাক বিশাল: পর্ব ৩০-এ দৈর্ঘ্যের সঙ্গে দৌড়াতে parameter ৪২ গুণ করেও ৩৬–৪০ অঙ্কে শূন্য ছিল।

dot h=128: L=41-60 (train-এ ছিল না) exact 0.430 CER 0.1020
dot h=128: L=61-80 (train-এ ছিল না) exact 0.080 CER 0.2762
dot h=128: L=81-120 (train-এ ছিল না) exact 0.005 CER 0.5084
additive h=128: L=41-60 (train-এ ছিল না) exact 0.310 CER 0.1062
additive h=128: L=61-80 (train-এ ছিল না) exact 0.000 CER 0.3586
…
dot h=64: L=41-60 (train-এ ছিল না) exact 0.620 CER 0.1002
…

৭ · Mask ছাড়া শেখালে কী হয় — একই input, ভিন্ন output

Dot h = ১২৮, seed ০ model-টি mask ছাড়াও শেখালাম, বাকি সব এক। Pad ঘরে encoder-এর state শূন্য, তাই score ০. ধারণা ছিল সামান্য খারাপ হবে। হলো অন্য কিছু:

~/bazarghar-dl$ uv run python run_align.py; uv run python run_extra.py   # লগ থেকে সংক্ষেপ করা
mask আছে: ১–১০ অঙ্ক, একা exact 0.998 | ৪০ অঙ্কের পাশে exact 0.998
mask নেই: ১–১০ অঙ্ক, একা exact 0.693 | ৪০ অঙ্কের পাশে exact 0.998
  mask নেই: gold 1674 | একা 16741 | ৪০ অঙ্কের পাশে 1674
  mask নেই: gold 1954 | একা 19541 | ৪০ অঙ্কের পাশে 1954
mask আছে: </s> লেখার ধাপে pad ঘরের গড় weight 0.000
mask নেই: </s> লেখার ধাপে pad ঘরের গড় weight 0.866

একই model, একই input “১৬৭৪”. একা দিলে “16741”, পাশে একটি ৪০ অঙ্কের নম্বর থাকলে “1674”. কেন? </s> লেখার ধাপে এই model weight-এর ০.৮৬৬ দিচ্ছে pad ঘরে। অর্থাৎ সে শিখেছে, “pad-এর শূন্য vector দেখলে থামতে হবে”। Pad হয়ে গেছে থামার সংকেত। Batch-এ pad না থাকলে সংকেতও নেই, আর model বাড়তি অঙ্ক লেখে। তার test টেবিলেও (প্রায় একই দৈর্ঘ্যের batch, তাই pad কম) ১–৫ অঙ্কে exact ০.৮৯০.

Loss-এর লগে এই সমস্যা ধরা পড়ে না: ৩৬–৪০ অঙ্কে mask-ছাড়া model ০.৯২৭ পায়, দেখতে ভালোই। ধরা পড়ে শুধু “একা বনাম batch” পরীক্ষায়। এটি একটি run; কিন্তু শিক্ষাটি সাধারণ: model ডেটার যেকোনো নকশা কাজে লাগাতে পারে, ডেটা-ভরাটের নকশাও। Live ব্যবস্থায় batch-এর সঙ্গী বদলালে ফল বদলাবে, এমন model চালানো যায় না।

৮ · Alignment heatmap পড়া

প্রতিটি output ধাপের weight সারি করে সাজালে হয় alignment matrix: সারি output-এর ধাপ, কলাম input-এর ঘর, প্রতি সারির যোগফল ১. আগে হাতে বানানো একটি ছবি দেখি, যেখানে উত্তর আমরা জানি। Key হলো অবস্থানের one-hot, value হলো অঙ্কের one-hot; query আমরাই বলে দিই কোন ঘর চাই। “4” দুবার আছে, ইচ্ছা করেই।

import numpy as np
import matplotlib.pyplot as plt
np.set_printoptions(precision=2, suppress=True, linewidth=60)
digits = [4, 7, 0, 4, 2, 9]                  # ৪৭০৪২৯, “4” দুবার আছে
T = len(digits)
V = np.eye(10)[digits]                       # value: অঙ্কের one-hot, (T, 10)
K = np.eye(T)                                # key: অবস্থানের one-hot, (T, T)

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

def align(order, beta=4.0):                  # order[t] = t ধাপে যে ঘর চাই
    Q = beta * np.eye(T)[order]              # query, (T_out, T)
    A = softmax(Q @ K.T)                     # alignment, (T_out, T)
    C = A @ V                                # context, (T_out, 10)
    return A, C.argmax(-1)

A1, copy = align(np.arange(T))               # সোজা নকল
A2, back = align(np.arange(T)[::-1])         # উল্টো ক্রম
print("কপি  :", copy)
print("উল্টো:", back)
print("A1, প্রথম ২ সারি:\n", A1[:2])
print("প্রতি সারির যোগফল:", A1.sum(1))

fig, axes = plt.subplots(1, 2, figsize=(7.2, 3.4))
for ax, A, name in zip(axes, (A1, A2), ("copy", "reverse")):
    ax.imshow(A, cmap="Blues", vmin=0, vmax=1)
    ax.set_title(name)
    ax.set_xticks(range(T), labels=digits)
    ax.set_yticks(range(T))
    ax.set_xlabel("input digit (key position)")
    ax.set_ylabel("output step t")
plt.show()

কপি  : [4 7 0 4 2 9]
উল্টো: [9 2 4 0 7 4]
A1, প্রথম ২ সারি:
 [[0.92 0.02 0.02 0.02 0.02 0.02]
 [0.02 0.92 0.02 0.02 0.02 0.02]]
প্রতি সারির যোগফল: [1. 1. 1. 1. 1. 1.]

এবার আসল শেখা model-এর weight. উদাহরণটি test-এর ছাঁচের ৮ অঙ্ক, “৬৮০৬৭৩৬২”. সারির বাঁয়ে ধাপ আর লেখা অক্ষর, $ মানে </s>. সত্যিকারের run, ২ ঘর দশমিকে:

dot h=128 seed 0 | input ৬৮০৬৭৩৬২ | output 68067362
       6    8    0    6    7    3    6    2
 0 6 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00
 1 8 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00
 2 0 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00
 3 6 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00
 4 7 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00
 5 3 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00
 6 6 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00
 7 2 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00
 8 $ 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00
additive h=128 seed 0 | input ৬৮০৬৭৩৬২ | output 68067362
       6    8    0    6    7    3    6    2
 0 6 0.93 0.05 0.01 0.00 0.00 0.00 0.00 0.00
 1 8 0.16 0.66 0.15 0.02 0.00 0.00 0.00 0.00
 2 0 0.01 0.11 0.80 0.07 0.01 0.00 0.00 0.00
 3 6 0.01 0.02 0.14 0.77 0.05 0.01 0.00 0.00
 4 7 0.00 0.00 0.00 0.09 0.81 0.07 0.01 0.02
 5 3 0.00 0.00 0.00 0.01 0.06 0.82 0.11 0.00
 6 6 0.00 0.00 0.00 0.00 0.01 0.07 0.89 0.03
 7 2 0.00 0.00 0.00 0.00 0.00 0.00 0.02 0.97
 8 $ 0.00 0.00 0.00 0.00 0.01 0.02 0.31 0.66

৯ · Attention কি ব্যাখ্যা? — একটি বিতর্ক আর আমাদের পরীক্ষা

Heatmap এত সুন্দর যে তাকে “model কেন এটি বলল”-এর ব্যাখ্যা বলে ফেলা সহজ। Jain ও Wallace-এর “Attention is not Explanation” (২০১৯) জানায়, তাঁদের দেখা কিছু NLP classification model-এ weight প্রায়ই gradient-ভিত্তিক গুরুত্বের সঙ্গে ভালো মেলে না, আর অনেক আলাদা weight দিয়েও প্রায় একই অনুমান পাওয়া যায়। Wiegreffe ও Pinter-এর “Attention is not not Explanation” (২০১৯) পাল্টা বলে, এই সিদ্ধান্ত নির্ভর করে “ব্যাখ্যা” বলতে কী বোঝানো হচ্ছে তার ওপর, আর পরীক্ষার ধরনের ওপর; কিছু পরিস্থিতিতে weight কাজের তথ্য দিতে পারে। বিতর্কটি শেষ হয়নি। সাধারণ রায় না দিয়ে আমরা নিজের model-এ একটি সরল পরীক্ষা করি: এক ধাপে weight জোর করে সরিয়ে দেখি, output token বদলায় কি না। সংখ্যাগুলো token অপরিবর্তিত থাকার ভাগ, ২১–২৫ অঙ্কের ৪০০টি input-এ।

~/bazarghar-dl$ uv run python run_align.py
dot h=128 seed 0      {'hard': 1.000, 'same': 0.722, 'other': 0.050, 'uniform': 0.152}
additive h=128 seed 0 {'hard': 1.000, 'same': 0.965, 'other': 0.002, 'uniform': 0.192}
~/bazarghar-dl$ uv run python run_extra.py
dot h=128 seed 0: t=0-এ argmax শেষ ঘরে 1.000 | t=0-এর token ঠিক 1.000 | weight অন্য অঙ্কের ঘরে সরালে token একই 0.994
dot h=128 seed 1: t=0-এ argmax শেষ ঘরে 1.000 | t=0-এর token ঠিক 1.000 | weight অন্য অঙ্কের ঘরে সরালে token একই 1.000
additive h=128 seed 0: t=0-এ argmax শেষ ঘরে 0.000 | t=0-এর token ঠিক 1.000 | weight অন্য অঙ্কের ঘরে সরালে token একই 0.000

(প্রথম দুই সারি লগ থেকে সংক্ষেপ করা, উদাহরণের সংখ্যা বাদ।) “hard” মানে চূড়ার ঘরে পুরো weight; “same” মানে একই অঙ্ক আছে এমন অন্য ঘরে; “other” মানে ভিন্ন অঙ্কের ঘরে; “uniform” মানে সব ঘরে সমান। পড়ে দেখুন:

• এই কাজে weight বেশির ভাগ ধাপে সত্যিই প্রভাব ফেলে. ভিন্ন অঙ্কের ঘরে সরালে token প্রায় সবসময় বদলায় (additive-এ অপরিবর্তিত মাত্র ০.০০২).
• ছড়ানো weight দরকারি ছিল না. Additive-এর গড় চূড়া ০.৭৮৪, পাশে অনেকটা ছড়ানো। অথচ সব weight চূড়ায় আনলে একটি token-ও বদলায় না। “পাশের অঙ্ক কাজে লাগছে” অনুমানটি এই পরীক্ষায় টিকল না।
• এক output, অনেক সম্ভাব্য ছবি. একই অঙ্কের অন্য ঘরে সরালেও token অনেকটাই একই থাকে (০.৭২২, ০.৯৬৫). তাই heatmap একমাত্র “সঠিক” ব্যাখ্যা নয়।
• প্রথম সারিটি dot-এ বিভ্রান্তিকর. শেষ ঘরে পুরো weight, কিন্তু সরালে প্রায় কিছুই বদলায় না। প্রথম অঙ্কটি সম্ভবত আসে decoder-এর শুরুর state থেকে। Additive-এ এই ধাপ আলাদা: সেখানে weight সরালে token বদলে যায়।

দুই model-এর accuracy কাছাকাছি, অথচ প্রথম সারির গল্প সম্পূর্ণ আলাদা। ঠিক এই কারণে একটি ছবি থেকে “model এই কারণে বলেছে” দাবি করা যায় না। কোনো অনুমানের ব্যাখ্যা দরকার হলে মেশিন লার্নিং কোর্সের পর্ব ৫৭-এর পদ্ধতি আর এই ধরনের হস্তক্ষেপ-পরীক্ষা পাশাপাশি রাখুন। আর আমাদের পরীক্ষা শুধু এই ছোট কাজের, এই দুটি model-এর।

১০ · AI-এর যুগে — attention-এর কোড যাচাই

AI assistant attention-এর কোড সহজে লেখে, চলেও। ভুলগুলো সাধারণত error দেয় না, চুপচাপ সংখ্যা বদলায়।

AI-এর দেওয়া attention হাতে পেলে — যাচাইয়ের চেকলিস্ট

• তিনটি আলাদা মাপ (B ≠ T ≠ H) দিয়ে সব ধাপের shape ছাপিয়ে মিলিয়েছি
• Softmax T-এর dim-এ, প্রতি সারির যোগফল ১, pad-এর weight ঠিক ০
• Mask-এর True/False-এর অর্থ আমার PyTorch version-এর docs-এ পড়েছি
• একই input একা আর batch-এ চালিয়ে output আর weight মিলিয়েছি
• হাতে বানানো একটি ছোট উদাহরণে (৩ token) ফল খাতার হিসাবের সঙ্গে মিলেছে
• Attention ছাড়া baseline-এর সঙ্গে দৈর্ঘ্য অনুযায়ী, কয়েকটি seed-এ তুলনা করেছি; train-এর দৈর্ঘ্যের বাইরেও চেষ্টা করেছি
• Heatmap-এর কোনো দাবি হস্তক্ষেপ-পরীক্ষায় যাচাই করেছি; ব্যক্তিগত ডেটা AI-কে দিইনি; প্রবন্ধের দাবি মূল সূত্রে মিলিয়েছি