RAG और सर्च इंजीनियरिंगमध्यमपाठ 2086 मिनट का पाठ

एम्बेडिंग्स और सिमिलैरिटी सर्च

एम्बेडिंग टेक्स्ट को संख्याओं की एक लिस्ट में बदल देती है, ताकि मिलते-जुलते अर्थ वाले टेक्स्ट एक-दूसरे के करीब रहें। जानें कि समानता कैसे मापी जाती है और सर्च कैसे तेज़ बनी रहती है।

✦ ट्यूटर से पूछें🧪 लैब · 25 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

एम्बेडिंग्स और सिमिलैरिटी सर्च

एम्बेडिंग टेक्स्ट को संख्याओं की एक लिस्ट में बदल देती है, ताकि मिलते-जुलते अर्थ वाले टेक्स्ट एक-दूसरे के करीब रहें। जानें कि समानता कैसे मापी जाती है और सर्च कैसे तेज़ बनी रहती…

1/3
आसान शब्दों में
किसी शहर के नक्शे के बारे में सोचें। एक जैसी चीज़ें बेचने वाली दुकानें अक्सर पास-पास होती हैं: फोन की सारी दुकानें एक ही गली में, मिठाइयों की सारी दुकानें दूसरी में। एम्बेडिंग हर वाक्य को एक तरह के नक्शे पर रखती है, ताकि मिलते-जुलते अर्थ वाले वाक्य एक-दूसरे के करीब आ जाएं। सर्च करने के लिए, आप देखते हैं कि आपका सवाल नक्शे पर कहाँ आता है और उसके आस-पास की चीज़ों को देखते हैं।
एक embedding model टेक्स्ट के किसी हिस्से को पढ़ता है और एक vector देता है: संख्याओं की एक तय लंबाई वाली लिस्ट। असली मॉडल्स हर टेक्स्ट के लिए सैकड़ों या हज़ारों संख्याएं देते हैं। हम संख्याओं को एक-एक करके नहीं पढ़ सकते, लेकिन पूरी लिस्ट उसके अर्थ को समझ लेती है। "मेरे पैसे कट गए लेकिन पेमेंट फेल हो गया" और "फेल हुए UPI ट्रांज़ैक्शन के लिए रिफंड" को ऐसे वेक्टर्स मिलते हैं जो एक ही दिशा में इशारा करते हैं, भले ही उनमें बहुत कम शब्द एक जैसे हों।

नज़दीकी मापना: कोसाइन सिमिलैरिटी

Cosine similarity दो वेक्टर्स के बीच के कोण (angle) को मापती है। जब वे एक ही दिशा में इशारा करते हैं तो यह 1 होती है, जब उनका कोई संबंध नहीं होता तो 0 के करीब होती है, और जब वे विपरीत दिशाओं में इशारा करते हैं तो नकारात्मक (negative) होती है। यह वेक्टर्स की लंबाई को नज़रअंदाज़ करती है और सिर्फ दिशा को देखती है।
कई सिस्टम स्टोर करते समय हर वेक्टर को 1 की लंबाई में normalise कर देते हैं। तब कोसाइन सिमिलैरिटी सिर्फ dot product रह जाती है: आमने-सामने की संख्याओं को गुणा करें और उन्हें जोड़ दें। यह बहुत तेज़ होता है।
Python: cosine similarity with made-up vectorspython
import numpy as np

# Made-up 4-number "embeddings", only to show the maths.
# Real embedding models return hundreds or thousands of numbers.
docs = {
    "How to reset your UPI PIN":       np.array([0.9, 0.1, 0.0, 0.2]),
    "Refund for a failed UPI payment": np.array([0.7, 0.7, 0.1, 0.0]),
    "Monsoon sowing tips for paddy":   np.array([0.0, 0.1, 0.9, 0.3]),
}
# Pretend this is the vector for "money was cut but the payment failed".
query = np.array([0.6, 0.8, 0.0, 0.1])

def cosine(a, b):
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))

ranked = sorted(docs, key=lambda title: cosine(query, docs[title]), reverse=True)
for title in ranked:
    print(f"{cosine(query, docs[title]):.3f}  {title}")
इसे चलाएँ और रिफंड वाला डॉक्यूमेंट पहले आएगा, पिन वाला डॉक्यूमेंट दूसरे नंबर पर, और खेती के नुस्खे सबसे आखिर में। एक असली सिस्टम बिल्कुल यही करता है, बस उसमें किसी एम्बेडिंग मॉडल के असली वेक्टर्स और बहुत सारे डॉक्यूमेंट्स होते हैं।

सर्च को तेज़ बनाना: एप्रोक्सीमेट नियरेस्ट नेबर

सवाल की तुलना स्टोर किए गए हर वेक्टर से करने को exact या brute-force सर्च कहा जाता है। यह आसान और पूरी तरह से सटीक है, और कुछ हज़ार हिस्सों (chunks) के लिए यह अक्सर काफी तेज़ होता है। लाखों चंक्स के लिए यह धीमा हो जाता है।
Approximate nearest neighbour (ANN) इंडेक्स थोड़ी सी सटीकता के बदले बहुत ज़्यादा स्पीड देते हैं। इनमें से एक लोकप्रिय तरीका HNSW (हायरार्किकल नेविगेबल स्मॉल वर्ल्ड) है। यह परतों (layers) में एक ग्राफ बनाता है: ऊपर की परतों में कम बिंदु और बड़ी छलांगों के लिए लंबे लिंक होते हैं, नीचे की परतों में ज़्यादा बिंदु और बारीक कदमों के लिए छोटे लिंक होते हैं। सर्च ऊपर से शुरू होती है, सही इलाके के पास छलांग लगाती है, और फिर सबसे करीबी पड़ोसियों तक नीचे उतरती है।
विकल्पकिसके लिए अच्छा हैकिस बात का ध्यान रखें
Brute-force (exact)छोटे कलेक्शन्स, टेस्ट्स, ANN के नतीजों की जाँच करने के लिएबड़े पैमाने पर धीमा
HNSW ग्राफबड़े कलेक्शन्स पर तेज़ सर्चज़्यादा मेमोरी इस्तेमाल करता है; कुछ असली पड़ोसियों को छोड़ सकता है; सेटिंग्स में स्पीड पाने के लिए रिकॉल छोड़ना पड़ता है
दूसरे ANN तरीके (जैसे क्लस्टरिंग या कम्प्रेशन)बहुत बड़े कलेक्शन्स, कम मेमोरीआम तौर पर ज़्यादा सटीकता खो देते हैं; ट्यूनिंग की ज़रूरत होती है
नोट
"Approximate" का मतलब है कि इंडेक्स कुछ असली सबसे करीबी पड़ोसियों को छोड़ सकता है। इसे मापें: उन्हीं सवालों को ब्रूट-फोर्स सर्च और इंडेक्स दोनों से चलाएँ, और देखें कि इंडेक्स उन सटीक टॉप नतीजों में से कितने वापस लौटाता है। इंडेक्स सेटिंग्स आम तौर पर आपको इस रिकॉल के बदले स्पीड को एडजस्ट करने देती हैं। उन सेटिंग्स के नामों के लिए अपने डेटाबेस के मौजूदा डॉक्स देखें।

वे बातें जहाँ लोग गलती करते हैं

  • डॉक्यूमेंट्स और सवालों के लिए एक ही मॉडल का इस्तेमाल करें। दो अलग-अलग एम्बेडिंग मॉडल्स के वेक्टर्स अलग-अलग "नक्शों" पर होते हैं और उनकी आपस में तुलना नहीं की जा सकती।
  • कुछ मॉडल्स को प्रीफ़िक्स या मोड की ज़रूरत होती है। कुछ एम्बेडिंग मॉडल्स चाहते हैं कि आप टेक्स्ट को क्वेरी या डॉक्यूमेंट के रूप में मार्क करें। मॉडल कार्ड पढ़ें।
  • मिलता-जुलता होने का मतलब सही होना नहीं है। "7 दिनों के भीतर रिफंड की अनुमति है" और "7 दिनों के बाद रिफंड की अनुमति नहीं है" वेक्टर स्पेस में बहुत करीब हो सकते हैं। समानता संभावित विकल्प ढूंढती है; जवाब वाले चरण को ध्यान से पढ़ना चाहिए।
  • हूबहू शब्द छूट सकते हैं। प्रोडक्ट कोड्स, एरर नंबर्स और दुर्लभ नामों को अक्सर अकेले वेक्टर्स ठीक से मैच नहीं कर पाते। हाइब्रिड सर्च वाला पाठ इसे ठीक करता है।
  • भाषाओं का सपोर्ट अलग-अलग होता है। कुछ एम्बेडिंग मॉडल्स हिंदी, तमिल या बंगाली को अच्छी तरह संभालते हैं, दूसरे खराब तरीके से। अपने यूज़र्स के असली सवालों के साथ टेस्ट करें।
इसे आज़माएं। कोड में क्वेरी वेक्टर को बदलकर [0.0, 0.2, 0.8, 0.4] कर दें। अब कौन सा डॉक्यूमेंट पहले आता है, और क्यों?

और देखें और पढ़ें

Hugging Face: models and documentationHugging Face · reading

लैब

मनगढ़ंत वेक्टर्स पर काम करने वाली एक ब्रूट-फोर्स वेक्टर सर्च, और इस पर एक नोट कि हर नतीजा क्या दिखाता है।

~25 min

समस्या

आपको Python 3 और numpy (pip install numpy) की ज़रूरत होगी। किसी API की की ज़रूरत नहीं है; सभी वेक्टर्स मनगढ़ंत हैं।

  1. शुरुआती कोड चलाएँ और रैंकिंग देखें।
  2. अपने मनगढ़ंत वेक्टर्स के साथ दो और डॉक्यूमेंट्स जोड़ें, उदाहरण के लिए बस पास या परीक्षा के नतीजों के बारे में। संख्याएं इस तरह चुनें कि उनमें से एक क्वेरी से मैच हो जाए।
  3. search को बदलें ताकि वह केवल उसी सिमिलैरिटी वाले नतीजे दिखाए जो एक थ्रेशोल्ड से ऊपर हों। 0.5 और 0.9 आज़माएं और लिखें कि क्या बदलाव आता है।
  4. दो वाक्य लिखें कि असली थ्रेशोल्ड को टेस्ट करके क्यों चुना जाना चाहिए, अंदाज़ा लगाकर क्यों नहीं।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1शुरुआती कोड मैट्रिक्स बनाने से पहले वेक्टर्स को नॉर्मलाइज़ क्यों करता है?दिखाएं

हर वेक्टर को 1 की लंबाई में नॉर्मलाइज़ करने के बाद, दो वेक्टर्स का डॉट प्रोडक्ट उनकी कोसाइन सिमिलैरिटी के बराबर होता है। इससे कोड हर जोड़ी के लिए लंबाइयों से भाग देने के बजाय, एक तेज़ मैट्रिक्स मल्टीप्लिकेशन से सभी डॉक्यूमेंट्स को स्कोर कर पाता है। इसका मतलब यह भी है कि लंबे और छोटे वेक्टर्स की तुलना केवल दिशा के आधार पर की जाती है।

Q2एक वेक्टर सर्च "Can I get a refund within 7 days?" के लिए सबसे ऊपर "Refund not allowed after 7 days" दिखाती है। क्या सर्च खराब हो गई है?दिखाएं

ज़रूरी नहीं। दोनों टेक्स्ट एक ही विषय के बारे में हैं और उनके ज़्यादातर अर्थ आपस में मिलते हैं, इसलिए वे वेक्टर स्पेस में पास-पास रहते हैं। रिट्रीवल का काम काम के विकल्प ढूंढना है; जवाब वाले चरण को चंक को ध्यान से पढ़ना चाहिए और सही जवाब देना चाहिए। एक री-रैंकर जो सवाल और चंक को एक साथ पढ़ता है, वह भी ऐसे मामलों को बेहतर तरीके से क्रमबद्ध करने में मदद कर सकता है।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

मैं कोई एम्बेडिंग मॉडल कैसे चुनूँ?

असली सवालों का एक छोटा टेस्ट सेट बनाएं जिनके सही चंक्स आपको पता हों, और उस पर दो या तीन चुनिंदा मॉडल्स को आज़माएं। अपनी भाषाओं में उनकी क्वालिटी, वेक्टर साइज़ (बड़ा होने का मतलब ज़्यादा स्टोरेज), स्पीड, लागत और लाइसेंस को देखें। पब्लिक लीडरबोर्ड एक शुरुआत हो सकते हैं, लेकिन आपका खुद का टेस्ट ज़्यादा मायने रखता है।

क्या मुझे कोसाइन सिमिलैरिटी इस्तेमाल करनी चाहिए या डॉट प्रोडक्ट?

अगर वेक्टर्स 1 की लंबाई में नॉर्मलाइज़्ड हैं, तो वे एक जैसी रैंकिंग देते हैं। कई एम्बेडिंग मॉडल्स इनमें से किसी एक की सलाह देते हैं; मॉडल कार्ड का पालन करें और इंडेक्स बनाते समय और सर्च करते समय एक ही विकल्प का इस्तेमाल करें।

क्या कोई वेक्टर्स से मेरे डॉक्यूमेंट्स पढ़ सकता है?

एम्बेडिंग्स को उतना ही संवेदनशील समझें जितना कि वह टेक्स्ट जिससे वे बने हैं। रिसर्चर्स ने कुछ परिस्थितियों में आंशिक टेक्स्ट रिकवरी करके दिखाई है। रोकथाम के उपायों के लिए वेक्टर स्टोर्स और एम्बेडिंग लीक्स देखें।

किस स्कोर का मतलब "काम का" (relevant) होता है?

कोई एक तय कट-ऑफ नहीं है। स्कोर्स मॉडल और डेटा पर निर्भर करते हैं। अगर आप कोई थ्रेशोल्ड चाहते हैं, तो अपने लेबल किए गए सवालों पर टेस्ट करके उसे चुनें, और जब भी आप मॉडल बदलें तो उसे फिर से चेक करें।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें