Sentence embedding আর semantic search

১ · Token-এর vector থেকে বাক্যের একটি vector — pooling আর mask

AI-এর ভিত্তি কোর্সের পর্ব ৬৯-এ এমন একটি model (multilingual-e5-small) সরাসরি ব্যবহার করেছেন, আর recall@k ও MRR হাতে গুনেছেন। এখানে আমরা ভেতরে ঢুকব: vector কীভাবে তৈরি হয়, কীভাবে শেখানো হয়, আর কোথায় শব্দ মেলানো খোঁজ এখনো জেতে।

পর্ব ৪৪-এ দেখেছেন, transformer প্রতিটি token-এর জন্য একটি contextual vector দেয়। ১৩টি token-এর বাক্যে output-এর shape (13, 384). Semantic search-এ দরকার পুরো বাক্যের একটি vector, যাকে বলে sentence embedding. সেখানে পৌঁছানোর ধাপটির নাম pooling. দুটি পরিচিত পথ:

• CLS pooling: প্রথম বিশেষ token-এর vector নেওয়া। Model যদি এভাবে শেখানো হয়, তবেই এটি অর্থবহ।
• Mean pooling: সব আসল token-এর vector-এর গড়। Sentence-BERT ধারায় এটিই সবচেয়ে প্রচলিত (পর্ব ৪৮-এ এর উল্লেখ আছে)।

Batch-এ বাক্যগুলোর দৈর্ঘ্য সমান করতে ছোট বাক্যে pad বসে। Pad-এর ঘরেও model কিছু না কিছু vector দেয়। তাই গড় নেওয়ার সময় attention mask দিয়ে pad বাদ দিতে হয়: mean = ∑_t m_t·h_t ÷ ∑_t m_t, যেখানে h_t হলো t নম্বর token-এর vector আর m_t আসল token-এ ১, pad-এ ০.

একই হিসাব দুটি বাক্যের batch-এ, NumPy-তে। শেষে দেখুন, mask ভুললে দুই বাক্য কতটা “কাছে” দেখায়।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
# batch-এ ২টি বাক্য, প্রতিটি ৪ ঘরে pad করা: shape (2, 4, 3)
H = np.array([[[1.0, 0.0, 2.0], [3.0, 1.0, 0.0], [2.0, 2.0, 1.0], [9.0, 9.0, 9.0]],
              [[0.0, 1.0, 1.0], [2.0, 0.0, 3.0], [8.0, 8.0, 8.0], [8.0, 8.0, 8.0]]])
mask = np.array([[1, 1, 1, 0],
                 [1, 1, 0, 0]])                # ১ = আসল token, ০ = pad
cls = H[:, 0]                                  # প্রথম ঘরের vector
naive = H.mean(axis=1)                         # pad-ও গড়ে ঢুকে যায়
m = mask[:, :, None].astype(float)             # (2, 4, 1): broadcasting-এর জন্য
mean = (H * m).sum(axis=1) / m.sum(axis=1)     # শুধু আসল token-এর গড়
print("CLS:\n", cls)
print("mask ছাড়া গড়:\n", naive)
print("mask-সহ গড়:\n", mean)
def unit(x):
    return x / np.linalg.norm(x, axis=-1, keepdims=True)
print("দৈর্ঘ্য আগে:", np.linalg.norm(mean, axis=1), " পরে:", np.linalg.norm(unit(mean), axis=1))
print("cos, mask-সহ :", round(float(unit(mean)[0] @ unit(mean)[1]), 3))
print("cos, mask ছাড়া:", round(float(unit(naive)[0] @ unit(naive)[1]), 3))
a, b = mean[0], 10 * mean[1]                   # দ্বিতীয়টিকে ১০ গুণ লম্বা করলাম
print("dot:", round(float(a @ b), 3), " cos:", round(float(unit(a) @ unit(b)), 3))

CLS:
 [[1. 0. 2.]
 [0. 1. 1.]]
mask ছাড়া গড়:
 [[3.75 3.   3.  ]
 [4.5  4.25 5.  ]]
mask-সহ গড়:
 [[2.  1.  1. ]
 [1.  0.5 2. ]]
দৈর্ঘ্য আগে: [2.449 2.291]  পরে: [1. 1.]
cos, mask-সহ : 0.802
cos, mask ছাড়া: 0.99
dot: 45.0  cos: 0.802

সত্যিকারের model-এ কি একই হিসাব চলে? multilingual-e5-small-এর last_hidden_state থেকে নিজে mask-সহ গড় নিয়ে sentence-transformers-এর ফলের সঙ্গে মেলালাম। সত্যিকারের run (CPU-তে; version অংশ ৬-এ):

~/bazarghar-dl$ uv run python pool.py
input_ids (3, 13) | mask row sums [13, 11, 12]
['<s>', '▁que', 'ry', ':', '▁রি', 'ফা', 'ন্ড', '▁কত', '▁দিনে', '▁পা', 'ব', '?', '</s>']
['<s>', '▁que', 'ry', ':', '▁refund', '▁koto', 'din', '▁e', '▁pa', 'bo', '</s>', '<pad>', '<pad>']
H (3, 13, 384) | max |own mean - sentence-transformers| = 5.22e-08
cos(own mask mean, no-mask mean) per sentence: [1.0, 0.998, 0.9986]
cos matrix, mask mean:
 [[1.    0.846 0.886]
 [0.846 1.    0.859]
 [0.886 0.859 1.   ]]
cos matrix, CLS:
 [[1.    0.918 0.948]
 [0.918 1.    0.93 ]
 [0.948 0.93  1.   ]]
(1): Pooling({... 'pooling_mode': 'mean' ...})
(2): Normalize()   # … SentenceTransformer-এর গঠন, ছাঁটা

চারটি কথা। এক, নিজের গড় আর library-র ফলের পার্থক্য ৫.২২ × ১০^−৮, অর্থাৎ library ঠিক এই হিসাবই করে; model-এর গঠনে লেখা আছে pooling_mode: mean আর তারপর Normalize. দুই, tokenizer “রিফান্ড”-কে তিন টুকরো করেছে, আর Banglish বাক্যে ২টি pad বসেছে। তিন, এখানে pad কম, তাই mask ছাড়া গড়ও প্রায় একই (০.৯৯৮); লম্বা আর ছোট বাক্য একসঙ্গে থাকলে পার্থক্য বাড়ে। চার, এই model mean pooling দিয়ে শেখানো; CLS নিলে তিন ভাষার cosine আরও বেশি (০.৯১৮–০.৯৪৮) দেখায়, কিন্তু উঁচু মান মানেই ভালো নয়, কারণ অন্য সব বাক্যও তখন কাছে আসতে পারে। Model যে pooling-এ শেখানো, সেটিই ব্যবহার করুন; model card আর modules.json তা বলে দেয় (পর্ব ৫৩)।

২ · Bi-encoder বনাম cross-encoder — কে কখন পড়ে

প্রশ্ন আর নথির মিল মাপার দুটি নকশা আছে।

• Bi-encoder: প্রশ্ন আর নথি আলাদা আলাদা একই encoder দিয়ে যায়; দুটি vector, তারপর একটি cosine. নথির vector আগেই একবার বানিয়ে রাখা যায়।
• Cross-encoder: প্রশ্ন আর নথি জুড়ে একটি input, “[CLS] প্রশ্ন [SEP] নথি [SEP]”. Self-attention-এ প্রশ্নের প্রতিটি token নথির প্রতিটি token দেখে, আর শেষে একটি score আসে। নির্ভুলতা প্রায়ই বেশি, কিন্তু আগে থেকে কিছু হিসাব করে রাখা যায় না।

খরচের হিসাবটাই আসল পার্থক্য। আমাদের run-এ (অংশ ৬) e5-small CPU-তে একটি নথি encode করতে গড়ে প্রায় ২৯ ms নিয়েছে। ধরুন ১,০০,০০০টি নথি।

• Bi-encoder: নথিগুলো একবারই encode: ১,০০,০০০ × ২৯ ms ≈ ৪৮ মিনিট, আগেভাগে। প্রতিটি প্রশ্নে একবার encode (প্রায় ২৯ ms) আর ১,০০,০০০ × ৩৮৪টি গুণ-যোগ, অর্থাৎ প্রায় ৩.৮ কোটি; একই যন্ত্রে NumPy-তে float32-এ এই গুণ মেপে পেয়েছি প্রায় ৪ ms.
• Cross-encoder: প্রতিটি প্রশ্নে ১,০০,০০০টি জোড়া, প্রতিটিতে একটি পুরো forward pass. একই গতি ধরলে প্রতি প্রশ্নে প্রায় ৪৮ মিনিট। এটি অচল।

তাই বাস্তবে দুটি একসঙ্গে: bi-encoder (বা BM25) দিয়ে হাজারের মধ্যে প্রথম ৫০–১০০টি, তারপর শুধু সেগুলোতে cross-encoder দিয়ে নতুন ক্রম। একে বলে reranking; Nogueira আর Cho-র ২০১৯ সালের কাজ BERT দিয়ে এই ধাপকে পরিচিত করে। বিস্তারিত আর সত্যিকারের reranker আসবে পর্ব ৬৯-এ (RAG — chunking, retrieval, reranking আর উত্তর তৈরি)। লাখ লাখ vector-এ দ্রুত খোঁজার কৌশল পর্ব ৬৮-এ (Vector index — FAISS, approximate nearest neighbor আর vector database). মাঝামাঝি একটি পথও আছে: ColBERT (Khattab ও Zaharia, ২০২০) প্রতিটি token-এর vector রাখে আর খোঁজার সময় token-স্তরে মেলায়; জায়গা বেশি লাগে।

৩ · Contrastive শেখা — Sentence-BERT, in-batch negative আর InfoNCE

সাধারণ BERT-এর vector গড় করলেই কি ভালো sentence embedding পাওয়া যায়? Reimers আর Gurevych-এর Sentence-BERT প্রবন্ধ (EMNLP ২০১৯) জানায়, তাঁদের পরীক্ষায় BERT-এর গড় vector বা CLS vector বাক্যের মিল মাপায় বেশ দুর্বল ছিল, কিছু ক্ষেত্রে GloVe-এর গড়ের চেয়েও খারাপ। সমাধান: একই encoder দুই বাক্যে চালিয়ে (siamese গঠন), জোড়ার label দিয়ে fine-tune করা, যাতে মিলের বাক্য কাছে আসে। এভাবে শেখার সাধারণ নাম contrastive learning; মূল ধারণা আর triplet loss আছে পর্ব ১৩-এ।

Retrieval-এর জন্য এখন বহুল প্রচলিত loss হলো InfoNCE (নামটি van den Oord ও সহকর্মীদের ২০১৮ সালের প্রবন্ধ থেকে)। একটি batch-এ B জোড়া (প্রশ্ন q_i, সঠিক নথি d_i). প্রতিটি প্রশ্নের জন্য batch-এর বাকি B − ১টি নথিকে ভুল উত্তর ধরা হয়: এগুলো in-batch negative, আলাদা করে খুঁজতে হয় না। Henderson ও সহকর্মীরা (২০১৭) উত্তর-সুপারিশে আর DPR (Karpukhin ও সহকর্মী, ২০২০) প্রশ্নোত্তরের retrieval-এ এই কৌশল ব্যবহার করেন।

L_i = −log [ exp(s_ii/τ) ÷ ∑_j exp(s_ij/τ) ]

এখানে s_ij = cos(q_i, d_j), আর τ হলো temperature, একটি ছোট ধনাত্মক সংখ্যা। লক্ষ্য করুন, এটি B শ্রেণির cross-entropy, যেখানে “সঠিক শ্রেণি” হলো নিজের জোড়া। e5-এর model card লিখেছে, তাদের InfoNCE-তে τ = ০.০১; সেই কারণে e5-এর cosine প্রায় সবসময় ০.৭–১-এর ঘরে থাকে, আর মানের চেয়ে ক্রম বেশি অর্থবহ।

এবার একটু বড় batch, এলোমেলো vector-এ, তিনটি τ দিয়ে।

import numpy as np
np.set_printoptions(precision=3, suppress=True)
rng = np.random.default_rng(42)
def unit(x):
    return x / np.linalg.norm(x, axis=1, keepdims=True)
B, d = 4, 8
Qv = unit(rng.normal(size=(B, d)))                 # ৪টি প্রশ্নের vector
Dv = unit(Qv + 0.6 * rng.normal(size=(B, d)))      # প্রতিটির সঠিক নথি: একটু সরানো
def infonce(Q, D, tau):
    S = Q @ D.T / tau                               # (B, B): সারি প্রশ্ন, কলাম নথি
    S = S - S.max(axis=1, keepdims=True)            # exp যেন overflow না করে
    logp = S - np.log(np.exp(S).sum(axis=1, keepdims=True))
    return -np.diag(logp).mean(), np.exp(np.diag(logp))
print("cos matrix (কর্ণে সঠিক জোড়া):\n", Qv @ Dv.T)
for tau in (1.0, 0.1, 0.05):
    L, p = infonce(Qv, Dv, tau)
    print(f"tau={tau:<4} loss={L:.3f}  P(সঠিক)={p}")
R = unit(rng.normal(size=(B, d)))                   # এলোমেলো নথি, কোনো মিল নেই
print("এলোমেলো নথি, tau=1:", round(float(infonce(Qv, R, 1.0)[0]), 3), " log B =", round(float(np.log(B)), 3))
# একটি ধাপ: সঠিক নথিকে প্রশ্নের দিকে একটু টানলে loss কমে কি?
D2 = unit(Dv + 0.3 * (Qv - Dv))
print("টানার পরে, tau=0.1:", round(float(infonce(Qv, D2, 0.1)[0]), 3))

cos matrix (কর্ণে সঠিক জোড়া):
 [[ 0.844 -0.048  0.909  0.263]
 [ 0.118  0.706  0.32  -0.029]
 [ 0.371  0.292  0.696  0.059]
 [-0.148  0.692  0.166  0.398]]
tau=1.0  loss=1.123  P(সঠিক)=[0.329 0.368 0.343 0.269]
tau=0.1  loss=1.037  P(সঠিক)=[0.342 0.976 0.945 0.05 ]
tau=0.05 loss=1.856  P(সঠিক)=[0.214 1.    0.998 0.003]
এলোমেলো নথি, tau=1: 1.53  log B = 1.386
টানার পরে, tau=0.1: 0.342

৪ · Normalise, cosine না dot — আর “query:” / “passage:”

Cosine = a·b ÷ (‖a‖‖b‖). দুই vector-এর দৈর্ঘ্য ১ হলে হর ১, তাই cosine আর dot product হুবহু সমান। এজন্য index বানানোর আগে সব vector normalise করে রাখা হয়; তারপর খোঁজ মানে শুধু একটি matrix গুণ (AI-এর ভিত্তি কোর্সের পর্ব ৩৩-এ এর ভিত্তি)। কিন্তু model যদি normalise না করা vector দেয়, আর আপনি dot দিয়ে খোঁজেন, তবে লম্বা vector-এর নথি সব প্রশ্নে এগিয়ে যায়। কিছু model ইচ্ছে করে dot-এর জন্য শেখানো হয় (dot-এ শেখানো DPR-এর মতো); কোন মাপে শেখানো, model card দেখে সেটিই ব্যবহার করুন।

দ্বিতীয় বিষয় asymmetric search: প্রশ্ন ছোট (“রিফান্ড কবে?”), নথি লম্বা অনুচ্ছেদ। দুটি একই রকম লেখা নয়। e5 পরিবার এটি সামলায় উপসর্গ দিয়ে: card অনুযায়ী প্রশ্নের আগে "query: ", নথির আগে "passage: "; card স্পষ্ট বলে, না দিলে মান কমবে। দুটি বাক্যের মিল মাপার মতো symmetric কাজে দুই দিকেই "query: ". অন্য model-এর নিয়ম ভিন্ন হতে পারে, যেমন কিছু model নির্দেশনার বাক্য চায়, কিছু model কিছুই চায় না।

Card-এর কথা আমাদের বাংলা প্রশ্নে কতটা খাটে, তা মেপে দেখেছি। সত্যিকারের run, অংশ ৬-এর একই ৪০টি নথি আর ৬০টি প্রশ্নে:

~/bazarghar-dl$ uv run python run.py      # অংশ ৬-এর একই run, ছাঁটা
MiniLM-L12: dim 384, params 117.7M, max_seq 128, pooling mean, docs 20.8 ms/doc CPU
  MiniLM unnormalised doc norms: min 1.63 max 4.17

system                     recall@1  recall@5  MRR@10
e5-small                      0.517     0.817  0.651
e5-small no-prefix            0.550     0.850  0.677
MiniLM-L12                    0.067     0.308  0.172
MiniLM-L12 dot-unnorm         0.050     0.233  0.125

e5-small - e5-small no-prefix: -0.026 [-0.080, +0.027]  wins 7 losses 12 ties 41

দুটি অবাক করা ফল। এক, e5-small-এ উপসর্গ বাদ দিলে এই ৬০টি প্রশ্নে MRR@১০ সামান্য বেশি (০.৬৭৭ বনাম ০.৬৫১), কিন্তু paired ব্যবধান [−০.০৮০, +০.০২৭] শূন্য পেরিয়ে যায়: ১২টি প্রশ্নে উপসর্গ ছাড়া ভালো, ৭টিতে খারাপ, ৪১টিতে সমান। তাই card-এর কথা এখানে ভুল প্রমাণিত হয়নি, আবার সমর্থনও পায়নি; ছোট, বানানো সংগ্রহে এটাই স্বাভাবিক। আমরা card-এর নিয়মই রাখছি, কারণ model ওভাবেই শেখানো। দুই, MiniLM-এর গঠনে কোনো Normalize ধাপ নেই; নথির vector-এর দৈর্ঘ্য ১.৬৩ থেকে ৪.১৭. Normalise না করে সরাসরি dot নিলে MRR@১০ ০.১৭২ থেকে ০.১২৫-এ নামে, কারণ লম্বা vector-এর নথি সব প্রশ্নে এগিয়ে আসে। MiniLM-এর নিজের মান কেন এত কম, তা অংশ ৬-এ।

৫ · BM25 — শব্দ মেলানোর খোঁজ, নিজে লেখা

Embedding-এর সঙ্গে তুলনার জন্য একটি শক্ত baseline দরকার। শব্দভিত্তিক খোঁজে বহু বছর ধরে মানদণ্ড BM25; এটি Stephen Robertson ও সহকর্মীদের Okapi ব্যবস্থা থেকে, ১৯৯০-এর দশকের TREC মূল্যায়নে পরিচিতি পায়। Inverted index আর ranking-এর ব্যবস্থাগত দিক আছে সিস্টেম ডিজাইন কোর্সের পর্ব ২৭-এ। সূত্রটি:

score(q, d) = ∑_{w ∈ q} IDF(w) · tf·(k₁ + 1) ÷ (tf + k₁·(1 − b + b·|d| ÷ avgdl))

এখানে tf হলো নথি d-তে শব্দ w কতবার আছে, |d| নথির দৈর্ঘ্য (শব্দ-সংখ্যা), avgdl সব নথির গড় দৈর্ঘ্য, আর IDF(w) = ln(১ + (N − df + ০.৫) ÷ (df + ০.৫)), যেখানে N মোট নথি আর df হলো কয়টি নথিতে শব্দটি আছে। k₁ (সাধারণত ১.২–২) ঠিক করে, একই শব্দ বারবার থাকলে score কত দ্রুত থেমে যায়; b (সাধারণত ০.৭৫) লম্বা নথিকে কতটা শাস্তি দেবে। TF-IDF-এর সঙ্গে পার্থক্য এই দুটি: tf-এর প্রভাব একটা সীমায় থামে, আর দৈর্ঘ্যের সমন্বয় আছে। IDF-এর এই রূপটি Lucene-এ ব্যবহৃত; মূল সূত্রে “১ +” নেই, তাই খুব সাধারণ শব্দে IDF ঋণাত্মক হতে পারত।

import math
docs = {"bh04": "ঢাকা সিটির ভেতরে ডেলিভারি চার্জ ৬০ টাকা, ১৫০০ টাকার বেশি অর্ডারে ফ্রি",
        "bh05": "গাজীপুর নারায়ণগঞ্জ সাভার আর কেরানীগঞ্জে ডেলিভারি চার্জ ৯০ টাকা",
        "bh06": "ঢাকা আর আশপাশের বাইরে সব জেলায় ডেলিভারি চার্জ ১২০ টাকা",
        "bh07": "ঢাকা সিটিতে ১ থেকে ২ দিনে আর অন্যান্য জেলায় ৩ থেকে ৫ দিনে ডেলিভারি হয়",
        "bh09": "ক্যাশ অন ডেলিভারি সর্বোচ্চ ২০০০০ টাকার অর্ডার পর্যন্ত চলে"}
tok = lambda s: s.replace(",", " ").replace("?", " ").split()
D = {k: tok(v) for k, v in docs.items()}
N, avgdl = len(D), sum(len(d) for d in D.values()) / len(D)
df = {}
for d in D.values():
    for w in set(d):
        df[w] = df.get(w, 0) + 1
def idf(w):
    return math.log((N - df[w] + 0.5) / (df[w] + 0.5) + 1)
def bm25(query, k1=1.5, b=0.75):
    scores = {}
    for k, d in D.items():
        s = 0.0
        for w in tok(query):
            tf = d.count(w)
            if tf:
                s += idf(w) * tf * (k1 + 1) / (tf + k1 * (1 - b + b * len(d) / avgdl))
        scores[k] = round(s, 3)
    return sorted(scores.items(), key=lambda x: -x[1])
print("avgdl =", avgdl, " idf(ডেলিভারি) =", round(idf("ডেলিভারি"), 3), " idf(সিটির) =", round(idf("সিটির"), 3))
for q in ["ঢাকা সিটির চার্জ কত?", "ঢাকায় ডেলিভারি চার্জ কত?", "রংপুরে ডেলিভারি চার্জ কত?"]:
    print(q, bm25(q)[:3])

avgdl = 11.0  idf(ডেলিভারি) = 0.087  idf(সিটির) = 1.386
ঢাকা সিটির চার্জ কত? [('bh04', 2.367), ('bh06', 1.124), ('bh05', 0.587)]
ঢাকায় ডেলিভারি চার্জ কত? [('bh05', 0.682), ('bh06', 0.653), ('bh04', 0.601)]
রংপুরে ডেলিভারি চার্জ কত? [('bh05', 0.682), ('bh06', 0.653), ('bh04', 0.601)]

৬ · সত্যিকারের তুলনা — BM25 বনাম দুটি model, ব্যবধানসহ

ডেটা. এই মডিউলের সব পর্বে একই সংগ্রহ: বাজারঘরের ৪০টি হেল্প-নথি (৩৫টি বাংলা, ৩টি ইংরেজি, ২টি Banglish), ফেরত, রিফান্ড, জেলাভিত্তিক ডেলিভারি চার্জ, পেমেন্ট, COD, ওয়ারেন্টি ইত্যাদি নিয়ে। নথি, নীতি আর সংখ্যা সবই কোর্সের জন্য হাতে বানানো; কোনো আসল প্রতিষ্ঠানের নয়। একটি নথি (bh40) পুরোনো, “archived” চিহ্নিত, ইচ্ছে করে রাখা। প্রশ্ন ৬০টি, হাতে লেখা, প্রতিটির সঠিক (gold) নথিসহ; দুটি প্রশ্নের gold নথি দুটি। প্রশ্নের ধরন: সাধারণ বাংলা ২৪, জায়গার নাম ৬, সংখ্যা ৫, “না”-বাচক ৫, বাংলা প্রশ্নে ইংরেজি বা Banglish নথি ৭, ইংরেজি প্রশ্ন ৪, Banglish প্রশ্ন ৯.

দুটি model একই ভিত্তি model (Multilingual-MiniLM-L12-H384) থেকে শুরু, তাই parameter সংখ্যাও সমান; পার্থক্য শেখার ডেটা আর পদ্ধতিতে। তৃতীয় একটি বড় model (multilingual-e5-base, ফাইল প্রায় ১.১ GB) চালানোর পরিকল্পনা ছিল; নামানোর গতি খুব কম থাকায় বাদ দিয়েছি, তার কোনো সংখ্যা এখানে নেই। লেখার সময়ের version: Python 3.14.4, torch 2.15.0 (CPU), transformers 5.22.2, sentence-transformers 6.2.0; model-এর revision পিন করা, সব কাজ CPU-তে। Recall@k-এর সংজ্ঞা recall@k = প্রথম k-এ gold নথির ভাগ; MRR@১০-এ প্রথম ১০-এর বাইরে হলে ০. ব্যবধান আসে paired bootstrap থেকে: একই প্রশ্নগুলো সব system-এর জন্য একসঙ্গে টানা। মূল অংশ, সংক্ষিপ্ত:

m = SentenceTransformer(name, revision=rev, device="cpu")
P = m.encode(["passage: " + t for t in texts], normalize_embeddings=True)  # (40, 384)
Qe = m.encode(["query: " + q for q in qs], normalize_embeddings=True)     # (60, 384)
ranks = np.argsort(-(Qe @ P.T), axis=1, kind="stable")                  # cosine = dot
idx = rng.integers(0, 60, size=(10000, 60))     # একই প্রশ্ন-সূচক সব system-এ: paired
lo, hi = np.percentile(d[idx].mean(1), [2.5, 97.5])   # d = দুই system-এর প্রশ্নভিত্তিক পার্থক্য

~/bazarghar-dl$ uv run python run.py
python 3.14.4, torch 2.15.0+cpu, transformers 5.22.2, sentence-transformers 6.2.0
docs 40 {'bn': 35, 'en': 3, 'banglish': 2} | questions 60 {'para': 24, 'dist': 6, 'xl': 7, 'num': 5, 'neg': 5, 'en': 4, 'bl': 9}
BM25 k1=1.5 b=0.75, avg doc len 38.1 tokens, queries with zero score everywhere: 1
e5-small: dim 384, params 117.7M, max_seq 512, pooling mean, docs 28.7 ms/doc CPU
MiniLM-L12: dim 384, params 117.7M, max_seq 128, pooling mean, docs 20.8 ms/doc CPU
  MiniLM unnormalised doc norms: min 1.63 max 4.17

system                     recall@1  recall@5  MRR@10
BM25                          0.392     0.667  0.502
e5-small                      0.517     0.817  0.651
MiniLM-L12                    0.067     0.308  0.172
RRF BM25+e5-small             0.483     0.717  0.598
RRF BM25>0+e5-small           0.483     0.750  0.612

95% bootstrap CI (10,000 resamples of the 60 questions, seed 42)
BM25                   MRR 0.502 [0.394, 0.612]  recall@5 0.667 [0.550, 0.783]
e5-small               MRR 0.651 [0.552, 0.746]  recall@5 0.817 [0.717, 0.917]
MiniLM-L12             MRR 0.172 [0.106, 0.247]  recall@5 0.308 [0.200, 0.425]
paired differences in MRR
e5-small - BM25: +0.149 [+0.047, +0.253]  wins 26 losses 12 ties 22
MiniLM-L12 - BM25: -0.330 [-0.442, -0.217]  wins 5 losses 40 ties 15
e5-small - MiniLM-L12: +0.479 [+0.375, +0.580]  wins 48 losses 4 ties 8

recall@5 by question type
system            para  dist   num   neg    xl    en    bl
n                   24     6     5     5     7     4     9
BM25              0.83  0.50  1.00  1.00  0.00  0.75  0.44
e5-small          0.96  0.50  0.60  1.00  0.43  1.00  0.89
MiniLM-L12        0.21  0.50  0.40  0.60  0.00  0.75  0.28

e5-small স্পষ্টভাবে BM25-এর চেয়ে ভালো: MRR@১০-এ +০.১৪৯, ব্যবধান [+০.০৪৭, +০.২৫৩] শূন্য ছোঁয় না; ২৬টি প্রশ্নে জয়, ১২টিতে হার। MiniLM BM25-এরও অনেক নিচে (০.১৭২)। লেখার সময়ে এর card-এর ভাষার তালিকায় bn নেই। Tokenizer একই, তাই বাংলা লেখা ঠিকই টুকরো হয়; কিন্তু শেখার সময় বাংলার জোড়া না থাকলে vector অর্থের কাছাকাছি সাজে না। ইংরেজি প্রশ্নে এর recall@৫ ০.৭৫, বাংলা প্রশ্নে ০.২১. “Multilingual” নাম দেখে নয়, card-এর তালিকায় নিজের ভাষা দেখে model বাছুন। ধরনভিত্তিক ছবি: BM25 সংখ্যা আর “না”-বাচক প্রশ্নে ১.০০, কারণ নির্দিষ্ট শব্দ মিলেছে, কিন্তু ভাষা-পেরোনো প্রশ্নে ০. e5 ভাষা-পেরোনোয় ০.৪৩, Banglish-এ ০.৮৯, অথচ সংখ্যায় ০.৬০. প্রতিটি ধরনে মাত্র ৪–৯টি প্রশ্ন, তাই এই ভাগগুলো দিক দেখায়, প্রমাণ নয়। পুরো ফলই একটি run, একটি বানানো সংগ্রহ, আর প্রশ্নগুলো লেখকের নিজের লেখা; এটি সাধারণ benchmark নয়।

৭ · Hybrid search — reciprocal rank fusion

BM25-এর score ০ থেকে ১৪, e5-এর ০.৭৮ থেকে ০.৯০: দুটি যোগ করা অর্থহীন। Reciprocal rank fusion (RRF; Cormack, Clarke আর Büttcher, SIGIR ২০০৯) শুধু অবস্থান দেখে। প্রতিটি নথির score = ∑ ১/(k + rank), যেখানে rank প্রতিটি তালিকায় তার অবস্থান (১ থেকে শুরু), আর k একটি ধ্রুবক; প্রবন্ধে k = ৬০. Rank ১ আর rank ২-এর পার্থক্য ছোট রাখে বলে একটি তালিকার একটি ভুল পুরো ফল উল্টে দিতে পারে না। এভাবে দুই খোঁজ মেলানোকে বলে hybrid search.

এবার সব ৬০টি প্রশ্নে, পাতাতেই। নিচের ফাইলে প্রতিটি প্রশ্নের জন্য সত্যিকারের run-এর BM25 আর e5-small-এর প্রথম ১০টি নথির নম্বর (bh বাদ দিয়ে) আর BM25-এ কয়টি নথির score ০-এর বেশি, তা দেওয়া আছে। Model এখানে চলছে না; শুধু ক্রম জোড়া লাগানো আর মাপা।

import numpy as np
import pandas as pd
cols = ["type", "gold", "bm25", "npos", "e5"]
df = pd.read_csv("ranks.tsv", sep="\t", header=None, names=cols, dtype=str)
for c in ["gold", "bm25", "e5"]:
    df[c] = df[c].str.split(r"[ ,]")         # "04 06" → ["04", "06"]
df["bm25+"] = [l[:int(n)] for l, n in zip(df.bm25, df.npos)]   # শুধু score > 0
def rrf(a, b, k=60):
    s = {}
    for lst in (a, b):
        for pos, d in enumerate(lst):        # pos 0 মানে rank 1
            s[d] = s.get(d, 0) + 1 / (k + pos + 1)
    return sorted(s, key=lambda d: -s[d])
df["rrf"] = [rrf(a, b) for a, b in zip(df.bm25, df.e5)]
df["rrf>0"] = [rrf(a, b) for a, b in zip(df["bm25+"], df.e5)]
def recall(g, lst, k):
    return len(set(g) & set(lst[:k])) / len(g)
def rr(g, lst):                              # MRR@10: প্রথম ১০-এ না থাকলে ০
    hit = [i for i, d in enumerate(lst[:10]) if d in g]
    return 1 / (hit[0] + 1) if hit else 0.0
names = ["bm25", "e5", "rrf", "rrf>0"]
rows = {}
for s in names:
    df[s + "@5"] = [recall(g, l, 5) for g, l in zip(df.gold, df[s])]
    rows[s] = {"recall@1": np.mean([recall(g, l, 1) for g, l in zip(df.gold, df[s])]),
               "recall@5": df[s + "@5"].mean(),
               "MRR@10": np.mean([rr(g, l) for g, l in zip(df.gold, df[s])])}
print(pd.DataFrame(rows).T.round(3))
print(df.groupby("type")[[s + "@5" for s in names]].mean().round(2))

       recall@1  recall@5  MRR@10
bm25      0.392     0.667   0.502
e5        0.517     0.817   0.651
rrf       0.475     0.717   0.603
rrf>0     0.475     0.783   0.614
      bm25@5  e5@5  rrf@5  rrf>0@5
type                              
bl      0.44  0.89   0.56     0.89
dist    0.50  0.50   0.50     0.50
en      0.75  1.00   1.00     0.75
neg     1.00  1.00   1.00     1.00
num     1.00  0.60   0.60     0.80
para    0.83  0.96   0.92     0.92
xl      0.00  0.43   0.14     0.29

৮ · ভাষা, লিপি আর ব্যর্থতার জায়গা — সংখ্যা, “না” আর জেলার নাম

গড় সংখ্যা লুকিয়ে রাখে কোথায় ভুল হচ্ছে। সত্যিকারের run থেকে বাছাই করা কয়েকটি প্রশ্ন; প্রতিটিতে প্রথম ৩টি নথি আর score, * মানে gold, শেষে gold-এর অবস্থান:

[04 dist] রংপুরে পার্সেল পাঠাতে কত টাকা লাগে?  gold bh06
   BM25       bh02 5.998  bh07 4.648  bh29 2.738   gold rank 13
   e5-small   bh33 0.808  bh09 0.807  bh38 0.804   gold rank 13
   MiniLM-L12 bh33 0.795  bh16 0.786  bh06* 0.757   gold rank 3
[05 dist] গুলশানে জিনিস পাঠাতে কত টাকা লাগে?  gold bh04
   BM25       bh02 5.998  bh07 4.648  bh29 2.738   gold rank 8
   e5-small   bh26 0.832  bh03 0.830  bh28 0.828   gold rank 11
   MiniLM-L12 bh33 0.764  bh16 0.750  bh14 0.739   gold rank 12
[08 num] দশ হাজার টাকার ফোন কি হাতে পেয়ে টাকা দিয়ে নেওয়া যাবে?  gold bh09
   BM25       bh19 6.716  bh16 6.250  bh40 3.953   gold rank 4
   e5-small   bh34 0.826  bh12 0.816  bh20 0.815   gold rank 13
   MiniLM-L12 bh16 0.865  bh06 0.852  bh33 0.844   gold rank 35
[42 num] ৫ কেজির পার্সেল সিলেটে পাঠাতে কত লাগবে?  gold bh06
   BM25       bh07 5.787  bh06* 3.200  bh02 2.616   gold rank 2
   e5-small   bh12 0.838  bh15 0.822  bh38 0.821   gold rank 18
   MiniLM-L12 bh16 0.821  bh33 0.804  bh14 0.801   gold rank 4
[43 num] কত টাকার অর্ডারে ঢাকায় ফ্রি ডেলিভারি?  gold bh04
   BM25       bh40 9.607  bh33 7.003  bh04* 5.872   gold rank 3
   e5-small   bh40 0.900  bh04* 0.894  bh06 0.886   gold rank 2
   MiniLM-L12 bh14 0.812  bh16 0.809  bh33 0.803   gold rank 8
[15 neg] ফোন পানিতে পড়ে নষ্ট, ওয়ারেন্টিতে ঠিক করে দেবে?  gold bh13
   BM25       bh13* 3.015  bh17 3.015  bh36 2.801   gold rank 1
   e5-small   bh15 0.813  bh13* 0.811  bh30 0.805   gold rank 2
   MiniLM-L12 bh16 0.828  bh14 0.796  bh06 0.770   gold rank 16
[38 neg] উপন্যাস পড়ে ভালো লাগেনি, ফেরত দেওয়া যাবে?  gold bh36
   BM25       bh36* 9.750  bh18 3.848  bh37 3.640   gold rank 1
   e5-small   bh37 0.808  bh36* 0.806  bh01 0.797   gold rank 2
   MiniLM-L12 bh36* 0.653  bh16 0.628  bh07 0.623   gold rank 1
[36 xl] ছাত্রদের জন্য কোনো ছাড় আছে?  gold bh34
   BM25       bh23 2.138  bh21 2.112  bh19 1.921   gold rank 34
   e5-small   bh34* 0.834  bh36 0.813  bh37 0.807   gold rank 1
   MiniLM-L12 bh36 0.719  bh16 0.710  bh06 0.707   gold rank 26
[58 xl] এক্সপ্রেস ডেলিভারির খরচ কত?  gold bh08
   BM25       bh29 4.530  bh02 4.494  bh03 3.461   gold rank 12
   e5-small   bh28 0.866  bh05 0.839  bh06 0.836   gold rank 19
   MiniLM-L12 bh40 0.655  bh04 0.655  bh26 0.597   gold rank 19
[53 bl] jama size e hoy nai, change korte chai  gold bh25
   BM25       bh34 6.031  bh10 5.290  bh01 0.000   gold rank 26
   e5-small   bh34 0.822  bh10 0.808  bh25* 0.805   gold rank 3
   MiniLM-L12 bh16 0.441  bh19 0.420  bh36 0.400   gold rank 11
[00 para] জিনিস পছন্দ না হলে কত দিনের মধ্যে ফেরত দিতে পারব?  gold bh01
   BM25       bh01* 8.689  bh25 6.419  bh02 5.393   gold rank 1
   e5-small   bh01* 0.841  bh02 0.841  bh37 0.839   gold rank 1
   MiniLM-L12 bh16 0.845  bh14 0.819  bh06 0.798   gold rank 16

প্রতিটি থেকে একটি করে শিক্ষা।

• জেলা আর এলাকার নাম: “রংপুরে” প্রশ্নের উত্তর আছে bh06-এ, যেখানে লেখা “সব জেলায়”; রংপুর যে সেই দলে, তা জানতে বাইরের জ্ঞান লাগে। BM25 আর e5 দুটিতেই rank ১৩. “গুলশান” যে ঢাকা সিটির ভেতরে, তা কোনো নথিতে নেই; rank ৮ আর ১১. Embedding-এর ভূগোল-জ্ঞানের ওপর ভরসা না করে নথিতে জেলা আর এলাকার তালিকা লিখুন, অথবা প্রশ্ন থেকে জায়গা চিনে metadata দিয়ে ছাঁকুন (পর্ব ৬৮)।
• সংখ্যা: “দশ হাজার টাকার ফোন” প্রশ্নে e5-এ সঠিক COD নথি ১৩ নম্বরে; “৫ কেজির পার্সেল সিলেটে” প্রশ্নে ১৮ নম্বরে, অথচ BM25-এ ২. Embedding “২০,০০০-এর নিচে কি না” ধরনের তুলনা করে না। আর উত্তরটি নিজেই হিসাব: ১২০ + ৪ × ২০ = ২০০ টাকা; এটি খোঁজার নয়, উত্তর তৈরির বা একটি হিসাবের tool-এর কাজ (পর্ব ৬৯ আর পর্ব ৭১, Tool use আর function calling — LLM থেকে কাজ)।
• পুরোনো নথি: “কত টাকার অর্ডারে ঢাকায় ফ্রি ডেলিভারি?” প্রশ্নে BM25 আর e5 দুটিই archived bh40-কে (১,০০০ টাকা, পুরোনো নিয়ম) প্রথমে আনে। Embedding তারিখ বা status দেখে না; status দিয়ে আগেই ছাঁকতে হয়, নইলে ভুল তথ্য সোজা উত্তরে ঢোকে।
• “না” আর শর্ত: “ফোন পানিতে পড়ে নষ্ট, ওয়ারেন্টিতে ঠিক করে দেবে?” প্রশ্নে e5 প্রথমে আনে দাবি করার নিয়ম (bh15); আসল উত্তর “পানি ঢোকা ওয়ারেন্টির বাইরে” আছে দুই নম্বরের bh13-এ। বিষয় মেলে, শর্ত মেলে না।
• ভাষা আর লিপি: ভাষা-পেরোনো খোঁজে “ছাত্রদের জন্য কোনো ছাড়” প্রশ্নে e5 Banglish নথি bh34 প্রথমে আনে, ভালো। কিন্তু “এক্সপ্রেস ডেলিভারির খরচ” প্রশ্নে ইংরেজি নথি “Express delivery” ১৯ নম্বরে। আবার Banglish প্রশ্নে e5 প্রায়ই দুটি Banglish নথি (bh10, bh34) আগে আনে, বিষয় না মিললেও: লিপির মিল একটি টান তৈরি করে। MiniLM-এ একই নথি bh16 অনেক প্রশ্নে ওপরে ওঠে, যা model ভাষাটি না জানার আরেকটি লক্ষণ।

প্রতিকারের সারকথা: নথির লেখা উন্নত করা (জেলার তালিকা, প্রতিটি ভাষায় সারাংশ), metadata আর status দিয়ে ছাঁকা, সংখ্যার কাজ হিসাবের ধাপে দেওয়া, cross-encoder দিয়ে reranking, আর প্রতিটি ধরনের প্রশ্ন eval set-এ রেখে নিয়মিত মাপা।

৯ · AI-এর যুগে — AI-এর লেখা semantic search যাচাই

AI assistant কয়েক সেকেন্ডে একটি semantic search লিখে দেয়। ভুলগুলো প্রায় সবই নীরব: কোড চলে, ফলও আসে, শুধু ফল খারাপ।

AI-এর দেওয়া semantic search হাতে পেলে — চেকলিস্ট

• Model card-এ লাইসেন্স, ভাষা, সর্বোচ্চ token, pooling আর উপসর্গ দেখেছি; revision পিন করেছি
• নিজের mask-সহ গড় library-র ফলের সঙ্গে মিলিয়েছি; ‖v‖ = ১ দেখেছি
• নিজের বাংলা আর Banglish বাক্যের token পড়েছি
• দাগানো প্রশ্ন-তালিকায় BM25-এর সঙ্গে তুলনা করেছি; প্রশ্নের ধরন ভাগ করে দেখেছি
• ফলের সঙ্গে n আর bootstrap ব্যবধান লিখেছি; বিকল্প বাছাইয়ের প্রশ্নেই জয় দাবি করিনি
• ব্যর্থ প্রশ্নগুলো নিজে পড়েছি: সংখ্যা, “না”, জায়গার নাম
• গ্রাহকের ব্যক্তিগত লেখা বা কোনো key AI-কে দিইনি