Vector আর similarity — dot product, cosine আর embedding-এর ধারণা

এই পর্ব দিয়ে শুরু হলো মডিউল ৬, AI-এর গণিত। লক্ষ্য গণিতের পরীক্ষা পাস করা নয়, বরং AI-এর ভেতরে যে কয়েকটি ধারণা বারবার ফিরে আসে, সেগুলোর পেছনের ছবিটি পরিষ্কার করা। প্রতিটি ধারণায় আমরা একই ক্রম মানব: আগে একটি ছবি বা ছোট সংখ্যার উদাহরণ হাতে হিসাব, তারপর সূত্র, তারপর NumPy দিয়ে যাচাই, শেষে AI-তে কোথায় লাগে। NumPy-তে vector, @ আর np.linalg.norm লেখার হাতের কাজ আপনি পর্ব ১৭-এ দেখেছেন, আর broadcasting পর্ব ১৫-এ; এখানে সেই হিসাবগুলোর অর্থ আর জ্যামিতি দেখব। কোড পাতাতেই চলবে (ব্রাউজারের ভেতরে Python, Pyodide); প্রথমবার চালাতে কয়েক সেকেন্ড লাগতে পারে।

১ · Vector-এর তিন চেহারা — সংখ্যার তালিকা, তীর আর feature-এর সারি

ক্রিকেটের স্কোরকার্ডে একজন ব্যাটারের লাইনটি ভাবুন: রান ৪৫, বল ৩২, চার ৫, ছক্কা ১. চারটি সংখ্যা, আর প্রতিটির জায়গা নির্দিষ্ট; “৩২” যদি রানের ঘরে চলে যায়, অর্থই বদলে যায়। ক্রম মেনে সাজানো এমন কয়েকটি সংখ্যাকে গণিতে বলে vector. কয়টি সংখ্যা আছে, সেটি vector-এর মাত্রা (dimension): এখানে ৪-মাত্রার vector.

একই vector-কে তিনভাবে দেখা যায়, আর তিনটি চেহারাই এই পর্বে কাজে লাগবে।

তৃতীয় চেহারাটিই AI-তে সবচেয়ে বেশি দেখা যায়। একজন ক্রেতা, একটি পণ্য, একটি ছবি, এমনকি একটি বাংলা রিভিউকেও সংখ্যার একটি সারিতে বদলে ফেলা গেলে কম্পিউটার তাদের তুলনা করতে পারে। এমন সারিকে বলে feature vector. রিনার vector-এ তিনটি সংখ্যা, তাই এটি ৩-মাত্রার জগতের একটি বিন্দু বা তীর। ৩ মাত্রা আমরা কল্পনা করতে পারি; ৩০০ মাত্রা পারি না, কিন্তু হিসাবের নিয়ম একই থাকে। এই পর্বের কৌশল তাই সহজ: ছবি আঁকব ২ মাত্রায়, বিশ্বাস করব নিয়মগুলো যেকোনো মাত্রায় খাটে, আর NumPy দিয়ে যাচাই করব।

লেখার নিয়ম: এই পর্বে vector-কে ছোট হাতের অক্ষরে লিখব (a, b, v), আর তার i-তম ঘরকে a_i. একক কোনো সংখ্যাকে, যেমন ২ বা ০.৫, বলে scalar; এর কোনো দিক নেই, শুধু মান।

২ · যোগ আর scalar গুণ — তীর জোড়া লাগানো আর লম্বা করা

রিকশায় বাসা থেকে প্রথমে পূর্বে ৩ ব্লক আর উত্তরে ১ ব্লক গেলেন (a = [3, 1]), তারপর সেখান থেকে পূর্বে ১ আর উত্তরে ২ ব্লক (b = [1, 2]). শেষে বাসা থেকে আপনি মোট কোথায়? পূর্বে 3 + 1 = 4, উত্তরে 1 + 2 = 3. এটিই vector যোগ: ঘরে ঘরে যোগ, a + b = [a₁ + b₁, a₂ + b₂] = [4, 3]. ছবিতে এর মানে: প্রথম তীরের মাথায় দ্বিতীয় তীরের লেজ বসানো। কোন তীর আগে, তাতে কিছু যায় আসে না; দুই পথেই একই বিন্দুতে পৌঁছান, তাই ছবিতে একটি সামান্তরিক (parallelogram) তৈরি হয়।

Scalar গুণ আরও সহজ: একটি সংখ্যা দিয়ে প্রতিটি ঘর গুণ। 2a = [6, 2]: একই দিক, দ্বিগুণ লম্বা। 0.5a অর্ধেক লম্বা, আর −1 দিয়ে গুণ করলে তীর ঘুরে ঠিক উল্টো দিকে যায়। মনে রাখুন, ধনাত্মক scalar দিয়ে গুণ করলে দিক বদলায় না; এই সাধারণ কথাটিই পরে cosine similarity-র প্রাণ।

AI-তে এই দুটি কাজ সর্বত্র। বাজারঘরের দুই মাসের বিক্রির vector যোগ করলে দুই মাসের মোট; একটি vector-কে 0.5 দিয়ে গুণ করলে অর্ধেক। দুটি vector-এর গড় মানে (a + b) / 2, তীরের মাথা দুটির ঠিক মাঝের বিন্দু; পর্ব ৬৫-এ (Clustering আর PCA) একটি দলের “কেন্দ্র” এভাবেই বের হবে। আর একটি neural network-এর প্রশিক্ষণে প্রতিটি ধাপে weight-এর vector থেকে একটি ছোট scalar গুণ করা vector বিয়োগ হয়; পর্ব ৩৪-এ (Derivative আর gradient descent) এই ধাপটি আসবে। NumPy-তে দুটি কাজই এক লাইনের: a + b আর 2 * a, দুটিই element-wise.

৩ · দৈর্ঘ্য মাপা — norm, unit vector আর normalisation

তীরটি কত লম্বা? ২ মাত্রায় উত্তর স্কুলের পিথাগোরাস: a = [3, 4] হলে দৈর্ঘ্য √(3² + 4²) = √25 = 5. ৩ বা বেশি মাত্রায় একই নিয়ম, শুধু বর্গ বেশি: সব ঘরের বর্গ যোগ করে বর্গমূল। দৈর্ঘ্যের এই মাপকে বলে L2 norm, আর চিহ্নে লেখা হয় ‖a‖ (দুই পাশে দুটি খাড়া দাগ)।

‖a‖₂ = √(a₁² + a₂² + … + a_n²) ‖a‖₁ = |a₁| + … + |a_n| ‖a‖_∞ = max |a_i|

এখানে n হলো মাত্রার সংখ্যা, আর |a_i| মানে চিহ্ন (± ) বাদ দেওয়া মান (absolute value). পর্ব ১৭-এ ঢাকার রাস্তার ছবি দিয়ে তিনটি norm দেখেছেন; এক লাইনে মনে করিয়ে দিই: L1 হলো রিকশার পথ (ঘরগুলোর absolute মানের যোগ, যার আরেক নাম Manhattan), L2 হলো কাকের সোজা পথ, আর L∞ (max norm) শুধু সবচেয়ে বড় একটি ঘর দেখে। [3, 4]-এর জন্য L1 = 7, L2 = 5, L∞ = 4. যেকোনো vector-এ L∞ ≤ L2 ≤ L1.

Unit vector — শুধু দিক, দৈর্ঘ্য ১

অনেক সময় আমরা শুধু দিকটা চাই, দৈর্ঘ্য নয়। যেমন দুজন ক্রেতা কোন ধরনের পণ্য বেশি কেনেন, সেটা তুলনা করতে চাই, কে কত বেশি কেনেন সেটা নয়। তখন vector-কে তার নিজের দৈর্ঘ্য দিয়ে ভাগ করা হয়: u = v / ‖v‖. ফলের দিক একই থাকে (ধনাত্মক scalar দিয়ে গুণ, অংশ ২ মনে করুন), কিন্তু দৈর্ঘ্য হয় ঠিক ১. দৈর্ঘ্য ১-এর vector-কে বলে unit vector, আর এই ভাগ করার কাজটিকে বলে normalisation. ২ মাত্রায় সব unit vector-এর মাথা একটি ব্যাসার্ধ ১-এর বৃত্তের ওপর থাকে। নিচে v = [2, 3, 6] ধাপে ধাপে normalise করে দেখুন। “পরে” চাপুন।

v      = [2, 3, 6]
v ** 2 = [4, 9, 36]

4 + 9 + 36 = 49

‖v‖ = √49 = 7
np.linalg.norm(v) → 7.0

u = v / 7
  = [2/7, 3/7, 6/7]
  ≈ [0.286, 0.429, 0.857]

ভগ্নাংশে: 4/49 + 9/49 + 36/49 = 49/49 = 1
৩ ঘর দশমিকে: 0.0818 + 0.1840 + 0.7344
            ≈ 1.0003  # rounding-এর ছাপ

৪ · Dot product — গুণ করে যোগ, আর কোণের মাপ

বাজারঘরের দুজন ক্রেতা তিন ধরনের পণ্যে (মুদি, প্রসাধনী, ঘরের জিনিস) মাসে কয়টি অর্ডার দেন: ক্রেতা ক = a = [1, 2, 2], ক্রেতা খ = b = [2, 1, 2]. দুজনের কেনার ধরন কতটা মেলে? প্রথম হাতিয়ার dot product, যার প্রথম রূপটি নিছক হিসাব: ঘরে ঘরে গুণ করে সব যোগ।

a · b = a₁b₁ + a₂b₂ + … + a_nb_n = ∑_i a_ib_i

∑ (সিগমা) মানে “সব i-এর জন্য যোগ করুন”। ফল একটিমাত্র সংখ্যা, vector নয়। পর্ব ১৭-এ এটিই ছিল দামের তালিকা আর অর্ডারের পরিমাণ থেকে মোট বিল। দ্বিতীয় রূপটি জ্যামিতিক, আর এটিই এই পর্বের কেন্দ্র:

a · b = ‖a‖ ‖b‖ cos θ

এখানে θ (থিটা) হলো দুটি তীরের মাঝের কোণ, আর cos θ হলো সেই কোণের cosine: কোণ 0° হলে 1, 90° হলে 0, 180° হলে −1. মানে dot product দুটি জিনিসের গুণফল: দুই তীর কত লম্বা, আর তারা কতটা একই দিকে। দুটি রূপ একই সংখ্যা দেয় (এটি একটি উপপাদ্য, cosine-এর সূত্র থেকে কয়েক লাইনে প্রমাণ হয়), তাই প্রথম রূপে সহজে হিসাব করে দ্বিতীয় রূপ থেকে কোণ বের করা যায়: cos θ = (a · b) / (‖a‖ ‖b‖). নিচে ক আর খ-এর হিসাব ধাপে ধাপে দেখুন।

1a, b = [1, 2, 2], [2, 1, 2]2for i in range(3):3    s += a[i] * b[i]4na, nb = norm(a), norm(b)5cos = s / (na * nb)

এবার একই হিসাব দুইভাবে কোডে: প্রথমে নিজে loop লিখে, তারপর NumPy দিয়ে। দুটির ফল মিলতে হবে, আর হাতের হিসাবের সঙ্গেও। সঙ্গে v = [2, 3, 6]-এর normalisation-ও যাচাই হবে।

import numpy as np

a = np.array([1, 2, 2])   # ক্রেতা ক: মুদি, প্রসাধনী, ঘরের জিনিস
b = np.array([2, 1, 2])   # ক্রেতা খ

# নিজে loop লিখে
s = 0
for x, y in zip(a, b):
    s += x * y
len_a = sum(x * x for x in a) ** 0.5
len_b = sum(y * y for y in b) ** 0.5
print("loop : dot =", s, " |a| =", len_a, " |b| =", len_b)

# NumPy দিয়ে
print("NumPy: dot =", a @ b, " |a| =", np.linalg.norm(a),
      " |b| =", np.linalg.norm(b))
print("L1 =", np.linalg.norm(a, 1), " Linf =", np.linalg.norm(a, np.inf))

cos = (a @ b) / (np.linalg.norm(a) * np.linalg.norm(b))
print("cos =", cos, " ~", round(cos, 4))
print("angle =", round(np.degrees(np.arccos(cos)), 2), "degrees")

v = np.array([2, 3, 6])
u = v / np.linalg.norm(v)            # unit vector
print("|v| =", np.linalg.norm(v), " u =", u.round(3))
print("|u| =", np.linalg.norm(u), " u @ u =", u @ u)

loop : dot = 8  |a| = 3.0  |b| = 3.0
NumPy: dot = 8  |a| = 3.0  |b| = 3.0
L1 = 5.0  Linf = 2.0
cos = 0.8888888888888888  ~ 0.8889
angle = 27.27 degrees
|v| = 7.0  u = [0.286 0.429 0.857]
|u| = 0.9999999999999999  u @ u = 0.9999999999999999

সমকোণের ঘটনাটি AI-তে খুব কাজের। [1, 0] আর [0, 1]-এর dot product 1×0 + 0×1 = 0: দুটির মধ্যে কোনো “মিল” নেই। একটি ক্রেতা যদি শুধু মুদি কেনেন আর অন্যজন শুধু প্রসাধনী, তাদের কেনার vector orthogonal. আর পর্ব ৬৮-এ (Neural network-এর ধারণা) দেখবেন, একটি কৃত্রিম নিউরনের প্রথম কাজই হলো ইনপুট আর weight-এর dot product: weight-এর দিকে যত বেশি মেলে, ফল তত বড়।

৫ · Cosine similarity — দৈর্ঘ্য নয়, দিক

অংশ ৪-এর শেষ সূত্রটিরই একটি নাম আছে: cosine similarity.

cos(a, b) = (a · b) / (‖a‖ ‖b‖)

তিনটি বৈশিষ্ট্য মনে রাখুন। প্রথমত, এর মান সবসময় −1 থেকে 1-এর মধ্যে (Cauchy–Schwarz অসমতা এটি নিশ্চিত করে)। 1 মানে হুবহু একই দিক, 0 মানে সমকোণ, −1 মানে উল্টো দিক। দ্বিতীয়ত, সব ঘর যদি শূন্য বা ধনাত্মক হয় (যেমন অর্ডারের সংখ্যা, খরচ, শব্দ কতবার এসেছে), তাহলে মান 0 থেকে 1-এর মধ্যেই থাকে, ঋণাত্মক হয় না। তৃতীয়ত, এবং সবচেয়ে গুরুত্বপূর্ণ: দৈর্ঘ্য এর হিসাবে ঢোকে না. যেকোনো vector-কে 10 দিয়ে গুণ করলে উপরে dot product 10 গুণ হয়, নিচে দৈর্ঘ্যও 10 গুণ হয়, কাটাকাটি হয়ে যায়। আসলে cosine similarity মানে দুটি unit vector-এর dot product: আগে normalise, তারপর dot.

এবার এমন একটি উদাহরণ যেখানে দুটি মাপ পরিষ্কারভাবে ভিন্ন উত্তর দেয়। তিনজন ক্রেতার মাসিক খরচ, শত টাকায়, [মুদি, প্রসাধনী]: A = [2, 1], B = [20, 10], C = [1, 3]. হাতে হিসাব করুন:

• A আর B: Euclidean দূরত্ব √(18² + 9²) = √405 ≈ 20.12. Cosine = (40 + 10) / (√5 × √500) = 50 / 50 = 1. B ঠিক 10 × A, তাই একই দিক।
• A আর C: Euclidean দূরত্ব √(1² + 2²) = √5 ≈ 2.24. Cosine = (2 + 3) / (√5 × √10) = 5 / √50 ≈ 0.707, মানে 45° কোণ।

Euclidean বলছে A-র সবচেয়ে কাছের প্রতিবেশী C (2.24 বনাম 20.12); cosine বলছে B (1 বনাম 0.707). দুটিই “সঠিক”, শুধু দুটি আলাদা প্রশ্নের উত্তর। নিচের কোড এই হিসাব যাচাই করে আর তীরগুলো আঁকে (ছবির লেখা ইংরেজিতে, কারণ এই পাতার matplotlib বাংলা অক্ষর ঠিকমতো জোড়া লাগাতে পারে না; পর্ব ২৮ দেখুন)।

import numpy as np
import matplotlib.pyplot as plt

# মাসিক খরচ (শত টাকা): [মুদি, প্রসাধনী]
A, B, C = np.array([2, 1]), np.array([20, 10]), np.array([1, 3])

def cosine(x, y):
    return (x @ y) / (np.linalg.norm(x) * np.linalg.norm(y))

for name, other in [("B", B), ("C", C)]:
    d = np.linalg.norm(A - other)
    c = cosine(A, other)
    print(f"A-{name}: Euclidean = {d:6.2f}  cosine = {c:.4f}  "
          f"cosine distance = {1 - c:.4f}")

fig, ax = plt.subplots(figsize=(5.5, 3.6))
for vec, lab, col in [(A, "A (2, 1)", "tab:blue"),
                      (B, "B (20, 10)", "tab:green"),
                      (C, "C (1, 3)", "tab:red")]:
    ax.annotate("", xy=vec, xytext=(0, 0),
                arrowprops=dict(arrowstyle="->", color=col, lw=2))
    ax.text(vec[0] + 0.4, vec[1] + 0.3, lab, color=col)
ax.set_xlim(0, 24); ax.set_ylim(0, 12); ax.set_aspect("equal")
ax.set_xlabel("groceries (100 taka)")
ax.set_ylabel("cosmetics (100 taka)")
ax.set_title("Euclidean: A is close to C.  Cosine: A matches B.")
plt.show()

A-B: Euclidean =  20.12  cosine = 1.0000  cosine distance = 0.0000
A-C: Euclidean =   2.24  cosine = 0.7071  cosine distance = 0.2929

৬ · দূরত্বের তিন মাপ, আর scaling কেন আগে

“মিল” মাপার উল্টো পিঠ হলো “দূরত্ব”: মিল যত বেশি, দূরত্ব তত কম। AI-তে তিনটি দূরত্ব সবচেয়ে বেশি দেখা যায়।

একটি সতর্কতা: cosine distance গণিতের কঠোর অর্থে “দূরত্ব” (metric) নয়, কারণ ত্রিভুজ অসমতা সবসময় মানে না; তবে কাছের-দূরের ক্রম সাজাতে এটি দিব্যি কাজ করে। SciPy-তে তিনটিই আছে: scipy.spatial.distance-এর euclidean, cityblock (Manhattan) আর cosine; মনে রাখুন SciPy-র cosine ফেরত দেয় দূরত্ব (1 − cos), similarity নয়। এই উল্টো-পাল্টা একটি পরিচিত বাগের উৎস।

টাকা বনাম দিন — কোন কলাম দূরত্ব ঠিক করে?

অংশ ১-এর ক্রেতা-vector-এ ফিরি: [বছরে অর্ডার, গড় খরচ (টাকা), শেষ অর্ডারের পর কত দিন]. বাজারঘরে নতুন ক্রেতা করিম = [11, 905, 8]: প্রায়ই কেনেন, সম্প্রতি কিনেছেন। পাঁচজন চেনা ক্রেতার মধ্যে কে তাঁর সবচেয়ে কাছের, যাতে তাঁর পছন্দ দেখে করিমকে প্রস্তাব দেওয়া যায়?

চোখে দেখলেই বোঝা যায় রিনা আর তানিয়া করিমের মতো: ঘন ঘন কেনেন, সম্প্রতি কিনেছেন। সুমন বছরে মাত্র ৩টি অর্ডার দেন আর দুই মাস কেনেননি। কিন্তু কাঁচা সংখ্যায় Euclidean দূরত্ব কী বলে? নিচের হিসাবটি ডেস্কটপে চালানো (সত্যিকারের run, লেখার সময়ে Python 3.14.4 আর NumPy 2.5.4):

~/bazarghar-ai$ python scaling.py
কাঁচা দূরত্ব  : [ 55.09  52.85 495.   118.45  95.03]
সবচেয়ে কাছে : সুমন
সুমনের পার্থক্যের বর্গ: [  64.   25. 2704.]
mean: [  7.6 994.   34.4]  std: [  4.22 212.    34.52]
standardise-এর পরে: [0.36 2.42 2.34 3.22 0.51]
সবচেয়ে কাছে : রিনা

স্ক্রিপ্টটি ছোট: পাঁচজনের X (shape (5, 3)) থেকে করিমের q বিয়োগ করে broadcasting-এ সারি ধরে np.linalg.norm(X - q, axis=1); তারপর প্রতিটি কলাম থেকে তার গড় বাদ দিয়ে standard deviation দিয়ে ভাগ, আর আবার একই দূরত্ব।

কাঁচা দূরত্বে করিমের সবচেয়ে কাছে সুমন (52.85), রিনা একটু পিছিয়ে (55.09). কেন? রিনার সঙ্গে করিমের পার্থক্য প্রায় পুরোটাই খরচে: 905 − 850 = 55 টাকা, যার বর্গ 3025. সুমনের সঙ্গে খরচের পার্থক্য মাত্র 5 টাকা; তাঁর বড় পার্থক্য দিনে (52 দিন, বর্গ 2704) আর অর্ডারে (8টি, বর্গ মাত্র 64). মানে কাঁচা হিসাবে “১টি অর্ডারের পার্থক্য” আর “১ টাকার পার্থক্য” সমান ওজন পাচ্ছে, অথচ বাস্তবে বছরে ৮টি অর্ডারের পার্থক্য অনেক বড় কথা আর ৫৫ টাকা খুব সামান্য। যে কলামের সংখ্যাগুলো বড় পরিসরে ছড়ানো (এখানে টাকা, তারপর দিন), সেটিই দূরত্ব ঠিক করে দেয়; অর্ডারের কলাম প্রায় কিছুই বলতে পারে না।

সমাধান feature scaling. সবচেয়ে প্রচলিত রূপ standardisation (z-score): প্রতিটি কলাম থেকে তার গড় (μ, মিউ) বাদ দিয়ে standard deviation (σ, সিগমা) দিয়ে ভাগ, z = (x − μ) / σ. ফলে প্রতিটি কলামের একক হয় “গড় থেকে কত standard deviation দূরে”, আর তিনটি কলাম তুলনীয় হয়। Standardise করার পরে করিমের সবচেয়ে কাছে রিনা (0.36), তারপর তানিয়া (0.51), আর সুমন অনেক দূরে (2.42): চোখের বিচারের সঙ্গে মিলেছে।

লক্ষ করুন, cosine similarity নিজেও scaling-এর প্রশ্ন থেকে মুক্ত নয়। Cosine প্রতিটি সারির দৈর্ঘ্য উপেক্ষা করে, কিন্তু কলামগুলোর মাপের পার্থক্য উপেক্ষা করে না: টাকার কলাম বড় হলে vector-এর দিকও প্রায় পুরোটাই টাকার দিকে হেলে থাকে। তাই কাঁচা ক্রেতা-ডেটায় cosine নিলেও আগে কলাম scale করা দরকার।

৭ · অনেক মাত্রার অদ্ভুত জগৎ — দূরত্ব কাছাকাছি চলে আসে

২ বা ৩ মাত্রায় আমাদের অন্তর্দৃষ্টি ভালো কাজ করে। কিন্তু AI-এর vector প্রায়ই শত শত বা হাজার মাত্রার। সেখানে একটি অবাক ঘটনা ঘটে: এলোমেলো বিন্দুর মধ্যে সবচেয়ে কাছের আর সবচেয়ে দূরের বিন্দুর দূরত্ব প্রায় সমান হয়ে আসে। একে বলে distance concentration. নিচের কোডে প্রতিটি মাত্রায় ৫০০টি এলোমেলো বিন্দু নেওয়া হয়েছে (প্রতিটি ঘর 0 থেকে 1-এর মধ্যে), আর একটি query বিন্দু থেকে সবচেয়ে কাছের ও সবচেয়ে দূরের দূরত্বের অনুপাত মাপা হয়েছে। অনুপাত 0-এর কাছে মানে “কাছের” আর “দূরের” স্পষ্ট আলাদা; 1-এর কাছে মানে সবাই প্রায় সমান দূরে।

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)
dims = [2, 5, 10, 50, 100, 500, 1000]
ratios = []
for d in dims:
    X = rng.random((500, d))     # ৫০০টি এলোমেলো বিন্দু
    q = rng.random(d)            # একটি query বিন্দু
    dist = np.linalg.norm(X - q, axis=1)
    r = dist.min() / dist.max()
    ratios.append(r)
    print(f"d={d:5d}  nearest={dist.min():7.3f}  "
          f"farthest={dist.max():7.3f}  ratio={r:.3f}")

fig, ax = plt.subplots(figsize=(5.5, 3.4))
ax.plot(dims, ratios, marker="o")
ax.set_xscale("log"); ax.set_ylim(0, 1)
ax.set_xlabel("number of dimensions d (log scale)")
ax.set_ylabel("nearest / farthest")
ax.set_title("Distances concentrate as dimension grows")
plt.show()

d=    2  nearest=  0.014  farthest=  1.049  ratio=0.013
d=    5  nearest=  0.185  farthest=  1.391  ratio=0.133
d=   10  nearest=  0.627  farthest=  1.874  ratio=0.335
d=   50  nearest=  1.812  farthest=  3.425  ratio=0.529
d=  100  nearest=  3.542  farthest=  4.806  ratio=0.737
d=  500  nearest=  8.507  farthest=  9.712  ratio=0.876
d= 1000  nearest= 12.269  farthest= 13.441  ratio=0.913

এই ঘটনা একটি বড় ধারণার অংশ, যাকে বলে curse of dimensionality (মাত্রার অভিশাপ)। শব্দটি সাধারণত Richard Bellman-এর নামে চলে, ১৯৫০-এর দশকের শেষে dynamic programming-এর কাজে; আর ১৯৯৯ সালে Beyer ও সহকর্মীরা “nearest neighbor কখন অর্থবহ” প্রশ্নে দূরত্বের এই কেন্দ্রীভবন বিশ্লেষণ করেন (পর্ব ১৭-এর ভাবনার প্রশ্ন ৪-এও এর কথা আছে)। তবে অভিশাপ কথাটি সতর্কভাবে পড়ুন। পরীক্ষাটি করা হয়েছে পুরোপুরি এলোমেলো, প্রতিটি মাত্রা স্বাধীন ডেটায়। বাস্তব ডেটায় গঠন থাকে: ১০০০ মাত্রার embedding-ও প্রায়ই আসলে অনেক কম “কার্যকর” মাত্রায় বিন্যস্ত থাকে, তাই সেখানে কাছের প্রতিবেশী খোঁজা অর্থবহ থাকতে পারে। প্রশ্নটি তাই “মাত্রা বেশি কি না” নয়, বরং “ডেটার মধ্যে আসল গঠন আছে কি না, আর আমার দূরত্ব সেই গঠন ধরছে কি না”। ব্যবহারিক শিক্ষা: অপ্রয়োজনীয় feature যোগ করলে দূরত্বভিত্তিক পদ্ধতি দুর্বল হয়, তাই feature বাছাই আর মাত্রা কমানো (পর্ব ৬৫, PCA) কাজে লাগে।

৮ · Embedding — অর্থকে vector বানানো, আর সবচেয়ে কাছের প্রতিবেশী

এতক্ষণ vector-এর ঘরগুলো ছিল আমাদের চেনা সংখ্যা: অর্ডার, টাকা, দিন। কিন্তু একটি শব্দ, একটি পণ্য বা একটি বাংলা রিভিউকে কীভাবে সংখ্যায় বদলাবেন, যাতে “অর্থে কাছাকাছি” জিনিস vector-এও কাছাকাছি হয়? এই ধারণার নাম embedding: প্রতিটি জিনিসকে একটি নির্দিষ্ট মাত্রার vector দেওয়া, যাতে মিল মানে ছোট কোণ (বড় cosine). লাইব্রেরির তাকের কথা ভাবুন: ভালো লাইব্রেরিয়ান একই বিষয়ের বই পাশাপাশি রাখেন, তাই একটি বই খুঁজে পেলে তার আশেপাশে একই ধরনের আরও বই পাওয়া যায়। Embedding হলো সেই তাক, শুধু ২ মাত্রার দেয়ালের বদলে শত মাত্রার জগতে।

নিচের টেবিলটি শেখানোর জন্য হাতে বানানো, কোনো মডেল থেকে শেখা নয়। বাজারঘরের আটটি পণ্য, প্রতিটি ৪-মাত্রার vector. বোঝার সুবিধার জন্য মাত্রাগুলোর একটি অর্থ দেওয়া হয়েছে।

এখন প্রশ্ন: একজন ক্রেতা রাইস কুকার দেখছেন; “এর মতো আর কী দেখাবেন”? এটিই nearest neighbour search: query vector-এর সঙ্গে প্রতিটি পণ্যের cosine মেপে সবচেয়ে বড়গুলো বেছে নেওয়া। ছোট করে দেখাতে নিচের ধাপে মাত্র চারটি প্রার্থী নেওয়া হয়েছে।

1q = E["রাইস কুকার"]2for p in candidates:3    cos = (q @ p) / (norm(q) * norm(p))4top = sorted(scores, reverse=True)[:3]

সব পণ্যের সঙ্গে সব পণ্যের cosine একসঙ্গে চাইলে loop লাগে না। প্রথমে প্রতিটি সারি normalise করুন (প্রতিটি সারি unit vector), তারপর U @ U.T: shape (8, 4) @ (4, 8) → (8, 8). ফলের [i, j] ঘর হলো পণ্য i আর j-এর cosine. এই টেবিলকে বলে similarity matrix; সারি ধরে normalise করতে keepdims=True লাগে যাতে (8, 1) shape-এর দৈর্ঘ্য broadcasting-এ প্রতিটি সারিকে ভাগ করে (পর্ব ১৫)।

import numpy as np
np.set_printoptions(precision=2, suppress=True)

# শেখানোর জন্য হাতে বানানো 4-মাত্রার embedding (আসল মডেলের নয়)
# মাত্রা: [খাবার-রান্না, যন্ত্র, শিশু-যত্ন, দামি]
names = ["চাল", "ডাল", "তেল", "রাইস কুকার",
         "ব্লেন্ডার", "চার্জার", "ডায়াপার", "লোশন"]
E = np.array([[0.90, 0.00, 0.10, 0.10],
              [0.85, 0.00, 0.15, 0.10],
              [0.80, 0.05, 0.05, 0.20],
              [0.60, 0.70, 0.00, 0.50],
              [0.50, 0.75, 0.00, 0.45],
              [0.00, 0.90, 0.05, 0.20],
              [0.10, 0.00, 0.95, 0.30],
              [0.05, 0.05, 0.90, 0.35]])

U = E / np.linalg.norm(E, axis=1, keepdims=True)  # প্রতিটি সারি unit
S = U @ U.T                                       # (8, 8) cosine টেবিল
print("S.shape:", S.shape)
print(S)

def top_k(i, k=3):
    order = np.argsort(-S[i])          # বড় থেকে ছোট
    order = order[order != i][:k]      # নিজেকে বাদ দিয়ে
    return [(names[j], round(float(S[i, j]), 3)) for j in order]

for i in [0, 3, 5, 6]:
    print(names[i], "→", top_k(i))

S.shape: (8, 8)
[[1.   1.   0.99 0.62 0.54 0.03 0.24 0.19]
 [1.   1.   0.98 0.61 0.54 0.03 0.3  0.25]
 [0.99 0.98 1.   0.71 0.63 0.11 0.23 0.2 ]
 [0.62 0.61 0.71 1.   0.99 0.75 0.2  0.24]
 [0.54 0.54 0.63 0.99 1.   0.82 0.18 0.23]
 [0.03 0.03 0.11 0.75 0.82 1.   0.12 0.18]
 [0.24 0.3  0.23 0.2  0.18 0.12 1.   1.  ]
 [0.19 0.25 0.2  0.24 0.23 0.18 1.   1.  ]]
চাল → [('ডাল', 0.998), ('তেল', 0.988), ('রাইস কুকার', 0.617)]
রাইস কুকার → [('ব্লেন্ডার', 0.994), ('চার্জার', 0.754), ('তেল', 0.708)]
চার্জার → [('ব্লেন্ডার', 0.822), ('রাইস কুকার', 0.754), ('লোশন', 0.179)]
ডায়াপার → [('লোশন', 0.995), ('ডাল', 0.296), ('চাল', 0.236)]

এই ছোট উদাহরণে প্রতিটি পণ্যের সঙ্গে প্রতিটি পণ্য তুলনা করা হয়েছে: n পণ্যে প্রায় n² তুলনা। আটটি পণ্যে তা কিছুই নয়, কিন্তু লাখ লাখ পণ্য বা কোটি রিভিউতে প্রতিটি query-র জন্য সব vector মাপা ধীর। তাই বড় ব্যবস্থায় approximate nearest neighbour (ANN) পদ্ধতি ব্যবহার হয়, যা সামান্য নির্ভুলতা ছেড়ে অনেক দ্রুত “প্রায় সবচেয়ে কাছের” ফল দেয়। Vector database এই কাজটিই করে; ডেটাবেসের দিক থেকে ধারণাটি দেখতে পারেন DBMS কোর্সের vector database পর্বে, আর পর্ব ৬৯-এ এটি হাতে-কলমে আসবে। আর সাজানোর খরচ বুঝতে DSA-র heap পর্ব দেখুন: পুরো তালিকা সাজানোর বদলে heap দিয়ে শুধু top-k বের করা যায়।

৯ · AI-এর যুগে — similarity-র কোড আর দাবি যাচাই

“এই পণ্যগুলোর মধ্যে similar গুলো বের করো” বা “ক্রেতাদের nearest neighbour দাও” লিখলে AI সহকারী দ্রুত কোড দেয়। এই বিষয়ে ভুলগুলো প্রায় কখনো error দেয় না, শুধু ভুল প্রতিবেশী দেয়, তাই চোখে পড়ে না। AI সহকারীরা প্রায়ই যা করে:

• দূরত্বের আগে scaling বাদ দেয়, অথবা scaling-এর μ আর σ পুরো ডেটা (test সহ) থেকে নেয়; আর ফল দেখায় সেই ডেটাতেই, যা দিয়ে সব ঠিক করা হয়েছে।
• Similarity আর distance গুলিয়ে ফেলে: SciPy-র cosine (দূরত্ব) দিয়ে “সবচেয়ে বড়” বাছে, অথবা argsort-এর ক্রম উল্টো না করেই সবচেয়ে অমিলগুলো “top-3” বলে দেয়, আর query নিজেকেই প্রথম ফল হিসেবে রেখে দেয়।
• শূন্য vector-এ 0 দিয়ে ভাগ উপেক্ষা করে; nan চাপা দিতে np.nan_to_num বসিয়ে দেয়, ফলে নতুন ক্রেতা চুপচাপ সবার “সমান কাছের” হয়ে যায়।
• বানানো বা পুরোনো API লেখে, যেমন NumPy 2-এ সরানো np.float, বা np.linalg.norm(x, p=2)-এর মতো parameter যা নেই (আসল নাম ord); অথবা sklearn-এর function-এর নাম আন্দাজে লেখে।
• বিশ্বাসযোগ্য শোনায় কিন্তু না-মাপা দাবি করে: “cosine সবসময় Euclidean-এর চেয়ে ভালো”, “এই embedding অর্থ বোঝে”, বা similarity-র একটি threshold (যেমন 0.8) কোনো যাচাই ছাড়াই “ভালো মান” বলে দেয়।

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

• একটি বা দুটি জোড়ার dot product, norm আর cosine হাতে হিসাব করে কোডের ফলের সঙ্গে মিলিয়েছি
• প্রতিটি কলামের একক আর পরিসর দেখেছি; scaling-এর μ আর σ শুধু train ডেটা থেকে নেওয়া হয়েছে
• similarity না distance, সেটি নিশ্চিত করেছি, আর সাজানোর দিক (বড় থেকে ছোট না ছোট থেকে বড়) ঠিক আছে; query নিজে ফলে নেই
• শূন্য-দৈর্ঘ্যের সারি, nan আর inf খুঁজেছি; কোনো warning বা error লুকানো হয়নি
• অচেনা প্রতিটি function আর parameter নিজের version-এর অফিসিয়াল docs-এ (numpy.org, scipy.org) মিলিয়েছি
• কয়েকটি ফল চোখে দেখে যাচাই করেছি (সত্যিই কি মিল আছে?), একটি সরল baseline-এর (যেমন “সবচেয়ে জনপ্রিয় পণ্য”) সঙ্গে তুলনা করেছি, আর ক্রেতার আসল ডেটা AI-তে পেস্ট করিনি