Positional encoding — sinusoidal, learned আর RoPE

পর্ব ৩৩-এ (Self-attention আর multi-head attention) দেখেছেন, Q, K আর V একই input থেকে আসে, আর score হয় dot product দিয়ে। সেখানে একটি প্রশ্ন খোলা রয়ে গেছে: ক্রমের খবর model পাবে কোথা থেকে? RNN-এ (পর্ব ২৮) ক্রমটি হিসাবের ধরনেই থাকত, কারণ token একটির পর একটি ঢুকত। এই পর্বে সেই খবর আলাদা করে ঢোকানোর পদ্ধতিগুলো দেখবেন। Dot product আর embedding-এর ভিত্তি AI-এর ভিত্তি কোর্সের পর্ব ৩৩ আর পর্ব ৬৯-এ আছে। ঘূর্ণনের matrix-এর জ্যামিতি আছে মেশিন লার্নিং কোর্সের পর্ব ৭-এ।

১ · ক্রম কোথায় হারায় — একই শব্দ, উল্টো অর্থ

বাজারঘরের দুটি review নিন: “ডেলিভারি ভালো, দাম খারাপ” আর “ডেলিভারি খারাপ, দাম ভালো”. শব্দ একই, শুধু জায়গা আলাদা, আর অর্থ প্রায় উল্টো। Self-attention-এর সূত্রে কিন্তু কোথাও ঘরের নম্বর নেই। প্রতিটি token বাকিদের সঙ্গে শুধু vector মেলায়।

এই ধর্মের নাম permutation equivariance: input-এর সাজানো বদলালে output-ও একইভাবে সাজানো বদলায়, মান নয়। তাই সব ঘরের গড় নিলে (mean pooling) ফল একদম এক হয়। নিচের কোডে দুই review-এর হিসাব করা হয়েছে, প্রথমে position ছাড়া, পরে প্রতিটি ঘরে একটি আলাদা vector যোগ করে। প্রথমবার চালালে Python আর NumPy লোড হতে কয়েক সেকেন্ড লাগতে পারে।

import numpy as np
rng = np.random.default_rng(34)
d = 8
vocab = ["ডেলিভারি", "ভালো", "দাম", "খারাপ"]
E = {w: rng.normal(size=d) for w in vocab}     # token embedding
WQ, WK, WV = rng.normal(size=(3, d, d)) / np.sqrt(d)

def self_attn(X):                              # X: (T, d)
    Q, K, V = X @ WQ, X @ WK, X @ WV
    S = Q @ K.T / np.sqrt(d)
    S = S - S.max(axis=-1, keepdims=True)      # stable softmax
    A = np.exp(S) / np.exp(S).sum(axis=-1, keepdims=True)
    return A @ V

a = ["ডেলিভারি", "ভালো", "দাম", "খারাপ"]
b = ["ডেলিভারি", "খারাপ", "দাম", "ভালো"]
Xa = np.array([E[w] for w in a])
Xb = np.array([E[w] for w in b])
P = rng.normal(size=(4, d))                    # প্রতিটি ঘরের নিজের vector

Ya, Yb = self_attn(Xa), self_attn(Xb)
print("position ছাড়া:")
print("  'ভালো'-র output-এর পার্থক্য:", np.abs(Ya[1] - Yb[3]).max().round(12))
print("  দুই বাক্যের গড় vector-এর পার্থক্য:", np.abs(Ya.mean(0) - Yb.mean(0)).max().round(12))

Pa, Pb = self_attn(Xa + P), self_attn(Xb + P)
print("position-সহ:")
print("  'ভালো'-র output-এর পার্থক্য:", np.abs(Pa[1] - Pb[3]).max().round(4))
print("  দুই বাক্যের গড় vector-এর পার্থক্য:", np.abs(Pa.mean(0) - Pb.mean(0)).max().round(4))

position ছাড়া:
  'ভালো'-র output-এর পার্থক্য: 0.0
  দুই বাক্যের গড় vector-এর পার্থক্য: 0.0
position-সহ:
  'ভালো'-র output-এর পার্থক্য: 1.991
  দুই বাক্যের গড় vector-এর পার্থক্য: 0.3723

Position ঢোকানোর জায়গা আছে তিনটি, আর পদ্ধতিগুলো মূলত এই জায়গাতেই আলাদা। নিচের ছবিটি এই পর্বের মানচিত্র।

২ · Learned embedding — সবচেয়ে সোজা উপায়, আর তার দেয়াল

সবচেয়ে সরল চিন্তা: token-এর জন্য যেমন nn.Embedding টেবিল (পর্ব ২৭), ঘরের নম্বরের জন্যও তেমন একটি টেবিল। একে বলে learned position embedding. ঘরের নম্বরটি হলো absolute position, শুরু থেকে গোনা:

x_t = E(token_t) + P(t), যেখানে P একটি (max_len, d) shape-এর শেখার যোগ্য matrix.

এই পদ্ধতি চলে এবং বহু পরিচিত model-এ ব্যবহার হয়েছে। Hugging Face-এর GPT-2 নথি বলে, এই model absolute position embedding ব্যবহার করে, n_positions-এর default 1024, আর input ডানদিকে pad করতে হয়। কারণ বাঁয়ে padding দিলে আসল token-গুলো ভুল ঘরের সারি পায় (পর্ব ১১-এর padding মনে করুন)।

দুর্বলতা দুটি। টেবিলের মাপের বাইরে গেলে সরাসরি error আসে, যাকে max length-এর দেয়াল বলা যায়। আর যে সারি training-এ কখনো ব্যবহার হয়নি, সেটি কিছুই শেখে না। নিচের খেলনা হিসাবে দ্বিতীয়টি হাতে ধরে দেখুন।

দেয়ালটি সত্যিকারের PyTorch-এ এমন দেখায়। ছোট model-টি পরে অংশ ৮-এ দেখবেন; এখানে max_len=16 দিয়ে প্রথমে ১৬, তারপর ১৭ ঘরের input দেওয়া হলো (সত্যিকারের run, CPU-তে; traceback ছোট করে দেখানো):

~/bazarghar-dl$ uv run python run_error.py
T=16: torch.Size([1, 16, 10])
Traceback (most recent call last):
  …
    return torch.embedding(weight, input, padding_idx, scale_grad_by_freq, sparse)
IndexError: index out of range in self

আরেকটি ফাঁদ আসে batch বানানোর সময়। Absolute position-এ ঘরের নম্বর গোনা হয় টেবিলের বাঁ থেকে। ধরা যাক “ভালো পণ্য” দুই token, আর batch-এর দৈর্ঘ্য ৪. ডানে pad করলে “ভালো” পায় ঘর ০, “পণ্য” পায় ঘর ১. বাঁয়ে pad করে নম্বর ঠিক না করলে তারা পায় ঘর ২ আর ৩, যদিও বাক্যের শুরু সেটিই। তাই generation-এ বাঁয়ে pad করলে attention mask থেকে আলাদা করে position নম্বর হিসাব করতে হয়। এই বিষয় পর্ব ৩৭-এ আবার আসবে।

৩ · Sinusoidal encoding — ঘড়ির কাঁটা থেকে সূত্র

২০১৭ সালের Transformer paper-এ (Vaswani ও সহলেখকেরা) শেখার বদলে একটি সূত্র ব্যবহার করা হয়, যার নাম sinusoidal encoding. ধারণাটি ঘড়ি থেকে সহজে আসে।

একটি কাঁটার অবস্থান বৃত্তের একটি বিন্দু, যা দুটি সংখ্যায় লেখা হয়: sin আর cos. শুধু sin নিলে চলে না, কারণ sin(a) = sin(π − a), মানে দুটি আলাদা কোণ একই মান দেয়। জোড়ায় নিলে এই দ্ব্যর্থতা থাকে না। ঘর t-এর জন্য, জোড়া n (n = ০, ১, …, d/২ − ১)-এ:

PE(t, 2n) = sin(ω_n t),   PE(t, 2n+1) = cos(ω_n t),   ω_n = 1 / 10000^2n/d

এখানে d হলো embedding-এর মাত্রা, আর ω_n হলো কাঁটাটি প্রতি ঘরে কত রেডিয়ান ঘোরে। একটি কাঁটার wavelength হলো 2π/ω_n, মানে সে কত ঘর পরে নিজের জায়গায় ফেরে। Paper অনুযায়ী এই মান 2π থেকে 10000·2π পর্যন্ত জ্যামিতিকভাবে বাড়ে। এই vector-টি token embedding-এর সঙ্গে যোগ হয়। এবার ঘর ৩-এর মান হাতে বের করুন।

import numpy as np
import matplotlib.pyplot as plt

def sinusoidal(T, d, base=10000.0):
    pos = np.arange(T)[:, None]                # (T, 1)
    w = 1.0 / base ** (np.arange(0, d, 2) / d) # (d/2,)
    pe = np.zeros((T, d))
    pe[:, 0::2] = np.sin(pos * w)
    pe[:, 1::2] = np.cos(pos * w)
    return pe

np.set_printoptions(precision=4, suppress=True, linewidth=60)
print("PE(3), d=4 :", sinusoidal(4, 4)[3])
print("PE(4), d=4 :", sinusoidal(5, 4)[4])

PE = sinusoidal(64, 32)
w = 1.0 / 10000 ** (np.arange(0, 32, 2) / 32)
print("shape:", PE.shape)
print("wavelength of 3 pairs:", (2 * np.pi / w)[[0, 4, 15]].round(1))
norms = np.linalg.norm(PE, axis=1)
print("row norm min, max:", norms.min().round(6), norms.max().round(6))

fig, ax = plt.subplots(figsize=(6.2, 3.2))
im = ax.imshow(PE.T, aspect="auto", cmap="RdBu_r", vmin=-1, vmax=1)
ax.set_xlabel("position t")
ax.set_ylabel("dimension")
ax.set_title("Sinusoidal encoding, d = 32")
fig.colorbar(im, ax=ax)
plt.show()

PE(3), d=4 : [ 0.1411 -0.99    0.03    0.9996]
PE(4), d=4 : [-0.7568 -0.6536  0.04    0.9992]
shape: (64, 32)
wavelength of 3 pairs: [    6.3    62.8 35332.9]
row norm min, max: 4.0 4.0

10000 কেন? সংখ্যাটির পেছনে কোনো গভীর গণিত আছে বলে paper দাবি করে না; এটি একটি নকশার পছন্দ। সবচেয়ে ধীর কাঁটার wavelength, d বড় হলে, প্রায় 2π·10000 ≈ ৬২,৮০০ ঘর, যা সেই সময়ের অনুবাদের বাক্যের চেয়ে অনেক লম্বা। তাই সাধারণ দৈর্ঘ্যে দুটি ঘরের vector একই হওয়ার ভয় থাকে না। Base অনেক ছোট হলে ধীর কাঁটাও দ্রুত ফিরে আসত। অনেক বড় হলে ধীর কাঁটাগুলো প্রায় নড়তই না, আর সেই মাত্রাগুলো কম তথ্য দিত। Paper-এ token embedding-কে আগে √d দিয়ে গুণ করে তারপর PE যোগ করার কথাও আছে, যাতে দুটির মাপ কাছাকাছি থাকে। অনেক কোডে এই গুণটি বাদ পড়ে, তাই পড়ার সময় মিলিয়ে নিন।

৪ · Dot product আর দূরত্ব — সূত্রটির লুকানো গুণ

দুই ঘর s আর t-এর vector-এর dot product নিন। cos a·cos b + sin a·sin b = cos(a − b) সূত্র জোড়ায় জোড়ায় বসালে:

PE(s) · PE(t) = ∑_n cos(ω_n(t − s))

ডান দিকে s বা t আলাদা করে নেই, আছে শুধু t − s, মানে relative position. অর্থাৎ ঘর ২০ আর ৩০-এর মিল, ঘর ৫০০ আর ৫১০-এর মিলের সমান। আরেকটি গুণও আছে: k ঘর সরানো একটি linear কাজ, PE(t + k) = M_k·PE(t), যেখানে M_k শুধু k-এর ওপর নির্ভর করে। Paper-এ এই ধর্মটিই সূত্র বেছে নেওয়ার একটি কারণ হিসেবে বলা হয়েছে। নিচে দুটোই মিলিয়ে দেখুন।

import matplotlib.pyplot as plt

PE = sinusoidal(600, 64)
dot = lambda s, t: PE[s] @ PE[t] / 32          # 32 = d/2, তাই সর্বোচ্চ 1
print("similarity (20, 30)  :", round(dot(20, 30), 6))
print("similarity (100, 110):", round(dot(100, 110), 6))
print("similarity (500, 510):", round(dot(500, 510), 6))

k = 7
w = 1.0 / 10000 ** (np.arange(0, 64, 2) / 64)
M = np.zeros((64, 64))
for n, wn in enumerate(w):                     # প্রতি জোড়ায় একটি 2x2 ঘূর্ণন
    c, s = np.cos(wn * k), np.sin(wn * k)
    M[2*n:2*n+2, 2*n:2*n+2] = [[c, s], [-s, c]]
print("max |PE(t+7) - M PE(t)|:", np.abs(PE[7:] - PE[:-7] @ M.T).max().round(12))

fig, ax = plt.subplots(figsize=(6.2, 3.0))
for d in (16, 64):
    P = sinusoidal(301, d)
    ax.plot(P @ P[0] / (d / 2), label=f"d = {d}")
ax.set_xlabel("distance k")
ax.set_ylabel("similarity")
ax.set_title("PE(t) and PE(t + k): similarity vs distance")
ax.legend()
plt.show()

similarity (20, 30)  : 0.657863
similarity (100, 110): 0.657863
similarity (500, 510): 0.657863
max |PE(t+7) - M PE(t)|: 0.0

৫ · Relative position — “কোন ঘরে” নয়, “কত দূরে”

২০১৮ সালে Shaw, Uszkoreit আর Vaswani self-attention-এ সরাসরি দূরত্ব ঢোকানোর একটি পদ্ধতি দেন। প্রতিটি ব্যবধান (j − i) একটি নির্দিষ্ট সীমায় কেটে তার জন্য শেখার যোগ্য vector রাখা হয়, আর সেটি score-এর হিসাবে যোগ হয়। সীমার বাইরের দূরত্বগুলো একই সারি পায়, তাই লম্বা input-এ error আসে না। ধরুন সীমা ২: তাহলে ব্যবধান −৭ আর −২ দুটোই −২ হয়ে যায়, আর টেবিলে থাকে মাত্র ৫টি সারি (−২, −১, ০, ১, ২)। লম্বা input-এ সারির সংখ্যা বাড়ে না। দাম হলো, সীমার বাইরের দূরত্বগুলো model আলাদা করতে পারে না। পরে T5-এর মতো model score-এ দূরত্বভিত্তিক একটি bias যোগ করার সহজ রূপ ব্যবহার করে।

এদের খরচ একটি: score-এর হিসাবের ভেতরে অতিরিক্ত term ঢোকে। প্রতিটি (i, j) জোড়ার জন্য টেবিল থেকে মান আনতে হয়, আর দ্রুত attention কোডের সঙ্গে মেলাতে কিছুটা বাড়তি কাজ লাগে। পরের অংশের RoPE একই ধরনের ফল দেওয়ার চেষ্টা করে শুধু Q আর K বদলে, score-এর সূত্র না ছুঁয়ে।

৬ · RoPE — Q আর K-কে ঘুরিয়ে দেওয়া

RoPE (Rotary Position Embedding) প্রস্তাব করা হয় Su ও সহলেখকদের ২০২১ সালের RoFormer paper-এ। মূল চিন্তা স্কুলের জ্যামিতি: দুটি vector-কে একই কোণে ঘোরালে তাদের dot product বদলায় না। Q আর K-এর প্রতিটি মাত্রা-জোড়াকে ঘোরানো হয়, ঘর t-এর জন্য tθ কোণে, rotation matrix R(a) দিয়ে:

R(iθ)q · R(jθ)k = qᵀ R(iθ)ᵀ R(jθ) k = q · R((j − i)θ) k

এখানে q আর k হলো একটি জোড়ার দুটি করে সংখ্যা, i আর j হলো দুই ঘরের নম্বর। ঘোরানো matrix-এর ধর্ম R(a)ᵀ R(b) = R(b − a) ব্যবহার হয়েছে। ফল: একই q আর k হলে score শুধু j − i-এর ওপর নির্ভর করে। প্রতিটি জোড়ার নিজের θ_n থাকে, যা sinusoidal-এর ω_n-এর মতোই গঠিত। V ঘোরানো হয় না। কোনো নতুন parameter-ও লাগে না।

এবার একটি জোড়া হাতে ঘোরান। সংখ্যাগুলো ছোট রাখতে ধরা হলো q = (1, 2), k = (3, 1), আর θ = ০.৫ রেডিয়ান।

এবার পুরো Q আর K-তে। “একই q আর k” শর্তটি পরীক্ষায় রাখতে একই token সব ঘরে বসানো হয়েছে। শেষে তুলনার জন্য যোগ করা absolute position, আর আলাদা আলাদা token-ও দেখা হয়েছে।

import numpy as np

def rope(x, base=10000.0):                     # x: (T, d), d জোড় সংখ্যা
    T, d = x.shape
    w = 1.0 / base ** (np.arange(0, d, 2) / d)
    a = np.arange(T)[:, None] * w              # (T, d/2)
    c, s = np.cos(a), np.sin(a)
    out = np.empty_like(x)
    out[:, 0::2] = x[:, 0::2] * c - x[:, 1::2] * s
    out[:, 1::2] = x[:, 0::2] * s + x[:, 1::2] * c
    return out

rng = np.random.default_rng(34)
T, d = 16, 8
q0, k0 = rng.normal(size=(2, d))               # একই token সব ঘরে
Q, K = np.tile(q0, (T, 1)), np.tile(k0, (T, 1))

S = rope(Q) @ rope(K).T                        # (T, T) score
for i, j in [(1, 4), (5, 8), (10, 13), (1, 5), (5, 9)]:
    print(f"score({i:2d},{j:2d}), offset {j-i}: {S[i, j]: .6f}")

spread = max(np.ptp(np.diag(S, k)) for k in range(-T + 1, T))
print("largest spread on any offset, RoPE:", spread.round(12))
print("norm kept:", np.allclose(np.linalg.norm(rope(Q), axis=1), np.linalg.norm(q0)))

pos = rng.normal(size=(T, d))                  # যোগ করা absolute position
A = (Q + pos) @ (K + pos).T
print("largest spread, added positions:", round(max(np.ptp(np.diag(A, k)) for k in range(-T + 1, T)), 4))

Qr, Kr = rng.normal(size=(2, T, d))            # আলাদা আলাদা token
Sr = rope(Qr) @ rope(Kr).T
print("different tokens at each slot:", round(np.ptp(np.diag(Sr, 3)), 4))

score( 1, 4), offset 3:  0.359317
score( 5, 8), offset 3:  0.359317
score(10,13), offset 3:  0.359317
score( 1, 5), offset 4:  0.708208
score( 5, 9), offset 4:  0.708208
largest spread on any offset, RoPE: 0.0
norm kept: True
largest spread, added positions: 20.8149
different tokens at each slot: 11.2301

৭ · ALiBi, আর কোন model কী ব্যবহার করে

ALiBi (Press, Smith ও Lewis, ২০২১) সবচেয়ে সরল চিন্তা: কোনো position vector নয়, softmax-এর আগে score থেকে দূরত্বের সমানুপাতিক একটি মান বিয়োগ:

score_ij ← score_ij − m·|i − j|

এখানে m একটি ঢাল, যা প্রতিটি head-এ আলাদা আর শেখা হয় না। ফলে দূরের token-এ attention কমে। কাছের দোকানের কথা আগে মনে পড়ার মতো একটি পক্ষপাত, আর সেটিই এর দুর্বলতাও হতে পারে যখন উত্তর অনেক দূরে থাকে। Paper-টির সারাংশ অনুযায়ী, ১০২৪ token-এ train করা একটি model ২০৪৮ token-এ চালিয়ে ২০৪৮-এ train করা sinusoidal model-এর সমান ফল পাওয়া গিয়েছিল। এটি তাঁদের নির্দিষ্ট পরীক্ষার ফল, সাধারণ নিয়ম নয়।

কোন model কী ব্যবহার করে, সেটি নিজে যাচাই করে নেওয়াই ভালো। নিচের তথ্য ২০২৬ সালের নভেম্বরে পড়া সরকারি নথি থেকে, আর নথি বদলাতে পারে:

সাম্প্রতিক অনেক open language model-এর config-এ RoPE-সংক্রান্ত ঘর দেখা যায়, তবে এটি কোনো সার্বজনীন নিয়ম নয়। যে model ব্যবহার করবেন, তার config.json আর model card দেখে নিন। Llama config-এও max_position_embeddings আছে: RoPE-তে টেবিল না থাকলেও একটি ঘোষিত সীমা থাকতে পারে। সেই সীমা ছাড়িয়ে গেলে কী হবে, তা নির্ভর করে ওই সংস্করণের কোডের ওপর, তাই চালিয়ে দেখতে হয়। ছবির জন্য position কীভাবে আলাদা, তা পর্ব ৩৮-এ (Vision Transformer) আসবে।

পুরো পর্বের তুলনা এক জায়গায়। Parameter-এর হিসাবে L হলো max length, d হলো embedding-এর মাত্রা, c হলো ব্যবধান কাটার সীমা, আর d_h হলো head-এর মাত্রা, h হলো head-এর সংখ্যা।

একটি উদাহরণে L = ১০২৪ আর d = ৭৬৮ হলে learned টেবিলে ১০২৪ × ৭৬৮ = ৭,৮৬,৪৩২টি parameter. বড় model-এর মোট parameter-এর তুলনায় এটি সামান্য, তাই parameter বাঁচানো পদ্ধতি বাছাইয়ের প্রধান কারণ সাধারণত নয়।

৮ · সত্যিকারের run — ছোটতে শেখা, লম্বায় পরীক্ষা

এতক্ষণ যা দেখলেন তা সূত্রের ধর্ম। Model আসলে নতুন দৈর্ঘ্যে কেমন করে, তার নাম length extrapolation, আর সেটি মেপেই জানতে হয়। পরীক্ষাটি বাজারঘরের অর্ডার নম্বরের মতো এলোমেলো অঙ্কের সারিতে, দুটি কাজ:

• back3 (relative নিয়ম): প্রতিটি ঘরে বলতে হবে ৩ ঘর আগের অঙ্ক। প্রথম ৩ ঘর ignore_index দিয়ে বাদ।
• first2 (absolute নিয়ম): প্রতিটি ঘরে বলতে হবে index 2-এর অঙ্ক, মানে শুরু থেকে নির্দিষ্ট একটি ঘর।

Model: PyTorch 2.15.0, Python 3.14-এ, GPU-তে। ২টি pre-norm block, d = ৬৪, ৪টি head, AdamW, ১,৫০০ ধাপ। Training-এর দৈর্ঘ্য T = ৮ থেকে ১৬, পরীক্ষা ১৬ থেকে ১২৮ পর্যন্ত। learned-এর টেবিল ১২৮ সারির, যাতে error না এসে আসল আচরণ দেখা যায়। Block-এর বিস্তারিত পর্ব ৩৫-এ আসবে; এখানে শুধু position-এর অংশটি দেখুন (আসল ফাইল থেকে নেওয়া অংশ, বাকি কোড ছোট করতে বাদ):

def rope(x, base=10000.0):                     # x: (B, heads, T, d_head)
    T, dh = x.shape[-2:]
    w = 1.0 / base ** (torch.arange(0, dh, 2, device=x.device).float() / dh)
    a = torch.arange(T, device=x.device).float()[:, None] * w   # (T, dh/2)
    c, s = a.cos(), a.sin()
    x0, x1 = x[..., 0::2], x[..., 1::2]
    return torch.stack([x0 * c - x1 * s, x0 * s + x1 * c], -1).flatten(-2)

class Attn(nn.Module):
    def forward(self, x):                      # x: (B, T, d)
        B, T, d = x.shape
        q, k, v = (t.view(B, T, self.h, self.dh).transpose(1, 2)
                   for t in self.qkv(x).chunk(3, -1))
        if self.use_rope:
            q, k = rope(q), rope(k)            # শুধু Q আর K ঘোরে, V নয়
        y = F.scaled_dot_product_attention(q, k, v)
        return self.out(y.transpose(1, 2).reshape(B, T, d))

def batch(task, B, T, gen, device):
    ids = torch.randint(0, 10, (B, T), generator=gen)
    if task == "back3":
        y = ids.roll(3, 1)
        y[:, :3] = -100
    elif task == "first2":
        y = ids[:, 2:3].expand(B, T).clone()
    return ids.to(device), y.to(device)

একটি হিসাব আগে পরিষ্কার করা দরকার: T > ১৬ কলামে শুধু নতুন ঘরগুলো (index ১৬ বা তার পরে) গোনা হয়েছে, কারণ প্রশ্নটি নতুন ঘর নিয়েই। প্রতিটি কলামে তিন seed-এর গড়, নিচের সারিতে সর্বনিম্ন-সর্বোচ্চ। অঙ্ক ১০টি, তাই এলোমেলো অনুমানে প্রায় ০.১০ আসার কথা। (সত্যিকারের run, version-এর প্রথম লাইনটি বাদ।)

~/bazarghar-dl$ uv run python run_compare.py back3
kind        T=16    T=32    T=64    T=128   (mean accuracy, min-max over seeds)
none       0.234   0.195   0.160   0.143
  range    0.23-0.24 0.19-0.20 0.16-0.16 0.14-0.14
learned    1.000   0.132   0.124   0.114
  range    1.00-1.00 0.13-0.14 0.12-0.13 0.11-0.11
sinusoidal 1.000   0.131   0.136   0.117
  range    1.00-1.00 0.11-0.17 0.13-0.14 0.11-0.12
rope       1.000   0.824   0.669   0.591
  range    1.00-1.00 0.78-0.89 0.62-0.73 0.57-0.63
total 178 s

~/bazarghar-dl$ uv run python run_compare.py first2
kind        T=16    T=32    T=64    T=128   (mean accuracy, min-max over seeds)
none       0.240   0.165   0.148   0.105
  range    0.24-0.24 0.17-0.17 0.14-0.15 0.10-0.11
learned    1.000   1.000   1.000   1.000
  range    1.00-1.00 1.00-1.00 1.00-1.00 1.00-1.00
sinusoidal 1.000   1.000   1.000   0.620
  range    1.00-1.00 1.00-1.00 1.00-1.00 0.30-1.00
rope       1.000   0.532   0.114   0.114
  range    1.00-1.00 0.40-0.64 0.08-0.13 0.11-0.12
total 354 s

(সময়টি অন্য কাজের সঙ্গে ভাগ করা GPU-তে, তুলনার যোগ্য নয়।) ফলগুলো একটি একটি করে পড়ুন:

RoPE back3-এ ০.৫৯১-এ নামল কেন, নতুন ঘরের জন্য, নাকি অন্য কিছু? “কারণ” অনুমান না করে তিনটি মাপ নেওয়া হলো:

~/bazarghar-dl$ uv run python run_diag.py
(1) accuracy by position band, mean of 3 seeds
T     pos 3-15   pos 16+
16    1.000
32    0.855   0.824
64    0.829   0.669
128   0.656   0.591
(2) attention mass of the last token, block 1, mean of heads and seeds
T     offset=3   offset<=15  offset>15
16    0.336      1.000       0.000
32    0.181      0.482       0.518
64    0.104      0.267       0.733
128   0.061      0.144       0.856
(3) same rope model, trained on T=8..64 instead of 8..16
T=16   mean 1.000  min 1.000  max 1.000
T=32   mean 1.000  min 1.000  max 1.000
T=64   mean 1.000  min 1.000  max 1.000
T=128  mean 1.000  min 1.000  max 1.000

(১) পুরোনো ঘর ৩–১৫-ও T = ১২৮-এ ০.৬৫৬-এ নেমেছে। তাই সমস্যা নতুন ঘর নয়। (২) প্রথম block-এ শেষ token-এর attention-এর ০.৮৫৬ অংশ চলে যাচ্ছে ১৫ ঘরের চেয়ে দূরের token-এ, যে ব্যবধান training-এ কখনো আসেনি। RoPE ব্যবধানের ফাংশন ঠিকই, কিন্তু অদেখা ব্যবধানে network কী করবে তা training ঠিক করে দেয়নি। (৩) Training-এ T = ৬৪ পর্যন্ত দিতেই একই RoPE model T = ১২৮-এও ১.০০০ করেছে। এই তিনটি পরীক্ষা একসঙ্গে এই ব্যাখ্যাকেই সমর্থন করে: অদেখা দূরত্বই বাধা, ঘরের নম্বর নয়।

আর first2-তে T = ১৬-তে RoPE ১.০০০ পেল কীভাবে, যেখানে ঘরের নম্বর সে সরাসরি দেখে না? অনুমান ছিল, দুই স্তর লাগবে:

~/bazarghar-dl$ uv run python run_layers.py
rope, layers=1, first2, T=16: 0.943 0.922 0.931
rope, layers=2, first2, T=16: 1.000 1.000 1.000

অনুমানটি পুরো মেলেনি: এক স্তরেই প্রায় ০.৯৩. একটি সম্ভাব্য ব্যাখ্যা হলো, sequence-এর শুরুর সীমাটি নিজেই একটি সংকেত, কারণ ঘর ২-এর বাঁয়ে দুটির বেশি token নেই। এই run তা প্রমাণ করে না; আমরা শুধু ফলটি জানাচ্ছি।

৯ · AI-এর যুগে — position-এর কোড যাচাই

AI সহকারী RoPE বা PE-র কোড মুহূর্তেই লিখে দেয়। ভুল থাকলেও কোড সাধারণত চলে, কারণ ভুল shape-এর চেয়ে ভুল গণিত বেশি হয়। এই ধরনের ভুল চোখে পড়ে না, তাই সংখ্যা দিয়ে মেলাতে হয়।

Position-এর কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• ছোট উদাহরণে PE বা RoPE-এর মান হাতে মিলিয়েছি (ঘর ৩, d = ৪)
• Q আর K-তেই ঘূর্ণন, দৈর্ঘ্য অপরিবর্তিত, ব্যবধান-ধর্ম numerically পরীক্ষা করেছি
• Training-এর চেয়ে লম্বা input দিয়ে কী হয়, তা চালিয়ে দেখেছি: error, না চুপচাপ ভুল
• নতুন ঘর আলাদা করে মেপেছি, অন্তত তিনটি seed-এ, position-ছাড়া baseline-সহ
• ব্যক্তিগত ডেটা, কী বা গ্রাহকের review AI-কে পাঠাইনি; পরীক্ষা করেছি বানানো ডেটায়