LLM-এর ভেতরে — tokenizer থেকে logits, context window আর hallucination

এই পর্বে দুটি সত্যিকারের model চলবে: Qwen/Qwen2.5-0.5B-Instruct (Apache 2.0, প্রায় ৪৯ কোটি parameter) আর openai-community/gpt2 (MIT); template-এর তুলনায় SmolLM2-135M-Instruct-এর tokenizer (Apache 2.0). সবই token ছাড়া নামানো যায়; model card আর লাইসেন্স দেখার নিয়ম AI-এর ভিত্তি কোর্সের পর্ব ৭১-এ। Desktop-এর সব run CPU-তে, torch 2.15.0, transformers 5.22.2, Python 3.12, লেখার সময়ে। ফল একটি স্থানীয় run-এর; ছোট model দিয়ে বড় পণ্যের মান বিচার করা যায় না। LLM-এর মূল ধারণা AI-এর ভিত্তি কোর্সের পর্ব ৭০-এ আছে; এখানে আমরা ভেতরে ঢুকব।

১ · একটি প্রশ্নের পুরো পথ

কুরিয়ারের একটি পার্সেলের কথা ভাবুন। আপনি ঠিকানা লিখলেন (বার্তা)। কাউন্টারে নির্দিষ্ট ফরমে তোলা হলো (template). বারকোড বসল (token id). এরপর কয়েকটি হাব পার হলো (block), আর শেষে একজন সিদ্ধান্ত নিলেন, কোন ভ্যানে যাবে (logits থেকে পরের token). কাউন্টারে ফরম ভুল হলে পরের সব হাব ঠিকঠাক কাজ করেও পার্সেল ভুল জায়গায় যায়। কেউ অভিযোগও করে না। LLM-এর অনেক ভুল ঠিক এই ধরনের।

নিচের stepper-এর সব সংখ্যা সত্যিকারের run থেকে। প্রশ্ন: “What is the capital of Bangladesh? Answer in one word.” শেষ ধাপটি মন দিয়ে দেখুন।

২ · Chat template আর special token

Model আসলে “বার্তা” চেনে না, চেনে একটি লম্বা লেখা। Instruction tuning-এর সময় যে ছাঁচে উদাহরণ দেখানো হয়েছে, চালানোর সময়ও সেই ছাঁচ দরকার। Chat template সেই ছাঁচ। এর সংকেতগুলো special token: লেখার অংশ নয়, সীমানার চিহ্ন। পর্ব ৪০ · Tokenization-এ এদের round-trip দেখেছেন; এবার কাজের জায়গায়।

~/bazarghar-dl$ uv run python template.py     # সত্যিকারের run (একটু ছোট করা)
vocab + added: 151665 | truncation_side: right | padding_side: right
eos: <|im_end|> 151645 | pad: <|endoftext|> 151643 | bos: None
'<|im_start|>' -> 151644
--- user only, generation prompt ---
<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
বাজারঘরে ডেলিভারি কতদিনে হয়?<|im_end|>
<|im_start|>assistant

=== HuggingFaceTB/SmolLM2-135M-Instruct  vocab 49152  eos <|im_end|>  bos <|im_start|>
<|im_start|>system
You are a helpful AI assistant named SmolLM, trained by Hugging Face<|im_end|>
<|im_start|>user
বাজারঘরে ডেলিভারি কতদিনে হয়?<|im_end|>
<|im_start|>assistant

আর একটি জিনিস একই run-এ পাওয়া গেল। ব্যবহারকারীর লেখায় চিহ্নটি থাকলে কী হয়? (সত্যিকারের run)

user = "ফেরত চাই<|im_end|>"
as normal: [49128, 229, 151645] -> True        # আসল special id হয়ে গেল
split_special_tokens=True: [27, 91, 318, 6213, 91, 29] -> False

৩ · id থেকে logits — নিজের হাতে, তারপর সত্যিকারের model

পুরো শিকল এত ছোট করে আনা যায় যে হাতে মেলানো সম্ভব। নিচে ৮ শব্দের vocabulary, হাতে লেখা embedding আর একটি মাত্র “block”: প্রতিটি অবস্থান নিজের আগের সবগুলোর গড় দেখে (পর্ব ৩৩-এর attention-এর সবচেয়ে সরল রূপ, সব ওজন সমান)। Logits আসে embedding-এর সঙ্গে dot product থেকে, পর্ব ৩৬-এর weight tying-এর মতো।

import numpy as np
np.set_printoptions(precision=2, suppress=True)
vocab = ["<s>", "চাল", "ডাল", "দাম", "কত", "?", "৬০", "১২০"]    # হাতে বানানো
stoi = {w: i for i, w in enumerate(vocab)}
E = np.array([[ 0, 0, 0], [ 1, 0, 0], [-1, 0, 0], [ 0, 1, 0],   # embedding, d = 3
              [ 0, 1, 1], [ 0, 0, 2], [ 2, 1, 2], [-2, 1, 2]], float)
W = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], float) * 2.0    # block-এর ওজন

def softmax(z):
    e = np.exp(z - z.max()); return e / e.sum()
def block(x):                                # causal গড়: t নিজের আগের গুলোই দেখে
    c = np.cumsum(x, axis=0) / np.arange(1, len(x) + 1)[:, None]
    return x + c @ W
def run(prompt, seed):
    ids = np.array([stoi[w] for w in prompt])
    x = E[ids]                               # (T, d)
    h = block(x)                             # (T, d)
    logits = h @ E.T                         # (T, V): weight tying
    p = softmax(logits[-1])                  # শুধু শেষ সারি
    tok = np.random.default_rng(seed).choice(len(vocab), p=p)
    return ids, x, h, logits, p, vocab[tok]

prompt = ["<s>", "চাল", "দাম", "কত", "?"]
ids, x, h, logits, p, nxt = run(prompt, seed=52)
print("ids     ", ids, "shape", ids.shape)
print("x[-1]   ", x[-1], "shape", x.shape)
print("h[-1]   ", h[-1], "shape", h.shape)
print("logits  ", logits[-1], "shape", logits.shape)
print("p       ", p.round(3), "sum", round(p.sum(), 3))
print("greedy  ", vocab[int(p.argmax())], "| sampled (seed 52):", nxt)
print("ডাল দিলে:", vocab[int(run(["<s>", "ডাল", "দাম", "কত", "?"], 52)[4].argmax())])
n = 2000
draws = np.random.default_rng(1).choice(len(vocab), n, p=p)
print("২০০০ বার sampling, ১২০ এসেছে:", int((draws == stoi["১২০"]).sum()), "| p×n =", round(p[stoi["১২০"]] * n, 1))

ids      [0 1 3 4 5] shape (5,)
x[-1]    [0. 0. 2.] shape (5, 3)
h[-1]    [0.4 0.8 3.2] shape (5, 3)
logits   [ 0.   0.4 -0.4  0.8  4.   6.4  8.   6.4] shape (5, 8)
p        [0.   0.   0.   0.   0.01 0.14 0.7  0.14] sum 1.0
greedy   ৬০ | sampled (seed 52): ৬০
ডাল দিলে: ১২০
২০০০ বার sampling, ১২০ এসেছে: 282 | p×n = 283.6

সত্যিকারের model-এ একই ধাপ

Forward hook দিয়ে প্রতিটি অংশের output ধরা হয়েছে। হাতে লেখা শিকলের সঙ্গে মিলিয়ে পড়ুন। সত্যিকারের run, কয়েকটি লাইন বাদ দেওয়া।

torch 2.15.0+cpu | transformers 5.22.2
layers 24 | d_model 896 | heads 14 | kv_heads 2 | vocab 151936 | max_pos 32768
params 494032768
tied: True
[2] ids shape: (1, 41) first 6: [151644, 8948, 198, 2610, 525, 1207]
[3] embed       shape (1, 41, 896)  last-position norm 0.6
[3] block 0     shape (1, 41, 896)  last-position norm 3.3
[3] block 11    shape (1, 41, 896)  last-position norm 14.4
[3] block 23    shape (1, 41, 896)  last-position norm 71.8
[3] final norm  shape (1, 41, 896)  last-position norm 242.0
[3] lm_head     shape (1, 41, 151936)  last-position norm 1365.7
[5] raw logit min/max: -15.67 16.96
    id   1143  'Ch'            logit  16.96  p 0.5207
    id     35  'D'             logit  14.97  p 0.0714
    id  43227  ' Dh'           logit  14.78  p 0.0586
    id  62819  'Bang'          logit  14.78  p 0.0586
    id  93793  'Islam'         logit  14.36  p 0.0387
[6] sum p = 1.0001 | chosen greedy id: 1143
[7] cache layers: 24 | key shape layer0: (1, 2, 41, 64)
[8] step 2 input shape: (1, 1) | logits shape (1, 1, 151936) | max abs diff vs full pass: 2.19e-05
    argmax same: True | next token: 'itt'
    key shape after step 2: (1, 2, 42, 64)
[9] greedy reply: 'Chittagong<|im_end|>'
    sample seed 52: 'Wittchs.<|im_end|>'
    generation_config defaults: {'do_sample': True, 'temperature': 0.7, 'top_p': 0.8, 'top_k': 20, 'repetition_penalty': 1.1}
[10] prompt 250 tokens + 60 new, use_cache=True: 4.98 s
[10] prompt 250 tokens + 60 new, use_cache=False: 50.15 s

৪ · Context window — হিসাব আর truncation

Context window হলো একবারে সামলানো token-এর সীমা। ভুল বোঝাবুঝি হয় তিন জায়গায়। Window token-এ মাপা, অক্ষরে নয়। Model-এর উত্তরও সাধারণত এর মধ্যে পড়ে। আর model-এর নিজের কোনো “স্মৃতি” নেই: chat মনে থাকে কারণ আপনার কোড প্রতিবার পুরো ইতিহাস আবার পাঠায়। চায়ের দোকানের ছোট খাতার মতো: পাতা ভরলে পুরনো হিসাব কেটে দিতেই হবে।

এবার সেই হিসাব কোডে। একটি বিপদ লক্ষ করুন: ব্যবহারকারী শুরুতে অর্ডার নম্বর বলেছিলেন। tokens() একটি ছোট বাংলা token-গোনার ফাংশন: ভান্ডারে শব্দ পেলে এক token, না পেলে প্রতি অক্ষরের UTF-8 byte আলাদা, যেভাবে পর্ব ৪০-এ byte-level BPE বাংলা ভাঙে।

VOCAB = {"অর্ডার", "নম্বর", "বাজার", "ঘর", "কত", "আমার", "ডেলিভারি", "ঢাকা", "দাম", "ফেরত"}
def tokens(text):                          # longest match, না মিললে UTF-8 byte
    out, i = [], 0
    while i < len(text):
        hit = max((v for v in VOCAB if text.startswith(v, i)), key=len, default=None)
        if hit: out.append(hit); i += len(hit)
        elif text[i] == " ": i += 1        # সরলতার জন্য space বাদ
        else: out += [f"b{b:02x}" for b in text[i].encode()]; i += 1
    return out
def count(m): return len(tokens(m["t"])) + 4   # প্রতি বার্তায় template-এর ৪ token

chat = [dict(r="system", t="বাজারঘর সহকারী"),
        dict(r="user", t="আমার অর্ডার নম্বর BG417"), dict(r="asst", t="ধন্যবাদ"),
        dict(r="user", t="ডেলিভারি কত দিনে"), dict(r="asst", t="ঢাকা ২ দিন"),
        dict(r="user", t="ফেরত কত দিনে"), dict(r="asst", t="৭ দিন"),
        dict(r="user", t="আমার অর্ডার নম্বর কত")]
def fit(chat, window, reserve):
    budget = window - reserve
    keep = list(chat); dropped = []
    while sum(map(count, keep)) > budget and len(keep) > 2:
        dropped.append(keep.pop(1))        # system রেখে সবচেয়ে পুরোনো
    return keep, dropped
for m in chat: print(f"{m['r']:6} {count(m):>3}  {m['t']}")
print("মোট:", sum(map(count, chat)), "token | 'বাজারঘর':", tokens("বাজারঘর"), "| 'ধন্য':", len(tokens("ধন্য")))
for w in (160, 120, 70):
    keep, drop = fit(chat, w, 16)
    used = sum(map(count, keep))
    print(f"\nwindow {w}, উত্তরের জন্য 16 | input-এর বাজেট {w-16}, ব্যবহার {used}")
    print(" বাদ:", [m["t"] for m in drop] or "কিছু না")
    print(" BG417 এখনো আছে?", any("BG417" in m["t"] for m in keep))

system  24  বাজারঘর সহকারী
user    12  আমার অর্ডার নম্বর BG417
asst    25  ধন্যবাদ
user    18  ডেলিভারি কত দিনে
asst    17  ঢাকা ২ দিন
user    18  ফেরত কত দিনে
asst    16  ৭ দিন
user     8  আমার অর্ডার নম্বর কত
মোট: 138 token | 'বাজারঘর': ['বাজার', 'ঘর'] | 'ধন্য': 12

window 160, উত্তরের জন্য 16 | input-এর বাজেট 144, ব্যবহার 138
 বাদ: কিছু না
 BG417 এখনো আছে? True

window 120, উত্তরের জন্য 16 | input-এর বাজেট 104, ব্যবহার 101
 বাদ: ['আমার অর্ডার নম্বর BG417', 'ধন্যবাদ']
 BG417 এখনো আছে? False

window 70, উত্তরের জন্য 16 | input-এর বাজেট 54, ব্যবহার 48
 বাদ: ['আমার অর্ডার নম্বর BG417', 'ধন্যবাদ', 'ডেলিভারি কত দিনে', 'ঢাকা ২ দিন', 'ফেরত কত দিনে']
 BG417 এখনো আছে? False

সত্যিকারের tokenizer-এর ফাঁদ

১৪টি বার্তার একটি বাংলা chat, ৩৬৫ token. সরাসরি max_length=60 দিয়ে truncation করলে দুই দিকে কী হয়? সত্যিকারের run; প্রথম লাইনটি ডিফল্ট, ডান দিক কাটা।

full chat tokens: 365
default truncation max_length=60, kept 60 tail: '�়?<|im_end|>\n<|im_start|>assistant\nঅর্ডা�'
left truncation, kept 60 head: '� 6 ঢাকায় �'
left truncation tail: '�ে দেব?<|im_end|>\n<|im_start|>assistant\n'

পণ্যের window, তাদের নিজের নথিতে

২০২৬ সালের নভেম্বরে অফিসিয়াল নথিতে যেমন দেখা গেছে। এগুলো পরিবর্তন হতে পারে, আর এই তালিকা কোনো ক্রম নয়; বড় window মানে ভালো উত্তর, এমনও নয়।

সীমা পার হলে কী হয়, সেটিও পণ্যভেদে আলাদা। Anthropic-এর নথি অনুযায়ী input একাই window ছাড়ালে API error দেয়, আর chat ইন্টারফেস পুরনো অংশ নিজে সামলাতে পারে। নিজের কোডে তাই নিজের সিস্টেমের নথি পড়ুন, আর token গুনুন।

৫ · অক্ষর গুনতে কেন ভুল হয়

একটি প্রশ্ন LLM-এর দুর্বলতা হিসেবে বিখ্যাত হয়েছে: “strawberry”-তে কয়টি r? কারণ বুঝতে আগে দেখুন, model আসলে কী পায়। নিচে সত্যিকারের run, greedy, কয়েকটি লাইন ছোট করা।

strawberry -> ['str', 'aw', 'berry']
banana -> ['banana']
bazarghar -> ['baz', 'arg', 'har']
mississippi -> ['miss', 'issippi']
বাজারঘর -> codepoints 7  utf8 bytes 21  tokens 8
ডেলিভারি -> codepoints 8  utf8 bytes 24  tokens 8

('strawberry', 'r', 3, '1', '1')     # শব্দ, অক্ষর, আসল গোনা, জোড়া শব্দে উত্তর, আলাদা অক্ষরে উত্তর
('banana', 'a', 3, '1', '1')
('mississippi', 's', 4, '3', '1')
('delivery', 'e', 2, '1', '1')
English n=20: joined word correct 3, spaced letters correct 3, always-say-1 baseline 3
Bangla n=15, 60 new tokens: gave a number 2, correct 0, always-say-1 baseline 6
spell: strawberry, s, r, w, r, b, t, r, i, l, e

Token কেন একটি বাধা, তা আলাদা করে মাপতে একটি খেলনা পরীক্ষা নিন। একই শব্দ, একই সরল “model” (প্রতি id-এর জন্য একটি সংখ্যা শেখে, least squares), শুধু input আলাদা: token id, না অক্ষরের id. মাত্র ২৫টি উদাহরণে শেখানো হলো। এটি LLM নয়; এটি শুধু দেখায়, অক্ষর-প্রতি id থাকলে তথ্যটি কত সহজে পাওয়া যায়।

import numpy as np
chunks = ("বাজার ঘর রিভিউ ডেলিভারি চাল ডাল তরকারি বাক্স পণ্য রসিদ দাম কম বেশি শহর নগর গ্রাম মাছ ফল "
          "সবজি কাপড় জামা জুতা ব্যাগ ফোন চার্জার কুকার হাঁড়ি থালা বাটি পরিবার সরকার ব্যবসা খরচ হিসাব "
          "খাতা দোকান মালিক গ্রাহক অর্ডার রাজশাহী রংপুর বরিশাল").split()
rng = np.random.default_rng(52)
zipf = 1 / np.arange(1, len(chunks) + 1); zipf /= zipf.sum()     # কিছু token বিরল
def word():
    return tuple(rng.choice(len(chunks), rng.integers(2, 4), p=zipf).tolist())
data = [word() for _ in range(160)]
text = ["".join(chunks[i] for i in w) for w in data]
y = np.array([t.count("র") for t in text], float)
chars = sorted(set("".join(text)))
cid = {c: i for i, c in enumerate(chars)}
def bag_token(w):
    v = np.zeros(len(chunks)); np.add.at(v, list(w), 1); return v
def bag_char(t):
    v = np.zeros(len(chars)); np.add.at(v, [cid[c] for c in t], 1); return v
tr, te = np.arange(25), np.arange(25, 160)                       # মাত্র ২৫টি শেখার উদাহরণ
for name, X in (("token ids", np.array([bag_token(w) for w in data])),
                ("char ids ", np.array([bag_char(t) for t in text]))):
    b = np.linalg.lstsq(X[tr], y[tr], rcond=None)[0]             # id-প্রতি একটি সংখ্যা শেখে
    pred = np.round(X[te] @ b)
    print(f"{name}: vocab {X.shape[1]:>2} | test ঠিক {(pred == y[te]).mean():.3f}")
seen = set(i for w in [data[j] for j in tr] for i in w)
X = np.array([bag_token(w) for w in data]); b = np.linalg.lstsq(X[tr], y[tr], rcond=None)[0]
pred = np.round(X[te] @ b)
has_new = np.array([any(i not in seen for i in data[j]) for j in te])
print("token: না-দেখা token আছে এমন শব্দ", int(has_new.sum()), "টি, ঠিক", round((pred == y[te])[has_new].mean(), 3),
      "| বাকি", int((~has_new).sum()), "টি, ঠিক", round((pred == y[te])[~has_new].mean(), 3))
j = te[np.where(pred != y[te])[0][0]]
print("ভুলের উদাহরণ:", [chunks[i] for i in data[j]], "ids", list(data[j]), "| আসল র:", int(y[j]), "| অনুমান:", int(np.round(X[j] @ b)))
print("গণনার সাধারণ কোড (str.count):", text[j].count("র"))
print("baseline, সবসময় গড়:", round((np.round(y[tr].mean()) == y[te]).mean(), 3))

token ids: vocab 42 | test ঠিক 0.881
char ids : vocab 37 | test ঠিক 1.000
token: না-দেখা token আছে এমন শব্দ 63 টি, ঠিক 0.746 | বাকি 72 টি, ঠিক 1.0
ভুলের উদাহরণ: ['রসিদ', 'বাজার', 'খরচ'] ids [9, 0, 32] | আসল র: 3 | অনুমান: 2
গণনার সাধারণ কোড (str.count): 3
baseline, সবসময় গড়: 0.4

৬ · Knowledge cutoff — model-এর ক্যালেন্ডার থেমে আছে

Training-এর ডেটা একটি তারিখে থামে। এরপরের ঘটনা model-এর ওজনে নেই; একে knowledge cutoff বলে। আগের অংশের সারণিতে কয়েকটি পণ্যের নথিতে লেখা তারিখ আছে। সবাই একে একভাবে বলে না: Anthropic-এর নথিতে “reliable knowledge cutoff” আর “training data cutoff” আলাদা সারি, অর্থাৎ শেষের দিকের তথ্য অসম্পূর্ণ হতে পারে। লাইব্রেরির API-র জন্য এটি সরাসরি বিপদ: পুরনো ডেটায় শেখা model পুরনো ফাংশন আত্মবিশ্বাসে লিখে দেয়।

"What is today's date? ..."               -> "Today's date is January 1, 2023."
'What year is it now? ...'                -> '2023'
'Who won the 2031 Cricket World Cup? ...' -> 'The 2031 Cricket World Cup was won by South Africa, defeating Australia in the final.'
with date in system: '2026'
capital with a note: 'Dhaka'
shop with a note: 'Bazarghar takes 3 days to deliver to Sylhet.'

৭ · Hallucination — কারণ আর একটি মাপা পরীক্ষা

পরীক্ষার হলে একজন ছাত্রের কথা ভাবুন, যিনি উত্তর জানেন না কিন্তু ফাঁকা খাতা জমা দিতে চান না। হাতের লেখা সুন্দর, বাক্য গোছানো, তথ্য বানানো। Hallucination-এর কাছাকাছি একটি ছবি এটি; তবে model-এর কোনো ভয় বা ইচ্ছা নেই। যান্ত্রিক কারণ সরল: pretraining-এর objective শুধু পরের token-এর log-probability বাড়ায় (পর্ব ১৩)। “এটি সত্য কি না” কোথাও একটি পদ হিসেবে নেই। উত্তর না জানলেও softmax সব token-এ কিছু না কিছু সম্ভাবনা দেয়, আর decoding একটি বেছে নেয়।

পরীক্ষা: Qwen2.5-0.5B-কে ৭০টি প্রশ্ন, greedy. ৪০টি বাস্তব (রাজধানী, মৌল, পাটিগণিত, ইতিহাস), আর ৩০টি বাজারঘর নিয়ে। বাজারঘর এই কোর্সের বানানো দোকান, তাই প্রতিষ্ঠার সাল বা ওয়াটের কোনো সত্য উত্তর নেই; ঠিক আচরণ একটিই, “জানি না”। ইংরেজিতে ২৪ নতুন token পর্যন্ত, বাংলায় ৯০। প্রতি উত্তরের token-প্রতি গড় log-probability মাপা হলো, আর seed ৫২-এ ৫টি sample নিয়ে শব্দের মিল। ঠিক-ভুল গোনা হয়েছে keyword মিলিয়ে, তাই গোনা নিখুঁত নয়।

কিছু উত্তরে বানানো ব্যক্তির নাম আর একটি ফোন নম্বর এসেছিল; সেগুলো এখানে দেখানো হয়নি, কারণ কারও আসল তথ্যের সঙ্গে মিলে যেতে পারে। ওপরের লাইনগুলোর সামনের অংশ জায়গার জন্য “…” করা হয়েছে। নিচের সারাংশ কয়েকটি script-এর সত্যিকারের আউটপুট, একসঙ্গে বসিয়ে একটু ছোট করা।

-- en
real, correct             n=28  mean logprob -0.083  agree 0.748
real, wrong               n= 2  mean logprob -0.438  agree 0.348
invented, gave an answer  n=14  mean logprob -0.531  agree 0.345
invented, abstained       n= 1  mean logprob -0.330  agree 0.165
English only: correct 28 | false or invented 16
 AUC mean_lp 0.978 | AUC agree 0.911
 keep mean_lp >= -0.1: correct kept 18/28, false kept 0/16
 keep mean_lp >= -0.2: correct kept 26/28, false kept 2/16
 keep mean_lp >= -0.5: correct kept 28/28, false kept 8/16
-- bn, 90 new tokens
real n 10  correct 1   abstain 0  echo-start 9   mean lp -0.323
fake n 15  correct 0   abstain 0  echo-start 13  mean lp -0.305
with 'say you do not know' system message: invented abstained 3 / 15 | real abstained 0 / 20
same subsets without it: invented 0 / 15 | real 0 / 20

গড় সংখ্যাটি কেন ধোঁকা দিতে পারে? “100 watts” উত্তরের −০.১৮৪ ধাপে ধাপে ভাঙা যাক। সব p সত্যিকারের run থেকে।

৮ · Calibration — আত্মবিশ্বাস কি নির্ভুলতার সঙ্গে মেলে?

খোলা প্রশ্নে সত্য মাপা কঠিন, তাই সীমিত একটি প্রশ্ন নিন: যেখানে সঠিক উত্তরের চাবি আছে, সেখানে আত্মবিশ্বাসের সংখ্যা কতটা মেলে? আবহাওয়ার পূর্বাভাসের মতো: ৭০% বৃষ্টির দিনগুলোর প্রায় ৭০%-এ বৃষ্টি হলে পূর্বাভাসটি calibrated. Reliability diagram, ECE আর temperature scaling-এর বিস্তারিত মেশিন লার্নিং কোর্সের পর্ব ২৬-এ; deep model-এর দিক পর্ব ১৩-এ। এখানে আমরা সেগুলো নিজের মাপা LLM-এর ফলে খাটাব।

পরীক্ষা: CommonsenseQA-র validation অংশের ১,২২১টি প্রশ্ন (tau/commonsense_qa, Hugging Face, MIT), পাঁচটি বিকল্প, ইংরেজি। Qwen2.5-0.5B-কে বলা হলো শুধু অক্ষর লিখতে। A থেকে E-এর পাঁচটি logit নিয়ে softmax, সবচেয়ে বড় মানটি আত্মবিশ্বাস। পুরো vocabulary-র ৯৯.৬% সম্ভাবনা এই পাঁচ অক্ষরেই ছিল। নিচে সেই ফলের ঝুড়িগুলো ডেটা হিসেবে বসানো।

import numpy as np, matplotlib.pyplot as plt
# প্রতি ঝুড়ি: নিচের সীমা, ওপরের সীমা, n, গড় আত্মবিশ্বাস, ঠিক উত্তর (desktop-এ মাপা)
B = np.array([(.2, .3,  15, .2766,   4), (.3, .4,  94, .3540,  31),
              (.4, .5, 150, .4483,  47), (.5, .6, 147, .5519,  69),
              (.6, .7, 153, .6509,  73), (.7, .8, 139, .7517,  72),
              (.8, .9, 151, .8540,  81), (.9, 1., 372, .9673, 279)])
lo, hi, n, conf, ok = B.T
acc, N = ok / n, n.sum()
gap = conf - acc
print(" ঝুড়ি       n   আত্মবিশ্বাস  নির্ভুলতা  ফারাক")
for r in zip(lo, hi, n, conf, acc, gap):
    print(f"{r[0]:.1f}-{r[1]:.1f}  {r[2]:4.0f}   {r[3]:.3f}      {r[4]:.3f}     {r[5]:+.3f}")
print("মোট n:", int(N), "| নির্ভুলতা:", round(ok.sum() / N, 4), "| গড় আত্মবিশ্বাস:", round((n * conf).sum() / N, 4))
print("ECE:", round((n / N * np.abs(gap)).sum(), 4), "| MCE:", round(np.abs(gap).max(), 4))
for t in (.2, .5, .7, .9):                 # শুধু আত্মবিশ্বাসী উত্তর রাখলে
    m = lo >= t - 1e-9
    print(f"আত্মবিশ্বাস > {t:.1f}: উত্তর রাখা {n[m].sum() / N:.3f}, নির্ভুলতা {ok[m].sum() / n[m].sum():.3f}")
plt.figure(figsize=(4.6, 3.6))
plt.plot([0, 1], [0, 1], "k--", label="perfect")
plt.bar(lo + .05, acc, width=.09, alpha=.55, label="accuracy")
plt.plot(lo + .05, conf, "o-", color="tab:red", label="mean confidence")
plt.xlabel("confidence bin"); plt.ylabel("value"); plt.legend(); plt.show()

 ঝুড়ি       n   আত্মবিশ্বাস  নির্ভুলতা  ফারাক
0.2-0.3    15   0.277      0.267     +0.010
0.3-0.4    94   0.354      0.330     +0.024
0.4-0.5   150   0.448      0.313     +0.135
0.5-0.6   147   0.552      0.469     +0.083
0.6-0.7   153   0.651      0.477     +0.174
0.7-0.8   139   0.752      0.518     +0.234
0.8-0.9   151   0.854      0.536     +0.318
0.9-1.0   372   0.967      0.750     +0.217
মোট n: 1221 | নির্ভুলতা: 0.5373 | গড় আত্মবিশ্বাস: 0.7196
ECE: 0.1824 | MCE: 0.3176
আত্মবিশ্বাস > 0.2: উত্তর রাখা 1.000, নির্ভুলতা 0.537
আত্মবিশ্বাস > 0.5: উত্তর রাখা 0.788, নির্ভুলতা 0.597
আত্মবিশ্বাস > 0.7: উত্তর রাখা 0.542, নির্ভুলতা 0.653
আত্মবিশ্বাস > 0.9: উত্তর রাখা 0.305, নির্ভুলতা 0.750

accuracy 0.5373 | mean confidence 0.7196 | ECE10 0.1824 | chance 0.2
ECE by n bins: {5: 0.1824, 10: 0.1824, 15: 0.1856, 20: 0.1832}
bootstrap 95% CI for ECE10: [0.1605, 0.212]
temperature fitted on 610: T=2.15 | test n=611 acc 0.5172 -> 0.5172 | ECE 0.2101 -> 0.0514 | NLL 1.4909 -> 1.2207
confident wrong: 'What do people need to do to change their lives?' | said better themselves (0.999) | key: face problems
confident wrong: 'Where would a cat snuggle up with their human?' | said bed (0.998) | key: comfortable chair

৯ · Logit lens — স্তরে স্তরে অনুমান দেখা

এখন পর্যন্ত আমরা শুধু শেষের logit দেখেছি। Logit lens একটি সরল প্রশ্ন করে: মাঝের কোনো স্তরের vector-কে সরাসরি শেষ normalization আর lm_head-এ দিলে কোন token এগিয়ে থাকে? ডাক্তার যেমন রোগ ধরার সময় ধাপে ধাপে অনুমান বদলান, অনেকটা সেরকম একটি ছবি মেলে; তবে এটি একটি মাপ, “চিন্তা” নয়। পর্ব ৪৯ · GPT-তে GPT-2-এর গঠন আছে; এখানে শুধু hook বসানো।

store = {}                       # condensed from the real script
def capture(i):
    def f(m, inp, out): store[i] = out[0] if isinstance(out, tuple) else out
    return f
hooks = [b.register_forward_hook(capture(i)) for i, b in enumerate(model.transformer.h)]
def lens(h): return model.lm_head(model.transformer.ln_f(h))

সত্যিকারের run, CPU-তে, seed লাগেনি কারণ sampling নেই। লম্বা সারণি থেকে কয়েকটি স্তর রাখা হলো। প্রথম প্রশ্নের লক্ষ্য token ' Paris', দ্বিতীয়টির ' 2000'.

prompt: 'The Eiffel Tower is located in the city of'
layer | top-1 at last position | p(top-1) | rank target | p(target) | norm
    4 | ' the'         | 0.318 |    448 | 0.0001 |  70.4
    7 | ' Ing'         | 0.230 |     95 | 0.0013 | 104.7
    8 | ' Rome'        | 0.168 |     12 | 0.0150 | 121.9
    9 | ' London'      | 0.248 |      1 | 0.1935 | 150.2
   10 | ' Paris'       | 0.165 |      0 | 0.1649 | 264.7
   11 | ' Paris'       | 0.064 |      0 | 0.0638 | 444.2
block 11 through lens vs the model's real logits, max abs diff: 0.00e+00

prompt: 'Bazarghar, the online shop, was founded in the year'
layer | top-1 at last position | p(top-1) | rank target | p(target) | norm
    4 | 'long'         | 0.569 |      5 | 0.0067 |  68.6
    6 | ' 2000'        | 0.315 |      0 | 0.3152 |  87.9
    9 | ' 2000'        | 0.902 |      0 | 0.9021 | 146.8
   11 | ' 2000'        | 0.233 |      0 | 0.2329 | 432.7
final top5: [(' 2000', 0.233), (' of', 0.029), (' 2013', 0.024), (' 2015', 0.023), (' 2001', 0.021)]

prompt: 'The capital of Bangladesh is'   target ' Dhaka'
   10 | ' Bangladesh'  | 0.480 |      1 | 0.1415 | 278.6
   11 | ' the'         | 0.114 |     13 | 0.0116 | 446.7

Bangla in gpt2: 14 tokens, every one decodes to '�'

১০ · AI-এর যুগে — LLM-এর ভেতরের কোড আর দাবি যাচাই

এই পর্বের কোড AI assistant মিনিটে লিখে দেয়। তবে এখানকার ভুলগুলো সাধারণত চুপচাপ ভুল ফল দেয়, ক্র্যাশ করে না।

AI বা LLM-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• Template-এর চূড়ান্ত লেখা print করে পড়েছি; generation prompt আছে
• Token গুনেছি, উত্তরের জায়গা রেখেছি, কাটা অংশ decode করে দেখেছি
• Tiny input-এ সব shape মিলিয়েছি, cache-সহ আর ছাড়া token এক কি না দেখেছি
• তথ্যের দাবি মূল উৎসে মিলিয়েছি; model-কে দিয়ে model-কে যাচাই করিনি
• Confidence-এর সংখ্যা নিজের ডেটায় মেপেছি, একটি run বা একটি উদাহরণে সিদ্ধান্ত নিইনি
• Library-র argument নিজের version-এর docs-এ দেখেছি; ব্যক্তিগত ডেটা বা key prompt-এ দিইনি