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

हाइब्रिड सर्च: कीवर्ड्स और वेक्टर्स

कीवर्ड सर्च सटीक शब्दों, कोड और नामों के लिए बहुत बढ़िया है। वेक्टर सर्च अर्थ (meaning) समझने के लिए बेहतरीन है। हाइब्रिड सर्च दोनों को चलाती है और नतीजों को आपस में मिलाती है।

✦ ट्यूटर से पूछें 🧪 लैब · 40 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

हाइब्रिड सर्च: कीवर्ड्स और वेक्टर्स

1/4

आसान शब्दों में

मान लीजिए भीड़भाड़ वाले मेले में आपका दोस्त खो गया है। आप एक व्यक्ति से अपने दोस्त के नाम का सही नेम टैग ढूंढने को कह सकते हैं, और दूसरे से "नीली शर्ट पहने एक लंबा लड़का" ढूंढने को कह सकते हैं। दोनों ऐसे लोगों को ढूंढते हैं जिन्हें दूसरा छोड़ देता है। दोनों से पूछने और फिर यह देखने पर कि वे दोनों किसकी तरफ इशारा कर रहे हैं, आपका दोस्त तेज़ी से मिल जाता है।

वेक्टर सर्च समान अर्थ वाले टेक्स्ट को ढूंढती है। लेकिन कई असली सवाल सटीक स्ट्रिंग्स पर निर्भर करते हैं: E-4012 जैसा कोई एरर कोड, Form 16 जैसा फॉर्म नंबर, किसी व्यक्ति का नाम, कोई प्रोडक्ट आईडी, या कोई सेक्शन नंबर। एम्बेडिंग्स इन्हें धुंधला कर सकती हैं। कीवर्ड सर्च सटीक शब्दों का मिलान करती है और इसमें बहुत अच्छी होती है।

BM25: क्लासिक कीवर्ड स्कोर

BM25 कीवर्ड्स के आधार पर डॉक्यूमेंट्स को रैंक करने का एक पुराना और परखा हुआ फ़ॉर्मूला है। यह किसी डॉक्यूमेंट को तब बेहतर स्कोर देता है जब:

उसमें सर्च किए गए शब्द हों, और जितनी ज़्यादा बार हों उतना अच्छा, लेकिन एक सीमा के बाद इसका फ़ायदा कम होने लगता है (दसवीं बार आने पर बहुत कम फ़र्क पड़ता है);
वे शब्द पूरे डेटा में दुर्लभ (rare) हों ("the" के मिलान की तुलना में "E-4012" का मिलना ज़्यादा मायने रखता है);
डॉक्यूमेंट असामान्य रूप से लंबा न हो, क्योंकि लंबे डॉक्यूमेंट्स में सिर्फ़ तुक्के से ही कई शब्द मिल जाते हैं।

दो सेटिंग्स इसे कंट्रोल करती हैं: k1 (शब्दों के दोहराव का फ़ायदा कितनी जल्दी कम होता है) और b (डॉक्यूमेंट की लंबाई कितनी मायने रखती है)। आम तौर पर शुरुआती वैल्यूज़ लगभग k1 = 1.2 से 2 और b = 0.75 होती हैं। ज़्यादातर सर्च इंजन और कई डेटाबेस में BM25 या उससे मिलता-जुलता फ़ॉर्मूला शामिल होता है।

सर्च क्वेरी (Query)	कीवर्ड सर्च (BM25)	वेक्टर सर्च
"error E-4012 on checkout"	मजबूत: सटीक कोड ढूंढ लेता है	चेकआउट का कोई भी एरर वापस ला सकता है
"money cut but order not placed"	कमज़ोर अगर डॉक्यूमेंट्स में लिखा हो "payment debited, order failed"	मजबूत: एक ही अर्थ, अलग शब्द
"Form 16 kab milega" (हिंग्लिश)	"Form 16" को बिल्कुल सटीक ढूंढ लेता है	मॉडल की भाषा समझ पर निर्भर करता है
किसी व्यक्ति का दुर्लभ सरनेम	मजबूत	अक्सर कमज़ोर

दो रैंक लिस्ट्स को जोड़ना: रेसिप्रोकल रैंक फ़्यूज़न

दोनों सर्च अलग-अलग पैमानों पर स्कोर देती हैं, इसलिए आप उन्हें सीधे जोड़ नहीं सकते। रेसिप्रोकल रैंक फ़्यूज़न (RRF) मूल स्कोर्स को नज़रअंदाज़ करता है और केवल उनकी रैंक (पोजीशन) का इस्तेमाल करता है। हर डॉक्यूमेंट जिस लिस्ट में आता है, उससे उसे 1 / (k + rank) मिलता है, और इन हिस्सों को जोड़ दिया जाता है। k के लिए एक आम डिफ़ॉल्ट वैल्यू 60 है। जो डॉक्यूमेंट्स दोनों लिस्ट में अच्छी रैंक पाते हैं, वे सबसे ऊपर आ जाते हैं।

Python: reciprocal rank fusionpython

def rrf(rankings, k=60):
    """Fuse several ranked lists of document ids into one ranked list.

    rankings: a list of lists, each ordered best first.
    k: dampening constant; 60 is a common default.
    """
    scores = {}
    for ranking in rankings:
        for rank, doc_id in enumerate(ranking, start=1):
            scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
    # Sort by fused score, highest first; ties broken by id for stable output.
    return sorted(scores, key=lambda d: (-scores[d], d))

keyword_hits = ["faq-12", "manual-3", "faq-7"]
vector_hits = ["faq-7", "faq-12", "blog-1"]
print(rrf([keyword_hits, vector_hits]))
# ['faq-12', 'faq-7', 'manual-3', 'blog-1']

faq-12 एक लिस्ट में पहले और दूसरी में दूसरे स्थान पर है, इसलिए यह जीत जाता है। blog-1 केवल एक बार तीसरे स्थान पर आता है, इसलिए यह सबसे नीचे रहता है। RRF को किसी ट्रेनिंग या स्कोर ट्यूनिंग की ज़रूरत नहीं होती, इसीलिए यह पहली पसंद के तौर पर काफ़ी लोकप्रिय है।

एक सामान्य हाइब्रिड पाइपलाइन

1
पहले फ़िल्टर लगाएं
परमिशन, भाषा, तारीख या डॉक्यूमेंट का प्रकार, जो कोड के ज़रिए लागू किए जाते हैं।
2
कीवर्ड सर्च
BM25 से टॉप रिज़ल्ट्स लें, उदाहरण के लिए टॉप 20 से 50।
3
वेक्टर सर्च
वेक्टर इंडेक्स से भी उतनी ही संख्या में टॉप रिज़ल्ट्स लें।
4
फ़्यूज़ (जोड़ें)
रेसिप्रोकल रैंक फ़्यूज़न के साथ दोनों को मिलाएँ।
5
री-रैंक करें और भेजें
ज़रूरत पड़ने पर फ़्यूज़ की गई लिस्ट को री-रैंक करें (अगला पाठ), फिर सबसे बेहतरीन कुछ को मॉडल के पास भेजें।

नोट

फ़्यूज़ करने का दूसरा तरीका नॉर्मलाइज़्ड स्कोर्स का वेटेड सम (भारित योग) है, जैसे 0.7 × वेक्टर प्लस 0.3 × कीवर्ड। यह अच्छा काम कर सकता है लेकिन इसे ट्यून करने की ज़रूरत होती है, और मॉडल बदलने पर वेट्स बदलने पड़ सकते हैं। RRF एक आसान और बेहतरीन बेसलाइन है जिसे मात देना आसान नहीं है।

सावधान रहें

फ़िल्टर दोनों सर्च पर लागू होने चाहिए। एक आम बग यह होता है कि वेक्टर सर्च यूज़र के परमिशन फ़िल्टर का पालन करती है लेकिन कीवर्ड सर्च नहीं करती, जिससे कोई पाबंदी वाला डॉक्यूमेंट कीवर्ड की तरफ़ से निकलकर पहुँच जाता है। देखें Securing RAG: permissions for retrieved documents।

इसे आज़माएं। RRF कोड में एक तीसरी लिस्ट ["manual-3", "faq-12"] जोड़ें। इसे चलाने से पहले नए क्रम का अंदाज़ा लगाएं। फिर जांचें।

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

लैब

प्योर Python में एक छोटा हाइब्रिड सर्च इंजन: BM25 और बनाए गए वेक्टर्स, जिन्हें RRF से फ़्यूज़ किया गया है।

~40 min

समस्या

स्टार्टर कोड को Python 3 के साथ चलाएं। यह केवल स्टैंडर्ड लाइब्रेरी का इस्तेमाल करता है। वेक्टर्स हाथ से बनाए गए हैं: एक असली सिस्टम में एक एम्बेडिंग मॉडल इन्हें तैयार करेगा।

इसे चलाएं और प्रत्येक क्वेरी के लिए तीन रिज़ल्ट लिस्ट्स को पढ़ें।
एक ऐसी क्वेरी ढूंढें जहाँ कीवर्ड सर्च सही हो और वेक्टर सर्च गलत, और एक ऐसी जहाँ इसका उल्टा हो। दोनों को लिख लें।
अपने खुद के दो डॉक्यूमेंट्स जोड़ें (बनाए गए वेक्टर्स के साथ), और एक नई क्वेरी जोड़ें (उसके अपने बनाए गए वेक्टर के साथ)।
RRF के k को बदलकर 1 करें और फिर 1000 करें। बताएं कि फ़्यूज़ किए गए क्रम में क्या बदलाव आता है।

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

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

रन करने के लिए Ctrl + Enter दबाएं

import math
import re

DOCS = {
    "d1": "Error E-4012 means the bank did not confirm the payment. Wait 30 minutes before retrying.",
    "d2": "If money was debited but the order failed, the amount is usually returned to your account.",
    "d3": "To change your delivery address, open My Orders and choose Edit Address.",
    "d4": "Error E-5001 means the delivery pincode is not serviceable yet.",
}
# Made-up 3-number vectors: [payment, delivery, error-ish]. Real ones come from a model.
VECS = {"d1": [0.7, 0.0, 0.7], "d2": [0.9, 0.1, 0.2], "d3": [0.0, 1.0, 0.0], "d4": [0.0, 0.6, 0.8]}
QUERIES = {
    "what does E-4012 mean": [0.2, 0.4, 0.9],
    "charged, purchase unsuccessful": [0.95, 0.1, 0.1],
}

def tokenize(text):
    return re.findall(r"[a-z0-9]+(?:-[a-z0-9]+)*", text.lower())

class BM25:
    def __init__(self, docs, k1=1.5, b=0.75):
        self.toks = {d: tokenize(t) for d, t in docs.items()}
        self.n = len(docs)
        self.avgdl = sum(len(t) for t in self.toks.values()) / self.n
        self.df = {}
        for toks in self.toks.values():
            for term in set(toks):
                self.df[term] = self.df.get(term, 0) + 1
        self.k1, self.b = k1, b

def idf(self, term):
        n = self.df.get(term, 0)
        return math.log(1 + (self.n - n + 0.5) / (n + 0.5))

def score(self, query, doc_id):
        toks, s = self.toks[doc_id], 0.0
        for term in tokenize(query):
            tf = toks.count(term)
            if tf:
                norm = 1 - self.b + self.b * len(toks) / self.avgdl
                s += self.idf(term) * tf * (self.k1 + 1) / (tf + self.k1 * norm)
        return s

def search(self, query, k=3):
        scored = [(self.score(query, d), d) for d in self.toks]
        return [d for s, d in sorted(scored, key=lambda x: (-x[0], x[1])) if s > 0][:k]

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))

def vector_search(qvec, k=3):
    return sorted(VECS, key=lambda d: (-cosine(qvec, VECS[d]), d))[:k]

def rrf(rankings, k=60):
    scores = {}
    for ranking in rankings:
        for rank, doc_id in enumerate(ranking, start=1):
            scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
    return sorted(scores, key=lambda d: (-scores[d], d))

bm25 = BM25(DOCS)
for q, qvec in QUERIES.items():
    kw, vec = bm25.search(q), vector_search(qvec)
    print(q)
    print("  keyword:", kw)
    print("  vector: ", vec)
    print("  fused:  ", rrf([kw, vec]))

आउटपुट

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

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

स्क्रिप्ट चलती है और प्रत्येक क्वेरी के लिए कीवर्ड, वेक्टर और फ़्यूज़ की गई लिस्ट्स को प्रिंट करती है
आपने एक-एक लाइन के कारण के साथ ऐसी क्वेरी ढूंढ ली है जहाँ हर तरीका दूसरे से बेहतर साबित होता है
आपके नए डॉक्यूमेंट्स और क्वेरी आउटपुट में दिखाई देते हैं
आपने बताया है कि बहुत छोटा या बहुत बड़ा k फ़्यूज़ किए गए क्रम को कैसे बदलता है

कठिन सवाल

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

Q1स्टार्टर में, टोकनाइज़र "e-4012" को "e" और "4012" में अलग करने के बजाय एक टोकन के रूप में क्यों रखता है?दिखाएं

क्योंकि वह कोड अपने आप में एक अर्थपूर्ण इकाई है। अगर इसे अलग किया जाता, तो "e" से शायद ही कोई काम का नतीजा मिलता और "4012" कीमतों या सालों जैसे असंबंधित नंबरों से मैच हो सकता था। हाइफ़न वाले कोड को एक साथ रखने से यह दुर्लभ, सटीक शब्द BM25 में पूरी तरह गिना जाता है। असली सर्च इंजनों में इसके लिए एनालाइज़र होते हैं; जांचें कि आपका सर्च इंजन कोड, आईडी और हाइफ़न को कैसे संभालता है।

Q2कीवर्ड सर्च केवल 1 नतीजा देती है और वेक्टर सर्च 3 देती है। RRF उस डॉक्यूमेंट के साथ कैसा व्यवहार करता है जो केवल वेक्टर्स द्वारा मिला है?दिखाएं

इसे अभी भी वेक्टर लिस्ट से 1/(k + rank) का स्कोर मिलता है, बस कीवर्ड लिस्ट से कुछ नहीं मिलता। इसलिए यह फ़्यूज़ किए गए नतीजे में दिख सकता है, आम तौर पर उन डॉक्यूमेंट्स के नीचे जो दोनों में पाए गए हैं। RRF के लिए यह ज़रूरी नहीं है कि दोनों लिस्ट्स की लंबाई बराबर हो, और किसी लिस्ट में न मिलने वाले डॉक्यूमेंट का स्कोर बस शून्य जुड़ता है।

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

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

क्या कीवर्ड सर्च अब पुरानी हो चुकी है?

नहीं। यह तेज़, सस्ती, समझने में आसान और सटीक शब्दों के लिए बेहतरीन है। कई बेहतरीन RAG सिस्टम हाइब्रिड सर्च का इस्तेमाल करते हैं क्योंकि दोनों तरीके एक-दूसरे की कमियों को पूरा करते हैं।

RRF में k आम तौर पर लगभग 60 क्यों होता है?

जब RRF को पहली बार पेश किया गया था, तब इसी वैल्यू का इस्तेमाल किया गया था, और यह कई मामलों में अच्छा काम करती है। एक बड़ा k रैंक 1 और रैंक 5 के बीच के अंतर को कम कर देता है। आप इसे अपने टेस्ट सेट पर ट्यून कर सकते हैं, लेकिन नतीजे अक्सर इसके प्रति बहुत ज़्यादा संवेदनशील नहीं होते।

कीवर्ड सर्च भारतीय भाषाओं को कैसे संभालती है?

यह इस बात पर निर्भर करता है कि आपका सर्च इंजन किस टोकनाइज़र और टेक्स्ट एनालिसिस का इस्तेमाल करता है। जांचें कि यह हर लिपि के लिए शब्दों को सही ढंग से अलग करता है, और याद रखें कि लैटिन अक्षरों में लिखी गई क्वेरी ("paisa") केवल कीवर्ड्स के आधार पर देवनागरी (पैसा) से मैच नहीं होगी। अगला पाठ इसी बारे में है।

क्या मुझे हाइब्रिड सर्च के लिए दो अलग सिस्टम्स की ज़रूरत है?

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

पाठ का टेस्ट

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

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

हाइब्रिड सर्च: कीवर्ड्स और वेक्टर्स

हाइब्रिड सर्च: कीवर्ड्स और वेक्टर्स

BM25: क्लासिक कीवर्ड स्कोर

दो रैंक लिस्ट्स को जोड़ना: रेसिप्रोकल रैंक फ़्यूज़न

एक सामान्य हाइब्रिड पाइपलाइन

पहले फ़िल्टर लगाएं

कीवर्ड सर्च

वेक्टर सर्च

फ़्यूज़ (जोड़ें)

री-रैंक करें और भेजें

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

समस्या

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

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

कठिन सवाल

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