LLM মূল্যায়ন — benchmark, LLM-as-judge আর তার ফাঁদ

এই পর্বের সব desktop run CPU-তে: torch 2.15.0, transformers 5.22.2, Python 3.12, লেখার সময়ে। Model তিনটি ছোট, open আর Apache 2.0: Qwen/Qwen2.5-0.5B-Instruct, HuggingFaceTB/SmolLM2-135M-Instruct আর HuggingFaceTB/SmolLM2-360M-Instruct; token ছাড়া নামানো যায়। পাতায় command আর script-এর নাম সহজ করে দেখানো, আউটপুট হুবহু; যেখানে ছোট করা, সেখানে বলা আছে। সব সংখ্যা একটি স্থানীয় run-এর, ছোট model আর ছোট set-এ; এগুলো দিয়ে কোনো বড় model বা পণ্যের মান বিচার করা যায় না। Precision, recall আর accuracy-র ভিত্তি AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ; LLM-এর মূল ধারণা একই কোর্সের পর্ব ৭০-এ।

১ · কী মাপবেন — নম্বরের আগে প্রশ্ন

বোর্ড পরীক্ষার খাতা দেখার কথা ভাবুন। একই খাতা দুজন পরীক্ষক দেখলে নম্বর একটু আলাদা হয়। প্রশ্ন ফাঁস হলে নম্বর বাড়ে, কিন্তু শেখা বাড়ে না। আর ১০টি প্রশ্নের পরীক্ষায় ৭ পাওয়া ছাত্র সত্যিই ৭০% জানে, এমন বলা কঠিন। LLM মূল্যায়নে এই তিনটি সমস্যাই আছে, শুধু আরও বড় আকারে। এই পর্বে প্রতিটি নিজের হাতে মাপবেন।

প্রথমে ঠিক করুন, ঠিক কী জানতে চান। “Model কতটা ভালো” কোনো প্রশ্ন নয়। বাজারঘরের সহায়তা-বটের জন্য প্রশ্নগুলো এমন:

একটি মাত্রা বাড়ালে অন্যটি প্রায়ই কমে। বড় model নির্ভুল, কিন্তু ধীর আর দামি। কড়া নিরাপত্তা নিয়ম কিছু নির্দোষ প্রশ্নও ফিরিয়ে দেয়। তাই মূল্যায়নের ফল একটি নম্বর নয়, একটি সারণি। প্রতিটি সংখ্যা কীভাবে আসে, তার পথটি নিচের ছবিতে।

২ · পরিচিত benchmark — কোনটি কী মাপে, আর কোথায় থামে

Benchmark হলো সবার জন্য একই প্রশ্নের set আর একই নম্বরের নিয়ম, যাতে model-গুলো তুলনা করা যায়। নিচের তথ্য প্রতিটির মূল প্রবন্ধ থেকে, ২০২৬ সালের নভেম্বরে মিলিয়ে দেখা। কোনো model-এর স্কোর এখানে দিচ্ছি না, কারণ স্কোর prompt আর নিয়মভেদে বদলায়, আর এগুলো দিয়ে model-এর ক্রম সাজানো এই পর্বের কাজ নয়।

তালিকায় নম্বরের তিনটি নিয়ম: বিকল্প বাছাই, উত্তর মেলানো আর বিচারক। আগে benchmark-এর দুটি অসুখ।

Contamination: প্রশ্ন আগেই ফাঁস

Pretraining-এর ডেটা ইন্টারনেট থেকে আসে, আর benchmark-ও ইন্টারনেটে থাকে। তাই test-এর প্রশ্ন, এমনকি উত্তরসহ, training-এ ঢুকে যেতে পারে। একে বলে data contamination. ফাঁস হওয়া প্রশ্নপত্রে ভালো নম্বর মুখস্থের প্রমাণ, শেখার নয়। ধারণাটি নতুন নয়: AI-এর ভিত্তি কোর্সের পর্ব ৫৬-এর leakage-ই, শুধু এখানে আপনি training ডেটা দেখতে পান না। GPT-3-এর প্রবন্ধে (Brown ও সহকর্মী, ২০২০) লেখকেরা ১৩ শব্দের n-gram মিল খুঁজে প্রতিটি benchmark-এর “পরিষ্কার” অংশ আলাদা করে নম্বর দিয়েছিলেন। এটি একটি চলনসই পরীক্ষা, পূর্ণ নয়: অনুবাদ বা ভিন্ন শব্দে লেখা প্রশ্ন এতে ধরা পড়ে না।

বন্ধ model-এর training ডেটা সাধারণত প্রকাশ হয় না, তাই বাইরে থেকে contamination পুরোপুরি যাচাই করা যায় না। ব্যবহারিক প্রতিরক্ষা তিনটি: নিজের অপ্রকাশিত প্রশ্ন; প্রকাশের তারিখের পরে লেখা প্রশ্ন; আর একই প্রশ্ন সামান্য বদলে (সংখ্যা, নাম, বিকল্পের ক্রম) নম্বর একই থাকে কি না দেখা। নম্বর হঠাৎ পড়ে গেলে সন্দেহ জাগে।

Saturation আর benchmark-এর নিজের ভুল

অনেক model যখন প্রায় পূর্ণ নম্বর পায়, তখন benchmark আর পার্থক্য দেখাতে পারে না। একে বলে saturation. তখন কঠিনতর সংস্করণ আসে, যেমন MMLU-Pro (Wang ও সহকর্মী, ২০২৪), যেখানে বিকল্প দশটি। আরেকটি সমস্যা: benchmark-এর উত্তরপত্র নিজেই নির্ভুল নয়। Gema ও সহকর্মীদের “Are We Done with MMLU?” (২০২৪) প্রবন্ধে কিছু বিষয়ে উল্লেখযোগ্য সংখ্যক প্রশ্নে ভুল বা অস্পষ্ট উত্তর পাওয়া যায়। ফলে শীর্ষের কাছে ০.৫ শতাংশ-বিন্দুর পার্থক্য প্রায়ই অর্থহীন। পর্ব ৪৫-এর Goodhart-এর কথাও এখানে খাটে: যে benchmark লক্ষ্য হয়ে যায়, সেটি দ্রুত মাপ হিসেবে দুর্বল হয়।

৩ · Multiple-choice — লেখা ছাড়াই উত্তর বাছাই

চার বিকল্পের প্রশ্নে model-কে কিছু লিখতে বলার দরকার নেই। পর্ব ৫২-এ দেখেছেন, model প্রতিটি token-এর সম্ভাবনা দেয়। তাই প্রতিটি বিকল্পকে প্রশ্নের পরে বসিয়ে জিজ্ঞেস করা যায়: এই লেখাটি আসার সম্ভাবনা কত? যে বিকল্পের log-probability সবচেয়ে বেশি, সেটিই model-এর উত্তর। একে বলে log-likelihood scoring. HellaSwag আর অনেক multiple-choice benchmark এভাবেই নম্বর পায়।

একটি বিকল্প c-তে token c₁, …, c_m থাকলে, প্রশ্ন x দেওয়া থাকলে:

score(c) = ∑_t=1..m log P(c_t | x, c₁, …, c_t−1)

এখানে প্রতিটি পদ শূন্য বা ঋণাত্মক, কারণ সম্ভাবনা ১-এর বেশি নয়। ফলে যত বেশি token, যোগফল তত নিচে নামে। ছোট বিকল্প শুধু ছোট বলেই সুবিধা পায়। প্রতিকার length normalisation: যোগফলকে token-এর সংখ্যা, অক্ষর বা byte দিয়ে ভাগ। EleutherAI-এর lm-evaluation-harness-এ এর একটি রূপ acc_norm নামে আছে; ঠিক কী দিয়ে ভাগ হয়, তা ব্যবহৃত version-এর docs-এ দেখে নিন, কারণ বর্ণনা আলাদা পাওয়া যায়।

দ্বিতীয় পথটি অক্ষর-ছাঁচ: প্রশ্নের সঙ্গে “A. … B. …” লিখে দিয়ে শুধু পরের token “A”, “B”, “C” না “D”, তার logit তুলনা। এতে বিকল্পের দৈর্ঘ্যের সমস্যা নেই, কিন্তু model-কে অক্ষর আর বিকল্প জোড়া লাগাতে হয়, যা ছোট model-এর জন্য আলাদা একটি কাজ। নিচের stepper-এর সব সংখ্যা সত্যিকারের run থেকে, Qwen2.5-0.5B-Instruct, বাজারঘরের একটি প্রশ্ন।

এবার একই হিসাব নিজে চালান। Log-prob-গুলো সত্যিকারের run থেকে তোলা; কোড শুধু তিন নিয়মে বাছাই করে।

import numpy as np
# সত্যিকারের run: Qwen2.5-0.5B-Instruct, প্রতিটি বিকল্পের প্রতি token-এর log-prob
ITEMS = {
 "কোনটি ফল? (ঠিক: পেয়ারা)": {
  "আলু":    [-0.0328, -4.0839, -5.0026, -0.9577, -3.6505],
  "পেঁয়াজ": [-0.0328, -2.7542, -7.1819, -5.6486, -0.1681, -4.1981, -0.0509, -0.0, -0.3474, -4.0867],
  "পেয়ারা":  [-0.0328, -2.7542, -7.1819, -3.4581, -0.0, -0.0, -1.7615, -0.0995, -2.9403],
  "রসুন":   [-0.0328, -6.8133, -3.678, -5.5076, -1.4021, -2.1348]},
 "বাংলাদেশের রাজধানী কোনটি? (ঠিক: ঢাকা)": {
  "চট্টগ্রাম": [-0.0077, -5.4281, -4.3726, -0.3279, -0.1168, -3.2139, -0.8962, -0.0967, -0.5885, -0.2497],
  "খুলনা":   [-0.0077, -6.5373, -1.649, -0.407, -2.2402, -3.3614, -1.1662],
  "ঢাকা":    [-0.0077, -8.8621, -0.4546, -0.5591, -0.3963],
  "রাজশাহী":  [-0.0077, -3.4702, -0.0224, -0.0367, -9.1895, -1.2463, -0.2008, -2.302, -0.0012]}}

for q, opts in ITEMS.items():
    names = list(opts)
    lp = [np.array(v) for v in opts.values()]
    S = np.array([v.sum() for v in lp])                      # যোগফল
    T = np.array([v.mean() for v in lp])                     # token প্রতি গড়
    C = np.array([v.sum() / len(n) for v, n in zip(lp, names)])  # অক্ষর প্রতি
    print(q)
    print(f"  {'বিকল্প':10}{'token':>6}{'যোগফল':>9}{'গড়':>8}{'অক্ষরপ্রতি':>11}")
    for n, v, s, t, c in zip(names, lp, S, T, C):
        print(f"  {n:10}{len(v):6d}{s:9.2f}{t:8.2f}{c:11.2f}")
    for rule, x in (("যোগফল", S), ("গড়", T), ("অক্ষরপ্রতি", C)):
        print(f"  {rule:10} → {names[int(x.argmax())]}")
    print()

কোনটি ফল? (ঠিক: পেয়ারা)
  বিকল্প     token    যোগফল     গড় অক্ষরপ্রতি
  আলু            5   -13.73   -2.75      -4.58
  পেঁয়াজ       10   -24.47   -2.45      -3.50
  পেয়ারা        9   -18.23   -2.03      -2.60
  রসুন           6   -19.57   -3.26      -4.89
  যোগফল      → আলু
  গড়        → পেয়ারা
  অক্ষরপ্রতি → পেয়ারা

বাংলাদেশের রাজধানী কোনটি? (ঠিক: ঢাকা)
  বিকল্প     token    যোগফল     গড় অক্ষরপ্রতি
  চট্টগ্রাম     10   -15.30   -1.53      -1.70
  খুলনা          7   -15.37   -2.20      -3.07
  ঢাকা           5   -10.28   -2.06      -2.57
  রাজশাহী        9   -16.48   -1.83      -2.35
  যোগফল      → ঢাকা
  গড়        → চট্টগ্রাম
  অক্ষরপ্রতি → চট্টগ্রাম

৪ · সত্যিকারের run — দুটি ছোট model, তিনটি প্রশ্নের set

তিনটি set: (১) এই পর্বের জন্য হাতে লেখা ৪০টি বাজারঘর প্রশ্ন, বাংলায় (দাম আর হিসাব, দৈনন্দিন তথ্য, বাংলাদেশের সাধারণ তথ্য, গ্রাহক-সেবার বুদ্ধি); (২) একই ৪০টি প্রশ্নের ইংরেজি অনুবাদ, একই উত্তরের অবস্থানে; (৩) OpenAI-এর openai/MMMLU-এর বাংলা অংশ (BN_BD), MIT license, dataset card অনুযায়ী পেশাদার অনুবাদকের করা MMLU test set, যার ১৪,০৪২টি প্রশ্ন থেকে seed ৫৮-এ ২০০টি নেওয়া, ৫৭টি বিষয়ের ৫১টি এসেছে। Model দুটি Qwen/Qwen2.5-0.5B-Instruct (প্রায় ৪৯ কোটি parameter) আর HuggingFaceTB/SmolLM2-135M-Instruct (প্রায় সাড়ে ১৩ কোটি), দুটিই Apache 2.0, revision hash ধরে নামানো। সব CPU-তে, torch 2.15.0, transformers 5.22.2, Python 3.12, লেখার সময়ে।

@torch.no_grad()                         # মূল দুটি ফাংশন, একটু ছোট করে
def cloze(model, tok, q, opts):          # প্রতিটি বিকল্পের প্রতি token-এর log-prob
    ctx = tok(f"প্রশ্ন: {q}\nউত্তর:", add_special_tokens=False)["input_ids"]
    out = []
    for o in opts:
        cont = tok(" " + o, add_special_tokens=False)["input_ids"]
        ids = torch.tensor([ctx + cont])
        lp = model(ids).logits[0, :-1].float().log_softmax(-1)
        tl = lp[torch.arange(ids.shape[1] - 1), ids[0, 1:]][len(ctx) - 1:]
        out.append(dict(lps=tl.tolist(), chars=len(o)))
    return out

@torch.no_grad()
def letter(model, tok, q, opts):         # অক্ষর-ছাঁচ: পরের token A/B/C/D-এর logit
    body = q + "\n" + "\n".join(f"{l}. {o}" for l, o in zip("ABCD", opts))
    p = tok.apply_chat_template([{"role": "user", "content": body + "\nAnswer with the letter only."}],
                                tokenize=False, add_generation_prompt=True)
    lg = model(tok(p, return_tensors="pt", add_special_tokens=False)["input_ids"]).logits[0, -1]
    return [float(lg[tok(x, add_special_tokens=False)["input_ids"][0]]) for x in "ABCD"]

~/bazarghar-dl$ uv run python mc_eval.py   # সত্যিকারের run, CPU-তে, ৩টি thread;
# দুটি script-এর আউটপুট একসঙ্গে, কলামের ফাঁকা জায়গা আর কয়েকটি লাইন ছোট করা
bazar answer positions: [12, 18, 10, 0]
mmmlu subjects in sample: 51 | answer positions: [55, 52, 42, 51]
Qwen2.5-0.5B-Instruct  bazar     n= 40 sum=0.200 per-tok=0.225 per-char=0.250 letter=0.325 letter-mass=1.000 time=62s
Qwen2.5-0.5B-Instruct  mmmlu_bn  n=200 sum=0.250 per-tok=0.230 per-char=0.235 letter=0.285 letter-mass=0.999 time=1331s
SmolLM2-135M-Instruct  bazar     n= 40 sum=0.200 per-tok=0.225 per-char=0.225 letter=0.150 letter-mass=0.725 time=27s
SmolLM2-135M-Instruct  mmmlu_bn  n=200 sum=0.275 per-tok=0.250 per-char=0.230 letter=0.215 letter-mass=0.790 time=802s
# দ্বিতীয় script: একই ৪০টি প্রশ্ন ইংরেজিতে ("Question: … Answer:")
Qwen2.5-0.5B-Instruct  bazar_en  n= 40 sum=0.500 per-tok=0.625 per-char=0.550 letter=0.625 letter-mass=0.992 time=30s
SmolLM2-135M-Instruct  bazar_en  n= 40 sum=0.200 per-tok=0.325 per-char=0.450 letter=0.175 letter-mass=0.719 time=11s

৫ · Generation আর exact match — বাংলার normalisation

GSM8K-এর মতো প্রশ্নে বিকল্প নেই; model উত্তর লেখে, আর শেষের সংখ্যাটি reference-এর সঙ্গে মেলানো হয়। একে বলে exact match. সমস্যা হলো “হুবহু”: “১৮০ টাকা” আর “180 taka” অর্থে এক, string-এ আলাদা। তাই মেলানোর আগে দুই পাশে একই answer normalisation: NFC, বাংলা অঙ্ক ইংরেজিতে, দাঁড়ি-কমা বাদ, বাড়তি ফাঁকা জায়গা এক, আর এককের সমার্থক শব্দ এক রূপে।

নিচের উত্তরগুলো Qwen2.5-0.5B-Instruct-এর সত্যিকারের output: বাজারঘর set-এর ১২টি হিসাবের প্রশ্ন, দুটি উদাহরণসহ (2-shot) prompt, greedy decoding, প্রথম লাইন রাখা। একবার প্রশ্ন বাংলায়, একবার ইংরেজিতে; reference দুই ক্ষেত্রেই বাংলায়।

import re, unicodedata
# সত্যিকারের run: Qwen2.5-0.5B-Instruct, 2-shot, greedy; প্রশ্ন বাংলায় (bn) আর ইংরেজিতে (en)
GOLD = ["১৮০ টাকা", "১৪৪ টাকা", "৪৫০ টাকা", "১৮০ টাকা", "৩৫০ টাকা", "৫০০ টাকা",
        "৫০ টাকা", "১০০০ গ্রাম", "২৮০ টাকা", "৭০ টাকা", "২৫%", "৪০০ টাকা"]
BN = ["৫৪ টাকা", "৩৪ টাকা", "৪০০ টাকা", "৫৪০ টাকা", "৭৩০ টাকা", "৫৩০ টাকা",
      "৩০০ টাকা", "৩", "৫৪ টাকা", "৫৪ টাকা", "৩৪০ টাকা", "৩০০ টাকা"]
EN = ["180 taka", "144 taka", "450 taka", "180 taka", "450 taka", "500 taka",
      "50 taka", "1000", "350 taka", "210 taka", "25%", "300 taka"]
EXTRA = [("১৮০ টাকা", " ১৮০  টাকা।"), ("১৮০ টাকা", "180 Tk."), ("১৮০ টাকা", "১৫০ নয়, ১৮০ টাকা"),
         ("১৮০ টাকা", "১৮০ নয়, ১৫০ টাকা")]          # শেষের ৪টি হাতে লেখা পরীক্ষা

DIG = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
UNIT = {"taka": "টাকা", "tk": "টাকা", "grams": "গ্রাম", "gram": "গ্রাম"}
def norm(s):
    s = unicodedata.normalize("NFC", s).translate(DIG).lower()
    s = re.sub(r"[।,.!?;:'\"]", " ", s)
    return " ".join(UNIT.get(w, w) for w in s.split())
def number(s):
    m = re.findall(r"\d+(?:\.\d+)?", norm(s))
    return m[-1] if m else None                # শেষ সংখ্যাটি, GSM8K-এর মতো

def em(golds, preds):
    raw = sum(g == p for g, p in zip(golds, preds))
    nm = sum(norm(g) == norm(p) for g, p in zip(golds, preds))
    num = sum(number(g) == number(p) for g, p in zip(golds, preds))
    return f"{raw:2d} {nm:2d} {num:2d}  / {len(golds)}"
print("             কাঁচা  norm  সংখ্যা")
print("বাংলা প্রশ্ন  ", em(GOLD, BN))
print("ইংরেজি প্রশ্ন ", em(GOLD, EN))
for g, p in EXTRA:
    print(f"{p!r:22} norm={norm(g) == norm(p)!s:5} সংখ্যা={number(g) == number(p)}")

             কাঁচা  norm  সংখ্যা
বাংলা প্রশ্ন    0  0  0  / 12
ইংরেজি প্রশ্ন   0  7  8  / 12
' ১৮০  টাকা।'          norm=True  সংখ্যা=True
'180 Tk.'              norm=True  সংখ্যা=True
'১৫০ নয়, ১৮০ টাকা'    norm=False সংখ্যা=True
'১৮০ নয়, ১৫০ টাকা'    norm=False সংখ্যা=False

৬ · LLM-as-judge — খোলা উত্তরের পরীক্ষক

“বৃষ্টিতে ডেলিভারি দেরি হলে কী বলবেন?” এর কোনো একক সঠিক লেখা নেই। Exact match এখানে অচল, আর পর্ব ৪৫-এর BLEU বা chrF অর্থ বোঝে না। মানুষ দিয়ে হাজার উত্তর পড়ানো ধীর আর দামি। তাই একটি LLM-কেই পরীক্ষক বানানো হয়: LLM-as-a-judge. ধারণাটি বড় আকারে পরীক্ষা করেন Zheng ও সহকর্মীরা, “Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena” প্রবন্ধে (২০২৩, NeurIPS-এর Datasets and Benchmarks track-এ প্রকাশিত)। তাঁদের হিসাবে GPT-4-এর মতো শক্তিশালী বিচারক মানুষের পছন্দের সঙ্গে ৮০%-এর বেশি ক্ষেত্রে মিলেছিল, যা তাঁদের ডেটায় দুজন মানুষের নিজেদের মিলের কাছাকাছি। একই প্রবন্ধে তাঁরা সীমাগুলোও তালিকা করেন।

Zheng ও সহকর্মীদের তালিকার তিনটি পক্ষপাত এই পর্বে মাপব। Position bias: মান না দেখে প্রথম (বা দ্বিতীয়) অবস্থানের উত্তরকে বেশি পছন্দ। Verbosity bias: লম্বা উত্তরকে বেশি পছন্দ, ভুল হলেও। Self-preference (তাঁদের ভাষায় self-enhancement): নিজের লেখার ধাঁচকে বেশি পছন্দ। গণিত বা যুক্তির প্রশ্নে বিচারকের নিজের ভুলও তাঁরা সীমা হিসেবে লেখেন।

৭ · Position bias মাপা — swap test, সত্যিকারের বিচারকে

পরীক্ষার জন্য এই পর্বে হাতে লেখা ৩৬টি বাজারঘর উত্তর-জোড়া। প্রতিটিতে একটি প্রশ্ন (কখনো সঙ্গে দোকানের নিয়ম), একটি ভালো আর একটি খারাপ উত্তর। কোনটি ভালো, তা লেখকের নিজের লেবেল; এটিই এখানে “মানুষের রায়”। তিন ধরনের জোড়া, প্রতিটি ১২টি: fact (খারাপটি নিয়ম বা হিসাব ভাঙে, দৈর্ঘ্য প্রায় সমান), long (খারাপটি লম্বা, ভদ্র, কিন্তু ভুল বা এড়িয়ে যাওয়া), tone (খারাপটি রূঢ় বা অসহযোগী)। বিচারক দুটি ছোট model: Qwen2.5-0.5B-Instruct আর HuggingFaceTB/SmolLM2-360M-Instruct, দুটিরই license Apache 2.0. প্রতিটি জোড়া দুই ক্রমে দেখানো হলো, আর রায় নেওয়া হলো পরের token “A” আর “B”-এর logit-এর পার্থক্য d থেকে, কোনো sampling ছাড়া। Pointwise-এ প্রতিটি উত্তরকে ১–৫ নম্বর, “1” থেকে “5” token-এর সম্ভাবনা দিয়ে প্রত্যাশিত নম্বর।

system: You are a strict judge of customer-support answers. Judge correctness against
        the rule first, then helpfulness and politeness. Length is not quality.
user:   Question: … [Answer A] … [Answer B] … Which answer is better? Reply with one letter: A or B.

~/bazarghar-dl$ uv run python judge_swap.py    # সত্যিকারের run, CPU-তে
== judge Qwen2.5-0.5B-Instruct  (125s, CPU)
 good-first correct 1.000 | good-second correct 0.000 | picks 'A' 1.000
 consistent after swap 0.000 | correct in both orders 0.000
  fact n=12 both-orders-correct 0.000 | pointwise good>bad 0.500 mean good 3.02 bad 3.17
  long n=12 both-orders-correct 0.000 | pointwise good>bad 0.250 mean good 2.47 bad 2.84
  tone n=12 both-orders-correct 0.000 | pointwise good>bad 0.333 mean good 2.49 bad 2.47
== judge SmolLM2-360M-Instruct  (158s, CPU)
 good-first correct 0.778 | good-second correct 0.167 | picks 'A' 0.806
 consistent after swap 0.056 | correct in both orders 0.000
  fact n=12 both-orders-correct 0.000 | pointwise good>bad 0.417 mean good 1.77 bad 1.80
  long n=12 both-orders-correct 0.000 | pointwise good>bad 0.667 mean good 1.68 bad 1.67
  tone n=12 both-orders-correct 0.000 | pointwise good>bad 0.750 mean good 1.76 bad 1.71

একটি জোড়া ধাপে ধাপে দেখুন। SmolLM2-360M, fact জোড়া: “নিয়ম: ঢাকার ভেতরে ডেলিভারি চার্জ ৬০ টাকা, বাইরে ১২০ টাকা। রাজশাহীতে কত?” ভালো উত্তর ১২০, খারাপ উত্তর ৬০।

এবার রায়গুলো নিজে বিশ্লেষণ করুন। নিচে দুই বিচারকের ৭২টি করে আসল রায়, অক্ষরে।

import numpy as np
from scipy.stats import binomtest
# সত্যিকারের run: ৩৬টি বাজারঘর জোড়া (১২ fact, ১২ long, ১২ tone), প্রতিটি দুই ক্রমে।
# v1: ভালো উত্তর A-তে থাকলে রায়; v2: ভালো উত্তর B-তে থাকলে রায়
J = {"Qwen2.5-0.5B": dict(v1="A" * 36, v2="A" * 36),
     "SmolLM2-360M": dict(v1="BAAAAABAAAAAAAAAAAAAAAAABBAAAABABABB",
                          v2="AAAAAABAAAAAAAAAAAAAAAAABBAAAABABAAB")}
kind = np.array(["fact"] * 12 + ["long"] * 12 + ["tone"] * 12)

for name, j in J.items():
    v1, v2 = np.array(list(j["v1"])), np.array(list(j["v2"]))
    ok1, ok2 = v1 == "A", v2 == "B"            # দুই ক্রমে ঠিক কি না
    same = ok1 == ok2                          # ক্রম বদলেও একই উত্তর জিতল
    win = ok1 & ok2                            # দুই ক্রমেই ভালোটি: আসল জয়
    tie = ~same                                # রায় ক্রমের সঙ্গে বদলাল: টাই
    b, c = int((ok1 & ~ok2).sum()), int((~ok1 & ok2).sum())
    p = binomtest(c, b + c, 0.5).pvalue if b + c else 1.0
    print(f"== বিচারক {name}")
    print(f"  'A' বলেছে {np.mean(np.r_[v1, v2] == 'A'):.2f} | swap consistency {same.mean():.2f}")
    print(f"  এক ক্রমে ঠিক: ভালোটি আগে {ok1.mean():.2f}, পরে {ok2.mean():.2f}")
    print(f"  McNemar: শুধু-আগে-ঠিক b={b}, শুধু-পরে-ঠিক c={c}, p={p:.2g}")
    print(f"  Zheng-নিয়মে: জয় {win.sum()}, হার {(~ok1 & ~ok2).sum()}, টাই {tie.sum()}")
    for k in ("fact", "long", "tone"):
        m = kind == k
        print(f"    {k:4}: ভালোটি আগে ঠিক {ok1[m].sum():2d}/12, পরে ঠিক {ok2[m].sum():2d}/12")

== বিচারক Qwen2.5-0.5B
  'A' বলেছে 1.00 | swap consistency 0.00
  এক ক্রমে ঠিক: ভালোটি আগে 1.00, পরে 0.00
  McNemar: শুধু-আগে-ঠিক b=36, শুধু-পরে-ঠিক c=0, p=2.9e-11
  Zheng-নিয়মে: জয় 0, হার 0, টাই 36
    fact: ভালোটি আগে ঠিক 12/12, পরে ঠিক  0/12
    long: ভালোটি আগে ঠিক 12/12, পরে ঠিক  0/12
    tone: ভালোটি আগে ঠিক 12/12, পরে ঠিক  0/12
== বিচারক SmolLM2-360M
  'A' বলেছে 0.81 | swap consistency 0.06
  এক ক্রমে ঠিক: ভালোটি আগে 0.78, পরে 0.17
  McNemar: শুধু-আগে-ঠিক b=28, শুধু-পরে-ঠিক c=6, p=0.0002
  Zheng-নিয়মে: জয় 0, হার 2, টাই 34
    fact: ভালোটি আগে ঠিক 10/12, পরে ঠিক  1/12
    long: ভালোটি আগে ঠিক 12/12, পরে ঠিক  0/12
    tone: ভালোটি আগে ঠিক  6/12, পরে ঠিক  5/12

judge Qwen2.5-0.5B-Instruct: swap-consistent 0.000 CI [0. 0.] (n=36)
   debiased (d1 - d2 > 0) picks the better answer 0.444 CI [0.278 0.611]
judge SmolLM2-360M-Instruct: swap-consistent 0.056 CI [0.    0.139] (n=36)
   debiased (d1 - d2 > 0) picks the better answer 0.639 CI [0.472 0.778]

৮ · কত প্রশ্ন লাগবে — CI, জোড়া তুলনা আর নমুনার আকার

৪০টি প্রশ্নে ০.৬২৫ মানে কী? আরও ৪০টি প্রশ্ন নিলে হয়তো ০.৫০ বা ০.৭৫ আসত। পর্ব ৪৫-এ বাক্য ধরে bootstrap দেখেছেন; এখানে প্রতিটি প্রশ্নের ফল ০ বা ১, তাই হিসাব আরও সহজ। প্রশ্ন ধরে resample করুন, আর দুই model বা দুই ভাষা তুলনায় একই সূচক দুই পাশে নিন (তত্ত্ব মেশিন লার্নিং কোর্সের পর্ব ২১-এ)।

পরিকল্পনার জন্য একটি সূত্রই যথেষ্ট। n টি প্রশ্নে accuracy p হলে standard error √(p(1 − p)/n), আর ৯৫% CI-এর অর্ধ-প্রস্থ প্রায়

h ≈ 1.96 × √(p(1 − p) / n),  তাই  n ≈ 1.96² × p(1 − p) / h²

এখানে ১.৯৬ normal বণ্টনের ৯৭.৫ শতাংশিক বিন্দু, আর h চাওয়া অর্ধ-প্রস্থ। n-এর বর্গমূল হরে আছে, তাই প্রস্থ অর্ধেক করতে প্রশ্ন চারগুণ লাগে। p = ০.৫-এ অনিশ্চয়তা সবচেয়ে বেশি; p ০ বা ১-এর কাছে গেলে কম। খুব ছোট n বা p একেবারে কিনারায় থাকলে এই normal approximation দুর্বল; তখন bootstrap বা Wilson interval ভালো।

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import binomtest
# সত্যিকারের run: Qwen2.5-0.5B-Instruct, অক্ষর-ছাঁচ, একই ৪০টি বাজারঘর প্রশ্ন বাংলায় আর ইংরেজিতে
bn = np.array(list("0100000000101001011000101000010110000101"), int)
en = np.array(list("1000011001100110110011101010111111101111"), int)
rng = np.random.default_rng(58)
idx = rng.integers(0, 40, size=(10000, 40))          # একই সূচক দুই পাশে: জোড়া
ci = lambda v: np.percentile(v, [2.5, 97.5]).round(3)
print(f"বাংলা   {bn.mean():.3f} CI {ci(bn[idx].mean(1))}")
print(f"ইংরেজি  {en.mean():.3f} CI {ci(en[idx].mean(1))}")
print(f"পার্থক্য {en.mean() - bn.mean():+.3f} জোড়া CI {ci((en[idx] - bn[idx]).mean(1))}")
b, c = int(((en == 1) & (bn == 0)).sum()), int(((en == 0) & (bn == 1)).sum())
print(f"McNemar: শুধু ইংরেজিতে ঠিক {b}, শুধু বাংলায় ঠিক {c}, p = {binomtest(c, b + c).pvalue:.4f}")

def n_needed(p, half):                                  # ±half চাইলে কত প্রশ্ন
    return int(np.ceil(1.96**2 * p * (1 - p) / half**2))
for p in (0.5, 0.8):
    print(f"p={p}:", {f"±{h}": n_needed(p, h) for h in (0.10, 0.05, 0.03, 0.01)})
hits = []                                               # সূত্রটি কি ঠিক? অনুকরণে যাচাই
for n in (40, 385):
    acc = rng.binomial(n, 0.5, size=20000) / n
    half = 1.96 * np.sqrt(0.25 / n)
    hits.append(f"n={n}: ±{half:.3f}-এর ভেতরে {np.mean(abs(acc - 0.5) <= half):.3f}")
print(" | ".join(hits))

n = np.arange(20, 2001)
fig, ax = plt.subplots(figsize=(6, 3.2))
for p in (0.5, 0.8, 0.95):
    ax.plot(n, 1.96 * np.sqrt(p * (1 - p) / n), label=f"accuracy {p}")
ax.axhline(0.05, color="gray", ls="--", lw=1)
ax.set_xscale("log"); ax.set_xlabel("number of eval items (log scale)")
ax.set_ylabel("95% CI half-width"); ax.legend(); ax.set_title("More items, narrower interval")

বাংলা   0.325 CI [0.175 0.475]
ইংরেজি  0.625 CI [0.475 0.775]
পার্থক্য +0.300 জোড়া CI [0.1 0.5]
McNemar: শুধু ইংরেজিতে ঠিক 16, শুধু বাংলায় ঠিক 4, p = 0.0118
p=0.5: {'±0.1': 97, '±0.05': 385, '±0.03': 1068, '±0.01': 9604}
p=0.8: {'±0.1': 62, '±0.05': 246, '±0.03': 683, '±0.01': 6147}
n=40: ±0.155-এর ভেতরে 0.960 | n=385: ±0.050-এর ভেতরে 0.942

model                    set       rule       n    acc  95% bootstrap CI   ±1.96·SE
Qwen2.5-0.5B-Instruct    bazar     letter    40  0.325  [0.175, 0.475]   ±0.145
Qwen2.5-0.5B-Instruct    bazar_en  letter    40  0.625  [0.475, 0.775]   ±0.150
Qwen2.5-0.5B-Instruct    mmmlu_bn  letter   200  0.285  [0.225, 0.350]   ±0.063
SmolLM2-135M-Instruct    mmmlu_bn  letter   200  0.215  [0.160, 0.275]   ±0.057
Qwen − Smol, letter, mmmlu_bn: diff +0.070 paired CI [-0.015  0.155] | unpaired CI [-0.015  0.155]

৯ · বাজারঘরের নিজের eval set, rubric আর regression test

প্রকাশিত benchmark সাধারণ ক্ষমতার আভাস দেয়; বাজারঘরের সিদ্ধান্ত নিতে লাগে নিজের প্রশ্ন। এই পর্বের ৪০টি প্রশ্ন আর ৩৬টি জোড়া তার একটি ছোট শুরু। বড় করার নিয়মগুলো:

• প্রশ্ন আসবে কাজ থেকে। আসল গ্রাহকের প্রশ্ন, ফোন নম্বর আর নাম মুছে। প্রতিটি নতুন ভুলের পর একটি নতুন প্রশ্ন যোগ হবে, যাতে একই ভুল ফিরে এলে ধরা পড়ে।
• ভাগ করে রিপোর্ট। দাম আর হিসাব, ফেরতের নিয়ম, ভদ্রতা, নিরাপত্তা। গড় ০.৮০ হলেও নিরাপত্তার ভাগে একটি ভুল বড় ক্ষতি।
• ফল দেখার আগে নিয়ম লেখা। কোন ছাঁচ, কোন normalisation, কোন বিচারক, কত প্রশ্ন, আর কোন সীমা পেরোলে নতুন version চালু হবে।

Rubric: “ভালো উত্তর” লিখে ফেলা

Rubric হলো নম্বর দেওয়ার লিখিত নিয়ম, যাতে দুজন পরীক্ষক একই খাতায় কাছাকাছি নম্বর দেন। বাজারঘরের সহায়তা-উত্তরের জন্য একটি ছোট rubric:

মানুষ দুজন একই rubric-এ নম্বর দিলে তাঁদের মিল Cohen's kappa দিয়ে মাপুন (হিসাব পর্ব ৪৫-এ)। তারপর একই মাপে বিচারক model আর মানুষের মিল। মানুষে-মানুষে মিল কম হলে আগে rubric ঠিক করুন; তখন বিচারকের দোষ ধরা অর্থহীন। Zheng ও সহকর্মীরা (২০২৩) এভাবেই তুলনা করেছিলেন: তাঁদের ডেটায় শক্তিশালী বিচারক আর মানুষের মিল মানুষে-মানুষে মিলের কাছাকাছি ছিল। আমাদের ছোট বিচারকের ক্ষেত্রে, §৭-এর ফল অনুযায়ী, সেই কাছাকাছি হওয়ার কোনো লক্ষণ নেই।

Regression test: নতুন version কী ভাঙল

Prompt, model, chat template বা library বদলালে পুরো set আবার চালাতে হয়। একে বলে regression test. গড় নম্বরের পাশাপাশি দেখুন, কোন প্রশ্ন আগে ঠিক ছিল আর এখন ভুল। এটিই McNemar-এর ছকের “শুধু পুরনোটি ঠিক” ঘর। গড় ২ শতাংশ-বিন্দু বাড়লেও সেই ঘরে যদি “OTP চাওয়া” প্রশ্নটি থাকে, version চালু হবে না। Prompt-এর regression নিয়ে বিস্তারিত পর্ব ৬৬ · Prompt পরীক্ষায়; RAG-এর faithfulness মাপা পর্ব ৭০ · RAG মূল্যায়নে।

১০ · AI-এর যুগে — মূল্যায়নের কোড আর দাবি যাচাই

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

AI বা LLM-এর দেওয়া মূল্যায়নের চেকলিস্ট

• একটি প্রশ্নে বিকল্পের token আর log-prob হাতে মিলিয়েছি
• ছাঁচ, shot-এর সংখ্যা, template আর নম্বরের নিয়ম লিখে রেখেছি
• Judge দুই ক্রমে চালিয়েছি; একটি ছোট অংশে মানুষের রায়ের সঙ্গে মিল মেপেছি
• প্রতিটি সংখ্যার পাশে n আর CI; তুলনা জোড়ায়
• Model-এর নাম আর revision, seed, library-র version নথিতে আছে
• নম্বরের পাশে কিছু আসল উত্তর নিজে পড়েছি; উদ্ধৃত প্রবন্ধ নিজে খুলেছি