📐 धडा 03 — Similarity: दोन अर्थ "किती जवळ" बसतात ते मोजणे

📍 तुम्ही इथे आहात: 8 पैकी धडा 03 · मागे: lesson-02-text-to-vectors · पुढे: lesson-04-nearest-neighbors

📦 या ब्रँचमध्ये काय आहे

धडे 01–02, आणि प्रत्येक vector database चे तीन ओळींचे हृदय: similarity function — आणि आपले फक्त एका ओळीचे dot product का आहे.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

Hall मध्ये दोन मुले उभी आहेत. ती किती "सारखी" आहेत? दोन प्रामाणिक मापे:

ती एकमेकांपासून किती दूर उभी आहेत 📏 (Euclidean distance): एकाकडून दुसऱ्याकडे चालत जा, पावले मोजा. कमी = जास्त सारखी.
ती कोणत्या दिशेला तोंड करून आहेत 🧭 (cosine similarity): ती कुठे उभी आहेत ते विसरा — ती दाखवत असलेल्या दिशांमधला कोन तुलना करा. एकच दिशा = 1.0, काटकोन = 0.0 (काहीच साम्य नाही), उलट दिशा = −1.0.

Text साठी दिशा जिंकते: robots बद्दलचा 10 पानांचा निबंध आणि robots बद्दलची एका ओळीची टीप एकाच दिशेला बोट दाखवतात — निबंध फक्त जास्त जोराने दाखवतो (लांब vector). Distance त्यांना वेगळे म्हणेल (निबंध दूर उभा असतो); cosine त्यांना भावंडे म्हणतो. अर्थ म्हणजे दिशा; लांबी म्हणजे फक्त आवाज. 📢

आणि आपला toy वापरतो ती व्यावसायिक युक्ती (vectordb.py): लिहितानाच प्रत्येक vector ची लांबी 1 करा (normalize) (धडा 02) — मग cosine म्हणजे साधा dot product उरतो: जुळणारे निर्देशांक गुणा, बेरीज करा. एक ओळ, प्रचंड वेगवान, hardware ला सोयीची. म्हणूनच आपल्या code मधले cosine() फक्त sum(x*y …) आहे — हुशारीचा भाग दारातच झालेला असतो.

🗺️ आकृती

flowchart TB
    subgraph hall["🗺️ the hall"]
        essay["📚 10-page robot essay<br/>long vector, points NE"]
        note["📝 one-line robot note<br/>short vector, points NE"]
        lunch["🍛 lunch menu<br/>points SW"]
    end
    cos["🧭 cosine: compare DIRECTIONS<br/>essay·note = 0.95 ✅ siblings<br/>essay·lunch = 0.02 — strangers"]
    dist["📏 distance: compare POSITIONS<br/>essay is 'far' from note ❌<br/>fooled by length/volume"]
    trick["⚡ the trick: normalize at write time<br/>→ cosine becomes a plain dot product<br/>(one line, hardware-fast)"]
    hall --> cos
    hall --> dist
    cos --> trick

❓ काय

Cosine similarity = dot(a,b) / (|a|·|b|) — vectors मधला कोन. Range −1…1; normalized vectors साठी ते म्हणजेच dot(a,b).
कच्चा (unnormalized) dot product दिशा आणि लांबी दोन्ही मिसळतो — काही recommendation systems ना तेच हवे असते ("लोकप्रियता महत्त्वाची").
Euclidean (L2) — प्रत्यक्ष अंतर; normalized vectors साठी ते cosine चे monotone जुळे आहे (क्रम तोच!), म्हणून normalize केल्यावर "कोणता metric" ही घबराट बहुतेक विरघळून जाते.
व्यावहारिक नियम: text search → normalized vectors वर cosine — आणि तुमचे embedding model ज्या metric साठी train झाले तोच वापरा (model cards मध्ये लिहिलेले असते; खरे DBs प्रत्येक collection साठी निवडू देतात).
Scores सापेक्ष असतात, निरपेक्ष सत्य नाहीत: 0.8 म्हणजे "80% बरोबर" नाही — thresholds तुमच्या data वर tune करावे लागतात (धडा 07 ची eval टीप).

🤔 का

प्रत्येक search निकालाचा क्रम, प्रत्येक "सारखे tickets" ranking, प्रत्येक RAG retrieval — याच एका आकड्याने लावलेले असते. Retrieval चुकीचे वाटले तर पहिली पायरी नेहमी: कोणता metric, सगळे normalize झाले होते का, दोन्ही बाजूंना तोच embedder? (तीन प्रश्न, नव्वद टक्के bugs.)

🧪 करून पाहा

python3 -c "
import sys; sys.path.insert(0,'vectordb')
from vectordb import embed, cosine
essay = 'the robot reads books about robots and robot learning ' * 10
note  = 'a robot book'
lunch = 'dal and rice for lunch on tuesday'
print('essay vs note :', round(cosine(embed(essay), embed(note)), 2), '← same direction, wildly different lengths')
print('essay vs lunch:', round(cosine(embed(essay), embed(lunch)), 2))
"

लांबी ×10 — similarity जशीच्या तशी. दिशा म्हणजे अर्थ; normalization ने आवाज आधीच खाऊन टाकला. 🧭

⏭️ पुढे

एक query विरुद्ध दहा लाख जागा — सगळ्यांना विचारणे खूप हळू आहे. Nearest neighbors: brute force, scaling ची भिंत, आणि shortcut नकाशे (ANN).

git checkout lesson-04-nearest-neighbors

📐 Lesson 03 — Similarity: measuring "how close" two meanings sit

📍 You are here: Lesson 03 of 8 · Previous: lesson-02-text-to-vectors · Next: lesson-04-nearest-neighbors

📦 What's in this branch

Lessons 01–02, plus the three-line heart of every vector database: the similarity function — and why ours is one line of dot product.

🧒 Explain like I'm 5

Two kids stand in the hall. How "similar" are they? Two honest measures:

How far apart they stand 📏 (Euclidean distance): walk from one to the other, count the steps. Smaller = more similar.
Which direction they face 🧭 (cosine similarity): ignore where they stand — compare the angle between the directions they point. Same direction = 1.0, right angles = 0.0 (nothing in common), opposite = −1.0.

For text, direction wins: a 10-page essay about robots and a one-line note about robots point the SAME way — the essay just points harder (longer vector). Distance would call them different (the essay stands far away); cosine calls them siblings. Meaning is a direction; length is just volume. 📢

And the professional trick our toy uses (vectordb.py): normalize every vector to length 1 at write time (lesson 02) — then cosine collapses into a plain dot product: multiply matching coordinates, add up. One line, massively fast, hardware-friendly. That's why cosine() in our code is just sum(x*y …) — the clever part already happened at the door.

🗺️ Diagram

flowchart TB
    subgraph hall["🗺️ the hall"]
        essay["📚 10-page robot essay<br/>long vector, points NE"]
        note["📝 one-line robot note<br/>short vector, points NE"]
        lunch["🍛 lunch menu<br/>points SW"]
    end
    cos["🧭 cosine: compare DIRECTIONS<br/>essay·note = 0.95 ✅ siblings<br/>essay·lunch = 0.02 — strangers"]
    dist["📏 distance: compare POSITIONS<br/>essay is 'far' from note ❌<br/>fooled by length/volume"]
    trick["⚡ the trick: normalize at write time<br/>→ cosine becomes a plain dot product<br/>(one line, hardware-fast)"]
    hall --> cos
    hall --> dist
    cos --> trick

❓ What

Cosine similarity = dot(a,b) / (|a|·|b|) — angle between vectors. Range −1…1; for normalized vectors it IS dot(a,b).
Dot product raw (unnormalized) mixes direction AND length — some recommendation systems want that ("popularity counts").
Euclidean (L2) — actual distance; for normalized vectors it's a monotone twin of cosine (same ranking!), so the "which metric" panic mostly dissolves once you normalize.
Practical rule: text search → cosine on normalized vectors — and match whatever metric your embedding model was trained for (model cards say; real DBs let you pick per-collection).
Scores are relative, not absolute truths: 0.8 isn't "80% right" — thresholds must be tuned on YOUR data (lesson 07's eval note).

🤔 Why

Every search result ordering, every "similar tickets" ranking, every RAG retrieval — sorted by this one number. When retrieval feels wrong, step one is always: what metric, was everything normalized, same embedder both sides? (Three questions, ninety percent of bugs.)

🧪 Try it

python3 -c "
import sys; sys.path.insert(0,'vectordb')
from vectordb import embed, cosine
essay = 'the robot reads books about robots and robot learning ' * 10
note  = 'a robot book'
lunch = 'dal and rice for lunch on tuesday'
print('essay vs note :', round(cosine(embed(essay), embed(note)), 2), '← same direction, wildly different lengths')
print('essay vs lunch:', round(cosine(embed(essay), embed(lunch)), 2))
"

Length ×10 — similarity unmoved. Direction is meaning; normalization already ate the volume. 🧭

⏭️ Next

One query vs a MILLION seats — asking everyone is too slow. Nearest neighbors: brute force, the scaling wall, and the shortcut maps (ANN).

git checkout lesson-04-nearest-neighbors

← Previoustext to vectors Next →nearest neighbors

This page is the lesson's README from the lesson-03-similarity branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.