Vector database — AI যুগের খোঁজ

১ · শব্দ মেলানো বনাম অর্থ মেলানো

একটি অনলাইন দোকানের সার্চ বক্সে একজন ক্রেতা লিখলেন “ফোনের চার্জার”. দোকানের ক্যাটালগে পণ্যটির নাম ইংরেজিতে — “Mobile charger 25W”. মানুষ হিসেবে আপনি এক মুহূর্তে বোঝেন, দুটি একই জিনিস। কিন্তু ডেটাবেস কী বোঝে?

এই পর্বের প্রথম ডেটাসেট একটি ছোট ক্যাটালগ — items টেবিল: item_id, title (পণ্যের নাম, কিছু বাংলায়, কিছু ইংরেজিতে), category, আর তিনটি সংখ্যা x, y, z — প্রতিটি পণ্যের একটি ছোট embedding (অংশ ২-এ ব্যাখ্যা)। আপাতত সংখ্যাগুলো বাদ রেখে সাধারণ কৌশলে খুঁজে দেখুন:

-- ক্রেতা লিখেছেন: "ফোনের চার্জার"
SELECT item_id, title FROM items WHERE title LIKE '%চার্জার%';
SELECT item_id, title FROM items WHERE title LIKE '%charger%';
SELECT item_id, title FROM items WHERE title LIKE '%ফোন%';

-- ১ম: কোনো সারি নেই
-- ২য়:
item_id │ title
1       │ Mobile charger 25W
-- ৩য়:
item_id │ title
2       │ ফোনের কভার

এই সমস্যার নাম semantic search — অর্থ দিয়ে খোঁজা। এর ভিত্তি তিনটি ধারণা: (১) প্রতিটি লেখা, ছবি বা পণ্যকে একটি সংখ্যার তালিকায় রূপান্তর, যার নাম embedding; (২) দুটি তালিকা কতটা কাছাকাছি, তা মাপার সূত্র; (৩) কোটি তালিকার মধ্যে দ্রুত কাছেরগুলো খুঁজে বের করার index. যে ডেটাবেস এই তিনটি কাজ ভালোভাবে করে, সেটিই vector database.

২ · Embedding — অর্থকে সংখ্যার তালিকায় বসানো

গণিতে vector মানে নির্দিষ্ট ক্রমে সাজানো কয়েকটি সংখ্যা, যেমন [0.70, 0.70, 0.10]. সংখ্যার সংখ্যাকে বলে dimension (মাত্রা)। দুই মাত্রার vector কাগজে একটি বিন্দু, তিন মাত্রার vector ঘরের ভেতরে একটি বিন্দু। বাস্তব embedding-এর মাত্রা সাধারণত কয়েকশো থেকে কয়েক হাজার — ৩৮৪, ৭৬৮, ১০২৪, ১৫৩৬ ইত্যাদি, মডেলভেদে।

প্রথম চেষ্টা: শব্দ গুনে vector

সবচেয়ে সরল উপায় হলো bag-of-words: সব ডকুমেন্টের প্রতিটি আলাদা শব্দ একটি মাত্রা, আর মান = শব্দটি কতবার আছে। এটি সত্যিই একটি vector, আর এর ওপর cosine হিসাবও করা যায় (অংশ ৩-এ সূত্র)। দেখা যাক “mobile charger” প্রশ্নে এটি কী দেয় — Python-এর শুধু standard library দিয়ে:

import math
from collections import Counter

def bow(text):                       # bag-of-words: শব্দ → কতবার
    return Counter(text.lower().split())

def cosine(a, b):
    dot = sum(a[w] * b[w] for w in a)
    na = math.sqrt(sum(v * v for v in a.values()))
    nb = math.sqrt(sum(v * v for v in b.values()))
    return dot / (na * nb)

docs = ["Mobile charger 25W", "phone charger fast", "mobile cover",
        "ফোনের চার্জার", "phoner charger", "cotton panjabi"]
q = bow("mobile charger")
print("vocabulary:", sorted({w for d in docs for w in bow(d)}))
for d in sorted(docs, key=lambda d: -cosine(q, bow(d))):
    print(f"{cosine(q, bow(d)):.3f}  {d}")

vocabulary: ['25w', 'charger', 'cotton', 'cover', 'fast', 'mobile', 'panjabi', 'phone', 'phoner', 'চার্জার', 'ফোনের']
0.816  Mobile charger 25W
0.500  mobile cover
0.500  phoner charger
0.408  phone charger fast
0.000  ফোনের চার্জার
0.000  cotton panjabi

শেখা embedding — মডেল যা বানায়

একটি embedding model (একটি নিউরাল নেটওয়ার্ক) বিপুল পরিমাণ লেখা থেকে শেখে কোন শব্দ বা বাক্য কোন প্রসঙ্গে আসে। “phone” আর “mobile” একই রকম বাক্যে আসে, তাই তাদের vector কাছাকাছি হয়। ২০১৩ সালে Google-এর Tomas Mikolov ও সহকর্মীদের word2vec এই চিন্তা জনপ্রিয় করে — বিখ্যাত উদাহরণ: king − man + woman-এর vector পড়ে queen-এর কাছে। পরে BERT (২০১৮)-এর মতো transformer মডেল আর Sentence-BERT (২০১৯)-এর মতো পদ্ধতি পুরো বাক্যের embedding দিতে শুরু করে। বহুভাষিক (multilingual) মডেল একই অর্থের বাংলা আর ইংরেজি বাক্যকে কাছাকাছি বসানোর চেষ্টা করে — তাই “ফোনের চার্জার” আর “mobile charger” একই এলাকায় পড়তে পারে। ছবির জন্যও embedding আছে: OpenAI-এর CLIP (২০২১) ছবি আর লেখাকে একই জায়গায় বসায়, ফলে “লাল শাড়ি” লিখে ছবি খোঁজা যায়।

এই পর্বের items টেবিলের x, y, z এমনই একটি খেলনা embedding — হাতে বানানো, যাতে হিসাব নিজে মেলানো যায়। বোঝার সুবিধার জন্য মোটামুটি ধরুন x ≈ “ডিভাইস-ভাব”, y ≈ “চার্জ-বিদ্যুৎ-ভাব”, z ≈ “পোশাক-ভাব”, আর মুদির জিনিসের মান ঋণাত্মক। প্রশ্ন “ফোনের চার্জার”-এর embedding ধরা হলো [0.70, 0.68, 0.12].

৩ · মিল মাপার তিন উপায় — cosine, dot product আর Euclidean

দুটি vector u = (u₁, …, u_d) আর v-এর জন্য তিনটি প্রচলিত মাপ:

• Dot product: u·v = u₁v₁ + u₂v₂ + … + u_dv_d. যত বড়, তত মিল। কিন্তু vector-এর দৈর্ঘ্যও এতে ঢুকে যায়।
• Cosine similarity: cos θ = u·v / (‖u‖ ‖v‖), যেখানে ‖u‖ = √(u₁² + … + u_d²) হলো দৈর্ঘ্য। শুধু দিক মাপে: −1 (উল্টো দিক) থেকে 1 (একই দিক)।
• Euclidean distance: ‖u − v‖ = √(Σ(uᵢ − vᵢ)²) — দুই বিন্দুর সোজা দূরত্ব (L2). যত ছোট, তত মিল।

তিনটি কি একই ক্রম দেয়? সবসময় নয়। নিচের ছবিতে দুই মাত্রার তিনটি vector — q = (3, 4), a = (4, 3), b = (6, 8). তারপর ধাপে ধাপে হিসাব:

এবার আসল ক্যাটালগে। এই পাতার SQLite-এ sqrt() ফাংশন আছে (SQLite ৩.৩৫ থেকে ঐচ্ছিক math function; পাতার ইঞ্জিনে চালু), তাই cosine সরাসরি SQL-এ লেখা যায়। প্রশ্নের vector একটি এক-সারির CTE q-তে রাখা হলো, আর FROM items, q প্রতিটি পণ্যের পাশে সেটি বসিয়ে দিল (cross join, পর্ব ২০):

-- প্রশ্ন "ফোনের চার্জার"-এর embedding
WITH q(qx, qy, qz) AS (VALUES (0.70, 0.68, 0.12))
SELECT title, category,
       round((x*qx + y*qy + z*qz)
             / (sqrt(x*x + y*y + z*z) * sqrt(qx*qx + qy*qy + qz*qz)), 4) AS cosine
FROM items, q
ORDER BY cosine DESC
LIMIT 5;

title               │ category    │ cosine
Mobile charger 25W  │ Electronics │ 0.9997
USB-C cable         │ Electronics │ 0.9831
Power bank 20000mAh │ Electronics │ 0.9804
সোলার ল্যাম্প       │ Home        │ 0.8636
Bluetooth headphone │ Electronics │ 0.8532

তিন মাপের পার্থক্য এই ডেটাতেও দেখা যায়, কারণ এখানে vector-গুলো normalize করা নয় (দৈর্ঘ্য 0.65 থেকে 1.0). পাঁচটি ইলেকট্রনিক্স পণ্যের তিন রকম ক্রম, window function দিয়ে (পর্ব ২৬):

WITH q(qx, qy, qz) AS (VALUES (0.70, 0.68, 0.12)),
m AS (
  SELECT title, x*qx + y*qy + z*qz AS dot,
         (x*qx + y*qy + z*qz) / (sqrt(x*x+y*y+z*z) * sqrt(qx*qx+qy*qy+qz*qz)) AS cos,
         sqrt((x-qx)*(x-qx) + (y-qy)*(y-qy) + (z-qz)*(z-qz)) AS l2
  FROM items, q WHERE category = 'Electronics')
SELECT title, round(dot, 3) AS dot, round(cos, 4) AS cosine, round(l2, 3) AS l2,
       RANK() OVER (ORDER BY dot DESC) AS r_dot,
       RANK() OVER (ORDER BY cos DESC) AS r_cos,
       RANK() OVER (ORDER BY l2)       AS r_l2
FROM m ORDER BY r_cos;

title               │ dot   │ cosine │ l2    │ r_dot │ r_cos │ r_l2
Mobile charger 25W  │ 0.978 │ 0.9997 │ 0.028 │ 1     │ 1     │ 1
USB-C cable         │ 0.899 │ 0.9831 │ 0.184 │ 3     │ 2     │ 2
Power bank 20000mAh │ 0.964 │ 0.9804 │ 0.197 │ 2     │ 3     │ 3
Bluetooth headphone │ 0.778 │ 0.8532 │ 0.52  │ 4     │ 4     │ 4
ফোনের কভার          │ 0.652 │ 0.7983 │ 0.594 │ 5     │ 5     │ 5

৪ · Exact k-NN — সবার সাথে মিলিয়ে দেখা, আর কেন তা বড় মাপে চলে না

অংশ ৩-এর কোয়েরি যা করল, তার নাম k-nearest neighbours (k-NN) খোঁজ, আর পদ্ধতিটি brute force: প্রতিটি vector-এর সাথে দূরত্ব হিসাব, তারপর সেরা k-টি রাখা। এর ফল নিখুঁত — একে বলে exact k-NN. খরচ হিসাব করা সহজ:

• n-টি vector, প্রতিটি d মাত্রার। একটি দূরত্বে d-টি গুণ ও যোগ, তাই মোট n·d গুণ-যোগ — O(n·d).
• সেরা k-টি রাখতে k আকারের একটি heap: O(n log k). পুরো সাজানো (ORDER BY) লাগে না।
• প্রতিটি vector অন্তত একবার মেমরি থেকে পড়তে হয়। float32-এ একটি সংখ্যা ৪ byte, তাই মোট ৪·n·d byte.

সংখ্যা বসান: n = ১ কোটি (10⁷) পণ্য-বিবরণ বা ডকুমেন্টের টুকরো, d = ৭৬৮. প্রতি প্রশ্নে 7.68 × 10⁹ গুণ-যোগ, আর 4 × 10⁷ × 768 ≈ ৩০.৭ GB ডেটা পড়া। আধুনিক সার্ভারের মেমরি সেকেন্ডে মোটামুটি কয়েক দশক GB পড়তে পারে, তাই একটি প্রশ্নেই প্রায় এক সেকেন্ড বা তার বেশি — আর সার্চ বক্সে প্রতি সেকেন্ডে শত শত প্রশ্ন আসে। GPU বা sharding (পর্ব ৫৪) সময় কমায়, কাজ নয়।

B-tree বা R-tree কেন সাহায্য করে না

পর্ব ৪০-এর B+ tree একটি মাত্রায় সাজায়; দুই-তিন মাত্রার ভৌগোলিক ডেটায় R-tree বা k-d tree এলাকা ভাগ করে খোঁজে। কিন্তু মাত্রা কয়েকশো হলে এরা প্রায় সব শাখাই খুলতে বাধ্য হয়। এর নাম curse of dimensionality: উচ্চ মাত্রায় এলোমেলো বিন্দুগুলোর পারস্পরিক দূরত্ব প্রায় সমান হয়ে আসে — “সবচেয়ে কাছের” আর “সবচেয়ে দূরের” বিন্দুর পার্থক্য আনুপাতিকভাবে ছোট হয়ে যায় — তাই কোনো এলাকাকে নিশ্চিতভাবে “বাদ” দেওয়া যায় না।

৫ · Approximate nearest neighbour — IVF, HNSW আর product quantization

IVF — আগে এলাকা বাছাই, তারপর খোঁজ

বড় লাইব্রেরিতে একটি বই খুঁজতে আপনি সব তাক ঘোরেন না — আগে ঠিক করেন বইটি কোন বিভাগে (ইতিহাস, বিজ্ঞান…), তারপর শুধু সেই বিভাগের তাক দেখেন। IVF (inverted file index) একই কাজ করে। তৈরির সময় k-means দিয়ে সব vector-কে L-টি দলে ভাগ করা হয়; প্রতিটি দলের কেন্দ্রবিন্দুকে বলে centroid, আর দলের সদস্যদের আইডির তালিকাকে বলে list (পর্ব ৩০-এর posting list-এর মতো — তাই নাম “inverted file”). খোঁজার সময়: প্রশ্নের সবচেয়ে কাছের nprobe-টি centroid বাছুন, শুধু সেই list-গুলোর vector-এর সাথে দূরত্ব হিসাব করুন।

খরচ: L-টি centroid-এর সাথে তুলনা, তারপর মোটামুটি nprobe × n / L-টি vector (দলগুলো সমান মাপের হলে)। n = ১০ লাখ, L = ১০০০, nprobe = ১০ হলে 1000 + 10 × 1000 = ১১,০০০ দূরত্ব — brute force-এর ১০ লাখের প্রায় ৯০ ভাগের এক ভাগ। দাম: আসল প্রতিবেশী যদি একটি দলের সীমানার ওপারে থাকে, আর সেই দল বাছাই না হয়, সে বাদ পড়বে। SQL-এই দেখুন। আমাদের ১০টি পণ্যকে চারটি list-এ ভাগ করা হয়েছে — নতুন দুটি টেবিল centroids(list_id, x, y, z) আর ivf_lists(item_id, list_id):

-- ধাপ ১: কোন list প্রশ্নের সবচেয়ে কাছে?
WITH q(qx, qy, qz) AS (VALUES (0.70, 0.68, 0.12))
SELECT list_id, round((x*qx + y*qy + z*qz)
       / (sqrt(x*x+y*y+z*z) * sqrt(qx*qx+qy*qy+qz*qz)), 4) AS cosine
FROM centroids, q ORDER BY cosine DESC;

-- ধাপ ২: nprobe = 1 — শুধু list 2-এর ভেতরে top-3
WITH q(qx, qy, qz) AS (VALUES (0.70, 0.68, 0.12))
SELECT i.item_id, i.title, round((x*qx + y*qy + z*qz)
       / (sqrt(x*x+y*y+z*z) * sqrt(qx*qx+qy*qy+qz*qz)), 4) AS cosine
FROM items i JOIN ivf_lists l USING (item_id), q
WHERE l.list_id IN (2)
ORDER BY cosine DESC LIMIT 3;

list_id │ cosine
2       │ 0.9367
1       │ 0.9174
3       │ 0.048
4       │ -0.4153

item_id │ title               │ cosine
1       │ Mobile charger 25W  │ 0.9997
4       │ Power bank 20000mAh │ 0.9804
6       │ সোলার ল্যাম্প       │ 0.8636

খেলনা ডেটায় একটি উদাহরণ যথেষ্ট নয়। নিচের Python প্রোগ্রাম ৮ মাত্রার ৪০০০টি vector বানায়, IVF তৈরি করে (৩২টি list, k-means), আর ৫০টি প্রশ্নে recall@10 ও প্রতি প্রশ্নে কতটি দূরত্ব হিসাব হলো তা মাপে:

import random
random.seed(7)
D, N, K, L = 8, 4000, 10, 32             # মাত্রা, ভেক্টর, top-k, list-সংখ্যা
centers = [[random.uniform(-1, 1) for _ in range(D)] for _ in range(40)]
point = lambda: [c + random.gauss(0, 0.25) for c in random.choice(centers)]
data = [point() for _ in range(N)]
d2 = lambda a, b: sum((x - y) ** 2 for x, y in zip(a, b))   # দূরত্বের বর্গ
near = lambda v, cs, n=1: sorted(range(len(cs)), key=lambda j: d2(v, cs[j]))[:n]

cent = random.sample(data, L)            # IVF তৈরি: k-means, ৫ বার হালনাগাদ
for _ in range(5):
    groups = [[] for _ in range(L)]
    for v in data: groups[near(v, cent)[0]].append(v)
    cent = [[sum(c) / len(g) for c in zip(*g)] if g else cent[j] for j, g in enumerate(groups)]
inv = [[] for _ in range(L)]
for i, v in enumerate(data): inv[near(v, cent)[0]].append(i)

queries = [point() for _ in range(50)]
truth = [set(near(q, data, K)) for q in queries]           # brute force: N দূরত্ব
print(f"brute force   recall@10=1.000  distances/query={N}")
for nprobe in (1, 2, 4, 8):
    hit = work = 0
    for q, t in zip(queries, truth):
        cand = [i for j in near(q, cent, nprobe) for i in inv[j]]
        work += L + len(cand)
        hit += len(t & set(sorted(cand, key=lambda i: d2(q, data[i]))[:K]))
    print(f"IVF nprobe={nprobe}  recall@10={hit / (K * len(queries)):.3f}  distances/query={work // len(queries)}")

brute force   recall@10=1.000  distances/query=4000
IVF nprobe=1  recall@10=0.918  distances/query=193
IVF nprobe=2  recall@10=0.986  distances/query=330
IVF nprobe=4  recall@10=0.996  distances/query=608
IVF nprobe=8  recall@10=1.000  distances/query=1133

HNSW — স্তরে স্তরে সাজানো পরিচিতির জাল

দ্বিতীয় পরিবারটি গ্রাফভিত্তিক। একটি proximity graph-এ প্রতিটি vector একটি node, আর প্রতিটি node তার কয়েকটি কাছের node-এর সাথে edge দিয়ে যুক্ত। খোঁজ হলো greedy search: কোনো একটি node থেকে শুরু করে বারবার সেই প্রতিবেশীর দিকে যান, যে প্রশ্নের আরও কাছে — যতক্ষণ আর উন্নতি না হয়। ঢাকা থেকে কারও ঠিকানা খুঁজতে আপনি প্রথমে জেলা, তারপর থানা, তারপর মহল্লা ধরে এগোন — বড় লাফ আগে, ছোট পা পরে। HNSW (Hierarchical Navigable Small World; Yury Malkov ও Dmitry Yashunin, ২০১৬ সালে প্রকাশিত) এই চিন্তাকে স্তরে সাজায়: সবচেয়ে নিচের স্তর ০-তে সব node, ওপরের প্রতিটি স্তরে এলোমেলোভাবে বাছা অল্প কিছু node আর লম্বা edge — দ্রুত দূরে যাওয়ার “হাইওয়ে”। খোঁজ শুরু হয় ওপরের স্তরের একটি নির্দিষ্ট entry point থেকে।

Q = (6.5, 5.5). Node-গুলোর অবস্থান: A(1,8), B(2,5), C(4,8), D(3,3), E(5,5), F(6,3), G(4,1), H(8,2), I(9,6), J(7,8), K(6,6). স্তর ২-এ edge শুধু A–H; স্তর ১-এ A–D, A–J, D–H, H–J; স্তর ০-তে ছবির ধূসর edge-গুলো। এবার খোঁজটি ধাপে ধাপে:

বাস্তব HNSW শুধু একটি “সেরা” node ধরে রাখে না। স্তর ০-তে সে ef_search আকারের একটি প্রার্থী-তালিকা (beam) রাখে — ধরুন সেরা ৪০টি — আর সেই সবার প্রতিবেশী যাচাই করে। এতে স্থানীয় ফাঁদে (local minimum) আটকে যাওয়ার সম্ভাবনা কমে। ef_search বাড়ালে recall বাড়ে, গতি কমে — IVF-এর nprobe-এর মতোই একটি নব। তৈরির সময় প্রতিটি node সর্বোচ্চ কয়টি প্রতিবেশী রাখবে (প্রচলিত নাম M, প্রায়ই ১৬) আর তৈরির সময়ের beam (ef_construction) — এ দুটিও recall, মেমরি আর তৈরির সময় ঠিক করে। HNSW সাধারণত একই recall-এ IVF-এর চেয়ে দ্রুত উত্তর দেয়, কিন্তু গ্রাফের edge-এর জন্য বাড়তি মেমরি লাগে আর তৈরি করতে সময় বেশি; মোছা ও হালনাগাদও জটিল।

Product quantization — vector ছোট করে রাখা

গতির পর দ্বিতীয় সমস্যা মেমরি। ৭৬৮ মাত্রার একটি float32 vector = ৩০৭২ byte; ১ কোটি vector ≈ ৩০.৭ GB, index ছাড়াই। Product quantization (PQ; Hervé Jégou, Matthijs Douze ও Cordelia Schmid, ২০১১) vector-কে ভাগ করে সংকুচিত করে:

1. ৭৬৮ মাত্রাকে m = ৯৬টি টুকরোয় ভাগ করুন, প্রতিটি ৮ মাত্রার।
2. প্রতিটি টুকরোর জন্য আলাদা k-means চালিয়ে ২৫৬টি প্রতিনিধি (codebook) বানান।
3. প্রতিটি টুকরোর জায়গায় শুধু কাছের প্রতিনিধির নম্বর রাখুন — ০ থেকে ২৫৫, অর্থাৎ ১ byte.

ফল: ৩০৭২ byte থেকে ৯৬ byte — ৩২ গুণ ছোট; ১ কোটি vector এখন প্রায় ০.৯৬ GB. খোঁজার সময় প্রশ্নের প্রতিটি টুকরো থেকে ২৫৬টি প্রতিনিধির দূরত্বের একটি টেবিল একবার বানানো হয় (৯৬ × ২৫৬ সংখ্যা), তারপর প্রতিটি সংকুচিত vector-এর দূরত্ব = ৯৬টি টেবিল-দেখা আর যোগ। দাম আবার নির্ভুলতা: দূরত্ব এখন আনুমানিক। তাই প্রচলিত কৌশল হলো PQ দিয়ে প্রার্থী বাছাই, তারপর সেরা কয়েকশোর আসল vector দিয়ে আবার হিসাব করে সাজানো (re-ranking). IVF আর PQ একসাথে (IVF-PQ) বড় মাপে খুব প্রচলিত; Facebook AI Research-এর open-source লাইব্রেরি FAISS (২০১৭) এগুলোর পরিচিত বাস্তবায়ন। সরল quantization-ও আছে — float32-এর বদলে float16 বা int8 (২ বা ৪ গুণ ছোট)।

৬ · Metadata filter আর hybrid search

“ঈদের উপহার — ইলেকট্রনিক্স থেকে”, “ফোনের চার্জার — স্টকে আছে এমন”, “এই নীতিমালা — শুধু আমার শাখার নথি থেকে”. vector-এর পাশে রাখা সাধারণ কলাম (category, দাম, স্টক, তারিখ, অনুমতি) দিয়ে ছাঁকাকে বলে metadata filtering. এখানে relational ডেটাবেসের সুবিধা স্পষ্ট: কোর্সের db-shop-এর products আর categories-এর পাশে একটি নতুন টেবিল যোগ করা হলো — product_vec(product_id, x, y, z), প্রতিটি পণ্যের একই ধাঁচের খেলনা embedding — আর বাকিটা সাধারণ JOIN আর WHERE.

-- প্রশ্ন "ঈদের উপহার", শুধু Electronics থেকে
WITH q(qx, qy, qz) AS (VALUES (0.40, 0.00, 0.80))
SELECT p.name, c.name AS category, p.price,
       round((v.x*qx + v.y*qy + v.z*qz)
             / (sqrt(v.x*v.x + v.y*v.y + v.z*v.z) * sqrt(qx*qx + qy*qy + qz*qz)), 4) AS cosine
FROM products p
JOIN categories c USING (category_id)
JOIN product_vec v USING (product_id), q
WHERE c.name = 'Electronics'
ORDER BY cosine DESC LIMIT 3;

name         │ category    │ price │ cosine
Smart Watch  │ Electronics │ 3500  │ 0.6706
Headphone    │ Electronics │ 1200  │ 0.5359
Mobile Phone │ Electronics │ 15000 │ 0.4708

Pre-filter বনাম post-filter

ছোট টেবিলে ফিল্টার আর সাজানো এক কোয়েরিতেই হয়ে যায়। কিন্তু ANN index থাকলে প্রশ্ন ওঠে — ফিল্টার কখন? দুটি পথ:

• Post-filtering: আগে index থেকে top-k আনুন, তারপর শর্ত না মানা সারি ফেলে দিন। সহজ, কিন্তু ফলে k-এর কম সারি থাকতে পারে — এমনকি শূন্য।
• Pre-filtering: আগে শর্ত মানা সারি বাছুন, তারপর শুধু তাদের মধ্যে কাছেরগুলো খুঁজুন। ফল সঠিক, কিন্তু শর্তে অনেক সারি বাদ পড়লে ANN index (যা সব সারির জন্য বানানো) ঠিকমতো কাজে লাগে না; তখন প্রায়ই বাছাই করা সারিতে brute force-ই দ্রুত।

-- প্রশ্ন "ফোনে চার্জ রাখার জিনিস"; শর্ত: stock > 0
WITH q(qx, qy, qz) AS (VALUES (0.65, 0.75, 0.05)),
s AS (SELECT p.name, p.stock, round((v.x*qx + v.y*qy + v.z*qz)
        / (sqrt(v.x*v.x+v.y*v.y+v.z*v.z) * sqrt(qx*qx+qy*qy+qz*qz)), 4) AS cosine
      FROM products p JOIN product_vec v USING (product_id), q)
SELECT * FROM (SELECT * FROM s ORDER BY cosine DESC LIMIT 3)   -- post-filter
WHERE stock > 0;

WITH q(qx, qy, qz) AS (VALUES (0.65, 0.75, 0.05)),
s AS (SELECT p.name, p.stock, round((v.x*qx + v.y*qy + v.z*qz)
        / (sqrt(v.x*v.x+v.y*v.y+v.z*v.z) * sqrt(qx*qx+qy*qy+qz*qz)), 4) AS cosine
      FROM products p JOIN product_vec v USING (product_id), q)
SELECT * FROM s WHERE stock > 0 ORDER BY cosine DESC LIMIT 3;  -- pre-filter

-- post-filter
name         │ stock │ cosine
Smart Watch  │ 5     │ 0.8638
Mobile Phone │ 12    │ 0.8525

-- pre-filter
name         │ stock │ cosine
Smart Watch  │ 5     │ 0.8638
Mobile Phone │ 12    │ 0.8525
Headphone    │ 40    │ 0.7702

Hybrid search — keyword আর vector একসাথে

অর্থ ধরা vector search-এর শক্তি, কিন্তু হুবহু টোকেন ধরা তার দুর্বলতা। মডেল নম্বর (“25W”), পণ্যের কোড, মানুষের নাম, NID বা অর্ডার নম্বর — embedding-এ এদের সূক্ষ্ম পার্থক্য প্রায়ই হারিয়ে যায়। Keyword search (পর্ব ৩০-এর BM25) ঠিক এখানেই শক্ত। দুটি মেলানোকে বলে hybrid search. সবচেয়ে সরল রূপ: দুই স্কোরের ওজনযুক্ত যোগফল। প্রশ্ন “25W charger”:

-- প্রশ্ন "25W charger": vector + keyword flag
WITH q(qx, qy, qz) AS (VALUES (0.62, 0.78, 0.04)),
s AS (SELECT title,
        (x*qx + y*qy + z*qz) / (sqrt(x*x+y*y+z*z) * sqrt(qx*qx+qy*qy+qz*qz)) AS cos,
        (lower(title) LIKE '%25w%') AS kw
      FROM items, q)
SELECT title, round(cos, 4) AS cosine, kw,
       round(0.7 * cos + 0.3 * kw, 4) AS hybrid
FROM s
ORDER BY hybrid DESC LIMIT 4;

title               │ cosine │ kw │ hybrid
Mobile charger 25W  │ 0.9917 │ 1  │ 0.9942
Power bank 20000mAh │ 0.9988 │ 0  │ 0.6992
USB-C cable         │ 0.9639 │ 0  │ 0.6748
সোলার ল্যাম্প       │ 0.9293 │ 0  │ 0.6505

এই মাপের সমস্যা এড়ানোর জনপ্রিয় উপায় reciprocal rank fusion (RRF; Gordon Cormack, Charles Clarke ও Stefan Büttcher, ২০০৯)। স্কোর ভুলে শুধু ক্রম নিন: প্রতিটি তালিকায় ডকুমেন্টের অবস্থান r হলে অবদান 1 / (k + r), আর সব তালিকার অবদান যোগ করুন; k সাধারণত ৬০. যে তালিকায় ডকুমেন্টটি নেই, সেখান থেকে অবদান ০. প্রশ্ন “USB-C charger”:

WITH q(qx, qy, qz) AS (VALUES (0.66, 0.74, 0.05)),
vec AS (SELECT item_id, ROW_NUMBER() OVER (ORDER BY (x*qx + y*qy + z*qz)
          / (sqrt(x*x+y*y+z*z) * sqrt(qx*qx+qy*qy+qz*qz)) DESC) AS r FROM items, q),
kw AS (SELECT item_id, ROW_NUMBER() OVER (ORDER BY hits DESC, item_id) AS r
       FROM (SELECT item_id, (instr(lower(title), 'usb-c') > 0)
                           + (instr(lower(title), 'charger') > 0) AS hits FROM items)
       WHERE hits > 0)
SELECT i.title, v.r AS vec_rank, k.r AS kw_rank,
       round(1.0/(60 + v.r) + coalesce(1.0/(60 + k.r), 0), 5) AS rrf
FROM items i JOIN vec v USING (item_id) LEFT JOIN kw k USING (item_id)
ORDER BY rrf DESC LIMIT 4;

title               │ vec_rank │ kw_rank │ rrf
Mobile charger 25W  │ 1        │ 1       │ 0.03279
USB-C cable         │ 3        │ 2       │ 0.032
Power bank 20000mAh │ 2        │ NULL    │ 0.01613
সোলার ল্যাম্প       │ 4        │ NULL    │ 0.01563

৭ · RAG — নিজের ডেটা দিয়ে LLM-কে উত্তর দেওয়ানো

ChatGPT-এর মতো LLM (large language model) বিপুল লেখা থেকে শিখেছে, কিন্তু আপনার ব্যাংকের সেবা-নির্দেশিকা, আপনার দোকানের ফেরত-নীতি বা গত সপ্তাহের অফিস-আদেশ তার জানা নেই। না জেনে প্রশ্ন পেলে সে প্রায়ই আত্মবিশ্বাসী কিন্তু বানানো উত্তর দেয় — একে বলে hallucination. RAG (retrieval-augmented generation; Patrick Lewis ও সহকর্মীরা, ২০২০) এর একটি সরল জবাব: প্রশ্নের উত্তর দেওয়ার আগে নিজের ডেটা থেকে প্রাসঙ্গিক অংশ খুঁজে এনে LLM-কে সাথে দিন, আর বলুন “শুধু এই লেখা থেকে উত্তর দাও”. খোঁজার অংশটিই vector database-এর কাজ।

একটি ব্যাংকের সেবা-নির্দেশিকার উদাহরণে পুরো পাইপলাইন দেখুন। প্রথম দুই ধাপ আগে একবার (এবং নথি বদলালে আবার) হয় — indexing; বাকি চার ধাপ প্রতিটি প্রশ্নে — query time.

c1: কার্ড হারালে বা চুরি হলে সঙ্গে সঙ্গে হেল্পলাইনে
    ফোন করে কার্ডটি ব্লক করুন।
c2: নতুন বা বদলি কার্ডের জন্য শাখায় আবেদন করুন;
    ফি সময়ভেদে আলাদা, শাখায় জেনে নিন।
c3: ATM থেকে দৈনিক টাকা তোলার একটি সীমা আছে।
c4: হিসাব খুলতে জাতীয় পরিচয়পত্র আর ছবি লাগে।

chunk_id │ embedding           │ source
c1       │ [0.85, 0.15, 0.50]  │ নির্দেশিকা, পৃ. ৩
c2       │ [0.60, 0.70, 0.20]  │ নির্দেশিকা, পৃ. ৩
c3       │ [0.20, 0.90, 0.30]  │ নির্দেশিকা, পৃ. ৫
c4       │ [0.10, 0.30, 0.95]  │ নির্দেশিকা, পৃ. ১

"কার্ড হারিয়ে গেলে কী করব?"
        ↓ embedding model
q = [0.80, 0.30, 0.45]

c1  0.986   ← কার্ড ব্লক
c2  0.856   ← বদলি কার্ড
c4  0.618
c3  0.603

নিচের তথ্য থেকেই উত্তর দাও। তথ্যে না থাকলে
বলো "জানি না"। প্রতিটি দাবির পাশে উৎস লেখো।

[c1] কার্ড হারালে বা চুরি হলে সঙ্গে সঙ্গে ...
[c2] নতুন বা বদলি কার্ডের জন্য শাখায় ...

প্রশ্ন: কার্ড হারিয়ে গেলে কী করব?

প্রথমে এখনই হেল্পলাইনে ফোন করে কার্ডটি ব্লক
করুন [c1]. তারপর বদলি কার্ডের জন্য শাখায়
আবেদন করুন; ফি শাখায় জেনে নিন [c2].

RAG-এর মান মাপা — recall@k

RAG-এর মান দুই অংশে ভাগ করে মাপুন। খোঁজের মান: কিছু প্রশ্নের জন্য মানুষ আগে থেকে চিহ্নিত করে রাখে কোন chunk-গুলো প্রাসঙ্গিক; তারপর recall@k = (top-k-এ আসা প্রাসঙ্গিক chunk) / (মোট প্রাসঙ্গিক chunk). প্রাসঙ্গিক chunk top-k-তে না এলে সবচেয়ে ভালো LLM-ও উত্তর দিতে পারবে না। উত্তরের মান: উত্তর কি প্রসঙ্গ-নির্ভর (প্রতিটি দাবি chunk-এ আছে?), আর প্রশ্নের জবাব দেয় কি? ANN index-এর recall (অংশ ৫, exact k-NN-এর তুলনায়) আর RAG-এর retrieval recall (মানুষের বিচারের তুলনায়) দুটি আলাদা মাপ — দুটিই লাগে।

৮ · কোথায় রাখবেন — pgvector, বিশেষায়িত vector DB, search engine আর SQLite

Vector রাখার চারটি বড় পরিবার আছে। নিচের কোডগুলো এই পাতায় চলবে না — শুধু পড়ার জন্য; সংস্করণভেদে নাম ও প্যারামিটার বদলাতে পারে, তাই ব্যবহারের আগে নিজের সংস্করণের নথি দেখুন।

PostgreSQL + pgvector

pgvector একটি open-source PostgreSQL extension (Andrew Kane-এর তৈরি, ২০২১ সাল থেকে)। এটি একটি vector(n) কলাম-টাইপ, দূরত্বের অপারেটর আর দুই রকম ANN index দেয়। সবচেয়ে বড় সুবিধা: vector থাকে আপনার সাধারণ টেবিলেই — একই transaction, JOIN, foreign key, backup আর অনুমতি।

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE items (
  item_id   bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  title     text NOT NULL,
  category  text NOT NULL,
  stock     int  NOT NULL DEFAULT 0,
  embedding vector(3) NOT NULL          -- বাস্তবে মডেলের মাত্রা, যেমন 768
);
INSERT INTO items (title, category, stock, embedding)
VALUES ('Mobile charger 25W', 'Electronics', 30, '[0.70,0.70,0.10]');

-- অপারেটর: <-> L2 দূরত্ব, <=> cosine দূরত্ব (= 1 − cosine), <#> ঋণাত্মক inner product
SELECT title, 1 - (embedding <=> '[0.70,0.68,0.12]') AS cosine
FROM items
WHERE category = 'Electronics'
ORDER BY embedding <=> '[0.70,0.68,0.12]'
LIMIT 5;

লক্ষ করুন: ORDER BY-এ দূরত্ব (ছোট = কাছে), similarity নয়; index কাজে লাগাতে এই রূপটিই লিখতে হয়। নতুন সংস্করণে L1-এর <+> আর halfvec (float16), sparsevec-এর মতো টাইপও এসেছে। Index দুই রকম, আর প্রতিটি নির্দিষ্ট অপারেটরের জন্য বানাতে হয় (operator class):

-- HNSW (pgvector 0.5.0 থেকে): cosine-এর জন্য
CREATE INDEX items_emb_hnsw ON items
  USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64);
SET hnsw.ef_search = 100;          -- ডিফল্ট 40; বাড়ালে recall বাড়ে, গতি কমে

-- IVFFlat: আগে ডেটা ঢোকান, তারপর index (k-means চলে থাকা সারিতে)
CREATE INDEX items_emb_ivf ON items
  USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
SET ivfflat.probes = 10;           -- = nprobe; ডিফল্ট 1

-- ফিল্টারসহ খোঁজে কম ফল এড়াতে (0.8.0 থেকে): iterative index scan
SET hnsw.iterative_scan = relaxed_order;

EXPLAIN ANALYZE
SELECT item_id FROM items ORDER BY embedding <=> '[0.70,0.68,0.12]' LIMIT 5;

EXPLAIN-এ Index Scan using items_emb_hnsw দেখলে নিশ্চিত হন index ব্যবহার হচ্ছে (পর্ব ৪১)। ভুল operator class (যেমন L2-র index, কিন্তু কোয়েরিতে <=>) হলে PostgreSQL নীরবে sequential scan করবে — ফল ঠিক, শুধু ধীর। মনে রাখুন, index-সহ ফল approximate: index-ছাড়া একই কোয়েরির সাথে মিলিয়ে recall মাপা যায়। Index-যোগ্য মাত্রার একটি সীমাও আছে (vector-এর জন্য ২০০০, halfvec-এ এর চেয়ে বেশি — সংস্করণ দেখে নিন)।

বিশেষায়িত vector DB, search engine আর SQLite

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="YOUR_API_KEY")          # key পরিবেশ-চলক থেকে নিন
pc.create_index(name="products", dimension=3, metric="cosine",
                spec=ServerlessSpec(cloud="aws", region="us-east-1"))
index = pc.Index("products")
index.upsert(vectors=[{"id": "1", "values": [0.70, 0.70, 0.10],
                       "metadata": {"category": "Electronics"}}])
res = index.query(vector=[0.70, 0.68, 0.12], top_k=3,
                  filter={"category": {"$eq": "Electronics"}}, include_metadata=True)

from qdrant_client import QdrantClient
from qdrant_client.models import (Distance, VectorParams, PointStruct,
                                  Filter, FieldCondition, MatchValue)

client = QdrantClient(url="http://localhost:6333")
client.create_collection("products",
    vectors_config=VectorParams(size=3, distance=Distance.COSINE))
client.upsert("products", points=[
    PointStruct(id=1, vector=[0.70, 0.70, 0.10], payload={"category": "Electronics"})])
hits = client.query_points("products", query=[0.70, 0.68, 0.12], limit=3,
    query_filter=Filter(must=[FieldCondition(key="category",
                                             match=MatchValue(value="Electronics"))])).points

from pymilvus import MilvusClient

client = MilvusClient("http://localhost:19530")
client.create_collection(collection_name="products", dimension=3, metric_type="COSINE")
client.insert("products", [{"id": 1, "vector": [0.70, 0.70, 0.10],
                            "category": "Electronics"}])
res = client.search("products", data=[[0.70, 0.68, 0.12]], limit=3,
                    filter='category == "Electronics"', output_fields=["category"])

import weaviate
from weaviate.classes.query import Filter

client = weaviate.connect_to_local()
products = client.collections.get("Product")
res = products.query.near_vector(near_vector=[0.70, 0.68, 0.12], limit=3,
          filters=Filter.by_property("category").equal("Electronics"))
for obj in res.objects:
    print(obj.properties)
client.close()

import chromadb

client = chromadb.Client()                       # মেমরিতে; ডিস্কে: PersistentClient(path=...)
col = client.create_collection("products", metadata={"hnsw:space": "cosine"})
col.add(ids=["1"], embeddings=[[0.70, 0.70, 0.10]],
        metadatas=[{"category": "Electronics"}], documents=["Mobile charger 25W"])
res = col.query(query_embeddings=[[0.70, 0.68, 0.12]], n_results=1,
                where={"category": "Electronics"})

PUT products
{ "mappings": { "properties": {
    "title":     { "type": "text" },
    "category":  { "type": "keyword" },
    "embedding": { "type": "dense_vector", "dims": 3, "index": true, "similarity": "cosine" } } } }

POST products/_search
{ "knn": { "field": "embedding", "query_vector": [0.70, 0.68, 0.12],
           "k": 3, "num_candidates": 50,
           "filter": { "term": { "category": "Electronics" } } } }

CREATE VIRTUAL TABLE vec_items USING vec0(embedding float[3]);
INSERT INTO vec_items (rowid, embedding) VALUES (1, '[0.70, 0.70, 0.10]');
SELECT rowid, distance
FROM vec_items
WHERE embedding MATCH '[0.70, 0.68, 0.12]' AND k = 3
ORDER BY distance;

৯ · খরচ, ফাঁদ আর কখন PostgreSQL + pgvector-ই যথেষ্ট

কখন PostgreSQL + pgvector-ই যথেষ্ট

একটি বাস্তবসম্মত শুরুর নিয়ম: যদি vector-এর সংখ্যা কয়েক লাখ থেকে কয়েক কোটির মধ্যে, index এক সার্ভারের মেমরিতে আঁটে, আর আপনার ডেটা আগেই PostgreSQL-এ — তাহলে pgvector দিয়ে শুরু করুন। লাভ: একটি সিস্টেম, একটি backup, transaction-এ লেখা আর vector একসাথে, ফিল্টারে পূর্ণ SQL আর JOIN, পরিচিত অনুমতি-ব্যবস্থা। বিশেষায়িত vector DB-র কথা ভাবুন যখন — বহু কোটি বা শত কোটি vector, প্রতি সেকেন্ডে বিপুল প্রশ্ন, অনেক সার্ভারে ছড়ানো দরকার, বা আপনার দলের PostgreSQL চালানোর অভিজ্ঞতা নেই এবং managed সেবা চান। তখনো source of truth relational ডেটাবেসেই রাখুন; vector DB তার প্রতিলিপি, তাই দুই-কপির consistency সমস্যাও আসে।

১০ · AI-এর যুগে vector search — AI-এর কোড যাচাই

“আমার পণ্যের জন্য semantic search বানাও” বা “একটি RAG chatbot বানাও” — AI টুল এমন অনুরোধে মিনিটেই চলার মতো কোড দেয়। কিন্তু এই বিষয়ের ভুলগুলো প্রায় কখনো error দেয় না; খারাপ ফল দেয়, চুপচাপ:

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

• ডকুমেন্ট আর প্রশ্ন একই মডেল ও সংস্করণে embed হচ্ছে; মাত্রা কলামের সাথে মেলে
• দূরত্বের মাপ (cosine, dot, L2) মডেলের নথির সাথে মেলে, আর index-এর operator class কোয়েরির অপারেটরের সাথে মেলে
• EXPLAIN-এ index scan দেখেছি; index-ছাড়া exact ফলের সাথে মিলিয়ে recall@k মেপেছি
• কড়া ফিল্টারে ফলের সংখ্যা গুনে দেখেছি (post-filter-এ k-এর কম আসছে কি না); অনুমতির ফিল্টার খোঁজের সময়েই
• বাংলা, ইংরেজি আর Banglish-এ একই প্রশ্নের একটি ছোট পরীক্ষা-সেট দিয়ে ফল যাচাই করেছি; নথি বদলালে vector হালনাগাদের ব্যবস্থা আছে