Embedding আর vector search — অর্থ দিয়ে খোঁজা

পর্ব ৬৭-এর শেষে দেখেছিলেন, TF-IDF-এর মিল মানে শব্দের মিল, অর্থের নয়। আর পর্ব ৩৩-এ হাতে বানানো একটি পণ্য-embedding দিয়ে cosine-এ “সবচেয়ে কাছের” পণ্য খুঁজেছিলেন। এই পর্ব দুটিকে জোড়া দেয়: embedding কোথা থেকে আসে, বিপুল vector-এ কীভাবে দ্রুত খোঁজা যায়, আর খোঁজ ভালো হলো কি না, তা কীভাবে মাপবেন। চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); প্রথম তিনটি একই namespace ভাগ করে (data-shared), আর প্রথমবার scikit-learn নামতে প্রায় ১০ সেকেন্ড লাগে। Pretrained model আর FAISS-এর জন্য ডেস্কটপের সত্যিকারের run.

১ · শব্দ মেলে না, অর্থ মেলে — TF-IDF কোথায় হারে

বাজারঘরের গ্রাহকসেবা দল চায় একটি খোঁজার বাক্স: কোনো কর্মী “দেরিতে ডেলিভারি” লিখলে আগের সব দেরির অভিযোগ একসঙ্গে উঠে আসুক। এমন খোঁজকে বলে semantic search: শব্দ হুবহু মেলানো নয়, অর্থ মেলানো। “দেরিতে এসেছে” আর “সময়মতো পৌঁছায়নি” একই অভিযোগের দুটি paraphrase, কিন্তু দুটিতে একটি শব্দও এক নয়।

এই পর্বের জন্য তিনটি ছোট কাল্পনিক ফাইল পাতার ভেতরে রাখা: corpus.csv-এ ১০টি বিষয়ে (দেরি, ভাঙা, দাম, মাপ, রিফান্ড, ভুল পণ্য, ব্যাটারি, রং ওঠা, রাইডারের ব্যবহার, তাজা খাবার) ৩টি করে মোট ৩০টি রিভিউ, যার দুটি Banglish-এ; background.txt-এ ৩৮টি label-ছাড়া ছোট বাক্য, শুধু অংশ ৩-এ প্রসঙ্গ শেখার জন্য; আর queries.csv-এ ২০টি প্রশ্ন, প্রতি বিষয়ে দুটি, অংশ ৪-এর মূল্যায়নের জন্য। বিষয়ের নাম কোডে ইংরেজিতে (late, broken, …)।

প্রথম ব্লকটি পর্ব ৬৭-এর বাংলা-বান্ধব tokenizer আর TfidfVectorizer দিয়ে সব লেখার (৩৮ + ৩০) TF-IDF বানায়, তারপর শুধু ৩০টি রিভিউয়ের মধ্যে একটি প্রশ্ন খোঁজে। প্রতিটি সারির L2 দৈর্ঘ্য ১, তাই dot product-ই cosine similarity.

import re
import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer

D = pd.read_csv("corpus.csv")                      # খোঁজার 30টি রিভিউ, 10টি বিষয়
B = [b for b in open("background.txt", encoding="utf-8").read().split("\n") if b]
BN = f"{chr(0x0980)}-{chr(0x09FF)}"                # বাংলা Unicode block (পর্ব ৬৭)
TOK = re.compile(rf"[\w{BN}]+")
def tok(t): return TOK.findall(t.lower())

vec = TfidfVectorizer(tokenizer=tok, token_pattern=None)
A = vec.fit_transform(B + list(D["text"])).toarray()   # 38 + 30 = 68টি লেখা
X = A[len(B):]                                     # শুধু খোঁজার 30টি রিভিউ
print("A", A.shape, "| X", X.shape, f"| X-এর শূন্য ঘর {(X == 0).mean():.1%}")

def show(scores, k=4):
    for i in np.argsort(-scores, kind="stable")[:k]:
        print(f"  {scores[i]:.3f}  {D['topic'][i]:<7} {D['text'][i]}")

q = "আমার অর্ডার দেরিতে এসেছে"
s = X @ vec.transform([q]).toarray()[0]            # L2 = 1, তাই dot = cosine
print("খোঁজা:", q)
show(s)
print("#1-এর score:", s[1], "|", D["text"][1])
print("ভাগ করা শব্দ:", set(tok(q)) & set(tok(D["text"][1])))
print("শূন্য score পাওয়া রিভিউ:", int((s == 0).sum()), "টি")

A (68, 196) | X (30, 196) | X-এর শূন্য ঘর 96.5%
খোঁজা: আমার অর্ডার দেরিতে এসেছে
  0.555  late    অর্ডার দেরিতে এসেছে, পাঁচ দিন অপেক্ষা করতে হলো
  0.372  wrong   লাল অর্ডার করেছিলাম, এসেছে নীল রঙের জামা
  0.200  wrong   ভুল জিনিস এসেছে, অর্ডারের সাথে মেলে না
  0.179  late    ডেলিভারি অনেক দেরিতে হলো, কথা ছিল দুই দিন, সময়মতো আসেনি
#1-এর score: 0.0 | পার্সেল সময়মতো পৌঁছায়নি, পুরো এক সপ্তাহ অপেক্ষা
ভাগ করা শব্দ: set()
শূন্য score পাওয়া রিভিউ: 26 টি

২ · One-hot থেকে sparse, তারপর dense — vector-এর তিন চেহারা

লেখাকে vector বানানোর তিনটি ধাপ, পুরোনো থেকে নতুন:

সংজ্ঞায়: embedding মানে প্রতিটি শব্দ, বাক্য বা জিনিসকে একটি নির্দিষ্ট মাত্রার dense vector দেওয়া, এমনভাবে যে অর্থে কাছাকাছি জিনিসের cosine বড় হয়। কিন্তু অর্থ যন্ত্র জানবে কীভাবে? উত্তরটি এসেছে ভাষাতত্ত্ব থেকে, distributional hypothesis নামে: যে শব্দগুলো একই রকম প্রসঙ্গে বসে, তাদের অর্থও প্রায়ই কাছাকাছি। “দেরিতে” আর “সময়মতো … না” দুটিই বসে “পার্সেল”, “অপেক্ষা”-র পাশে; “তাজা” আর “টাটকা” বসে “মাছ”, “স্বাদ”-এর পাশে। শব্দের পাশাপাশি আসা (co-occurrence) গুনলেই অর্থের একটি ছায়া পাওয়া যায়।

নিচের stepper-এর সংখ্যা ব্লক ১-এর TF-IDF আর পরের অংশের ১০ মাত্রার LSA থেকে (ডেস্কটপে একই কোডের সত্যিকারের run).

৩ · পাতাতেই embedding শেখা — truncated SVD আর LSA

“কোন শব্দ কোন প্রসঙ্গে বসে” তথ্যটি এর মধ্যেই আছে: ব্লক ১-এর matrix A, যার ৬৮টি সারি লেখা আর ১৯৬টি কলাম শব্দ। কিন্তু A বিশাল আর গোলমেলে: প্রতিটি শব্দ একটি আলাদা কলাম। আমরা চাই অল্প কয়েকটি “গোপন দিক”, যেখানে একসঙ্গে আসা শব্দগুলো একই দিকে পড়ে। এটিই পর্ব ৬৫-এর PCA-র ভাবনা, আর হাতিয়ারও একই: SVD.

A = U · diag(S) · V^T

এখানে S হলো singular value-এর তালিকা, বড় থেকে ছোট; V^T-এর প্রতিটি সারি শব্দের জগতে একটি দিক; U-র প্রতিটি সারি একটি লেখা সেই দিকগুলোতে কতটা আছে। শুধু প্রথম k-টি দিক রাখলে (truncated SVD) পাওয়া যায় A-র সবচেয়ে ভালো k-মাত্রার কাছাকাছি রূপ (Eckart–Young উপপাদ্য)। তখন P = V_k (V^T-এর প্রথম k সারি, ঘুরিয়ে কলাম), যেকোনো লেখার TF-IDF vector × P = তার k-মাত্রার embedding, আর P-এর সারি × S হলো শব্দের embedding. শব্দ-নথি matrix-এ এই পদ্ধতির নাম latent semantic analysis (LSA).

পরের ব্লক k = ১০ নিয়ে LSA চালায়, চারটি শব্দের সবচেয়ে কাছের শব্দ দেখায়, তারপর stepper-এর দুই বাক্য আর ব্লক ১-এর প্রশ্নটি নতুন vector দিয়ে আবার খোঁজে। ব্লকটি ব্লক ১-এর A, vec, show আর q ব্যবহার করে।

import numpy as np

U, S, Vt = np.linalg.svd(A, full_matrices=False)   # A = U · diag(S) · Vt
print("U", U.shape, "S", S.shape, "Vt", Vt.shape)
print("প্রথম 12টি singular value:", S[:12].round(3))
k = 10
P = Vt[:k].T                                      # (196, 10): TF-IDF থেকে 10 মাত্রায়
W = P * S[:k]                                     # প্রতিটি শব্দের 10-মাত্রার vector
W = W / np.linalg.norm(W, axis=1, keepdims=True)
words = list(vec.get_feature_names_out())
for w in ["দেরিতে", "ভাঙা", "দাম", "তাজা"]:
    sim = W @ W[words.index(w)]
    near = [j for j in np.argsort(-sim, kind="stable") if words[j] != w][:4]
    print(f"{w:<7} →", ", ".join(f"{words[j]} {sim[j]:.3f}" for j in near))

def embed(texts):                                 # নতুন লেখা: TF-IDF, তারপর P, তারপর L2
    E = vec.transform(texts).toarray() @ P
    n = np.linalg.norm(E, axis=1, keepdims=True)
    return np.divide(E, n, out=np.zeros_like(E), where=n > 1e-9)   # প্রায় 0 হলে 0

Dk = embed(D["text"])                             # 30টি রিভিউয়ের dense vector
print("শূন্য vector:", [D["text"][i][:22] for i in np.flatnonzero(~Dk.any(axis=1))])
a, b = embed(["দেরিতে এসেছে", "সময়মতো পৌঁছায়নি"])
np.set_printoptions(precision=2, suppress=True, linewidth=60)
print("a =", a, "\nb =", b)
print("cos(a, b) =", round(float(a @ b), 3))
print("খোঁজা:", q)
show(Dk @ embed([q])[0])

U (68, 68) S (68,) Vt (68, 196)
প্রথম 12টি singular value: [1.799 1.697 1.666 1.64  1.557 1.537 1.501 1.483 1.476 1.409 1.359 1.352]
দেরিতে  → আসেনি 0.996, দিন 0.981, সময়মতো 0.976, এল 0.963
ভাঙা    → ফাটা 0.996, কাপ 0.991, কাপও 0.984, বাক্সে 0.984
দাম     → কিনতাম 0.989, মূল্য 0.989, একটু 0.988, কম 0.988
তাজা    → স্বাদ 0.999, আম 0.999, মিষ্টি 0.999, একদম 0.996
শূন্য vector: ['refund ekhono paini, d', 'battery khub durbol, d', 'rider bhai khub binoyi']
a = [-0.6   0.29 -0.32  0.07 -0.25  0.26 -0.35 -0.03 -0.42
 -0.15] 
b = [-0.39  0.08 -0.17  0.36 -0.53  0.05 -0.43  0.16 -0.4
  0.14]
cos(a, b) = 0.777
খোঁজা: আমার অর্ডার দেরিতে এসেছে
  0.924  late    অর্ডার দেরিতে এসেছে, পাঁচ দিন অপেক্ষা করতে হলো
  0.748  wrong   লাল অর্ডার করেছিলাম, এসেছে নীল রঙের জামা
  0.723  late    পার্সেল সময়মতো পৌঁছায়নি, পুরো এক সপ্তাহ অপেক্ষা
  0.632  late    ডেলিভারি অনেক দেরিতে হলো, কথা ছিল দুই দিন, সময়মতো আসেনি

৪ · খোঁজা কতটা ভালো হলো — recall@k আর MRR

একটি উদাহরণে ভালো দেখানো কিছুই প্রমাণ করে না। খোঁজের মান মাপতে লাগে একটি label দেওয়া প্রশ্ন-তালিকা: প্রতিটি প্রশ্নের জন্য আগে থেকে ঠিক করা, কোন নথিগুলো প্রাসঙ্গিক। আমাদের queries.csv-এ ২০টি প্রশ্ন, প্রতিটির প্রাসঙ্গিক উত্তর একই বিষয়ের ৩টি রিভিউ। Information retrieval-এর দুটি বহুল ব্যবহৃত মাপ:

• Recall@k = (প্রথম k ফলে কতগুলো প্রাসঙ্গিক) ÷ (মোট প্রাসঙ্গিক)। আমাদের ৩টি প্রাসঙ্গিক, তাই recall@3-এর মান ০, ০.৩৩, ০.৬৭ বা ১. পর্ব ৬০-এর recall-এর মতোই, শুধু তালিকার প্রথম k-টিতে সীমিত।
• MRR (mean reciprocal rank): প্রতিটি প্রশ্নে প্রথম প্রাসঙ্গিক ফলটি কত নম্বরে (r), তার উল্টো 1/r; তারপর সব প্রশ্নের গড়। প্রথমেই ঠিক ফল হলে ১, দ্বিতীয়তে ০.৫, তৃতীয়তে ০.৩৩. যিনি শুধু প্রথম ঠিক উত্তরটি চান, তাঁর অভিজ্ঞতা এটি মাপে।

এবার একই হিসাব কোডে, ২০টি প্রশ্নে, TF-IDF আর কয়েকটি k-এর LSA-র জন্য। ব্লকটি ব্লক ১ আর ২-এর D, X, vec, Vt ব্যবহার করে। সমতায় (kind="stable") আগের সারির রিভিউ আগে আসে, যাতে ফল প্রতিবার এক থাকে।

import numpy as np
import pandas as pd

Q = pd.read_csv("queries.csv")       # 20টি প্রশ্ন; ঠিক উত্তর = একই বিষয়ের 3টি রিভিউ
def evaluate(score_fn, k=3):
    rec, rr = [], []
    for topic, q in zip(Q["topic"], Q["query"]):
        order = np.argsort(-score_fn(q), kind="stable")
        rel = set(np.flatnonzero(D["topic"] == topic).tolist())
        rec.append(len(rel & set(order[:k].tolist())) / len(rel))   # recall@k
        first = next(r for r, i in enumerate(order, 1) if i in rel)
        rr.append(1 / first)                                      # reciprocal rank
    return np.array(rec), np.array(rr)

def unit(E):                                       # সারি L2 = 1; প্রায় শূন্য সারি 0-ই থাকে
    n = np.linalg.norm(E, axis=-1, keepdims=True)
    return np.divide(E, n, out=np.zeros_like(E), where=n > 1e-9)

def lsa_scorer(kk):
    Pk = Vt[:kk].T
    Dn = unit(X @ Pk)
    return lambda q: Dn @ unit(vec.transform([q]).toarray()[0] @ Pk)

tf = evaluate(lambda q: X @ vec.transform([q]).toarray()[0])
print(f"TF-IDF     recall@3 {tf[0].mean():.3f}  MRR {tf[1].mean():.3f}")
for kk in (5, 10, 20, 40):
    r = evaluate(lsa_scorer(kk))
    print(f"LSA k={kk:<4} recall@3 {r[0].mean():.3f}  MRR {r[1].mean():.3f}")
ls = evaluate(lsa_scorer(10))
print("\nযেখানে recall@3 বদলেছে (TF-IDF → LSA k=10):")
for q, a, b in zip(Q["query"], tf[0], ls[0]):
    if a != b:
        print(f"  {a:.2f} → {b:.2f}  {q}")

TF-IDF     recall@3 0.550  MRR 0.883
LSA k=5    recall@3 0.550  MRR 0.788
LSA k=10   recall@3 0.733  MRR 0.929
LSA k=20   recall@3 0.617  MRR 0.942
LSA k=40   recall@3 0.600  MRR 0.942

যেখানে recall@3 বদলেছে (TF-IDF → LSA k=10):
  0.67 → 0.33  পণ্য আসতে অনেক দেরি হলো
  0.67 → 0.33  ডেলিভারি সময়মতো হয়নি
  0.67 → 1.00  জিনিস ভাঙা অবস্থায় এসেছে
  0.33 → 0.00  কাপ ফেটে গেছে
  0.33 → 1.00  দাম খুব চড়া
  0.33 → 1.00  মাপে বড় হয়েছে
  0.67 → 1.00  সাইজ ঠিক হয়নি
  0.33 → 0.67  রিফান্ড দিচ্ছে না
  0.33 → 1.00  যা চেয়েছি তা পাঠায়নি
  0.33 → 0.67  ব্যাটারি তাড়াতাড়ি শেষ
  0.67 → 1.00  ধোয়ার পর রং চলে গেছে
  0.33 → 0.67  ডেলিভারি ম্যানের আচরণ ভালো
  0.67 → 1.00  মাছ টাটকা ছিল
  0.67 → 1.00  সবজির স্বাদ ভালো

৫ · Pretrained sentence embedding — ডেস্কটপে সত্যিকারের run

বাস্তবে লক্ষ-কোটি বাক্যে আগেই শেখানো একটি pretrained model নামিয়ে ব্যবহার করা হয়, যা প্রতিটি বাক্যের জন্য একটি vector দেয়: sentence embedding. এমন model সাধারণত transformer-ভিত্তিক, আর শেখে contrastive learning দিয়ে: মিল থাকা জোড়ার vector কাছে, এলোমেলো জোড়ার দূরে। Nils Reimers আর Iryna Gurevych-এর ২০১৯ সালের Sentence-BERT প্রবন্ধ এই ধারাকে জনপ্রিয় করে, আর sentence-transformers library সেখান থেকেই।

কোন model, কেন, আর লাইসেন্স

বাছাইয়ের শর্ত ছিল: ছোট, ল্যাপটপের CPU-তে চলে, account বা token ছাড়া নামানো যায়, খোলা লাইসেন্স, আর model card-এ বাংলার উল্লেখ। বেছে নেওয়া হয়েছে Hugging Face Hub-এর intfloat/multilingual-e5-small. লেখার সময়ে তার model card যা বলে (নিজে পড়ে যাচাই করা):

• ভাষা: metadata-য় ৯৪টি ভাষার তালিকা, তাতে bn (বাংলা) আছে। Banglish-এর কোনো আলাদা উল্লেখ নেই।
• আকার: ১২টি স্তর, embedding-এর মাপ ৩৮৪; microsoft/Multilingual-MiniLM-L12-H384 থেকে শুরু করা। Weight ফাইল model.safetensors প্রায় ৪৭১ MB.
• লাইসেন্স: metadata-য় license: mit. Repo-তে আলাদা LICENSE ফাইল নেই, তাই MIT-এর মানক লেখাটি পড়ে নেওয়া হয়েছে: ব্যবহার, বদল আর বিতরণের অনুমতি, শর্ত হলো copyright ও লাইসেন্সের লেখা সঙ্গে রাখা, আর কোনো warranty নেই (MIT License). Model যে ডেটায় শেখানো, তার নিজস্ব শর্ত আলাদা প্রশ্ন; card-এ তার বিস্তারিত তালিকা নেই।
• ব্যবহারের নিয়ম: খোঁজার কাজে প্রশ্নের আগে "query: " আর নথির আগে "passage: " জুড়তে হবে, নইলে card অনুযায়ী মান কমে। আর FAQ-তে লেখা, cosine score সাধারণত ০.৭ থেকে ১.০-এর মধ্যে থাকে, কারণ training-এ খুব কম temperature (০.০১) ব্যবহার হয়েছে; গুরুত্বপূর্ণ হলো score-এর ক্রম, মান নয়।
• সীমা: লম্বা লেখা ৫১২ token-এ কেটে ফেলা হয়। Card-এর উদ্ধৃতি: Liang Wang ও সহকর্মী, “Multilingual E5 Text Embeddings: A Technical Report”, ২০২৪.

Model card আর লাইসেন্স পড়ার পুরো অভ্যাস পর্ব ৭১ (Pretrained model ব্যবহার — Hugging Face, model card আর লাইসেন্স)-এ। এখানে নির্দিষ্ট reproducibility-র জন্য model-এর revision (commit) পিন করা হয়েছে।

~/bazarghar-ai$ python -m venv .venv
~/bazarghar-ai$ .venv/bin/python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
~/bazarghar-ai$ .venv/bin/python -m pip install sentence-transformers faiss-cpu scikit-learn pandas

from sentence_transformers import SentenceTransformer
MODEL, REV = "intfloat/multilingual-e5-small", "614241f622f53c4eeff9890bdc4f31cfecc418b3"
m = SentenceTransformer(MODEL, revision=REV, device="cpu")
P = m.encode(["passage: " + t for t in D.text], normalize_embeddings=True)   # (30, 384)
def qemb(texts):
    return m.encode(["query: " + t for t in texts], normalize_embeddings=True)
# … TF-IDF আর LSA k=10: পাতার ব্লক ১–৩-এর হুবহু কোড; একই evaluate()
res = {"TF-IDF": evaluate(tfidf), "LSA k=10": evaluate(lsa),
       "e5-small": evaluate(lambda q: P @ qemb([q])[0])}

~/bazarghar-ai$ python st_search.py
Python 3.14.4, torch 2.15.0+cpu, sentence-transformers 6.2.0, scikit-learn 1.9.1
model intfloat/multilingual-e5-small rev 614241f | dim 384
P (30, 384) float32 | ‖row‖ [1. 1. 1.] | 3 ms/review
TF-IDF    recall@3 0.550  MRR 0.883
LSA k=10  recall@3 0.733  MRR 0.929
e5-small  recall@3 0.617  MRR 0.835
per query recall@3 (TF-IDF / LSA / e5):
  0.67 0.33 0.67  পণ্য আসতে অনেক দেরি হলো
  0.67 0.33 0.67  ডেলিভারি সময়মতো হয়নি
  0.67 1.00 0.33  জিনিস ভাঙা অবস্থায় এসেছে
  0.33 0.00 0.67  কাপ ফেটে গেছে
  0.33 1.00 1.00  দাম খুব চড়া
  …
  0.33 0.67 0.00  রিফান্ড দিচ্ছে না
  1.00 1.00 0.33  অন্য রঙের জিনিস এসেছে
  …
  0.67 1.00 0.33  মাছ টাটকা ছিল
  0.67 1.00 1.00  সবজির স্বাদ ভালো

আমার অর্ডার দেরিতে এসেছে   (সব 30টির score 0.747–0.859)
  0.859 late    অর্ডার দেরিতে এসেছে, পাঁচ দিন অপেক্ষা করতে হলো
  0.850 refund  ফেরত দেওয়ার পর রিফান্ড আসতে দেরি হচ্ছে
  0.831 wrong   ভুল জিনিস এসেছে, অর্ডারের সাথে মেলে না
  … #1 'সময়মতো পৌঁছায়নি' : score 0.799, rank 14

delivery onek deri hoise   (সব 30টির score 0.754–0.810)
  0.810 refund  refund ekhono paini, dui shoptaho hoye gelo
  0.808 battery battery khub durbol, druto shesh hoye jay
  0.804 rider   ডেলিভারি ম্যান খুব ভদ্র, হাসিমুখে পণ্য দিয়ে গেলেন

…

taka ferot chai   (সব 30টির score 0.761–0.814)
  0.814 size    সাইজ মেলেনি, জামা গায়ে আঁটসাঁট
  0.810 battery battery khub durbol, druto shesh hoye jay
  0.810 size    মাপ ঠিক নেই, সাইজ চার্ট ভুল

মাছ পচা ছিল   (সব 30টির score 0.737–0.847)
  0.847 fresh   মাছ একদম তাজা, স্বাদ দারুণ
  0.807 fade    একবার ধোয়ার পর রং উঠে গেছে
  0.797 fade    কাপড় ফ্যাকাশে হয়ে গেল, মান খারাপ

দাম সস্তা, খুশি   (সব 30টির score 0.781–0.857)
  0.857 price   দাম অনেক বেশি, বাজারে কম টাকায় পাওয়া যায়
  0.857 fresh   মাছ একদম তাজা, স্বাদ দারুণ
  0.855 price   মূল্য বেশি মনে হলো, দাম একটু কমানো উচিত

সত্যিকারের run, লেখার সময়ের version-এ (CPU only, transformers 5.22.1, huggingface_hub 2.4.0); কিছু লাইন “…” দিয়ে বাদ। প্রথমবার নামানোর সময় library সতর্ক করেছিল যে token ছাড়া গতির সীমা কম; এই খোলা model-এ token লাগেনি, দিইনি। পরের run HF_HUB_OFFLINE=1 দিয়ে, cache থেকে।

ফল যা বলে:

• গড়ে e5 TF-IDF-এর চেয়ে ভালো, LSA-র চেয়ে খারাপ (recall@3 ০.৬১৭ বনাম ০.৫৫০ আর ০.৭৩৩)। LSA পেয়েছিল এই প্রশ্নের জন্য সাজানো ডেটা আর k; e5 সংগ্রহটির কিছুই দেখেনি। ২০টি প্রশ্নে একটি প্রশ্নের এক ধাপ বদল মানে গড়ে ০.০১৭, তাই পার্থক্যগুলো দুর্বল প্রমাণ।
• যেখানে e5 জেতে: “কাপ ফেটে গেছে” (TF-IDF ০.৩৩, LSA ০, e5 ০.৬৭): subword tokenizer আর বিপুল লেখা থেকে “ফেটে”/“ফাটা”-র সম্পর্ক এসেছে বলে মনে হয়।
• যেখানে হারে: “রিফান্ড দিচ্ছে না”-এ ০; আর “সময়মতো পৌঁছায়নি” ৩০টির মধ্যে ১৪ নম্বরে (০.৭৯৯)।
• সংকীর্ণ score: সব প্রশ্ন মিলিয়ে ৩০টির score ০.৭৪–০.৯২-এর মধ্যে (ওপরের প্রশ্নে ০.৭৪৭–০.৮৫৯), card যেমন বলেছিল। তাই “০.৮-এর বেশি হলে প্রাসঙ্গিক” ধরনের সীমা অর্থহীন।
• Banglish দুর্বল: “delivery onek deri hoise” আর “taka ferot chai”-এর প্রথম ফলগুলো ভুল; model যেন লিপির মিলকে অর্থের চেয়ে বেশি টানে। Card-এ বাংলা আছে, Banglish নেই।
• বিপরীত অর্থ কাছাকাছি: “মাছ পচা ছিল”-এর প্রথম ফল “মাছ একদম তাজা” (০.৮৪৭)। বিষয় মিলেছে, মনোভাব উল্টো; খোঁজে এটি চলে, কিন্তু embedding-এর মিলকে মনোভাবের মিল ভাববেন না।

৬ · Vector search-এর যন্ত্র — normalise, dot, top-k আর খরচ

খোঁজার যন্ত্রের দুটি পর্যায়: একবার সব নথির vector বানিয়ে রাখা (index), তারপর প্রতিটি প্রশ্নের vector বানিয়ে সবচেয়ে কাছেরগুলো খোঁজা। ছবির সবচেয়ে জরুরি অংশ মাঝের লাল দাগ: দুই পর্যায়ে একই model, একই version.

Normalise করলে cosine = dot. পর্ব ৩৩-এর সূত্র cos θ = (a·b) / (‖a‖ ‖b‖). সব vector আগেই unit vector করে রাখলে হর ১, তাই n-টি cosine মানে একটি matrix-vector গুণ X @ q: প্রতিটি সারির জন্য d-টি গুণ আর যোগ। মোট খরচ প্রতি প্রশ্নে O(n·d) (time complexity), আর মেমরি n·d·৪ byte (float32-এ প্রতিটি সংখ্যা ৪ byte).

Top-k বাছাই। সব n-টি score সাজালে লাগে O(n log n). কিন্তু আমাদের চাই শুধু সেরা k-টি। দুটি পথ: NumPy-র argpartition, যা গড়ে O(n) সময়ে সেরা k-টিকে আলাদা করে (ভেতরের ক্রম ছাড়া), তারপর শুধু সেই k-টি সাজানো; অথবা আকারে k-এর একটি min-heap, যার মাথায় সবসময় এখন পর্যন্ত সেরা k-এর সবচেয়ে দুর্বলটি থাকে। নতুন score তার চেয়ে বড় হলে বদল, নইলে বাদ। খরচ O(n log k), আর মেমরিতে মাত্র k-টি। Heap-এর গঠন বিস্তারিত দেখুন DSA কোর্সের heap পর্বে; Python-এ heapq.

পরের ব্লক বড় মাপে একই কাজ করে: ২০,০০০টি এলোমেলো ৩৮৪-মাত্রার float32 vector (e5-small-এর মাপে), normalise, X @ q, argpartition, আর পুরো argsort-এর সঙ্গে সময়ের তুলনা। সময় মাপা হয়েছে সাতবারের মধ্যে সবচেয়ে কম দিয়ে, যাতে প্রথম-বারের বাড়তি খরচ বাদ যায়। এই ব্লক আগের ব্লকগুলোর namespace ব্যবহার করে না।

import time
import numpy as np

n, d, k = 20_000, 384, 5
rng = np.random.default_rng(42)
X = rng.standard_normal((n, d), dtype=np.float32)     # 20,000টি এলোমেলো "embedding"
X /= np.linalg.norm(X, axis=1, keepdims=True)         # প্রতিটি সারি unit vector
q = X[123] + 0.5 * rng.standard_normal(d, dtype=np.float32) / np.sqrt(d)
q /= np.linalg.norm(q)                                # query: #123-এর কাছের একটি বিন্দু

def ms(f, r=7):                                       # r বারের মধ্যে সবচেয়ে কম সময়
    best = 1e9
    for _ in range(r):
        t = time.perf_counter(); f(); best = min(best, time.perf_counter() - t)
    return best * 1000

s = X @ q                                             # n টি dot product = n টি cosine
top = np.argpartition(-s, k)[:k]                      # সেরা k-টি, ক্রম ছাড়া, গড়ে O(n)
top = top[np.argsort(-s[top])]                        # শুধু k-টিকে সাজানো
print("dtype", X.dtype, "| shape", X.shape, "| X.nbytes", X.nbytes)
print("top-5:", top.tolist(), "\ncosine:", s[top].round(3).tolist())
print("পুরো argsort-এর সঙ্গে মেলে?", np.array_equal(top, np.argsort(-s)[:k]))
print(f"X @ q {ms(lambda: X @ q):.2f} ms | argpartition {ms(lambda: np.argpartition(-s, k)):.2f} ms"
      f" | argsort {ms(lambda: np.argsort(-s)):.2f} ms")
c = (X[200:] @ X[:200].T).ravel()                     # এলোমেলো জোড়ার cosine কেমন?
print(f"এলোমেলো জোড়ার cosine: গড় {c.mean():.4f}, sd {c.std():.4f}, সর্বোচ্চ {c.max():.3f}")
print(f"1/√d = {1 / np.sqrt(d):.4f}")
for N in (20_000, 10**6):
    print(f"n = {N:>9,}: গুণ-যোগ {N * d:>11,} প্রতি query | মেমরি {N * d * 4 / 1e6:,.1f} MB")

dtype float32 | shape (20000, 384) | X.nbytes 30720000
top-5: [123, 13592, 520, 5480, 16836] 
cosine: [0.885, 0.195, 0.195, 0.186, 0.184]
পুরো argsort-এর সঙ্গে মেলে? True
X @ q 9.40 ms | argpartition 0.30 ms | argsort 1.30 ms
এলোমেলো জোড়ার cosine: গড় 0.0000, sd 0.0510, সর্বোচ্চ 0.252
1/√d = 0.0510
n =    20,000: গুণ-যোগ   7,680,000 প্রতি query | মেমরি 30.7 MB
n = 1,000,000: গুণ-যোগ 384,000,000 প্রতি query | মেমরি 1,536.0 MB

৭ · Approximate nearest neighbour — HNSW, IVF আর vector database

প্রতি প্রশ্নে ১০ লাখ dot product অনেক কাজে চলে যায়, কিন্তু কোটি vector আর প্রতি সেকেন্ডে শত প্রশ্নে brute-force search ধীর আর দামি। Approximate nearest neighbour (ANN) পদ্ধতি একটি সৎ লেনদেন করে: সব vector না দেখে “প্রায় সবচেয়ে কাছের”গুলো খোঁজে। মূল্য দিতে হয় recall-এ: প্রকৃত সেরা k-এর কিছু হারাতে পারে। দুটি প্রধান ধারণা:

দুটিকে বলে HNSW আর IVF index. বড় মাপে vector-গুলো product quantization-এর মতো কৌশলে চাপা দেওয়া হয়, যাতে মেমরি কমে, কিছু নির্ভুলতার বিনিময়ে। ডেস্কটপে FAISS (Meta-র গবেষকদের খোলা library) দিয়ে তিনটি index-এর তুলনা: সত্যিকারের নির্ভুল উত্তর (IndexFlatIP, অর্থাৎ brute-force inner product) থেকে recall@10 মাপা, আর প্রতি প্রশ্নের গড় সময়। ১ লাখ ৩৮৪-মাত্রার vector, ২০০টি প্রশ্ন, এক thread, দুই রকম ডেটা: ২০০টি গুচ্ছে জড়ো হওয়া (আসল embedding-এর কাছাকাছি একটি অনুমান) আর একেবারে এলোমেলো।

faiss.omp_set_num_threads(1)                      # সব index এক thread-এ, তুলনা ন্যায্য
faiss.normalize_L2(X); faiss.normalize_L2(Q)      # এখন inner product = cosine
flat = faiss.IndexFlatIP(d); flat.add(X)          # নির্ভুল উত্তর
hnsw = faiss.IndexHNSWFlat(d, 32, faiss.METRIC_INNER_PRODUCT); hnsw.add(X)
hnsw.hnsw.efSearch = 64
ivf = faiss.IndexIVFFlat(faiss.IndexFlatIP(d), d, 316, faiss.METRIC_INNER_PRODUCT)
ivf.train(X); ivf.add(X)                          # train = k-means, 316টি দল
ivf.nprobe = 8

~/bazarghar-ai$ python ann_bench.py        # 200টি গুচ্ছে জড়ো হওয়া vector
Python 3.14.4, numpy 2.5.4, faiss 1.15.1
exact  IndexFlatIP          recall@10 1.000  8.077 ms/query
HNSW build (M=32): 8.4 s
HNSW   efSearch=16           recall@10 0.916  0.063 ms/query
HNSW   efSearch=64           recall@10 0.982  0.110 ms/query
HNSW   efSearch=256          recall@10 0.989  0.247 ms/query
IVF build (nlist=316, k-means): 0.8 s
IVF    nprobe=1              recall@10 0.863  0.046 ms/query
IVF    nprobe=8              recall@10 1.000  0.214 ms/query
IVF    nprobe=32             recall@10 1.000  0.849 ms/query
memory: X 153.6 MB (n*d*4)

~/bazarghar-ai$ python ann_random.py       # একই কোড, গুচ্ছহীন এলোমেলো vector
Python 3.14.4, numpy 2.5.4, faiss 1.15.1
exact  IndexFlatIP          recall@10 1.000  8.226 ms/query
HNSW build (M=32): 35.5 s
HNSW   efSearch=16           recall@10 0.056  0.139 ms/query
HNSW   efSearch=64           recall@10 0.144  0.479 ms/query
HNSW   efSearch=256          recall@10 0.394  1.710 ms/query
IVF build (nlist=316, k-means): 0.8 s
IVF    nprobe=1              recall@10 0.019  0.035 ms/query
IVF    nprobe=8              recall@10 0.085  0.228 ms/query
IVF    nprobe=32             recall@10 0.255  0.841 ms/query
memory: X 153.6 MB (n*d*4)

সত্যিকারের run, একবার; সময় যন্ত্রভেদে বদলাবে, অনুপাতই দেখার জিনিস। গুচ্ছবদ্ধ ডেটায় HNSW efSearch=64-এ recall@10 ০.৯৮২, সময় ৮.০৭৭ থেকে ০.১১০ ms, প্রায় ৭০ গুণ দ্রুত; IVF nprobe=8-এ নির্ভুল উত্তরই (১.০০০), কারণ দলগুলো স্পষ্ট আলাদা। এলোমেলো ডেটায় একই সেটিংয়ে HNSW ০.১৪৪, IVF ০.০৮৫. কারণ ব্লক ৪-এ দেখা: এলোমেলো উঁচু মাত্রায় সবাই সবার থেকে প্রায় সমান দূরে, তাই graph বা দল কোনো শর্টকাট দিতে পারে না।

কোটি vector রাখা, নতুন রিভিউ যোগ, মোছা, metadata দিয়ে ছাঁকা (“শুধু ঢাকার, গত মাসের”), আর ব্যাকআপ: এসব নিয়ে কাজ করে vector database, বা PostgreSQL-এর pgvector-এর মতো extension. ডেটাবেসের দিক থেকে বিস্তারিত, IVF, HNSW আর product quantization-সহ, আছে DBMS কোর্সের vector database পর্বে। বাজারঘরের কয়েক হাজার রিভিউয়ে অবশ্য ব্লক ৪-এর brute-force-ই যথেষ্ট।

৮ · বাস্তবে চালাতে — hybrid search, version, গোপনীয়তা, bias আর RAG

Hybrid search: দুই খোঁজ একসঙ্গে

অংশ ৫ দেখিয়েছে, embedding কখনো হারায় যেখানে শব্দ মেলানো জেতে: পণ্যের কোড, বিরল নাম, “রিফান্ড”-এর মতো নির্দিষ্ট শব্দ। তাই বাস্তব ব্যবস্থায় প্রায়ই hybrid search: শব্দভিত্তিক তালিকা (TF-IDF বা BM25, ১৯৯০-এর দশকে Stephen Robertson ও সহকর্মীদের Okapi ব্যবস্থা থেকে) আর embedding-এর তালিকা মেলানো হয়। একটি সহজ পদ্ধতি reciprocal rank fusion (Cormack, Clarke আর Büttcher, ২০০৯): প্রতিটি নথির score = ∑ 1/(60 + তালিকায় তার অবস্থান). শুধু অবস্থান লাগে বলে score-এর আলাদা মাপ (TF-IDF ০–১, e5 ০.৭–১) সমস্যা নয়। এটি এখানে চালানো হয়নি।

একই model, একই version

দুটি ভিন্ন model-এর vector একই জগতে থাকে না, মাত্রা সমান হলেও। LSA-তেও তাই: background বদলে SVD আবার চালালে P বদলায়, পুরোনো Dk অচল। এর নাম embedding drift. নিয়মগুলো:

• Index আর প্রশ্নে হুবহু একই model, একই revision, একই উপসর্গ (“passage: ”/“query: ”), একই normalization.
• প্রতিটি index-এর সঙ্গে model-এর নাম, revision, মাত্রা আর তৈরির তারিখ লিখে রাখা; model বদলালে পুরো index নতুন করে বানানো।
• নতুন model আনার আগে দুটির recall@k একই প্রশ্ন-তালিকায় তুলনা করা।
• Library version বদলালেও ফল সামান্য বদলাতে পারে (e5-এর card নিজেই বলে); একটি “পরিচিত বাক্য → পরিচিত vector” পরীক্ষা রাখুন।

গোপনীয়তা: embedding লেখার ছায়া বহন করে

Embedding দেখতে শুধু সংখ্যা, কিন্তু গবেষণা সতর্ক করে: Congzheng Song আর Ananth Raghunathan ২০২০ সালে দেখান যে embedding থেকে মূল লেখার কিছু শব্দ আর বৈশিষ্ট্য আন্দাজ করা যায়, আর John Morris ও সহকর্মীরা ২০২৩ সালে কিছু model-এর embedding থেকে ছোট লেখার অনেকটাই ফিরিয়ে আনার পদ্ধতি দেখান (embedding inversion). কতটা ফেরানো যায় তা model আর লেখাভেদে বদলায়, আর এই model-এ বা বাংলায় আমরা তা মাপিনি। তবু নিরাপদ অনুমান: ব্যক্তিগত তথ্যসহ রিভিউয়ের embedding-কে মূল লেখার মতোই গোপন ধরুন, আর সম্ভব হলে embedding-এর আগেই ব্যক্তিগত তথ্য মুছুন। বাইরের API-তে embedding বানালে লেখাটি সেই সেবার কাছে যায়; এই পর্বে model তাই নিজের যন্ত্রেই চালানো।

Bias: জ্যামিতি সমাজের ছাপও ধরে

পর্ব ৩৩-এর analogy-র আলোচনায় দেখেছেন, word embedding-এ পেশার সঙ্গে লিঙ্গের stereotype পাওয়া গেছে (Bolukbasi ও সহকর্মী, ২০১৬)। Aylin Caliskan ও সহকর্মীরা ২০১৭ সালে (Science) cosine-ভিত্তিক একটি পক্ষপাত-মাপ দিয়ে একই ধরনের ছাপ দেখান। Sentence embedding-ও শেখা ডেটার প্রতিফলন, তাই bias থাকতে পারে; বাংলায় তা কতটা, তার মাপ আমাদের কাছে নেই। বাজারঘরের বাস্তব প্রশ্ন: Banglish বা আঞ্চলিক বানানে লেখা অভিযোগ কি কম খুঁজে পাওয়া যায়? অংশ ৫-এর ফল বলে সম্ভবত হ্যাঁ, মানে কিছু গ্রাহকের অভিযোগ কম গুরুত্ব পায়। দলভিত্তিক মাপ আর নথিপত্র পর্ব ৭২ (দায়িত্বশীল AI-এর অভ্যাস — bias যাচাই, গোপনীয়তা আর নথিপত্র)-এ।

RAG-এর প্রথম ধাপ

RAG (retrieval-augmented generation) নকশায় প্রশ্নের embedding দিয়ে প্রাসঙ্গিক কয়েকটি নথি খুঁজে প্রশ্নের সঙ্গে ভাষা model-কে দেওয়া হয়। প্রথম অর্ধেক হুবহু এই পর্ব, তাই এখানকার প্রতিটি দুর্বলতা RAG-এ ঢোকে: খোঁজ ভুল নথি আনলে উত্তরও ভুলের ওপর দাঁড়ায়। বাকি অর্ধেক পর্ব ৭০ (LLM কীভাবে কাজ করে — token, পরের শব্দের অনুমান আর সীমা)-এ।

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

“বাংলা রিভিউয়ের জন্য semantic search বানিয়ে দাও” বললে AI assistant কয়েক লাইনে কোড দেয়, যা চলে আর ফল দেখায়। দেখতে ভালো ফলের নিচে ভুলগুলো প্রায়ই নীরব:

AI-এর লেখা vector search হাতে পেলে — যাচাইয়ের চেকলিস্ট

• Model-এর নাম, revision, লাইসেন্স আর ভাষার তালিকা model card-এ নিজে পড়েছি
• Index আর প্রশ্নে একই model, একই revision, একই উপসর্গ আর normalization
• Label দেওয়া প্রশ্ন-তালিকায় recall@k আর MRR মেপেছি, TF-IDF baseline-এর পাশে
• ভুল ফলগুলো একে একে পড়েছি: Banglish, বিপরীত অর্থ, বিরল শব্দ
• ANN ব্যবহার করলে flat index-এর তুলনায় recall আর সময় মেপেছি
• কোনো আসল গ্রাহকের তথ্য বাইরের সেবায় পাঠাইনি; embedding-কে গোপন ডেটা ধরেছি