RAG মূল্যায়ন — retrieval metric, faithfulness আর বাংলা ডকুমেন্ট

১ · দুই অংশ, দুই রকম ভুল — কেন অংশ ধরে মাপবেন

RAG-এও একই কথা। পর্ব ৬৯-এ (RAG — chunking, retrieval, reranking আর উত্তর তৈরি) পুরো pipeline তৈরি হচ্ছে: নথি ভাগ করা, খোঁজা, prompt বানানো, উত্তর লেখা। এখানে প্রশ্ন একটাই: কতটা ভালো কাজ করছে, আর খারাপ হলে কোথায়? দুটি অংশ আলাদা মাপতে হয়:

• Retriever: প্রশ্নের উত্তর যে নথিতে আছে, সেটি প্রথম k-টির মধ্যে এল কি না, আর কত ওপরে এল।
• Generator: আনা নথি হাতে পেয়ে LLM ঠিক উত্তর লিখল কি না, উৎসের বাইরে কিছু বানাল কি না, ঠিক উৎসের নম্বর দিল কি না, আর উত্তর না থাকলে “জানি না” বলল কি না।

এই ভাগকে বলে component-wise evaluation. এর সবচেয়ে কাজের কৌশল oracle context: retriever বাদ দিয়ে ঠিক নথিটি নিজে হাতে generator-কে দেওয়া। তখনও উত্তর ভুল হলে দোষ generator-এর; oracle-এ ঠিক কিন্তু সাধারণ pipeline-এ ভুল হলে দোষ retriever-এর।

শব্দগুলো অন্য কোর্সে দেখেছেন। মেশিন লার্নিং কোর্সের পর্ব ৫৩-এ recommender-এর তালিকা মাপতে precision@k আর nDCG এসেছে; পর্ব ৪৫-এ মানুষের বিচার আর kappa; পর্ব ৫৮-এ LLM-as-judge-এর ফাঁদ; পর্ব ৬৬-এ eval set আর paired bootstrap. এখানে সবগুলো এক জায়গায়, বাজারঘরের হেল্প সেন্টারের ৪০টি বানানো বাংলা, ইংরেজি আর Banglish নথিতে, সত্যিকারের model দিয়ে।

২ · Retrieval মাপার চারটি metric — recall@k, precision@k, MRR, nDCG

Retriever একটি সাজানো তালিকা দেয়। প্রতিটি প্রশ্নের জন্য আগে থেকে হাতে ঠিক করা থাকে কোন নথিগুলো প্রাসঙ্গিক; এগুলোকে বলে gold নথি। ধরা যাক প্রথম k-টির মধ্যে r-টি gold, আর মোট gold g-টি।

• Recall@k = r ÷ g. প্রয়োজনীয় নথির কত ভাগ ধরা পড়ল। RAG-এ এটিই প্রথম শর্ত, কারণ যা আনা হয়নি, generator তা দেখতেই পায় না।
• Precision@k = r ÷ k. আনা নথির কত ভাগ কাজের। কম হলে prompt-এ আবর্জনা বাড়ে, token-এর খরচ বাড়ে, আর model ভুল নথি থেকে উত্তর তুলতে পারে।
• MRR: প্রথম gold নথি rank p-তে এলে reciprocal rank = ১ ÷ p; সব প্রশ্নের গড় MRR. প্রথম ঠিক নথি কত ওপরে, শুধু সেটুকু দেখে।
• nDCG@k: প্রতিটি অবস্থানের প্রাসঙ্গিকতাকে ১ ÷ log₂(i + ১) দিয়ে ছাড় দিয়ে যোগ (DCG), তারপর সবচেয়ে ভালো সম্ভাব্য সাজানোর যোগফল (IDCG) দিয়ে ভাগ। মান ০ থেকে ১. একাধিক gold নথি আর graded relevance (যেমন ২ = পুরো উত্তর, ১ = আংশিক) দুটোই সামলায়।

নিচে আমাদের সত্যিকারের run-এর একটি প্রশ্ন: “otp keu chaile ki korbo”. এখানে দুটি নথি প্রাসঙ্গিক, bh20 (OTP-র নিয়ম) আর bh21 (প্রতারণা থেকে সাবধান)।

এবার ছয়টি সত্যিকারের প্রশ্নে চারটি metric একসঙ্গে। Rank-গুলো পরের অংশের run থেকে নেওয়া; খালি তালিকা মানে gold নথি প্রথম ১০-এ আসেনি।

import numpy as np
# সত্যিকারের run থেকে: প্রতিটি প্রশ্নে gold নথি কোন rank-এ এল ([] = প্রথম ১০-এ নেই)
runs = {
    "BM25":     {"নারায়ণগঞ্জ": [3], "ঢাকায় ফ্রি": [3], "otp keu chaile": [1, 3],
                 "order cancel": [], "রংপুর": [], "delivery Dhaka": [7]},
    "e5-small": {"নারায়ণগঞ্জ": [1], "ঢাকায় ফ্রি": [2], "otp keu chaile": [2, 4],
                 "order cancel": [4], "রংপুর": [], "delivery Dhaka": [4]},
}
n_gold = {"otp keu chaile": 2}          # বাকিগুলোতে gold নথি ১টি
disc = 1 / np.log2(np.arange(2, 12))     # rank 1..10-এর discount

def scores(pos, g, k=5):
    rel = np.zeros(10)
    rel[[p - 1 for p in pos]] = 1
    dcg = (rel[:k] * disc[:k]).sum()
    idcg = disc[:min(g, k)].sum()
    return [rel[:1].sum() / g, rel[:k].sum() / g, rel[:k].sum() / k,
            1 / min(pos) if pos else 0.0, dcg / idcg]

print(f"{'':16}{'R@1':>6}{'R@5':>6}{'P@5':>6}{'RR':>6}{'nDCG@5':>8}")
for name, qs in runs.items():
    print(name)
    rows = []
    for q, pos in qs.items():
        s = scores(pos, n_gold.get(q, 1))
        rows.append(s)
        print(f"  {q:14}" + "".join(f"{v:6.2f}" for v in s[:4]) + f"{s[4]:8.3f}")
    m = np.mean(rows, axis=0)
    print(f"  {'গড়':14}" + "".join(f"{v:6.2f}" for v in m[:4]) + f"{m[4]:8.3f}")

                   R@1   R@5   P@5    RR  nDCG@5
BM25
  নারায়ণগঞ্জ     0.00  1.00  0.20  0.33   0.500
  ঢাকায় ফ্রি     0.00  1.00  0.20  0.33   0.500
  otp keu chaile  0.50  1.00  0.40  1.00   0.920
  order cancel    0.00  0.00  0.00  0.00   0.000
  রংপুর           0.00  0.00  0.00  0.00   0.000
  delivery Dhaka  0.00  0.00  0.00  0.14   0.000
  গড়             0.08  0.50  0.13  0.30   0.320
e5-small
  নারায়ণগঞ্জ     1.00  1.00  0.20  1.00   1.000
  ঢাকায় ফ্রি     0.00  1.00  0.20  0.50   0.631
  otp keu chaile  0.00  1.00  0.40  0.50   0.651
  order cancel    0.00  1.00  0.20  0.25   0.431
  রংপুর           0.00  0.00  0.00  0.00   0.000
  delivery Dhaka  0.00  1.00  0.20  0.25   0.431
  গড়             0.17  0.83  0.20  0.42   0.524

৩ · সত্যিকারের retrieval মাপ — ৬০টি প্রশ্ন, আর chunk-এর আকার

মডিউল ১১-এর পর্বগুলো বাজারঘরের হেল্প সেন্টারের ৪০টি নথির একটি সাধারণ সংগ্রহ ভাগ করে ব্যবহার করে (সব বানানো; ৩৫টি বাংলা, ৩টি ইংরেজি, ২টি Banglish; bh40 পুরোনো, বাতিল)। পর্ব ৬৭-এ এই নথির ওপর ৬০টি প্রশ্ন আর তাদের gold নথি লেখা হয়েছে। সংখ্যা যাতে মেলানো যায়, সেই প্রশ্নই আবার চালালাম, এবার nDCG আর precision-সহ। সত্যিকারের run (CPU-তে, ৩টি thread; Python 3.12.13, torch 2.15.0, sentence-transformers 6.2.0; model intfloat/multilingual-e5-small, MIT লাইসেন্স):

~/bazarghar-dl$ uv run python retrieval.py
python 3.12.13, torch 2.15.0+cu132, transformers 5.22.2, sentence-transformers 6.2.0
doc-level: 40 docs, 60 questions, time 1.2s
              R@1     R@3     R@5    R@10     P@3  MRR@10 nDCG@10
BM25        0.392   0.550   0.667   0.750   0.189   0.502   0.559
e5-small    0.517   0.742   0.817   0.883   0.250   0.651   0.708
e5 - BM25 MRR@10: +0.149  95% CI [+0.050, +0.255]  (paired bootstrap, 2000)
e5 - BM25 nDCG@10: +0.149  95% CI [+0.058, +0.248]  (paired bootstrap, 2000)

chunk-level, e5-small, 34 answerable of 40 questions
chunking  chunks avgchr  hit@1  hit@3  hit@5  all@3    MRR
sent40        47    179  0.794  0.971  0.971  0.941  0.873
fixed80      143     72  0.735  0.882  0.941  0.794  0.817
fixed160      78    124  0.765  0.912  0.971  0.853  0.837
fixed320      41    201  0.794  0.971  0.971  0.941  0.873

প্রথম অংশ পর্ব ৬৭-এর সঙ্গে হুবহু মিলেছে: MRR@১০ BM25 ০.৫০২, e5-small ০.৬৫১. একই ডেটা, একই কোড, একই সংখ্যা; এটি নিজেই একটি পরীক্ষা যে মাপার যন্ত্র ঠিক আছে। P@৩ কম (০.২৫) দেখে ঘাবড়াবেন না: বেশিরভাগ প্রশ্নে gold নথি মাত্র একটি, তাই P@৩-এর সর্বোচ্চ মানই ০.৩৩.

দ্বিতীয় অংশ পর্ব ৭০-এর নিজের ৪০টি প্রশ্নে (পরের অংশে বিস্তারিত), এবার chunk ধরে। Chunking চার রকম: sent40 মানে শিরোনাম ধরে ভাগ, তারপর প্রায় ৪০ শব্দের বাক্যগুচ্ছ, ১টি বাক্য overlap; fixedN মানে N অক্ষরের টুকরো, ২৫% overlap. hit@k = প্রথম k-টি chunk-এর অন্তত একটি gold নথি থেকে; all@3 = বহু-নথির প্রশ্নে সব gold নথি প্রথম ৩-এ।

• ৮০ অক্ষরের ছোট টুকরোয় hit@৩ নেমে ০.৮৮২ আর all@৩ ০.৭৯৪. টুকরো এত ছোট যে শব্দ মাঝখানে কাটে (“ে যায়। ভিসা বা…”), আর একটি তথ্যের দুই অংশ দুই chunk-এ চলে যায়।
• বাক্য ধরে ভাগ আর ৩২০ অক্ষরের টুকরো একই ফল দিল। আমাদের নথি ছোট (গড়ে প্রায় ২০০ অক্ষর), তাই ৩২০ অক্ষরে প্রায় প্রতিটি নথি একটি chunk. বড় নথিতে এই ফল খাটবে না; নিজের ডেটায় মাপবেন।

৪ · একটি বাংলা RAG eval set বানানো

Retrieval-এর জন্য দরকার প্রশ্ন আর gold নথি। উত্তর মাপতে আরও দুটি জিনিস লাগে: একটি রেফারেন্স উত্তর, আর উত্তর স্বয়ংক্রিয়ভাবে যাচাইয়ের একটি নিয়ম। আমি হাতে ৪০টি প্রশ্ন লিখেছি (eval set), ছয় ধরনের:

প্রতিটি সারিতে প্রশ্ন, gold নথি, রেফারেন্স উত্তর আর কয়েকটি key: উত্তরে যে সংখ্যা বা শব্দ থাকতেই হবে। উত্তর নেই এমন প্রশ্নে key নেই; সেখানে ঠিক উত্তর মানে “উৎসে এই তথ্য নেই”-এর মতো বাক্য। তিনটি সারি (ফাইল থেকে হুবহু, সংক্ষিপ্ত):

("n01", "চট্টগ্রামে ৩ কেজির একটি পার্সেলের ডেলিভারি চার্জ কত হবে?", ["bh06"], "১৬০ টাকা (১২০ + ২ × ২০)", "numeric", [r"\b160\b"]),
("m01", "মন বদলে ঢাকা সিটি থেকে পণ্য ফেরত দিলে কত টাকা কাটা যায়, আর Nagad-এ রিফান্ড কত দিনে আসে?", ["bh03", "bh02"], "৬০ টাকা; ৩ কর্মদিবস", "multi", [r"\b60\b", r"\b3\b"]),
("u04", "Nagad-এ টাকা দিলে কত শতাংশ ক্যাশব্যাক পাব?", [], "উৎসে নেই", "unanswerable", []),

বাংলা ডকুমেন্টে key মেলানোর আগে উত্তরকে normalise করতে হয়, নইলে ঠিক উত্তরও ভুল গোনা হবে:

• অঙ্কের লিপি: model কখনো “৭ দিন”, কখনো “7 দিন” লেখে (একই run-এ দুটোই এসেছে)। বাংলা অঙ্ক Latin-এ বদলে নিন।
• হাজারের কমা: “১,৫০০” আর “1500” এক করতে সংখ্যার ভেতরের কমা বাদ দিন।
• শব্দসীমা: Python-এর regex-এ বাংলা অক্ষরও “word” অক্ষর, তাই \b7\b “৭টি”-র ভেতরের ৭ ধরে না, কারণ ৭ আর ট-এর মাঝে কোনো সীমা নেই। উপরের ফাইলে key-গুলো \b দিয়ে লেখা, তাই মেলানোর কোড আগে সেগুলোকে অঙ্কের সীমায় বদলে নেয়: (?<![0-9])7(?![0-9]), অর্থাৎ দুপাশে অন্য অঙ্ক নেই।
• উত্তর নেই চেনা: “উৎসে এই তথ্য নেই”, “উৎসে নেই”, “উত্তর নেই”, একই কথার তিন রূপ এসেছে।

৫ · উত্তরের মাপ — সঠিকতা, faithfulness, প্রাসঙ্গিকতা আর citation

Generator-এর উত্তর চারটি আলাদা প্রশ্নে মাপা হয়। এগুলো একে অন্যের বদলি নয়:

এগুলো কেন আলাদা, আমাদের run-এর দুটি উত্তরেই দেখা যায়। “ঢাকা সিটিতে কত টাকার অর্ডারে ডেলিভারি ফ্রি?” প্রশ্নে model লিখল “১,০০০ টাকা”, যা হাতে দেওয়া পুরোনো নথিতে হুবহু আছে: faithful কিন্তু ভুল। আবার “বাজারঘরের অ্যাপ কোন সালে চালু হয়েছে?” প্রশ্নে লিখল “বাজারঘর প্লাস সদস্যপদের ফি বছরে ৯৯৯ টাকা”: উৎসে আছে, কিন্তু প্রশ্নের সঙ্গে সম্পর্কহীন, অর্থাৎ faithful কিন্তু অপ্রাসঙ্গিক।

Faithfulness মাপার প্রচলিত পথ হলো claim decomposition: উত্তরকে ছোট ছোট দাবিতে ভাঙা, তারপর প্রতিটি দাবি উৎসে খোঁজা। একটি সত্যিকারের উত্তরে (প্রশ্ন: “বাজারঘর প্লাসের বার্ষিক ফি কত, আর ঢাকার বাইরে সদস্যরা মাসে কয়টি অর্ডারে ফ্রি ডেলিভারি পান?”):

দাবি ভাঙার কাজটি সাধারণত আরেকটি LLM করে; সেটি অংশ ৮-এ। তার আগে একটি সস্তা, স্বচ্ছ পরীক্ষা: উত্তরের প্রতিটি বাক্যের সংখ্যা উৎসে আছে কি না, আর শব্দের কত ভাগ উৎসের সঙ্গে মেলে। নিচে চারটি সত্যিকারের উত্তর।

import re
# Qwen2.5-1.5B-Instruct-এর সত্যিকারের উত্তর আর তাকে দেওয়া উৎস (ছোট করতে উৎসের অপ্রাসঙ্গিক বাক্য বাদ)
cases = [
 ("m03", "বাজারঘর প্লাস সদস্যপদের ফি বছরে ৯৯৯ টাকা। ঢাকার বাইরে সদস্যরা মাসে ৪টি অর্ডারে ফ্রি ডেলিভারি পান। সদস্যপদ নেওয়ার ১৪ দিনের মধ্যে কোনো ফ্রি ডেলিভারি ব্যবহার না করলে পুরো ফি ফেরত দেওয়া হয়।",
  "বাজারঘর প্লাসের বার্ষিক ফি: ৯৯৯ টাকা\n\nঢাকার বাইরে সদস্যরা মাসে কয়টি অর্ডারে ফ্রি ডেলিভারি পান:\n\n- ৩টি অর্ডারে ফ্রি ডেলিভারি পান (সদস্যপদ নেওয়ার ১৪ দিনের"),
 ("n02", "চেকআউটের সময় গিফট র‍্যাপ বেছে নেওয়া যায়, খরচ প্রতি পণ্যে ৫০ টাকা। সঙ্গে ১৫০ অক্ষর পর্যন্ত একটি বার্তা কার্ডে ছাপা হয়।",
  "উৎস: [1]\n\nপ্রশ্ন: দুটি পণ্যে গিফট র‍্যাপ নিলে মোট র‍্যাপের খরচ কত?\n\nউত্তর: ৫০ টাকা × ২ = ৩০০ টাকা"),
 ("s10", "কাস্টমার কেয়ার প্রতিদিন সকাল ৯টা থেকে রাত ১০টা পর্যন্ত খোলা। শুক্রবার সময় বিকেল ৩টা থেকে রাত ১০টা।",
  "উত্তর: শুক্রবার কাস্টমার কেয়ার খোলা হয় রাত ১০টা।"),
 ("b02", "লগইনের সময় নিবন্ধিত মোবাইল নম্বরে একটি OTP যায়, যার মেয়াদ ৫ মিনিট। পাসওয়ার্ড",
  "OTP অ্যাকাউন্টে পাওয়া যায়। OTP যখন মেয়াদ ৫ মিনিট হবে, তখন তার প্রতি মিনিটে ৩০ সেকেন্ড পর্যন্ত পাওয়া যায়।"),
]
BN = str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789")
def norm(s): return re.sub(r"(?<=\d),(?=\d{3})", "", s.translate(BN))
def nums(s): return set(re.findall(r"\d+", re.sub(r"\[\d+\]", " ", norm(s))))
def words(s): return set(w for w in re.findall(r"[\wঀ-৿]+", norm(s)) if len(w) > 1)

for qid, src, ans in cases:
    print(f"== {qid}")
    S_num, S_w = nums(src), words(src)
    for sent in re.split(r"(?<=[।?!])\s*|\n+", ans):
        if not words(sent) or sent.startswith(("উৎস:", "প্রশ্ন:")):
            continue
        extra = sorted(nums(sent) - S_num)
        overlap = len(words(sent) & S_w) / len(words(sent))
        verdict = "সংখ্যা মেলেনি " + str(extra) if extra else "সংখ্যা ঠিক"
        print(f"  {overlap:4.2f}  {verdict:22}  {sent.strip()[:38]}")

== m03
  0.67  সংখ্যা ঠিক              বাজারঘর প্লাসের বার্ষিক ফি: ৯৯৯ টাকা
  0.89  সংখ্যা ঠিক              ঢাকার বাইরে সদস্যরা মাসে কয়টি অর্ডারে
  0.89  সংখ্যা মেলেনি ['3']     - ৩টি অর্ডারে ফ্রি ডেলিভারি পান (সদস্য
== n02
  0.50  সংখ্যা মেলেনি ['2', '300']  উত্তর: ৫০ টাকা × ২ = ৩০০ টাকা
== s10
  0.75  সংখ্যা ঠিক              উত্তর: শুক্রবার কাস্টমার কেয়ার খোলা হ
== b02
  0.50  সংখ্যা ঠিক              OTP অ্যাকাউন্টে পাওয়া যায়।
  0.29  সংখ্যা মেলেনি ['30']    OTP যখন মেয়াদ ৫ মিনিট হবে, তখন তার প্

৬ · অংশ ধরে সত্যিকারের run — k, oracle আর chunk-এর আকার

এবার পুরো pipeline. Generator Qwen/Qwen2.5-1.5B-Instruct (Apache 2.0), retriever e5-small, chunk sent40. পাঁচটি অবস্থা: প্রথম ১, ৩ আর ৫টি chunk; oracle (gold নথির সব chunk; উত্তর নেই এমন প্রশ্নে k = ৩-এর একই chunk, কারণ সেখানে কোনো gold নেই); আর ৮০ অক্ষরের টুকরোর প্রথম ৩টি। Prompt সব অবস্থায় একই:

তারপর user বার্তায় “উৎস: [1] (শিরোনাম, হালনাগাদ তারিখ) লেখা …” আর প্রশ্ন। Decoding greedy (do_sample=False, seed 0), সর্বোচ্চ ১৬০টি নতুন token, bfloat16, GPU-তে। ৮০টি উত্তর (k৩ আর oracle) মোট ৮২ সেকেন্ডে; সর্বোচ্চ GPU memory ৩,০৫১ MB. সত্যিকারের run, ফল গোনা (সংক্ষিপ্ত):

~/bazarghar-dl$ uv run python score.py
condition    acc   ans-acc  unans-abst  ret-hit  all-gold  cite-only  avg-in-tok  avg-sec
k1          0.450    0.353       1.000    0.794     0.706         1         490     0.62
k3          0.525    0.529       0.500    0.971     0.941         7         959     1.17
k5          0.475    0.529       0.167    0.971     0.941         5        1389     1.55
oracle      0.550    0.559       0.500    1.000     1.000         2         653     0.88
fixed80_k3  0.525    0.559       0.333    0.882     0.794         2         638     1.63

by question type, auto acc (k3 | oracle | fixed80_k3):
  single        n=18  0.67  0.56  0.72
  numeric       n= 4  0.00  0.00  0.00
  multi         n= 4  0.00  0.25  0.25
  banglish      n= 4  0.50  1.00  0.50
  english       n= 4  1.00  1.00  0.75
  unanswerable  n= 6  0.50  0.50  0.33

citations (answerable answers that cite at least one source):
  k3          n= 8  precision 0.750  recall 0.688
  k5          n=10  precision 0.600  recall 0.600
  oracle      n= 2  precision 1.000  recall 0.750
  fixed80_k3  n=21  precision 0.810  recall 0.762
…
auto vs my labels:
  correctness k3          human acc 0.525  auto acc 0.525  agree 1.000  kappa 1.000
  correctness fixed80_k3  human acc 0.450  auto acc 0.525  agree 0.925  kappa 0.851
     disagree: ['s18', 'm04', 'b02']
  number-check faithfulness vs my F labels: n=63  my unfaithful 19  check says unfaithful 8  agree 0.762  kappa 0.324

এখান থেকে পাঁচটি শিক্ষা। মনে রাখবেন, এগুলো একটি ছোট model আর ৪০টি প্রশ্নের একটি local run, সাধারণ সত্য নয়।

1. বাধা retriever-এ নয়। k = ৩-এ ঠিক নথি এসেছে ৯৭% প্রশ্নে, অথচ উত্তর ঠিক ৫৩%. Oracle-এ retrieval নিখুঁত, তবু উত্তর ঠিক ৫৬%. অর্থাৎ বাকি ভুলের প্রায় সবটাই generator-এর। এই সিদ্ধান্ত oracle ছাড়া নেওয়া যেত না; শুধু শেষ সংখ্যা ৫২.৫% দেখে কেউ হয়তো retriever বদলাতে সপ্তাহ খরচ করতেন।
2. k একটি দাঁড়িপাল্লা। k = ১-এ model উত্তর নেই এমন ৬টি প্রশ্নেই ঠিকভাবে “উৎসে নেই” বলেছে, কিন্তু উত্তর আছে এমন ৩৪টি প্রশ্নের ১৬টিতেও তাই বলেছে। k = ৫-এ উল্টো: বেশি লেখা হাতে পেয়ে উত্তর নেই এমন ৬টির ৫টিতে “উৎসে নেই” বলেনি, আর তার ৪টিতে কাছাকাছি তথ্য জুড়ে উত্তর বানিয়েছে। Prompt-এর দৈর্ঘ্যও ৪৯০ থেকে ১,৩৮৯ token.
3. সংখ্যার হিসাব আর বহু নথি সবচেয়ে দুর্বল। চারটি হিসাবের প্রশ্নের একটিও কোনো অবস্থায় ঠিক হয়নি। এই কাজে 1.5B model-এর সীমা স্পষ্ট; হিসাবের অংশ কোডে করা (পর্ব ৭১-এর tool) একটি বাস্তব সমাধান।
4. Citation বেশি দেখাই ভালো নয়। Citation precision হিসাব হয় শুধু যেসব উত্তরে নম্বর আছে তাদের ওপর: k৩-এ মাত্র ৮টি. ছোট n-এর হার আলাদা করে লিখুন। আরেকটি বিপদ: আমার নিজের গোনায় k৩-এর ৫টি উত্তর ছিল শুধু “উত্তর: [1]” বা “উৎস: [1]”, উত্তর ছাড়াই নম্বর। স্বয়ংক্রিয় cite-only কলাম ৭ দেখায়, কারণ সেটি “৩” বা “উত্তর: 1”-এর মতো শুধু-সংখ্যার ঠিক উত্তরকেও এই দলে ফেলেছে; আরেকটি নীরব মাপ-ভুল।
5. স্বয়ংক্রিয় মাপ নিজে যাচাই করুন। k৩-এর ৪০টি উত্তরে key-মেলানো আর আমার নিজের রায় হুবহু মিলেছে, কিন্তু ৮০ অক্ষরের অবস্থায় ৩টি অমিল: b02-তে “৫ মিনিট” আছে বলে key পাশ, অথচ পাশে বানানো “৩০ সেকেন্ড”।

পার্থক্যগুলো কি আসল? একই ৪০টি প্রশ্নে মাপা, তাই paired bootstrap (মেশিন লার্নিং কোর্সের পর্ব ২১ আর পর্ব ২২)। নিচের block সত্যিকারের প্রতি-প্রশ্ন ফল থেকে ভুলের শ্রেণি গোনে আর ব্যবধান বের করে; desktop-এ একই seed-এ একই সংখ্যা এসেছিল।

import numpy as np
from collections import Counter
# সত্যিকারের run: ৪০টি প্রশ্নে স্বয়ংক্রিয় key-মিলের ফল (১ = ঠিক), একই প্রশ্ন-ক্রমে
runs = {
    "k1":     "0001011000111101000000000000101101111111",
    "k3":     "1001011010111101110000000000111111011001",
    "k5":     "1001001010111111100000001000111111010000",
    "oracle": "1101011000111101000000001011111111011001",
}
R = {c: np.array([int(ch) for ch in s]) for c, s in runs.items()}
# k3-এর ৪০টি উত্তরে আমার হাতে দেওয়া ভুল-শ্রেণি
kinds = ("ok cite_only cite_only ok stale ok ok cite_only ok unsupported ok ok ok ok "
         "cite_only ok ok ok ignored number number number partial unsupported number "
         "partial miss unsupported ok ok ok ok ok ok cite_only ok ok halluc_un halluc_un ok").split()
print("k3 ভুল-শ্রেণি:", Counter(kinds).most_common())

rng = np.random.default_rng(0)
idx = rng.integers(0, 40, (10000, 40))       # একই resample সব তুলনায়
base = R["k3"]
for c in ("k1", "k5", "oracle"):
    d = R[c] - base
    bs = d[idx].mean(axis=1)
    lo, hi = np.percentile(bs, [2.5, 97.5])
    win, lose = int(((R[c] == 1) & (base == 0)).sum()), int(((R[c] == 0) & (base == 1)).sum())
    print(f"{c:6} - k3: {d.mean():+.3f}  95% CI [{lo:+.3f}, {hi:+.3f}]  ভালো {win}, খারাপ {lose}")
# শুধু উত্তর নেই এমন ৬টি প্রশ্ন (শেষের ৬টি): abstain-এর হার
print("abstain, উত্তর নেই এমন ৬টি:", {c: int(R[c][-6:].sum()) for c in R})

k3 ভুল-শ্রেণি: [('ok', 21), ('cite_only', 5), ('number', 4), ('unsupported', 3), ('partial', 2), ('halluc_un', 2), ('stale', 1), ('ignored', 1), ('miss', 1)]
k1     - k3: -0.075  95% CI [-0.225, +0.075]  ভালো 3, খারাপ 6
k5     - k3: -0.050  95% CI [-0.175, +0.075]  ভালো 2, খারাপ 4
oracle - k3: +0.025  95% CI [-0.100, +0.150]  ভালো 4, খারাপ 3
abstain, উত্তর নেই এমন ৬টি: {'k1': 6, 'k3': 3, 'k5': 1, 'oracle': 3}

৭ · ভুলের শ্রেণিবিন্যাস — একটি ভুল কোন ধাপের

সংখ্যা বলে কতটা খারাপ, error analysis বলে কেন। প্রতিটি ভুল উত্তরে পরপর চারটি প্রশ্ন করুন। প্রথম “না”-তেই শ্রেণি ঠিক হয়ে যায়। নিচের পাঁচটি ঘটনা সব আমাদের run-এর।

আরেকটি পরিচিত শ্রেণি “ভুল ভাষা”। আমাদের run-এ k৩-এ চারটি ইংরেজি প্রশ্নের উত্তর ইংরেজিতেই এসেছে; Banglish প্রশ্নের উত্তর এসেছে বাংলা লিপিতে। সেটি ভুল কি না, তা আপনার নীতির ওপর নির্ভর করে, তাই নিয়মটি আগে লিখে রাখুন। দুই ধরনের ৪০টি করে উত্তরে আমার নিজের শ্রেণি গোনা (একজন লেবেলার, তাই নিজেই পক্ষপাতদুষ্ট হতে পারি):

my error tally:
  k3          {'ok': 21, 'cite_only': 5, 'number': 4, 'unsupported': 3, 'partial': 2, 'halluc_un': 2, 'stale': 1, 'ignored': 1, 'miss': 1}
  fixed80_k3  {'ok': 18, 'miss': 4, 'halluc_un': 4, 'cite_only': 3, 'partial': 3, 'number': 2, 'unsupported': 2, 'stale': 1, 'ignored': 1, 'wrongchunk': 1, 'garbled': 1}

ছবিটা পরিষ্কার: বাক্য-ভিত্তিক chunk-এ retrieval-এর ভুল মাত্র ১টি, বাকি সব generator-এর (শুধু নম্বর, বানানো সংখ্যা, উৎসে নেই এমন দাবি, অর্ধেক উত্তর)। ৮০ অক্ষরের টুকরোয় retrieval miss বেড়ে ৪টি। কোথায় খাটবেন, সেটি এই তালিকাই বলে।

৮ · LLM-as-judge দিয়ে faithfulness — আর তাকে যাচাই

৬৩টি উত্তর হাতে পড়ে লেবেল দেওয়া যায়, কিন্তু হাজার উত্তরে সেটি ধীর আর দামি, তাই প্রচলিত পথ LLM-as-judge: আরেকটি model-কে উৎস আর উত্তর দিয়ে জিজ্ঞেস করা, “প্রতিটি দাবি কি উৎসে আছে?” পর্ব ৫৮-এ দেখেছেন বিচারকের পক্ষপাত: position bias, লম্বা উত্তরের দিকে ঝোঁক, self-preference. এখানে আমরা মাপব।

বিচারক একই Qwen2.5-1.5B-Instruct (অর্থাৎ নিজের উত্তর নিজে বিচার করছে; এটি ইচ্ছাকৃত দুর্বল পরীক্ষা, বড় বিচারক এখানে চালানো যায়নি)। Prompt-এ বলা হলো শুধু YES বা NO লিখতে; পরের token-এর logits থেকে P(YES) নিয়েছি, ০.৫-এর বেশি হলে YES. প্রতিটি উত্তর দুবার: একবার উৎস আগে, উত্তর পরে; একবার উল্টো ক্রমে। তুলনা আমার নিজের faithfulness লেবেলের সঙ্গে (৬৩টি উত্তর যাতে কোনো দাবি আছে; ৪৪টি faithful, ১৯টি নয়)। সত্যিকারের run (GPU-তে, ১২৬টি বিচার ৩০.৫ সেকেন্ডে, সর্বোচ্চ ৩,২৭৯ MB; সংক্ষিপ্ত):

~/bazarghar-dl$ uv run python judge.py
token ids YES [14004] NO [8996]
k3 s01 1 0.991 'YES'  0.349 'NO'
k3 s04 1 0.010 'NO'  0.068 'NO'
k3 s10 0 0.755 'YES'  0.068 'NO'
k3 n02 0 0.438 'NO'  0.042 'NO'
k3 m02 0 0.562 'YES'  0.107 'NO'
k3 e02 1 0.958 'YES'  0.026 'NO'
…
fixed80_k3 s16 1 0.500 'NO'  0.706 'YES'
fixed80_k3 b02 0 0.060 'NO'  0.321 'NO'
fixed80_k3 u06 0 0.202 'NO'  0.531 'YES'
meta {'n': 63, 'sec': 30.5, 'peak_mb': 3279}

প্রতিটি লাইনে: অবস্থা, প্রশ্ন, আমার লেবেল, উৎস-আগে P(YES) আর লেখা উত্তর, উত্তর-আগে P(YES) আর লেখা উত্তর। s04-এর মতো একদম ঠিক উত্তরেও (“90 টাকা”, উৎসে আছে) বিচারক NO বলেছে; s10-এর ভুল উত্তরে YES. এখন মিল মাপি। শুধু “কতবার একমত” যথেষ্ট নয়, কারণ দুজনেই বেশিরভাগ সময় একই উত্তর দিলে কাকতালীয় মিলও বেশি হয়। Cohen's kappa সেই কাকতালীয় অংশ বাদ দেয়।

একই হিসাব কোডে, সঙ্গে kappa-র bootstrap ব্যবধান। সংখ্যাগুলো বিচারকের সত্যিকারের P(YES), তিন দশমিকে কাটা।

import numpy as np
# আমার faithfulness লেবেল (১ = সব দাবি উৎসে আছে), ৬৩টি উত্তর
H = np.array([int(c) for c in "111111011111110001001001111110111111111111011100010100101111010"])
# Qwen2.5-1.5B বিচারকের P(YES), দুই ক্রমে (সত্যিকারের run)
p_src = [.991,.010,.321,.438,.018,.818,.755,.076,.014,.777,.349,.223,.269,.148,.438,.018,.294,.202,.562,.085,.047,
         .085,.053,.076,.651,.651,.958,.042,.438,.085,.867,.881,.706,.798,.915,.818,.731,.852,.924,.085,.593,.469,
         .245,.500,.378,.940,.085,.500,.706,.562,.562,.562,.148,.060,.068,.245,.836,.940,.867,.269,.245,.798,.202]
p_ans = [.349,.068,.223,.182,.042,.095,.068,.020,.060,.068,.223,.042,.076,.294,.042,.182,.531,.294,.107,.119,.223,
         .033,.085,.020,.042,.164,.026,.294,.119,.469,.245,.037,.095,.076,.042,.107,.053,.269,.085,.026,.068,.202,
         .294,.706,.245,.223,.245,.107,.107,.245,.223,.060,.294,.321,.026,.076,.148,.133,.321,.223,.438,.053,.531]

def kappa(a, b):
    po = (a == b).mean()
    pe = a.mean() * b.mean() + (1 - a.mean()) * (1 - b.mean())
    return po, pe, (po - pe) / (1 - pe)

rng = np.random.default_rng(0)
idx = rng.integers(0, len(H), (2000, len(H)))
for name, p in (("উৎস আগে", p_src), ("উত্তর আগে", p_ans)):
    J = (np.array(p) > 0.5).astype(int)
    po, pe, k = kappa(J, H)
    ks = [kappa(J[i], H[i])[2] for i in idx]
    lo, hi = np.percentile(ks, [2.5, 97.5])
    print(f"{name}: YES-এর হার {J.mean():.3f}  মিল {po:.3f}  pe {pe:.3f}  kappa {k:.3f}  95% CI [{lo:.2f}, {hi:.2f}]")
    print(f"   সারণি: মানুষ ১/বিচারক ১ = {((J==1)&(H==1)).sum()}, ১/০ = {((J==0)&(H==1)).sum()},"
          f" ০/১ = {((J==1)&(H==0)).sum()}, ০/০ = {((J==0)&(H==0)).sum()}")
A, B = (np.array(p_src) > 0.5), (np.array(p_ans) > 0.5)
print("শুধু ক্রম বদলে রায় উল্টেছে:", int((A != B).sum()), "/", len(H))

উৎস আগে: YES-এর হার 0.429  মিল 0.603  pe 0.472  kappa 0.249  95% CI [0.05, 0.45]
   সারণি: মানুষ ১/বিচারক ১ = 23, ১/০ = 21, ০/১ = 4, ০/০ = 15
উত্তর আগে: YES-এর হার 0.048  মিল 0.286  pe 0.320  kappa -0.051  95% CI [-0.16, 0.03]
   সারণি: মানুষ ১/বিচারক ১ = 1, ১/০ = 43, ০/১ = 2, ০/০ = 17
শুধু ক্রম বদলে রায় উল্টেছে: 30 / 63

৯ · AI-এর যুগে — AI-এর বানানো RAG মূল্যায়ন যাচাই

AI assistant এক মিনিটে একটি RAG evaluation script লিখে দেয়, সঙ্গে সুন্দর একটি সংখ্যা। ভুলগুলো প্রায় সবই নীরব।

AI-এর দেওয়া RAG মূল্যায়ন হাতে পেলে — চেকলিস্ট

• Retrieval আর generation আলাদা মেপেছি, oracle context-সহ
• Eval set-এ উত্তর নেই, বহু নথি, সংখ্যা আর Banglish প্রশ্ন আছে; প্রশ্ন লিখেছি retriever চালানোর আগে
• স্বয়ংক্রিয় মাপ আর নিজের হাতের রায় অন্তত কয়েক ডজন উত্তরে মিলিয়েছি
• LLM বিচারকের kappa মেপেছি, ক্রম উল্টে দেখেছি
• ফলের সঙ্গে n, seed, model, decoding আর ব্যবধান লিখেছি
• ভুল উত্তরগুলো নিজে পড়ে শ্রেণিতে ভাগ করেছি
• গ্রাহকের ব্যক্তিগত লেখা বা কোনো key AI-কে দিইনি