NLP মূল্যায়ন — F1, BLEU, ROUGE, chrF আর মানুষের বিচার

১ · পরীক্ষার খাতা দেখার নিয়ম: task অনুযায়ী metric

বাংলা রচনার খাতা আর গণিতের খাতা একই নিয়মে দেখা হয় না। গণিতে উত্তর মিললেই নম্বর। রচনায় একই কথা হাজারভাবে লেখা যায়, তাই পরীক্ষক অর্থ আর ভাষা দুটোই দেখেন। NLP-তেও তাই। কোনো task-এর উত্তর একটিই হলে হিসাব সহজ। অনুবাদ বা সারাংশে সঠিক উত্তর অনেক, আর আমাদের হাতে থাকে মাত্র একটি বা দুটি নমুনা উত্তর, যাকে বলে reference.

পর্ব ৩৯ (NLP-এর পথ)-এ প্রতিটি task-কে input থেকে output হিসেবে সাজানো হয়েছে। এখানে দেখব তাদের নম্বর দেওয়ার নিয়ম:

২ · F1-এর তিন রূপ: macro, micro আর span

Precision, recall আর F1-এর সংজ্ঞা AI-এর ভিত্তি কোর্সের পর্ব ৬০-এ আছে। অনেক class-এর গড় নেওয়ার আলোচনা মেশিন লার্নিং কোর্সের পর্ব ২৫-এ। এখানে শুধু NLP-র জন্য জরুরি হিসাবটি।

বাজারঘরের ১০০টি রিভিউ (বানানো সংখ্যা): ৮০টি ভালো, ১৫টি খারাপ, ৫টি মিশ্র। একটি model-এর ফল:

• Macro-F1: প্রতিটি class-এর F1-এর সাধারণ গড়, (০.৯২৯ + ০.৫৯৩ + ০) / ৩ = ০.৫০৭. ছোট class-ও সমান ভোট পায়।
• Micro-F1: আগে সব TP, FP, FN যোগ, তারপর F1: ২×৮৬ / (২×৮৬ + ১৪ + ১৪) = ০.৮৬. প্রতিটি রিভিউতে ঠিক একটি label থাকলে এটি accuracy-র সমান।

০.৮৬ দেখে মনে হয় model ভালো। অথচ মিশ্র রিভিউ সে একটিও চেনে না। ০.৫০৭ সেই ঘাটতি দেখায়। পর্ব ৪২ (Deep learning দিয়ে text classification)-এ এই হিসাবই আসল ডেটায় চলে।

Span F1: শব্দ নয়, পুরো টুকরো মিলতে হবে

বিস্তারিত পর্ব ৪৩ (Sequence labeling)-এ। মূল কথা একটি বাক্যেই। বাক্য: “রাজশাহী থেকে চাল ৫০০ টাকায় অর্ডার করলাম আজ”, মোট ৮টি token. সঠিক span ৩টি: রাজশাহী (জেলা), চাল (পণ্য), ৫০০ টাকায় (দাম)। Model দিল: রাজশাহী (জেলা), চাল (জেলা), ৫০০ (দাম)।

• Token accuracy: “চাল” আর “টাকায়” ভুল, বাকি ৬টি ঠিক, তাই ৬/৮ = ৭৫%.
• Span F1: সীমা আর ধরন দুটোই মিলেছে শুধু রাজশাহীর। P = ১/৩, R = ১/৩, তাই F1 = ০.৩৩.

৭৫% শুনতে ভালো, কিন্তু অর্ডারের তথ্য তোলার কাজে তিনটি তথ্যের দুটিই ভুল। বেশিরভাগ token আসলে কোনো entity-র বাইরে, তাই token accuracy সহজে বড় দেখায়।

৩ · BLEU: clipped precision আর brevity penalty

২০০২ সালে Papineni ও সহকর্মীরা BLEU প্রস্তাব করেন। ধারণাটি সরল: মানুষের অনুবাদের সঙ্গে যন্ত্রের অনুবাদের যত বেশি শব্দের টুকরো (n-gram) মেলে, তত ভালো। কিন্তু সরল হিসাবে দুটি ফুটো আছে। একটি শব্দ বারবার লিখলে “মিল” বাড়ে। আর খুব ছোট বাক্য লিখলে শতভাগ precision মেলে। দুটি ফুটো বন্ধ করার দুটি কৌশল এই পর্বের প্রথম stepper দুটিতে।

Clipping precision-এর ফাঁক বন্ধ করে। কিন্তু খুব ছোট বাক্যের ফাঁক খোলাই থাকে, কারণ precision-এর হরে candidate-এর নিজের দৈর্ঘ্য। তাই আসে brevity penalty (BP):

BLEU = BP × exp( (১/N) ∑_n=1..N log p_n )

এখানে p_n হলো n-gram-এর clipped precision, আর N সাধারণত ৪। Log-এর গড় নিয়ে exp করা মানে গুণোত্তর গড়। তাই কোনো একটি p_n শূন্য হলে পুরো BLEU শূন্য। এবার নিজে চালান:

import math
from collections import Counter
def grams(toks, n):
    return Counter(tuple(toks[i:i + n]) for i in range(len(toks) - n + 1))
def bleu(cand, refs, N=4):
    c, rs = cand.split(), [r.split() for r in refs]
    ps = []
    for n in range(1, N + 1):
        best = Counter()
        for r in rs:
            best |= grams(r, n)               # প্রতিটি n-gram-এর সর্বোচ্চ গণনা
        got = grams(c, n)
        ps.append((sum((got & best).values()), sum(got.values())))  # & = clip
    r_len = min((len(r) for r in rs), key=lambda L: (abs(L - len(c)), L))
    bp = 1.0 if len(c) >= r_len else math.exp(1 - r_len / len(c))
    if min(m for m, _ in ps) == 0:
        return ps, bp, 0.0
    logp = sum(math.log(m / t) for m, t in ps) / N
    return ps, bp, 100 * bp * math.exp(logp)
ref = "আজ সকালে ঢাকার বাজারে নতুন চাল এসেছে বলে দাম কমেছে"
tests = {"হুবহু": ref,
         "বাজারের": ref.replace("বাজারে", "বাজারের"),
         "দোকানে": ref.replace("বাজারে", "দোকানে"),
         "ছোট": "আজ সকালে ঢাকার বাজারে নতুন চাল",
         "চাল×৬": "চাল চাল চাল চাল চাল চাল"}
for name, h in tests.items():
    ps, bp, s = bleu(h, [ref])
    print(f"{name:8}", " ".join(f"{m}/{t}" for m, t in ps), f"BP={bp:.3f} BLEU={s:.2f}")
ps, bp, s = bleu("খুব খুব খুব ভালো পণ্য", ["এই পণ্য খুব ভালো"], N=1)
print("clip, এক reference:", ps[0])
ps, bp, s = bleu("খুব খুব খুব ভালো পণ্য", ["এই পণ্য খুব ভালো", "খুব খুব ভালো পণ্য"], N=1)
print("clip, দুই reference:", ps[0])

৪ · বাংলায় BLEU কেন কষ্ট পায়, আর chrF কী করে

বাংলায় একটি শব্দের অনেক রূপ: বাজার, বাজারে, বাজারের, বাজারটি, বাজারগুলোতে। পর্ব ৩৯-এ দেখেছি বিভক্তি আর প্রত্যয় মিলে এই বৈচিত্র্য তৈরি করে। ইংরেজিতে অনেক সময় বিভক্তির কাজ করে আলাদা শব্দ (“in the market”), ফলে একটি ভুলে মাত্র একটি শব্দ নষ্ট হয়। বাংলায় সব একই শব্দের গায়ে লেগে থাকে। BLEU-তে শব্দটি মিলল কি মিলল না, মাঝামাঝি কিছু নেই। আর একটি শব্দের ভুল আশপাশের সব n-gram নষ্ট করে।

chrF: শব্দের বদলে অক্ষরের টুকরো

chrF (Maja Popović, ২০১৫) শব্দ ভেঙে অক্ষরের n-gram গোনে। সাধারণত n = ১ থেকে ৬। প্রতিটি n-এ precision আর recall বের করে তাদের গড় নেয়। শেষে F-score:

chrF_β = (১ + β²) · P · R / (β² · P + R)

P আর R হলো ছয় রকম n-এর গড় precision আর recall. β = ২ মানে recall-কে বেশি গুরুত্ব, অর্থাৎ reference-এর তথ্য হারানোর শাস্তি বেশি। নিচের ছবিতে মূল পার্থক্য:

from collections import Counter

def cgrams(s, n):
    s = s.replace(" ", "")                    # sacrebleu-র মতো ফাঁকা বাদ
    return Counter(s[i:i + n] for i in range(len(s) - n + 1))

def chrf(cand, ref, N=6, beta=2, detail=False):
    Ps, Rs = [], []
    for n in range(1, N + 1):
        gc, gr = cgrams(cand, n), cgrams(ref, n)
        if not gc or not gr:                  # এত লম্বা n-gram নেই
            continue
        m = sum((gc & gr).values())
        Ps.append(m / sum(gc.values()))
        Rs.append(m / sum(gr.values()))
    P, R = sum(Ps) / len(Ps), sum(Rs) / len(Rs)
    F = (1 + beta**2) * P * R / (beta**2 * P + R) if P + R else 0.0
    return (Ps, Rs, 100 * F) if detail else 100 * F

print("code point:", list("বাজারে"), "বনাম", len("বাজারের"), "টি")
print("শব্দ দুটির chrF:", round(chrf("বাজারের", "বাজারে"), 2),
      "| বাজারে-দোকানে:", round(chrf("দোকানে", "বাজারে"), 2))

ref = "আজ সকালে ঢাকার বাজারে নতুন চাল এসেছে বলে দাম কমেছে"
for w in ("বাজারের", "দোকানে"):
    Ps, Rs, F = chrf(ref.replace("বাজারে", w), ref, detail=True)
    print(f"{w:8} P:", " ".join(f"{p:.2f}" for p in Ps), f"chrF={F:.2f}")

neg = ref.replace("কমেছে", "কমেনি")           # অর্থ উল্টো
print("কমেনি (অর্থ উল্টো):", round(chrf(neg, ref), 2))
print("beta=1 হলে বাজারের:", round(chrf(ref.replace("বাজারে", "বাজারের"), ref, beta=1), 2))

আরেকটি নাম জেনে রাখুন: TER (Translation Edit Rate; Snover ও সহকর্মী, ২০০৬)। Reference-এ পৌঁছাতে কতগুলো শব্দ বদলানো, মুছা, যোগ করা বা সরানো লাগে, তাকে reference-এর শব্দসংখ্যা দিয়ে ভাগ করা। এটি কম হলে ভালো। §৫-এ এর আসল মানও দেখবেন।

৫ · সত্যিকারের run: sacrebleu-র সঙ্গে মেলানো

নিজের কোড সঠিক কি না, তার পরীক্ষা হলো প্রতিষ্ঠিত library-র সঙ্গে মেলানো। ডেস্কটপে CPU-তে চালিয়েছি (লেখার সময়ে Python 3.13.5, sacrebleu 2.6.0, rouge-score 0.1.2; version বদলাতে পারে)। নিচের কোড আসল script-এর সংক্ষিপ্ত রূপ। “নিজের” কলাম আসে পাতার ব্লকের একই হিসাবের একটি ছোট module থেকে। আউটপুট হুবহু।

cd ~/bazarghar-dl
uv add sacrebleu rouge-score

from sacrebleu.metrics import BLEU, CHRF, TER
raw = BLEU(tokenize="none", smooth_method="none")  # tokenizer ও smoothing বন্ধ
print(raw.corpus_score([h], [[ref]]).score, CHRF().corpus_score([h], [[ref]]).score,
      TER().corpus_score([h], [[ref]]).score)
for t in ("none", "13a", "intl", "char"):           # tokenizer বদলে
    print(t, BLEU(tokenize=t, smooth_method="none").corpus_score([h], [[r]]).score)
print(BLEU(tokenize="none").corpus_score([h4], [[r4]]))   # default smoothing: exp

sacrebleu 2.6.0
candidate  নিজের-BLEU sacre-BLEU  নিজের-chrF sacre-chrF  TER
বাজারের       65.80      65.80      92.81      92.81  10.0
দোকানে        65.80      65.80      80.69      80.69  10.0
ছোট           51.34      51.34      63.66      63.66  40.0

-- ১. tokenizer: দাঁড়ি লেগে থাকলে --
none  BLEU  50.81  tokens: 5
13a   BLEU  50.81  tokens: 5
intl  BLEU 100.00  tokens: 6
char  BLEU 100.00  tokens: 31

-- ২. smoothing: 4-gram মিল শূন্য --
নিজের   0.0
none    BLEU = 0.00 42.9/16.7/0.0/0.0 (BP = 1.000 ratio = 1.167 hyp_len = 7 ref_len = 6)
exp     BLEU = 14.54 42.9/16.7/10.0/6.2 (BP = 1.000 ratio = 1.167 hyp_len = 7 ref_len = 6)
সই      nrefs:1|case:mixed|eff:no|tok:none|smooth:exp|version:2.6.0

-- ৩. Unicode: চোখে এক, code point-এ আলাদা --
একই লেখা? False | বাড়ি-র code point: 6 বনাম 7
NFC ছাড়া BLEU 53.73 chrF 82.22
দুটোয় NFC BLEU 100.0

ছাঁকা হিসাবে সব কলাম দুই দশমিক পর্যন্ত মিলেছে। তাহলে “BLEU” নম্বর আলাদা হয় কোথায়? আউটপুটের বাকি তিনটি অংশে তিনটি কারণ:

• Tokenizer. Candidate-এ দাঁড়ির আগে ফাঁকা (পৌঁছাবে ।), reference-এ লাগানো (পৌঁছাবে।). পড়তে একই বাক্য। sacrebleu-র default tokenizer 13a ASCII যতিচিহ্ন আলাদা করে, কিন্তু দাঁড়ি নয়। তাই ৫০.৮১. intl Unicode যতিচিহ্নও আলাদা করে, তাই ১০০. একই বাক্যে শুধু tokenizer বদলে প্রায় ৫০ নম্বরের ফারাক। বাংলার জন্য intl বা নিজের পরীক্ষিত tokenizer ঠিক করে নিন, আর সব system-এ একই রাখুন।
• Smoothing. আমাদের কোডে ৩-gram আর ৪-gram-এ মিল শূন্য, তাই BLEU ০। sacrebleu-র default exp শূন্যের জায়গায় ছোট মান বসায়: প্রথম শূন্যে ১০০/(২×৫) = ১০.০, পরেরটিতে ১০০/(৪×৪) = ৬.২৫. ফল ১৪.৫৪. কোনোটিই ভুল নয়, তবে দুটি এক metric নয়।
• Unicode. “বাড়ি”-র “ড়” একক code point (U+09DC) হতে পারে, আবার ড + ় দুটিও হতে পারে। চোখে এক, অথচ NFC ছাড়া BLEU ৫৩.৭৩. NFC করলে ১০০. sacrebleu নিজে থেকে এটি করেনি, এই পরীক্ষাই তার প্রমাণ। নিয়মটি পর্ব ১১-এর মতোই: মেলানোর আগে দুই পাশে একই normalisation.

৬ · দুটি system, দুই metric, উল্টো রায়

এবার ইচ্ছা করে বানানো ৬টি বাজারঘর বাক্যে সত্যিকারের পরীক্ষা। System A-র অর্থ ঠিক, কিন্তু বিভক্তির ভুল ছড়ানো। System B-র লম্বা অংশ হুবহু, কিন্তু মূল তথ্য ভুল। বাক্যগুলো বানানো, তাই ফলাফল কোনো আসল system সম্পর্কে কিছু বলে না; এটি শুধু metric-এর আচরণ দেখায়।

system A: BLEU 12.70  precisions [63.0, 31.2, 9.5, 1.4]  chrF2 77.13  TER  37.0
system B: BLEU 49.02  precisions [69.4, 58.1, 51.4, 41.9]  chrF2 62.81  TER  38.9
system A: ROUGE-1 F 0.628  ROUGE-2 F 0.312
system B: ROUGE-1 F 0.660  ROUGE-2 F 0.551

BLEU বলছে B প্রায় চার গুণ ভালো। chrF বলছে A এগিয়ে। TER প্রায় সমান। আর ৪ নম্বর বাক্যটি পড়লে আপনি নিজেই দেখবেন, B গ্রাহককে উল্টো কথা বলছে: টাকা ফেরত পাবেন “না”। A ব্যাকরণে কাঁচা, কিন্তু গ্রাহক বুঝবেন।

এর মানে “chrF সবসময় ঠিক” নয়। §৪-এ দেখেছি, “কমেনি”-র মতো অর্থ-উল্টানো ভুলে chrF-ও উদার। একটি বড় গবেষণা (Kocmi ও সহকর্মী, ২০২১, “To Ship or Not to Ship”) মানুষের বিচারকে মানদণ্ড ধরে শুধু BLEU-র ওপর নির্ভর করতে নিষেধ করে, COMET-কে প্রধান আর chrF-কে সহায়ক বা বিকল্প হিসেবে সুপারিশ করে। সেই ফল সব ভাষায় সমানভাবে খাটে, এমন দাবি বাংলার জন্য আমি যাচাই করিনি।

Goodhart: নম্বর যখন লক্ষ্য হয়ে যায়

মেশিন লার্নিং কোর্সের পর্ব ২-এ Goodhart-এর নিয়ম আছে: মাপ যখন লক্ষ্য হয়, তখন সেটি আর ভালো মাপ থাকে না। উপরের System B দেখায় কীভাবে: reference-এর লম্বা টুকরো কপি করলেই BLEU বাড়ে। আসল বিপদ আসে দলের মধ্যে: “এই সপ্তাহে BLEU ২ বাড়াতে হবে” লক্ষ্য হলে কেউ post-processing দিয়ে test reference-এর ধাঁচে লেখা মেলাবেন, বা test set দেখে tuning করবেন (AI-এর ভিত্তি কোর্সের পর্ব ৫৬)। প্রতিকার: একাধিক metric, আলাদা করে রাখা test set, আর নিয়মিত মানুষের নমুনা পড়া।

৭ · ROUGE: সারাংশের নম্বর, আর rouge-score-এর বাংলা ফাঁদ

ROUGE (Chin-Yew Lin, ২০০৪) সারাংশ মাপে। ROUGE-N-এ মডেলের সারাংশ আর মানুষের সারাংশের n-gram মিল গোনা হয়, মিল clip করে। সারাংশে হারানো তথ্য বড় বিষয়, তাই recall গুরুত্বপূর্ণ:

P = মিল / pred-এর n-gram, R = মিল / target-এর n-gram, F = 2PR / (P + R)

from collections import Counter

def grams(toks, n):
    return Counter(tuple(toks[i:i + n]) for i in range(len(toks) - n + 1))

def rouge(pred, target, n):
    gp, gt = grams(pred.split(), n), grams(target.split(), n)
    m = sum((gp & gt).values())
    P = m / max(sum(gp.values()), 1)
    R = m / max(sum(gt.values()), 1)
    F = 2 * P * R / (P + R) if P + R else 0.0
    return m, sum(gp.values()), sum(gt.values()), P, R, F

def show(label, pred, target):
    for n in (1, 2):
        m, a, b, P, R, F = rouge(pred, target, n)
        print(f"{label} ROUGE-{n}: মিল {m}, pred {a}, target {b}"
              f" → P={P:.3f} R={R:.3f} F={F:.3f}")

target = "ডেলিভারি দেরিতে এলেও চালের মান ভালো ছিল আর দাম কম ছিল"
pred = "চালের মান ভালো কিন্তু ডেলিভারি দেরিতে এসেছে"
show("ঠিক ক্রম ", pred, target)
show("উল্টো ক্রম", target, pred)              # target আর pred অদলবদল

source = target + " তবে প্যাকেট ছেঁড়া ছিল আর ফোনে কেউ ধরেনি আর দোকান দূরে আর রাস্তা খারাপ"
show("পুরো উৎস", source, target)              # সারাংশ নয়, পুরো লেখা কপি

সত্যিকারের run: default tokenizer বাংলা ফেলে দেয়

Google-এর rouge-score package খুব প্রচলিত। নিচের কোড চালিয়েছি (sc._tokenizer শুধু ভেতরটা দেখার জন্য; এটি private, নিজের কাজে এর ওপর ভরসা করবেন না):

import re
from rouge_score import rouge_scorer
fmt = lambda r: {k: tuple(round(x, 3) for x in v) for k, v in r.items()}
target = "ডেলিভারি দেরিতে এলেও চালের মান ভালো ছিল আর দাম কম ছিল"
pred = "চালের মান ভালো কিন্তু ডেলিভারি দেরিতে এসেছে"
sc = rouge_scorer.RougeScorer(["rouge1", "rouge2"])   # default tokenizer
print("১. default:", fmt(sc.score(target, pred)))
print("   tokens :", sc._tokenizer.tokenize(target))
print("   নিজের সঙ্গে নিজে:", sc.score(target, target)["rouge1"].fmeasure)
t2 = "USB চার্জারটি দুই দিনেই নষ্ট হয়ে গেছে, টাকা ফেরত চাই"
p2 = "দারুণ USB চার্জার, খুব টেকসই, সবাইকে কিনতে বলব"
print("২. উল্টো অর্থ:", fmt(sc.score(t2, p2)))
print("   tokens :", sc._tokenizer.tokenize(t2), sc._tokenizer.tokenize(p2))
print("   অঙ্ক   :", sc._tokenizer.tokenize("দাম ৫০০ টাকা, ওজন 5 কেজি"))
print(r"৩. \w+ ফাঁদ:", re.findall(r"\w+", "বাজারের চাল"))
class BanglaTok:                                      # শুধু tokenize() লাগে
    def tokenize(self, text):
        return re.findall(r"[ঀ-৿‌‍a-zA-Z0-9]+", text)
print("৪. tokens :", BanglaTok().tokenize("বাজারের চাল ভালো। USB ৫০০"))
fix = rouge_scorer.RougeScorer(["rouge1", "rouge2"], tokenizer=BanglaTok())
print("   ঠিক    :", fmt(fix.score(target, pred)))
print("   উল্টো অর্থ:", fmt(fix.score(t2, p2)))

১. default: {'rouge1': (0.0, 0.0, 0.0), 'rouge2': (0.0, 0.0, 0.0)}
   tokens : []
   নিজের সঙ্গে নিজে: 0.0
২. উল্টো অর্থ: {'rouge1': (1.0, 1.0, 1.0), 'rouge2': (0.0, 0.0, 0.0)}
   tokens : ['usb'] ['usb']
   অঙ্ক   : ['5']
৩. \w+ ফাঁদ: ['ব', 'জ', 'র', 'র', 'চ', 'ল']
৪. tokens : ['বাজারের', 'চাল', 'ভালো', 'USB', '৫০০']
   ঠিক    : {'rouge1': (0.714, 0.455, 0.556), 'rouge2': (0.5, 0.3, 0.375)}
   উল্টো অর্থ: {'rouge1': (0.125, 0.1, 0.111), 'rouge2': (0.0, 0.0, 0.0)}

প্রতিটি অংশ আলাদা শিক্ষা:

1. সব শূন্য, কোনো error নেই। Package-এর tokenize ছোট হাতের a-z0-9 ছাড়া সব token বাদ দেয় (source-এ নিয়মটি ^[a-z0-9]+$). বাংলা token তালিকা খালি। হুবহু একই লেখার নম্বরও ০.০.
2. অদ্ভুত ১.০. “চার্জার নষ্ট” আর “দারুণ টেকসই”, উল্টো অর্থ। শুধু usb বেঁচে ছিল, দুই পাশেই। ROUGE-1 F = ১.০. বাংলা অঙ্ক ৫০০ বাদ, ইংরেজি 5 থাকল। মিশ্র লেখায় (Banglish, ব্র্যান্ডের নাম) তাই শূন্য নয়, ভুলভাবে উঁচু নম্বর আসে।
3. আরেকটি ফাঁদ: \w+. Python-এর re-তে বাংলা কার (Mc, Mn শ্রেণির চিহ্ন) \w-এ পড়ে না। “বাজারের” ভেঙে হলো ব, জ, র, র। তাই “সহজ regex” দিয়েও ঠিক হয় না।
4. ঠিক করা। tokenizer=-এ এমন object দিন যার tokenize() আছে। Regex-এ বাংলা ব্লক U+0980–U+09FF রাখুন, ZWNJ আর ZWJ-ও। দাঁড়ি (U+0964) এই ব্লকের বাইরে, তাই আপনাআপনি সরে। এবার নিজের লেখা কোডের সঙ্গে হুবহু মিল: ০.৭১৪, ০.৪৫৫, ০.৫৫৬.

৮ · নম্বরটি কতটা পাকা: bootstrap আর kappa

৪০টি বাক্যের একটি test set-এ দুটি system-এর BLEU ৭৭.৮ আর ৬৮.১. অন্য ৪০টি বাক্য হলে কি একই হতো? Bootstrap এর উত্তর অনুমান করে (তত্ত্ব মেশিন লার্নিং কোর্সের পর্ব ২১-এ)। শুধু একটি কথা: BLEU সাধারণ গড় নয়, তাই বাক্য ধরে resample করে গণনাগুলো আবার যোগ করতে হয়। আর দুই system-এ একই সূচক নিতে হয়, যাতে তুলনাটি জোড়া থাকে (মেশিন লার্নিং কোর্সের পর্ব ২২)।

মানুষের বিচার: adequacy আর fluency

মানুষ দিয়ে অনুবাদের মূল্যায়নে দীর্ঘদিনের দুটি মাপ adequacy আর fluency. Adequacy: উৎসের অর্থ কতটা এসেছে। Fluency: বাংলা হিসেবে কতটা স্বাভাবিক। §৬-এর System A adequacy-তে ভালো, fluency-তে কাঁচা; B উল্টো। স্কোরার দুজন একমত না হলে স্কোরটিই অনির্ভরযোগ্য, তাই তাঁদের মিল মাপতে হয়। Cohen's kappa (১৯৬০) কাকতালীয় মিল বাদ দেয় (annotation-এর বিস্তারিত মেশিন লার্নিং কোর্সের পর্ব ৫-এ)।

import numpy as np
from collections import Counter as C
rng = np.random.default_rng(42)
items = ["চাল", "ডাল", "তেল", "চিনি", "লবণ", "আটা"]
towns = ["ঢাকার", "রাজশাহীর", "খুলনার", "সিলেটের", "বরিশালের"]
refs = [f"{towns[rng.integers(5)]} গুদাম থেকে {items[rng.integers(6)]} আজ বিকেলে আপনার ঠিকানায় পাঠানো হবে"
        for _ in range(40)]
def noisy(ref, p):                       # p সম্ভাবনায় শব্দে ভুল বিভক্তি
    return " ".join(w + "ের" if rng.random() < p else w for w in ref.split())
def g(t, n): return C(tuple(t[i:i+n]) for i in range(len(t)-n+1))
def stats(c, r):                         # m1..m4, t1..t4, c_len, r_len
    c, r = c.split(), r.split()
    m = [sum((g(c, n) & g(r, n)).values()) for n in range(1, 5)]
    return m + [len(c)-n+1 for n in range(1, 5)] + [len(c), len(r)]
def bleu(S):                             # S-এর শেষ অক্ষে যোগ করা ১০টি গণনা
    logp = np.log(np.maximum(S[..., :4], 1e-9) / S[..., 4:8]).mean(-1)
    return 100 * np.minimum(1, np.exp(1 - S[..., 9] / S[..., 8])) * np.exp(logp)
X = np.array([stats(noisy(r, .10), r) for r in refs])
Y = np.array([stats(noisy(r, .13), r) for r in refs])
idx = rng.integers(0, 40, size=(2000, 40))   # একই সূচক দুই system-এ: জোড়া
bx, by = bleu(X[idx].sum(1)), bleu(Y[idx].sum(1))
ci = lambda v: np.percentile(v, [2.5, 97.5]).round(1)
print(f"X={bleu(X.sum(0)):.1f} CI {ci(bx)} | Y={bleu(Y.sum(0)):.1f} CI {ci(by)}")
print(f"X-Y CI {ci(bx - by)}")
a = np.array([4,4,3,2,4,1,3,3,2,4,3,1,4,2,3,4,3,2,4,3])  # adequacy ১–৪, বানানো
b = np.array([4,3,3,2,4,2,3,4,2,4,3,1,3,2,3,4,2,2,4,3])
def kappa(a, b):
    po = np.mean(a == b)
    pe = sum(np.mean(a == v) * np.mean(b == v) for v in range(1, 5))
    return po, pe, (po - pe) / (1 - pe)
print("po=%.2f pe=%.4f kappa=%.3f" % kappa(a, b))
ks = [kappa(a[i], b[i])[2] for i in rng.integers(0, 20, size=(1000, 20))]
print("kappa CI", np.percentile(ks, [2.5, 97.5]).round(2))

Kappa-র “০.৬–০.৮ মানে ভালো” ধরনের নামকরণ (Landis ও Koch, ১৯৭৭) খুব প্রচলিত, কিন্তু সীমাগুলো তাঁদের নিজেদের ভাষাতেও স্বেচ্ছাচারী। স্কোর ক্রমযুক্ত (১–৪) হলে ৩ আর ৪-এর অমিল ১ আর ৪-এর অমিলের সমান নয়; তখন weighted kappa ভালো।

৯ · বাংলায় মূল্যায়ন: reference নিজেই প্রশ্নের মুখে

সব reference-ভিত্তিক metric ধরে নেয়, reference ঠিক। বাংলায় এই ধারণা নড়বড়ে হতে পারে:

• একটি reference মানে একটি সমাধান। “দাম কমেছে” আর “দাম কমে গেছে” দুটোই ঠিক। §৩-এ দেখেছি দ্বিতীয় reference কীভাবে মান বদলায়।
• সাধু, চলিত আর উপভাষা। “করিয়াছে”, “করেছে” আর চট্টগ্রাম বা সিলেটের রূপ, n-gram-এর কাছে সব আলাদা। Reference শুধু প্রমিত চলিতে হলে উপভাষায় ঠিক উত্তরও ভুল গোনা হবে। ফলে metric অজান্তে এক দলের ভাষাকে পুরস্কৃত করতে পারে।
• বানান আর Banglish. “পৌঁছাবে/পৌছাবে”, “delivery/ডেলিভারি”: পাঠকের কাছে এক, BLEU-র কাছে আলাদা।
• Reference-এর উৎস। Reference নিজেই যন্ত্রে অনুবাদ করে সম্পাদনা করা হলে তা যন্ত্রের ধাঁচ পুরস্কৃত করে। ডেটা কার্ডে উৎস দেখুন। বড় পাবলিক উদাহরণ BanglaNMT (Hasan ও সহকর্মী, ২০২০), XL-Sum-এর বাংলা অংশ; নিজের কাজে ব্যবহারের আগে তাদের license আর উৎস পড়ুন।

এই পর্বের ব্যবহারিক রিপোর্ট-ছক:

• NFC আর tokenizer লিখেছি; সব system-এ একই
• Identity test পাশ করেছে (একই লেখায় ১০০ বা ১.০)
• অন্তত দুটি ভিন্ন ধরনের metric (যেমন chrF আর BLEU), signature-সহ
• জোড়া bootstrap CI, বাক্য ধরে resample
• কয়েক ডজন বাক্য মানুষ পড়েছেন; দুই স্কোরারের kappa-সহ

১০ · AI-এর যুগে: metric-এর কোড AI লিখলে

AI সহকারী metric-এর কোড দ্রুত লিখে দেয়, আর ভুলগুলো চুপচাপ থাকে। সাধারণ ভুল: rouge-score default-এই বাংলায় চালানো; score()-এর argument উল্টো দেওয়া; sentence BLEU গড় করে corpus BLEU বলা; smoothing আর tokenizer না বলা; একটি run-এর সংখ্যা দিয়ে “system ভালো” ঘোষণা; মনগড়া benchmark নম্বর বা প্রবন্ধের নাম; পুরোনো argument. Model “অর্থ বুঝেছে” দাবিও উড়িয়ে দিন, n-gram মিল সে কথা বলে না।

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

• নিজের version-এর অফিসিয়াল ডক বা source পড়ে argument মিলিয়েছি
• একই লেখায় চালিয়ে পূর্ণ নম্বর, আর সম্পূর্ণ ভিন্ন লেখায় প্রায় শূন্য দেখেছি
• ছোট উদাহরণে n-gram গোনা হাতে মিলিয়েছি
• Test set যাচাই বা tuning-এ ফাঁস হয়নি; একাধিক seed-এ model তুলনা করেছি
• নম্বরের পাশে কয়েকটি আসল output পড়েছি; উদ্ধৃত প্রবন্ধটি নিজে খুলে দেখেছি