दो-चरणीय पुनर्प्राप्ति क्यों काम करती है
एक-चरणीय पुनर्प्राप्ति में रिकॉल और सटीकता के बीच समझौते को समझें और जानें कि तेज़ मोटे पुनर्प्राप्तकर्ता के बाद धीमा लेकिन सटीक पुनः-रैंककर्ता दोनों के लाभ कैसे देता है।
दो-चरणीय पुनर्प्राप्ति क्यों काम करती है, CoddyKit पर AI Engineering Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह AI Engineering Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। AI Engineering Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
पुनर्प्राप्ति में Recall-Precision का समझौता
हर retrieval system को एक मूलभूत समझौते का सामना करना पड़ता है: recall यह मापता है कि आपको कितने प्रासंगिक documents मिले (क्या कोई छूट गया?), जबकि precision यह मापता है कि शीर्ष परिणाम कितने सटीक हैं (प्राप्त documents में से वास्तव में कितने प्रासंगिक हैं?)। दोनों को एक साथ अधिकतम करना computational रूप से महँगा है। तेज़ पुनर्प्राप्तकर्ता recall के लिए precision का त्याग करते हैं; सटीक rankers accuracy के लिए speed का त्याग करते हैं।
Bi-Encoder बनाम Cross-Encoder: मुख्य अंतर
Two-stage retrieval के केंद्र में मौजूद दोनों प्रकार के models इस बात में भिन्न हैं कि वे query और document को कैसे देखते हैं। एक bi-encoder query और प्रत्येक document को स्वतंत्र रूप से encode करता है और उनके vectors के बीच similarity मापता है — यह तेज़ होता है, लेकिन स्वतंत्र encoding से सीमित रहता है। एक cross-encoder query और document को एक ही input के रूप में जोड़कर देखता है, जिससे दोनों के बीच गहरा interaction संभव होता है — यह अत्यधिक सटीक होता है, लेकिन candidate set पर O(n) complexity रखता है।
# Bi-encoder: compute query embedding ONCE, compare to all doc embeddings
# O(1) query encoding + O(n) dot products via ANN index = fast
query_vec = embed(query) # done once
results = vector_index.search(query_vec, top_k=100) # fast ANN search
# Cross-encoder: re-scores (query, doc) pairs jointly
# O(k) forward passes for k candidate documents = slow but accurate
for doc in results[:100]:
score = cross_encoder.score(query, doc.text) # joint scoringचरण 1: तेज़ मोटी पुनर्प्राप्ति
पहला चरण एक तेज़ पुनर्प्राप्तकर्ता होता है — सामान्यतः approximate nearest neighbor index या BM25 index वाला bi-encoder — जो उच्च recall लेकिन सीमित precision के साथ बड़ा candidate set (50-200 documents) प्राप्त करता है। लक्ष्य सटीक होना नहीं, बल्कि प्रासंगिक documents को न चूकना है। हम व्यापक दायरा रखते हैं और कुछ false positives स्वीकार करते हैं, क्योंकि दूसरा चरण उन्हें छाँट देगा।
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
# Stage 1: retrieve 100 candidates (high recall, modest precision)
vectorstore = FAISS.from_documents(documents, OpenAIEmbeddings())
coarse_retriever = vectorstore.as_retriever(
search_kwargs={'k': 100} # large candidate set
)
candidates = coarse_retriever.invoke(query)
print(f'Stage 1: retrieved {len(candidates)} candidate documents')चरण 2: सटीक Cross-Encoder Re-ranking
दूसरा चरण, चरण 1 से candidate set लेकर, एक cross-encoder की सहायता से प्रत्येक (query, document) जोड़ी का स्कोर फिर से निकालता है, जो दोनों को साथ पढ़ता है। चूँकि यह पूरे corpus के बजाय केवल 50-200 candidates को process करता है, इसलिए महँगी joint encoding संभव होती है। जोड़े गए input पर cross-encoder का गहरा attention, bi-encoder की तुलना में वास्तविक relevance का अनुमान लगाने में कहीं अधिक सटीक होता है।
from sentence_transformers import CrossEncoder
reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
def rerank(query: str, candidates: list[str], top_k: int = 5) -> list[str]:
# Score each (query, document) pair jointly
pairs = [[query, doc] for doc in candidates]
scores = reranker.predict(pairs)
# Sort by score descending
ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
return [doc for doc, _ in ranked[:top_k]]
candidate_texts = [doc.page_content for doc in candidates]
final_docs = rerank(query, candidate_texts, top_k=5)
print(f'Stage 2: selected top {len(final_docs)} documents after re-ranking')यह संयोजन क्यों काम करता है
Two-stage design एक महत्वपूर्ण असमानता का लाभ उठाता है: पहले चरण का तेज़ ANN search लाखों documents तक milliseconds में scale हो सकता है, जबकि दूसरे चरण का सटीक cross-encoder केवल छोटे candidate pool पर काम करता है। आपको approximate search की scalability और exact joint scoring की accuracy दोनों मिलती हैं। पूरी pipeline तेज़ और अत्यधिक सटीक होती है — ऐसा कोई भी चरण अकेले हासिल नहीं कर सकता।
Two-Stage Retrieval की Latency Profile
एक सामान्य two-stage pipeline में: चरण 1 (1M documents पर vector ANN search) में 5-20ms लगते हैं; चरण 2 (100 candidates पर cross-encoder) में document की लंबाई और hardware के आधार पर 100-500ms लगते हैं। कुल latency budget 150-600ms होता है — अधिकांश applications के लिए स्वीकार्य। चरण 2 में GPU acceleration से छोटे documents की re-ranking 30ms से कम समय में हो सकती है, जिससे latency-संवेदी applications में यह pipeline single-stage retrieval की प्रतिस्पर्धी बन जाती है।
import time
def two_stage_search(query, coarse_retriever, reranker, top_k=5):
t0 = time.perf_counter()
candidates = coarse_retriever.invoke(query) # stage 1
t1 = time.perf_counter()
candidate_texts = [c.page_content for c in candidates]
final_docs = rerank(query, candidate_texts, top_k) # stage 2
t2 = time.perf_counter()
print(f'Stage 1 (retrieval): {(t1-t0)*1000:.1f}ms')
print(f'Stage 2 (re-ranking): {(t2-t1)*1000:.1f}ms')
print(f'Total: {(t2-t0)*1000:.1f}ms')
return final_docsसही Candidate Set आकार चुनना
पहले चरण के candidate set का आकार एक महत्वपूर्ण hyperparameter है। आकार बहुत छोटा (मान लें, 10) होने पर re-ranking शुरू होने से पहले ही प्रासंगिक documents छूट सकते हैं। आकार बहुत बड़ा (मान लें, 500) होने पर चरण 2 की latency बहुत बढ़ जाती है। recall at N curve — N के अलग-अलग मानों पर प्राप्त किए गए प्रासंगिक documents की संख्या — इस चयन का मार्गदर्शन करती है। सामान्यतः 50 से 150 candidates के बीच सबसे अच्छा संतुलन मिलता है, जहाँ recall लगभग saturation पर होता है, लेकिन latency अभी भी नियंत्रित रहती है।
def recall_at_n(coarse_retriever, test_queries, golden_relevant, n_values):
for n in n_values:
recalls = []
for query, relevant in zip(test_queries, golden_relevant):
# Temporarily set k to n
coarse_retriever.search_kwargs['k'] = n
results = coarse_retriever.invoke(query)
retrieved_ids = {r.metadata.get('id') for r in results}
relevant_found = len(set(relevant) & retrieved_ids)
recalls.append(relevant_found / len(relevant))
avg = sum(recalls) / len(recalls)
print(f'N={n}: recall={avg:.3f}')Hybrid प्रथम चरण + Cross-Encoder द्वितीय चरण
सबसे शक्तिशाली two-stage configuration में प्रथम चरण के रूप में hybrid retriever (dense + BM25) और द्वितीय चरण के रूप में cross-encoder का संयोजन होता है। Hybrid retrieval semantic और keyword matching को मिलाकर प्रथम चरण के recall को अधिकतम करता है, फिर cross-encoder संयुक्त candidate pool में से सबसे प्रासंगिक documents का सटीक चयन करता है। यह configuration मानक परीक्षणों पर लगातार अत्याधुनिक retrieval quality प्राप्त करता है।
from langchain.retrievers import EnsembleRetriever
# Stage 1: hybrid retrieval for maximum recall
hybrid_retriever = EnsembleRetriever(
retrievers=[bm25_retriever, vector_retriever],
weights=[0.4, 0.6],
)
# Stage 2: cross-encoder re-ranking for high precision
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder
cross_encoder_model = HuggingFaceCrossEncoder(model_name='cross-encoder/ms-marco-MiniLM-L-6-v2')
compressor = CrossEncoderReranker(model=cross_encoder_model, top_n=5)
from langchain.retrievers import ContextualCompressionRetriever
two_stage = ContextualCompressionRetriever(
base_compressor=compressor,
base_retriever=hybrid_retriever,
)Commercial Re-ranking APIs
यदि आप अपना model manage किए बिना cross-encoder की accuracy चाहते हैं, तो Cohere Rerank और Jina AI Reranker दोनों cloud-hosted re-ranking APIs उपलब्ध कराते हैं। आप एक query और document texts की सूची भेजते हैं और बदले में relevance scores प्राप्त करते हैं। ये APIs बड़े cross-encoder models (अक्सर 500M+ parameters) का उपयोग करती हैं, जो self-hosted छोटे cross-encoders से बेहतर प्रदर्शन करते हैं, लेकिन इनके लिए अतिरिक्त API latency (50-300ms) और प्रत्येक re-ranked document के अनुसार शुल्क देना पड़ता है।
import cohere
co = cohere.Client('YOUR_API_KEY')
def cohere_rerank(query: str, documents: list[str], top_k: int = 5):
response = co.rerank(
model='rerank-english-v3.0',
query=query,
documents=documents,
top_n=top_k,
)
return [
{'text': documents[r.index], 'score': r.relevance_score}
for r in response.results
]
final = cohere_rerank(query, candidate_texts, top_k=5)
for doc in final:
print(f'Score {doc["score"]:.3f}: {doc["text"][:80]}')Two-Stage कब अनावश्यक है
Single-stage की तुलना में two-stage retrieval जटिलता और latency बढ़ाता है। यह हमेशा आवश्यक नहीं होता। 10,000 से कम documents वाले छोटे corpora के लिए, पूरे set पर एक single cross-encoder पर्याप्त तेज़ हो सकता है। जिन applications में 100ms से कम latency महत्वपूर्ण है और accuracy में लाभ सीमित है, वहाँ single-stage dense retrieval बेहतर हो सकता है। जब आपके पास बड़ा corpus, accuracy की ऊँची आवश्यकताएँ और 200-500ms retrieval latency सहने की क्षमता हो, तभी two-stage का उपयोग करें।
अत्यधिक Scale के लिए Three-Stage Retrieval
करोड़ों दस्तावेज़ों वाले कॉर्पस के लिए कभी-कभी तीन-चरणीय पाइपलाइन का उपयोग किया जाता है: पहले चरण में ANN की सहायता से 10,000 उम्मीदवार प्राप्त किए जाते हैं, दूसरे चरण में तेज़ छोटे क्रॉस-एनकोडर का उपयोग करके उन्हें 100 तक पुनः-रैंक किया जाता है, और तीसरे चरण में बड़े शक्तिशाली क्रॉस-एनकोडर से उन्हें 5 तक पुनः-रैंक किया जाता है। प्रत्येक चरण छोटे सेट पर अधिक महँगा और अधिक सटीक मॉडल लागू करता है। इस आर्किटेक्चर का उपयोग बड़े पैमाने के खोज इंजन और दस्तावेज़ प्रश्न-उत्तर प्रणालियों में किया जाता है।
त्वरित जाँच
इस पाठ से यह समझ जाँचें कि दो-चरणीय पुनर्प्राप्ति क्यों काम करती है।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: द्वि-एनकोडर तेज़ होते हैं, लेकिन स्वतंत्र क्वेरी-दस्तावेज़ एनकोडिंग तक सीमित रहते हैं; क्रॉस-एनकोडर संयुक्त एनकोडिंग के कारण सटीक होते हैं, लेकिन पूरे कॉर्पस में खोज के लिए बहुत धीमे होते हैं; और दो-चरणीय पुनर्प्राप्ति दोनों को जोड़ती है: उच्च रिकॉल के लिए तेज़ पहला चरण, जिसके बाद उच्च प्रिसीजन के लिए सटीक दूसरा चरण आता है। प्रासंगिक दस्तावेज़ छूटने से बचाने के लिए पहला चरण आवश्यकता से कहीं अधिक उम्मीदवार प्राप्त करता है। अब हम Cohere और BGE की सहायता से क्रॉस-एनकोडर पुनः-रैंकिंग लागू करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “दो-चरणीय पुनर्प्राप्ति क्यों काम करती है” पाठ निःशुल्क है?
हाँ—“दो-चरणीय पुनर्प्राप्ति क्यों काम करती है” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और AI Engineering Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। AI Engineering Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“दो-चरणीय पुनर्प्राप्ति क्यों काम करती है” में मैं क्या सीखूँगा?
एक-चरणीय पुनर्प्राप्ति में रिकॉल और सटीकता के बीच समझौते को समझें और जानें कि तेज़ मोटे पुनर्प्राप्तकर्ता के बाद धीमा लेकिन सटीक पुनः-रैंककर्ता दोनों के लाभ कैसे देता है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ AI Engineering Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या AI Engineering Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर AI Engineering Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“दो-चरणीय पुनर्प्राप्ति क्यों काम करती है” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस AI Engineering Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर AI Engineering Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- दो-चरणीय पुनर्प्राप्ति क्यों काम करती है
- Cohere और BGE के साथ क्रॉस-एन्कोडर पुनः-रैंकिंग
- संदर्भपरक संपीड़न और प्रासंगिकता फ़िल्टरिंग
- पुनः-रैंकिंग के प्रभाव को मापना