GPT আর decoder-only model — next-token prediction

AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ LLM-এর সরল ছবি দেখেছেন, আর পর্ব ৭১-এ model card পড়া শিখেছেন। পর্ব ৩৬-এ নিজে একটি ছোট MiniGPT লিখেছেন। এই পর্বে একই ছাঁচের আসল model খুলে দেখব, আর নিজের হাতে তার হিসাব মেলাব।

১ · একটাই কাজ — পরের token অনুমান

Next-token prediction মানে: ক্রম x₁, …, x_t দেখে P(x_t+1 | x₁, …, x_t) দেওয়া। এখানে x মানে token, P মানে সম্ভাব্যতা। Chain rule দিয়ে পুরো লেখার সম্ভাব্যতা হয় এই শর্তাধীন সম্ভাব্যতাগুলোর গুণ; এর বিস্তার আছে পর্ব ৪৬-এ (Language modeling — n-gram থেকে neural LM আর perplexity).

Decoder-only model নাম এসেছে ২০১৭ সালের Transformer-এর decoder থেকে। সেখানে দুই ধরনের attention ছিল: নিজের ওপর causal self-attention, আর encoder-এর ওপর cross-attention. Encoder বাদ দিলে cross-attention-এরও কাজ থাকে না। বাকি থাকে causal self-attention, FFN আর residual. প্রশ্ন, উত্তর, অনুবাদ সব একই লেখার ক্রম হয়ে যায়। পর্ব ৩০-এর encoder–decoder-এর সঙ্গে এটাই মূল পার্থক্য।

এই ছবিতে নতুন কিছু নেই। Block আছে পর্ব ৩৫-এ, attention পর্ব ৩৩-এ। আসল নতুন প্রশ্ন তিনটি: লক্ষ্য কীভাবে বানানো হয়, ভবিষ্যৎ কীভাবে ঢাকা থাকে, আর সংখ্যাগুলো কী করে মেলে।

Objective-টি এক লাইনে লেখা যায়। ধরুন ক্রমে T+1টি token আছে। তাহলে

loss = −(1/T) ∑_t=1…T ln P_θ(x_t+1 | x₁, …, x_t)

এখানে θ মানে model-এর সব weight, ln মানে স্বাভাবিক লগারিদম। এটি পর্ব ১৩-এর cross-entropy-ই, শুধু প্রতিটি ঘরে একবার করে। Training-এ শর্তের ভেতরে আসল আগের token বসে, model-এর নিজের অনুমান নয়। পর্ব ৩০-এ একেই teacher forcing বলেছিলাম। Causal mask থাকায় পুরো ক্রম একবারে পাঠানো যায়; T ঘরের জন্য T বার forward লাগে না। Decoder-only model-এর training এত দ্রুত হওয়ার বড় কারণ এটিই। কিন্তু generation-এ নিজের আগের অনুমানই input, তাই সেখানে token ধরে ধরে এগোতে হয়।

২ · Label shift — একই লেখা, এক ঘর সরানো

Label shift-এর জন্য আলাদা উত্তরপত্র লাগে না, লেখাটাই উত্তরপত্র। তাই একে self-supervised বলা হয়। এক বাক্যের ছোট batch-এ নিচে দেখুন। <pad> ঘর গড়ে গোনা হয় না; পর্ব ১৩-এর ignore_index সেই কাজ করে।

এবার একই হিসাব কোডে। সঙ্গে একটি সাধারণ বাগ: shift করতে ভুলে গেলে কী হয়। একটি নকল model নেওয়া হলো, যে শুধু input কপি করে।

import numpy as np

vocab = ["<bos>", "আমি", "শাড়ি", "কিনেছি", "<eos>", "<pad>"]
ids = np.array([0, 1, 2, 3, 4, 5, 5])    # one sentence, two pads
inp, tgt = ids[:-1], ids[1:].copy()
tgt[tgt == 5] = -100                     # ignore_index
logits = np.array([
    [0.2, 3.0, 0.1, 0.1, 0.1, 0],        # after <bos>
    [0.1, 0.2, 2.5, 1.0, 0.1, 0],        # after আমি
    [0.1, 0.1, 0.3, 2.8, 0.5, 0],        # after শাড়ি
    [0.1, 0.1, 0.2, 0.2, 2.2, 0],        # after কিনেছি
    [1.0, 1.0, 1.0, 1.0, 1.0, 0],        # at <eos> (ignored)
    [1.0, 1.0, 1.0, 1.0, 1.0, 0]])       # at <pad> (ignored)
p = np.exp(logits) / np.exp(logits).sum(1, keepdims=True)
keep = tgt != -100
pt = p[np.arange(len(tgt))[keep], tgt[keep]]
for a, b, q in zip(inp[keep], tgt[keep], pt):
    print(f"{vocab[a]} -> {vocab[b]}  p={q:.3f}  -ln p={-np.log(q):.3f}")
loss = -np.log(pt).mean()
print(f"loss={loss:.3f} perplexity={np.exp(loss):.3f} counted={keep.sum()} of {len(tgt)}")

# a fake model that only copies its input
copy = np.full((len(ids), 6), -5.0)
copy[np.arange(len(ids)), ids] = 5.0
pc = np.exp(copy) / np.exp(copy).sum(1, keepdims=True)
shifted = -np.log(pc[np.arange(4), ids[1:5]]).mean()
no_shift = -np.log(pc[np.arange(5), ids[:5]]).mean()
print(f"copy model: shifted loss={shifted:.3f}, forgot-shift loss={no_shift:.4f}")

<bos> -> আমি  p=0.784  -ln p=0.243
আমি -> শাড়ি  p=0.630  -ln p=0.462
শাড়ি -> কিনেছি  p=0.726  -ln p=0.320
কিনেছি -> <eos>  p=0.615  -ln p=0.486
loss=0.378 perplexity=1.459 counted=4 of 6
copy model: shifted loss=10.000, forgot-shift loss=0.0002

হাতে একটি পরীক্ষার হিসাব, আর শুরুর loss

ধরুন একটি ঘরে V = 3, logit = [2, 1, 0], সঠিক token প্রথমটি। e² = 7.389, e¹ = 2.718, e⁰ = 1; যোগফল 11.107. তাই p = 7.389 ÷ 11.107 = 0.665, আর −ln p = 0.408 nat. Bit-এ নিতে ln 2 = 0.693 দিয়ে ভাগ: 0.589 bit. Perplexity = e^0.408 = 1.50. এইটুকু খাতায় করে নিলে বড় model-এর লগ পড়তে ভয় লাগে না।

আরেকটি কাজের অভ্যাস: প্রশিক্ষণের আগে loss দেখা। না শেখা model সব token-এ প্রায় সমান সম্ভাব্যতা দেয়, তাই loss হওয়ার কথা ln V-এর কাছে। GPT-2-তে ln 50257 = 10.825. সত্যিকারের run-এ, একই ইংরেজি বাক্যে:

ln V = 10.825
seed 0 untrained loss 11.125
seed 1 untrained loss 10.98
seed 2 untrained loss 11.003
trained loss 3.358

না শেখা model তিন seed-এই প্রায় ১১, যা হিসাবের কাছাকাছি। শুরুতে loss অনেক কম বা অনেক বেশি এলে আগে ডেটা বা shift-এ বাগ খুঁজুন, তারপর training চালান।

৩ · Causal mask — ভবিষ্যৎ বর্তমানকে বদলাতে পারে না

পর্ব ৩৬-এ causal mask লিখেছিলেন। এবার দাবিটি পরীক্ষা করি। পরীক্ষার হলে খাতা ঢেকে লেখার মতো: ওপরের লাইন দেখা যায়, নিচের লাইন নয়। একাধিক স্তরেও কি ঢাকা থাকে? নিচে তিন স্তরের ছোট attention, শুধু শেষ token বদলে। Mask ছাড়া একই পরীক্ষাও আছে।

import numpy as np

rng = np.random.default_rng(42)
T, d = 5, 8
Wq, Wk, Wv = (rng.normal(size=(d, d)) / d**0.5 for _ in range(3))

def attn(x, masked):
    Q, K, V = x @ Wq, x @ Wk, x @ Wv
    s = Q @ K.T / d**0.5
    if masked:
        s = np.where(np.tril(np.ones((T, T))) == 1, s, -np.inf)
    w = np.exp(s - s.max(1, keepdims=True))     # softmax, row by row
    return (w / w.sum(1, keepdims=True)) @ V

def net(x, masked):
    for _ in range(3):                          # three layers
        x = x + attn(x, masked)
    return x

x = rng.normal(size=(T, d))
y = x.copy()
y[4] += 10.0                                    # change only the LAST token
print(np.tril(np.ones((T, T), dtype=int)))
for masked in (True, False):
    diff = np.abs(net(x, masked) - net(y, masked)).max(axis=1)
    print("masked :" if masked else "no mask:", np.round(diff, 4))

[[1 0 0 0 0]
 [1 1 0 0 0]
 [1 1 1 0 0]
 [1 1 1 1 0]
 [1 1 1 1 1]]
masked : [ 0.      0.      0.      0.     10.9639]
no mask: [36.7369 40.8886 24.4399 38.5548 20.2014]

আসল GPT-2-তেও একই পরীক্ষা চালিয়েছি (সত্যিকারের run, CPU-তে): ৯ token-এর ইংরেজি বাক্যে শুধু শেষ token বদলে।

seq length 9 changed only position 8
max|diff| at positions 0..n-2: 0.00e+00
max|diff| at position n-1   : 15.67

দুটি mask গুলিয়ে ফেলবেন না। Causal mask স্থাপত্যের অংশ, ক্রমের ভবিষ্যৎ ঢাকে, প্রতিটি forward-এ একই নকশা। Attention mask batch-এর অংশ, <pad> ঢাকে, ব্যবহারকারী পাঠায়। GPT-2-এর নিজের pad token নেই; আমাদের run-এ pad_token_id-তে eos বসিয়েছি। Batch-এ generation করলে padding বাঁ দিকে দিতে হয়, নইলে শেষ ঘর হবে pad, আর “পরের token” অনুমান হবে pad-এর পরের। Hugging Face-এর docs এই নিয়ে সাবধান করে; ডান দিকের padding training-এ ঠিক থাকে, কারণ সেখানে label −100 দিয়ে ঢাকা।

৪ · GPT-2 খুলে দেখা — module tree আর হাতে গোনা

সত্যিকারের run, CPU-তে: openai-community/gpt2 (MIT licence, model card দেখে নেওয়া), লেখার সময়ে torch 2.15.0, transformers 5.22.2, Python 3.12. ডাউনলোডে কোনো token লাগেনি। আউটপুট print(model)-এর; কমান্ড সরল করে লেখা, আর ... দিয়ে কিছু অংশ ছোট করা:

$ cd ~/bazarghar-dl && uv run python run_gpt2.py
GPT2LMHeadModel(
  (transformer): GPT2Model(
    (wte): Embedding(50257, 768)
    (wpe): Embedding(1024, 768)
    (drop): Dropout(p=0.1, inplace=False)
    (h): ModuleList(
      (0-11): 12 x GPT2Block(
        (ln_1): LayerNorm((768,), eps=1e-05, ...)
        (attn): GPT2Attention(
          (c_attn): Conv1D(nf=2304, nx=768)
          (c_proj): Conv1D(nf=768, nx=768)
          ...
        )
        (ln_2): LayerNorm((768,), eps=1e-05, ...)
        (mlp): GPT2MLP(
          (c_fc): Conv1D(nf=3072, nx=768)
          (c_proj): Conv1D(nf=768, nx=3072)
          (act): NewGELUActivation()
          ...
        )
      )
    )
    (ln_f): LayerNorm((768,), eps=1e-05, ...)
  )
  (lm_head): Linear(in_features=768, out_features=50257, bias=False)
)

দুটি অদ্ভুত জিনিস। Conv1D এখানে নামেই convolution, কাজে linear layer; পর্ব ৩১-এর Conv1d নয়। আর c_attn একটিই layer, 768 থেকে 2304 = 3 × 768: Q, K, V একসঙ্গে বেরিয়ে তিন ভাগ হয়। Parameter গোনা শুরু করি।

Run-এ h[0]-এর ভেতরের সারিগুলো দেখুন; হিসাব মেলানোর জন্য এটুকুই লাগে:

h[0] detail:
  ln_1.weight            (768,)                768
  ln_1.bias              (768,)                768
  attn.c_attn.weight     (768, 2304)     1,769,472
  attn.c_attn.bias       (2304,)             2,304
  attn.c_proj.weight     (768, 768)        589,824
  attn.c_proj.bias       (768,)                768
  ln_2.weight            (768,)                768
  ln_2.bias              (768,)                768
  mlp.c_fc.weight        (768, 3072)     2,359,296
  mlp.c_fc.bias          (3072,)             3,072
  mlp.c_proj.weight      (3072, 768)     2,359,296
  mlp.c_proj.bias        (768,)                768

Shape-টি খেয়াল করুন: (768, 2304) মানে (in, out). PyTorch-এর nn.Linear-এ উল্টো: (out, in). পুরোনো checkpoint কোনো নিজের-লেখা nn.Linear model-এ ঢোকাতে গেলে এই matrix-গুলো transpose করতে হয়। AI-এর লেখা GPT-2 loader-এ এই ভুল প্রায়ই পাবেন; ফল ত্রুটি নয়, shape মিলে গেলে চুপচাপ ভুল (যেমন 768×768-এর c_proj).

এবার সূত্রটিকে calculator বানাই। V, ctx, d, L বদলে যেকোনো GPT-ধাঁচের decoder গোনা যায়।

def decoder_params(V, ctx, d, L, ff=4, tied=True):
    tok, pos = V * d, ctx * d                 # token and position tables
    attn = (d * 3*d + 3*d) + (d * d + d)      # QKV together + output
    mlp = (d * ff*d + ff*d) + (ff*d * d + d)  # two linear layers, with bias
    block = attn + mlp + 2 * (2*d)            # two LayerNorms: scale + shift
    head = 0 if tied else V * d               # tied: no new weight
    return tok, pos, block, L * block + 2*d + tok + pos + head

REAL_GPT2 = 124_439_808                       # model.parameters(), desktop run
tok, pos, block, total = decoder_params(50257, 1024, 768, 12)
print(f"token {tok:>13,}\npos   {pos:>13,}\nblock {block:>13,}\ntotal {total:>13,}")
print("matches real GPT-2:", total == REAL_GPT2)
print("if not tied:", f"{decoder_params(50257, 1024, 768, 12, tied=False)[3]:,}")

print("\n   d   L  ctx            total  token share")
for d, L, c in [(768, 12, 1024), (1024, 24, 1024), (1280, 36, 1024),
                (1600, 48, 1024), (12288, 96, 2048)]:
    t, _, _, n = decoder_params(50257, c, d, L)
    print(f"{d:>5} {L:>3} {c:>4} {n:>16,}  {t/n:.1%}")
print("h never appeared: d stays fixed, each head gets d/h.")

token    38,597,376
pos         786,432
block     7,087,872
total   124,439,808
matches real GPT-2: True
if not tied: 163,037,184

   d   L  ctx            total  token share
  768  12 1024      124,439,808  31.0%
 1024  24 1024      354,823,168  14.5%
 1280  36 1024      774,030,080  8.3%
 1600  48 1024    1,557,611,200  5.2%
12288  96 2048  174,604,259,328  0.4%
h never appeared: d stays fixed, each head gets d/h.

এই সংখ্যাগুলো থেকে দুটি কাজের হিসাব. ফাইলের আকার: 137,022,720 × 4 byte ≈ 522.7 MiB, Hub-এ দেখানো আকারের সঙ্গে মেলে। Context-এর সীমা: wpe-তে ১০২৪টি সারি, তাই সেটিই দেয়াল। সত্যিকারের run:

1024 ok (1, 1024, 50257)
1025 IndexError index out of range in self

“Context ছাড়িয়ে গেছে” কোনো সুন্দর বার্তা আসেনি; সাধারণ IndexError. লম্বা বাংলা লেখা এই model-এ দ্রুত এই দেয়ালে ধাক্কা খায়।

৫ · GPT-1, ২, ৩ — প্রবন্ধে যা আছে, আর GPT-4-এ যা নেই

নিচের তথ্য মূল প্রবন্ধ থেকে পড়া, ২০২৬ সালের নভেম্বরে। কোনো র‍্যাঙ্কিং নয়, শুধু প্রকাশিত মাপ।

GPT-2 প্রবন্ধে নিজের বদল স্পষ্ট লেখা: LayerNorm সরে গেল প্রতিটি sub-block-এর input-এ, অর্থাৎ pre-norm; শেষ attention block-এর পরে আরেকটি LayerNorm; residual layer-এর শুরুর weight 1/√N দিয়ে ছোট করা; vocabulary ৫০,২৫৭; আর byte-level BPE. হিসাব করে দেখুন: প্রতি block-এ দুটি residual শাখা ধরলে N = 2 × 12 = 24, তাই 1/√24 ≈ 0.204. Hugging Face-এর কোডেও এই ধারণা 2 * n_layer হিসেবে আছে; ছোট model-এ এটি বড় প্রভাব নয়, ৯৬ স্তরে অনেক বড়। GPT-1 আগেই শেখা position embedding আর GELU নিয়েছিল। GPT-3 প্রবন্ধে আকার নিয়ে বিস্তারিত সারণি আছে; scaling-এর প্রশ্নে যাবে পর্ব ৫১ (Scaling — ডেটা, parameter, compute আর emergent আচরণের দাবি)।

এই ধারার একটি চিন্তা হলো: কাজটি prompt-এই বলে দেওয়া যায়। GPT-2 প্রবন্ধে সারাংশ পেতে লেখার পরে TL;DR: বসিয়ে দেখা হয়েছিল, কোনো আলাদা head ছাড়াই। GPT-3 প্রবন্ধের নামই “Language Models are Few-Shot Learners”: কয়েকটি উদাহরণ prompt-এ দিলে নতুন কাজের নকশা ধরা। তবে দুই প্রবন্ধেই ফল কাজভেদে অনেক আলাদা, আর আজকের assistant-গুলোতে এর ওপর সাধারণত আরও প্রশিক্ষণ থাকে; সেই ধাপ পরের মডিউলগুলোর বিষয়।

ChatGPT, Gemini, Claude, Grok, Kimi নামগুলো ব্যবহারকারীর কাছে product. এদের পেছনের model-এর ভেতরের কতটা প্রকাশিত, তা নির্মাতা আর সংস্করণ ভেদে আলাদা। এই পর্বে আমরা তাদের ভেতরের নকশা নিয়ে কোনো দাবি করছি না। প্রকাশিত তথ্য তাদের নিজের নথিতে দেখুন, তারিখ মিলিয়ে; সেটি বদলাতে পারে।

৬ · GPT-2 বাংলা পড়লে কী হয়

GPT-2-এর tokenizer যেকোনো লেখা নিতে পারে, কারণ তার শুরু byte থেকে। কিন্তু ইংরেজি লেখায় শেখা merge বাংলায় তেমন কাজে লাগে না। বাংলার প্রতিটি অক্ষর UTF-8-এ ৩ byte, তাই বেশির ভাগ অক্ষর ভেঙে যায়। Tokenizer-এর হিসাব আছে পর্ব ৪০-এ। এখানে দেখব model-এর ওপর কী প্রভাব পড়ে। সত্যিকারের run:

bn chars 35 bytes 95 tokens 68
first ids [48071, 228, 48071, 106, 48071, 123, 220, 48071, 105, 48071, 122, 48071]
first tokens ['à¦', 'Ĩ', 'à¦', '®', 'à¦', '¿', 'Ġ', 'à¦', '¬', 'à¦', '¾', 'à¦']
decode one by one ['�', '�', '�', '�', '�', '�']
roundtrip ok: True
per-token loss first 15: [5.71, 0.93, 3.59, 0.63, 3.22, 3.41, 0.14, 2.4, 0.09, 1.13, 0.04, 4.53, 0.19, 1.6, 0.11]

“আমি বাজারঘর থেকে একটি শাড়ি কিনেছি।” বাক্যে ৩৫টি code point, ৬৮টি token. প্রথম তিনটি অক্ষরই ৬টি token: à¦ (অর্থাৎ বাংলা ব্লকের শুরুর দুই byte), তারপর শেষ byte. একা একটি token decode করলে � আসে। পুরো ক্রম একসঙ্গে decode করলে অক্ষর ফিরে আসে, তাই roundtrip ok: True.

এবার ছয়টি ইংরেজি বাক্য আর তাদের আমাদের করা বাংলা অনুবাদে (বাজারঘরের রিভিউ-ধাঁচে, হাতে লেখা) loss:

একটি local run, ছয়টি ছোট বাক্য; সাধারণ সিদ্ধান্ত নয়। কিন্তু শিক্ষাটি পরিষ্কার। প্রথম সারি দেখে মনে হবে, বাংলায় model ভালো। উল্টো। ওপরের per-token তালিকায় দেখুন: à¦-এর মতো পরের অংশ অনুমান করা সহজ, loss ০.১-এর কাছাকাছিও নামে। সহজ টুকরো গড় নামিয়ে দেয়। Perplexity তুলনা তখনই চলে, যখন tokenizer আর লেখা একই। ভিন্ন tokenizer বা ভিন্ন ভাষায় bit প্রতি অক্ষর বা প্রতি byte দেখুন। হিসাব: bit/অক্ষর = 1.793 × 379 ÷ ln 2 ÷ 195 ≈ ৫.০৩। এখানেও মনে রাখুন, ইংরেজি আর বাংলার তথ্য-ঘনত্ব এক নয়, তাই এটিও নিখুঁত তুলনা নয়।

বাজারঘরের কাজে এই হিসাবের অর্থ কী? কাল্পনিক দোকানটির তিনটি কাজ ভাবুন:

৭ · এক ধাপ next token — logit থেকে লেখা

এবার সত্যিকারের একটি ধাপ। Prompt “The capital of Bangladesh is”, GPT-2, CPU-তে। সংখ্যাগুলো run থেকে নেওয়া।

পুরো top-10, ইংরেজি আর বাংলা prompt দুটোতেই (সত্যিকারের run; সংখ্যা হুবহু, ফোনে ধরার জন্য কলাম ছোট করে, আর �-এর পাশে আসল token লেখা):

prompt: The capital of Bangladesh is | tokens: 5
     262 ' the'        0.1142
     257 ' a'          0.0627
     783 ' now'        0.0365
    1363 ' home'       0.0261
     635 ' also'       0.0251
    5140 ' located'    0.0251
    1900 ' known'      0.0236
     287 ' in'         0.0228
   19483 ' Bangladesh' 0.0218
     407 ' not'        0.0211
  top-10 mass 0.379
prompt: বাংলাদেশের রাজধানী | tokens: 38
   48071 '�'    (à¦)  0.7363
     220 ' '          0.1045
     156 '�'    (à)   0.0843
      11 ','          0.0074
     198 '\n'         0.0041
     837 ' ,'         0.0031
      13 '.'          0.0019
     357 ' ('         0.0017
   24231 '�'    (à¥)  0.0017
   28225 ' �'   (Ġà¤) 0.0015
  top-10 mass 0.9466

দেখুন: ঢাকা top-10-এ নেই। Model তথ্য ভান্ডার নয়, ভাষার নকশা শিখেছে। বাংলা prompt-এ সে মূলত অনুমান করছে “এরপর আরেকটি বাংলা byte-এর শুরু”। অর্থের অনুমান এটি নয়। এরপর আসে ফাঁকা জায়গা আর বিরামচিহ্ন; শেষ দিকে à¥ আর à¤ আসলে দেবনাগরী ব্লকের byte.

বাজারঘর-ধাঁচের ইংরেজি prompt “The saree I ordered from the online shop arrived”-এ top-5: in 0.2035, on 0.0935, within 0.0491, today 0.0481, with 0.0445. ব্যাকরণে যুক্তিসঙ্গত; ধারণা করা যায়, web লেখায় এমন বাক্য প্রচুর আছে। কিন্তু এটি নকশা ধরা, দোকানের কোনো তথ্য নয়।

এবার লেখা তৈরি। প্রতিটি ৪০ নতুন token, temperature 0.8, top-k 50, seed লেখা আছে। হুবহু আউটপুট, এক অক্ষরও বদলানো হয়নি:

seed 42 | 'The delivery from the online shop was made to the same address as in the case of the original orders. The order was then delivered to the addresses listed in the order form.\n\nThe original orders are not subject to the processing fees'
seed 7 | "The delivery from the online shop was only a few minutes, but the wait time was so long it made me question how I could let my daughter's birthday party go, let alone my business.'\n\nThe woman was not in the"
seed 42 | 'আমি বাজারঘর থেকে একটি শাড়ি কিনেছি। লািমি ন���্ \u09b4্যেঠহেক'
seed 7 | 'আমি বাজারঘর থেকে একটি শাড়ি কিনেছি। । इंदी प्क राक्न दीख्य्ं'

ইংরেজি ব্যাকরণ মোটামুটি ঠিক, অর্থ এলোমেলো। বাংলা সোজাসুজি অকেজো: অর্থহীন অক্ষর, ভাঙা byte (�), Unicode-এর ফাঁকা ঘর (\u09b4, repr-এ যেমন ছাপা হয়েছে), এমনকি seed 7-এ দেবনাগরী। সৎ উপসংহার: সাধারণ GPT-2 বাংলা লেখার জন্য নয়। এটি model-এর “বোকামি” নয়; তার training লেখা আর tokenizer-এর ফল।

গতির একটি হিসাব: ৪০ token-এ GPT-2 small CPU-তে প্রায় ১ সেকেন্ড (০.৯৮, ০.৯৪), Qwen2.5-0.5B প্রায় ৩.২ সেকেন্ড। প্রতি token-এ KV cache-সহ এক ধাপ; এক local run, CPU ভাগাভাগি করে চলা অবস্থায়, সাধারণ মাপ নয়। Model যত বড়, প্রতি token তত ভারী; দ্রুত করার উপায় পর্ব ১২ আর পর্ব ৫৯-এ (ছোট আর দ্রুত model — quantization, distillation আর pruning).

তুলনায় একটি ছোট বহুভাষিক open model

একই পরীক্ষা Qwen/Qwen2.5-0.5B-তে (সত্যিকারের run, CPU-তে; Apache 2.0, token ছাড়া নামানো যায়, weight প্রায় ১ GB). ২০২৬ সালের নভেম্বরে model card-এ যেমন দেখা গেছে: প্রায় ০.৪৯ B parameter, আর base model-কে কথোপকথনের জন্য সুপারিশ করা হয় না। নির্মাতাদের ব্লগ “২৯-এর বেশি ভাষা” বলে; উদাহরণের তালিকায় বাংলার নাম নেই। তাই আগে মাপি। প্রথম সারণি একই ছয় জোড়া বাক্যে, দুই model-এর লগ থেকে নেওয়া।

প্রতি token-এ loss প্রায় সমান দেখাচ্ছে; প্রতি অক্ষরে খরচ প্রায় অর্ধেক। ওপরের নিয়মটি এখানেই কাজে লাগল। বাংলা prompt-এ Qwen2.5-এর top-10 আর generation (seed আর সেটিং GPT-2-র মতো, হুবহু):

bn chars 35 bytes 95 tokens 37
decode one by one ['আ', 'ম', 'ি', ' �', '�', 'া�', '�', 'া�', '�', '�', '�', 'র']
prompt: বাংলাদেশের রাজধানী | tokens: 19
   35178 ' �'             0.7024
   72258 'র'              0.1157
  148156 'দ'              0.0343
      11 ','              0.0209
     320 ' ('             0.0105
      12 '-'              0.0098
     220 ' '              0.0089
  148787 'গ'              0.0079
  147645 'ত'              0.0062
     198 '\n'             0.0061
  top-10 mass 0.9227
seed 42 | 'আমি বাজারঘর থেকে একটি শাড়ি কিনেছি। তা করে আমাদের সমস্যা অময় ওড়াড়ার ই'
seed 7 | 'আমি বাজারঘর থেকে একটি শাড়ি কিনেছি। তার ছোট হাতে মাধব থেকে মালুর জন্তু এ'
seed 42 | 'বাংলাদেশের রাজধানী বিশ্বাসকুপের সমৃদ্ধি সাম্রাজ্যে বিক্র'
seed 7 | 'বাংলাদেশের রাজধানী নামের উন্নয়ন করিয়েছেন কোথাও কখন ? য'

পার্থক্য চোখে পড়ার মতো: বাংলা অক্ষর আর শব্দের চেহারা অনেকটা ঠিক, ভাঙা byte দেখা যায়নি। কিছু অক্ষর একা token হয়েছে (আ, ম, র), তবু কিছু অক্ষর এখনো byte-এ ভাঙে। কিন্তু অর্থ নেই, আর “রাজধানী”-র পরে ঢাকা আসেনি; ইংরেজি prompt-এ Dh এসেছিল চতুর্থ স্থানে (0.0559). এটি একটি base model-এর একটি run, ছোট পরীক্ষা, আর দুই model-এর আকার ও training আলাদা (প্রায় ৪ গুণ parameter), তাই কে “ভালো”, সে রায় এখান থেকে হয় না। শেখার কথা: সাবলীল চেহারা আর সত্য আলাদা জিনিস। আর Qwen2.5-0.5B-র মতো ছোট model দিয়ে কাজ চালানোর আগে নিজের ডেটায় মেপে নিন।

৮ · Open উত্তরসূরিরা — block-এ কী বদলাল

ছাঁচ একই: token embedding, causal block, LM head. বদলেছে block-এর ভেতরটা। উপাদানগুলো আগেই শিখেছেন: RoPE পর্ব ৩৪-এ, RMSNorm আর SwiGLU পর্ব ৩৫-এ, GQA পর্ব ৩৭-এ। নিচের সারণি প্রতিটির নিজের প্রবন্ধ বা config থেকে, ২০২৬ সালের নভেম্বরে নথিতে যেমন দেখা গেছে। এগুলো কোনো র‍্যাঙ্কিং নয়।

“প্রতি token-এ সক্রিয়” সংখ্যাটি লক্ষ্য করুন: MoE-তে মোট parameter আর প্রতি token-এর গণনা আলাদা। আর open weights মানেই open source নয়: weight পাওয়া যায়, কিন্তু training data সাধারণত পুরোপুরি প্রকাশিত থাকে না, আর licence প্রতিটির আলাদা। DeepSeek ও Llama-র ক্ষেত্রেও licence নিজে পড়ুন।

MoE-র ছোট হিসাব. Mixtral-এ সব expert মিলিয়ে প্রায় 47B, সক্রিয় প্রায় 13B, প্রতি স্তরে ৮-এর মধ্যে ২টি। ধরুন E = সব স্তরে এক expert-এর parameter, R = বাকি সব। তাহলে R + 8E = 47 আর R + 2E = 13. বিয়োগে 6E = 34, তাই E ≈ 5.67B, R ≈ 1.67B. সংখ্যাগুলো গোলানো, তাই হিসাবও মোটামুটি। কিন্তু সূত্র পরিষ্কার: memory-তে সব expert রাখতে হয়, গণনায় লাগে কম। “47B-এর model” আর “13B-এর গতি” তাই দুটিই আংশিক সত্য।

SwiGLU-র ছোট হিসাব. GELU-র FFN-এ দুটি matrix: 2·d·4d = 8d². SwiGLU-তে তিনটি: 3·d·m, যেখানে m মাঝের মাপ। m = 8d/3 নিলে আবার 8d²; কেন, সেটি পর্ব ৩৫-এ দেখেছেন। Mistral 7B-তে d = 4096, m = 14336, যা 8d/3-এর চেয়ে বড়, তাই একটি FFN-এ 3 × 4096 × 14336 = 176,160,768 সংখ্যা, 8d²-এর 134,217,728-এর জায়গায়। Config পড়লেই এই হিসাব করা যায়।

এবার তত্ত্ব মিলিয়ে দেখি। যে Qwen2.5-0.5B চালিয়েছি, তার module tree-ই বলে দেয় কী বদলেছে (সত্যিকারের run; অংশবিশেষ):

Qwen2ForCausalLM(
  (model): Qwen2Model(
    (embed_tokens): Embedding(151936, 896)
    (layers): ModuleList(
      (0-23): 24 x Qwen2DecoderLayer(
        (self_attn): Qwen2Attention(
          (q_proj): Linear(in=896, out=896, bias=True)
          (k_proj): Linear(in=896, out=128, bias=True)
          (v_proj): Linear(in=896, out=128, bias=True)
          (o_proj): Linear(in=896, out=896, bias=False)
        )
        (mlp): Qwen2MLP(
          (gate_proj): Linear(in=896, out=4864, bias=False)
          (up_proj): Linear(in=896, out=4864, bias=False)
          (down_proj): Linear(in=4864, out=896, bias=False)
          (act_fn): SiLUActivation()
        )
        (input_layernorm): Qwen2RMSNorm((896,), eps=1e-06)
        (post_attention_layernorm): Qwen2RMSNorm(...)
      )
    )
    (norm): Qwen2RMSNorm((896,), eps=1e-06)
    (rotary_emb): Qwen2RotaryEmbedding()
  )
  (lm_head): Linear(in=896, out=151936, bias=False)
)
config: heads 14, kv-heads 2, context 32768, tied True
total = 494,032,768

(in_features-কে জায়গার জন্য in লেখা হয়েছে; config-এর লাইনটিও ছোট করা।) GPT-2-র সঙ্গে মিলিয়ে দেখুন: position table নেই, তার জায়গায় rotary_emb; LayerNorm-এর জায়গায় RMSNorm; FFN-এ তিনটি matrix; K আর V মাত্র 128 মাপের, Q 896. Parameter হাতে: Q 803,712 + K 114,816 + V 114,816 + O 802,816 + FFN 3 × 4,358,144 + RMSNorm 2 × 896 = 14,912,384. ২৪ স্তরে 357,897,216; embedding 136,134,656; শেষ norm 896. যোগফল 494,032,768, হুবহু মিল। Card-এর “embedding বাদে ০.৩৬ B”-ও মিলে গেল। আর nn.Linear-এর weight এখানে (out, in): run-এ k_proj.weight-এর shape (128, 896).

GQA আর RoPE-এর হিসাবও হাতে করা যায়, এই model-এর মাপেই:

import numpy as np

d, L, h, g, T = 896, 24, 14, 2, 32768     # d, layers, heads, kv-heads, context
dh = d // h
qkv = lambda heads: d * heads * dh + heads * dh  # one projection, with bias
print(f"head_dim={dh}  Q={qkv(h):,}")
print(f"K+V, {h} kv-heads: {2*qkv(h):,}")
print(f"K+V,  {g} kv-heads: {2*qkv(g):,}  saved per layer {2*(qkv(h)-qkv(g)):,}")

def cache_gib(kv_heads, bytes_per=2):     # KV cache: float16, batch 1
    return 2 * L * kv_heads * dh * T * bytes_per / 2**30
print(f"cache at T={T}: full {cache_gib(h):.2f} GiB, GQA {cache_gib(g):.2f} GiB")
print(f"learned position table: {T*d:,}  RoPE table: 0")

def rope(x, t, base=10000.0):             # rotate pairs (a_i, b_i) by t*w_i
    n = len(x) // 2
    w = base ** (-np.arange(n) * 2 / len(x))
    c, s = np.cos(t * w), np.sin(t * w)
    a, b = x[:n], x[n:]
    return np.concatenate([a * c - b * s, a * s + b * c])

rng = np.random.default_rng(42)
q, k = rng.normal(size=4), rng.normal(size=4)
for tq, tk in [(5, 3), (105, 103), (7, 3)]:
    print(f"pos q={tq:>3} k={tk:>3} gap={tq-tk} q.k={rope(q, tq) @ rope(k, tk):+.6f}")

head_dim=64  Q=803,712
K+V, 14 kv-heads: 1,607,424
K+V,  2 kv-heads: 229,632  saved per layer 1,377,792
cache at T=32768: full 2.62 GiB, GQA 0.38 GiB
learned position table: 29,360,128  RoPE table: 0
pos q=  5 k=  3 gap=2 q.k=+2.661916
pos q=105 k=103 gap=2 q.k=+2.661916
pos q=  7 k=  3 gap=4 q.k=+0.306416

নতুন model দেখলে কী পড়বেন. এই পর্বের হিসাব যেকোনো decoder-এ চলে। Config থেকে নিন: vocabulary, d, layer, head, kv-head, FFN-এর মাপ, activation, position (RoPE না table), context, tied কি না। তারপর পাঁচটি প্রশ্ন: parameter হাতে মেলে কি? কোন token-এ আপনার ভাষা কতটা ভাঙে? KV cache কত memory চায়? Licence কী বলে? Card training data নিয়ে কী বলে, আর কী বলে না? এই অভ্যাস থাকলে কোনো নতুন নামের ঝলকে আপনি বিভ্রান্ত হবেন না।

৯ · AI-এর যুগে — GPT নিয়ে AI-এর সাহায্য

এই পর্বের প্রতিটি হিসাব AI-কে দিয়ে করানো যায়। বিপদ হলো ভুলও একই আত্মবিশ্বাসে আসে। আমাদের নিজের কাজেই ধরা পড়েছে: GPT-2 medium-এর layer ১৬ ভেবে হিসাব মেলেনি; config দেখে পাওয়া গেল ২৪, xl-এর ৪৮।

• Parameter গণনা আসল model.parameters()-এর সঙ্গে মিলিয়েছি
• Label shift ছোট batch-এ হাতে পরীক্ষা করেছি, দুইবার সরানো হয়নি
• শেষ token বদলে দেখেছি, আগের ঘরের logit বদলায়নি
• model.eval() আর torch.no_grad() রেখেছি
• তুলনার আগে tokenizer আর একক (token, অক্ষর, byte) একই আছে কি না দেখেছি
• কোনো model-এর তথ্যের জন্য মূল প্রবন্ধ, card বা config পড়েছি, তারিখসহ
• Generation-এর ফল কয়েকটি seed-এ দেখেছি; গোপন বা ব্যক্তিগত ডেটা কোনো AI-কে দিইনি