RAG pipeline steps की एक line है: query से retrieval, retrieval से prompt, और prompt से LLM का जवाब। LLM को आप बदल नहीं सकते, इसलिए जवाब सुधारने के लिए आप उससे पहले के steps बदलते हैं। Stanford की slide ऐसी pipeline के तीन रूप दिखाती है: Naive, Advanced और Modular RAG।
इसकी ज़रूरत lesson 5 के आख़िर में दिखी थी। वहाँ retriever और generator साथ में train होते थे। लेकिन API से लिए LLM के parameters आप नहीं बदल सकते, जैसे GPT या Gemini के। तब lesson 2 की दोनों गलतियाँ लौट आती हैं। when can I get help from a TA पर retriever एक भी passage नहीं लौटाता। which office hour is least crowded पर पुराना forum post queue log के बराबर score पाता है।
इस lesson की सीढ़ी
सीढ़ी में 10 पड़ाव हैं। पहले 5 आसान version जैसे ही हैं, और 6 से 10 आपको Stanford की slides के level तक ले जाते हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।
Frozen LLM और pipelineबता पाएँगे कि API वाले LLM के साथ lesson 5 की training क्यों नहीं चलती।
पहले से क्या चाहिए: Lesson 2 (retriever, word overlap, stopwords, recall ceiling), Lesson 3 (embedding, index) और Lesson 5 (RAG model, concatenate, Exact Match)। पड़ाव 9 में Lesson 4 (conditional probability, chain rule) भी काम आता है। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।
1Frozen LLM: आप सिर्फ़ prompt बदल सकते हैं
Frozen LLM वो LLM है, जिसके parameters आप नहीं बदल सकते। आप उसे सिर्फ़ prompt भेजते हैं, और जवाब पाते हैं। API वाले LLM के company के server पर हैं, इसलिए आपके लिए वो frozen है।
Lesson 5 का RAG इस हालत में train नहीं हो सकता। वहाँ एक ही loss से retriever और generator, दोनों के parameters बदलती थी। Frozen LLM के parameters बदल ही नहीं सकते, इसलिए ये रास्ता बंद है।
तो बदलने को वो सब बचता है, जो LLM तक पहुँचने से पहले होता है: query, retriever और prompt। Pipeline steps की ऐसी line है, जिसमें हर step का output अगले step का input बनता है। जैसे retriever का output top-K passages हैं, और वही passages prompt का input बनते हैं।
Pipeline में top-K passages एक ही prompt में जाते हैं। Lesson 5 में हर passage के साथ generator अलग से चलता था, और फिर वज़न वाला जोड़ होता था। यहाँ LLM को कुछ ऐसा prompt मिलता है: मेरा example
Answer using only the passages below. Cite passage IDs. [P3] Queue log, last 3 weeks: Tuesday 4pm office hour averaged 14 students waiting; Thursday 9am office hour averaged 3. [P2] Office hours: Tuesday 4pm in Room 104 and Thursday 9am on Zoom, run by the TAs. Question: Which office hour is least crowded, and where is it?
LLM खुद तय करता है कि कौन सी बात किस passage से ले: Thursday 9am queue log से, और Zoom office hours page से। [P3] और [P2] lesson 2 के corpus वाले ID हैं, ताकि जवाब citation दे सके।
इस आज़ादी की कीमत ये है कि LLM अपनी गलती से कुछ नहीं सीखता, और retriever को उस गलती का पता ही नहीं चलता। यानी lesson 2 वाली हालत लौट आई, जिसमें retriever और reader अलग-अलग बने थे। इसलिए हर step को अलग से अच्छा बनाना पड़ता है, और बाकी lesson यही steps दिखाता है।
2Naive RAG: indexing time और query time
Naive RAG सबसे सीधी pipeline है: पहले से बना index, और फिर हर query पर retrieval, prompt और frozen LLM। बीच में कोई extra step नहीं है, इसलिए इसे naive, यानी सीधा-सादा, कहते हैं। इसके steps उन्हीं दो हिस्सों में बँटते हैं, जो lesson 3 में थे।
Pipeline की भाषा में इन दो हिस्सों को indexing time और query time कहते हैं। Indexing time के steps एक बार चलते हैं: documents को passages में तोड़िए, हर passage का बनाइए, और सबको में रखिए। Embedding वो vector है, जो encoder किसी text से बनाता है।
Documents2,000 documents
Passages में तोड़िए60,000 passages
Index60,000 embeddings, एक बार
Indexing time: ये line एक बार चलती है। Numbers lesson 2 की company से हैं: 2,000 documents × 30 paragraphs = 60,000 passages। मेरा example
Query time के steps हर query पर चलते हैं:
Query1 embedding
Retrieve60,000 dot products, top-5
Prompt5 × 500 tokens + सवाल
Frozen LLMRead, 1 call
Query time: ये line हर query पर चलती है। मेरा example
यानी हर query पर 1 embedding, 60,000 और 1 LLM call लगती है। Prompt में passages के 5 × 500 = 2,500 tokens जाते हैं। Query time के दो मुख्य steps के नाम Retrieve और Read हैं। Read में LLM passages पढ़कर जवाब लिखता है, lesson 2 के की तरह।
Stanford की slide का बायाँ हिस्सा: Naive RAG। Documents से Indexing तक indexing time है, और Query से Output तक query time। Frozen LLM के आगे बर्फ़ का निशान है। Image पर click करने से वो पूरे size में खुलती है।
अब शुरू वाले दोनों सवाल इस pipeline पर चलाइए। Retriever के लिए lesson 2 का लेते हैं, क्योंकि उसका हर score आप हाथ से गिन सकते हैं। Word overlap गिनता है कि query के कितने शब्द passage में भी हैं, और गिनने से पहले which और is जैसे हटाता है।
Query
Retriever ने क्या लौटाया
K = 2 पर LLM को क्या मिला
when can I get help from a TA
कुछ नहीं, हर passage का score 0।
कुछ नहीं। Office hours page, जिसमें जवाब है, LLM तक नहीं पहुँचा।
which office hour is least crowded
Queue log (2), पुराना forum post (2), office hours page (1)।
Queue log और forum post, यानी सही data के साथ 2024 की पुरानी राय।
दोनों गलतियाँ अलग किस्म की हैं। TA वाले सवाल पर सही passage आया ही नहीं, और यही lesson 2 की है। Least crowded वाले सवाल पर सही passage आया, लेकिन गलत passage भी बराबर score लेकर साथ आया, यानी ये क्रम की गलती है। दोनों गलतियाँ LLM तक पहुँचने से पहले हो चुकी हैं, इसलिए LLM कितना भी अच्छा हो, वो इन्हें ठीक नहीं कर सकता।
पहले सोचिए
Corpus में 500 नए passages जुड़े, और एक पुराना document बदल गया। Naive RAG में कौन से steps दोबारा चलाने होंगे, और कौन से नहीं?
जवाब देखिए
सिर्फ़ indexing time के steps, और वो भी सिर्फ़ बदले हुए text के लिए। 500 नए passages के embeddings बनाकर index में जोड़िए, और बदले document के passages के embeddings दोबारा बनाइए। ऐसा न करें, तो index पुराना text लौटाता रहेगा। Query time के steps वैसे ही चलते हैं, और LLM में कुछ नहीं बदलता।
3Pre-retrieval: retrieval से पहले query सुधारना
Pre-retrieval वो steps हैं, जो query को retriever तक भेजने से पहले सुधारते हैं। Slide पर इनके तीन नाम हैं: query routing, query rewriting और query expansion। पहले TA वाले सवाल पर expansion देखिए, क्योंकि ये सवाल query के शब्दों की वजह से हारा।
Stopwords हटाने के बाद इस query में help और ta बचते हैं। Office hours page में TAs लिखा है, ta नहीं, और word overlap शब्दों को हूबहू मिलाता है। help किसी passage में नहीं है। यानी जवाब वाला passage corpus में है, बस query के शब्द उससे नहीं मिलते।
Query expansion query में उससे जुड़े शब्द जोड़ता है, ताकि वो passages के शब्दों से मिल सके। TA वाली query में office hours जोड़िए, तो retriever के पास चार शब्द हैं: help, ta, office और hours। मेरा example
Passage
मिले शब्द
Expansion से पहले
Expansion के बाद
Office hours page
office, hours
0
2
Queue log
office इसमें hour लिखा है, hours नहीं।
0
1
बाकी चार passages
कोई नहीं
0
0
अब office hours page सबसे ऊपर है, और LLM तक पहुँचता है। ये शब्द अक्सर एक LLM जोड़ता है, जिसे छोटा prompt मिलता है: इस सवाल से जुड़े search शब्द लिखिए।
बाकी दो steps भी query पर काम करते हैं। Query rewriting पूरी query दोबारा लिखता है। जैसे user छोटे रूप में पूछे OH timings?, तो एक LLM उसे CS 329Z office hours schedule बना देता है। Query routing तय करता है कि किस index में ढूँढना है। जैसे when is the project milestone due syllabus वाले index में जाए।
Pipeline के steps चालू-बंद कीजिए
Retriever lesson 2 वाला word overlap है। Expansion query में शब्द जोड़ता है। Rerank लौटे हुए passages को दूसरे score से दोबारा sort करता है, और वो अगले पड़ाव में आता है। rerank scores मेरे बनाए हैं
#
Passage
Overlap
Rerank
इन steps की कीमत है। Rewriting और expansion के लिए अक्सर हर query पर एक extra LLM call लगती है, इसलिए जवाब धीमा और महँगा होता है। ये query का मतलब भी बदल सकते हैं: model OH को Ohio समझ ले, तो search गलत जगह जाएगी।
पहले सोचिए
Widget में which office hour is least crowded चुनिए। Expansion इस query में waiting जोड़ता है। Queue log और पुराने forum post का नया score क्या होगा? फिर widget में check कीजिए।
जवाब देखिए
Query के शब्द अब office, hour, least, crowded और waiting हैं। Queue log में office, hour और waiting हैं, इसलिए score 3। Forum post में least और crowded हैं, इसलिए score 2। अब queue log अकेला सबसे ऊपर है, लेकिन K = 2 पर forum post अब भी prompt में जाता है।
4Post-retrieval: लौटी list सुधारना
Post-retrieval वो steps हैं, जो retriever की लौटाई list को prompt में जाने से पहले सुधारते हैं। Slide पर इनके तीन नाम हैं: rerank, summary और fusion। पहले least crowded वाले सवाल पर rerank देखिए, क्योंकि वहाँ गलती क्रम की थी।
Retriever ने queue log और forum post को बराबर 2 दिया। उसे नहीं दिखता कि queue log तीन हफ़्ते का data है, और forum post 2024 की एक राय।
Retriever तेज़ है, क्योंकि वो हर passage को मोटे तौर पर देखता है। लौटे हुए passages गिनती में कम हैं, इसलिए उन पर एक धीमा लेकिन ज़्यादा सटीक model चल सकता है। ये model query और passage को साथ पढ़कर नया score देता है, और list दोबारा sort करता है। इसे rerank कहते हैं, और इस model को reranker। Reranker कैसे बनता है, ये lesson 14 में है।
Retriever ने तीन passages लौटाए थे, और reranker उनमें से forum post को सबसे नीचे रखता है: rerank scores मेरे बनाए हैं
Passage
Retriever score
Reranker score
K = 2 पर LLM तक?
Queue log
2
0.92
हाँ
Office hours page
1
0.41
हाँ
पुराना forum post
2
0.35
नहीं
K = 2 पर अब queue log और office hours page जाते हैं, और ये जोड़ी पूरा जवाब देती है। Queue log बताता है कि Thursday 9am में भीड़ कम है, और office hours page बताता है कि वो Zoom पर है। यही वो prompt है, जो पड़ाव 1 में दिखा था।
पहले सोचिए
Widget में TA वाली query चुनिए। Expansion बंद रखिए, और Rerank चालू कीजिए। क्या office hours page अब LLM तक पहुँचेगा?
जवाब देखिए
नहीं। Retriever ने एक भी passage नहीं लौटाया, तो reranker के पास sort करने को कुछ है ही नहीं। अब Expansion भी चालू कीजिए: office hours page list में आता है, और rerank उसे सबसे ऊपर रखता है।
Reranker सिर्फ़ उन्हीं passages का क्रम बदलता है, जो retriever ने लौटाए। इसलिए दोनों तरह के steps अलग गलती ठीक करते हैं। Pre-retrieval छूटे हुए passage को list में लाता है, और post-retrieval list का क्रम सुधारता है।
Retrieval के बाद दो और steps आते हैं। पहला summary है: passages को prompt में डालने से पहले छोटा करना। Lesson 1 की context window में passages के लिए 7,000 tokens की जगह थी, यानी 500 tokens वाले 14 passages। हर passage 100 tokens का हो जाए, तो वही 14 passages 14 × 100 = 1,400 tokens लेते हैं। मेरा example खतरा ये है कि summary कोई ज़रूरी detail गिरा दे, जैसे Room 104।
दूसरा fusion है: कई ranked lists को मिलाकर एक list बनाना। मान लीजिए आपने original query से भी ढूँढा, और rewrite की हुई query office hours schedule से भी। पहली list है queue log, forum post, office hours page। दूसरी में सिर्फ़ office hours page (2) और queue log (1) हैं। ये दोनों passages दोनों lists में हैं, इसलिए मिली हुई list में उन्हें ऊपर आना चाहिए। मिलाने का पक्का हिसाब lesson 14 में है।
Naive RAG में pre-retrieval और post-retrieval steps जोड़ने से जो pipeline बनती है, उसे Advanced RAG कहते हैं।
Stanford की slide का बीच वाला हिस्सा: Advanced RAG। नारंगी boxes नए steps हैं: Retrieval से ऊपर Pre-Retrieval के तीन steps, और नीचे Post-Retrieval के तीन।
5Modular RAG: modules और patterns
Modular RAG pipeline को modules में देखता है, जिन्हें आप किसी भी क्रम में जोड़ सकते हैं। Module pipeline का एक हिस्सा है, जो एक काम करता है, जैसे Retrieve, Rerank या Read। Modules के एक तय क्रम को pattern कहते हैं। जैसे Naive RAG का pattern है: Retrieve, फिर Read।
इसकी ज़रूरत उन सवालों पर पड़ती है, जिनके जवाब के हिस्से अलग-अलग passages में हैं। Advanced RAG भी हर सवाल पर एक ही बार ढूँढता है, इसलिए जो पहली search में नहीं आया, वो कभी नहीं आता। जिस सवाल के लिए कई बार ढूँढना पड़े, उसे multi-hop question कहते हैं।
हमारे corpus में भी ऐसा सवाल है: पड़ाव 1 के prompt वाला Which office hour is least crowded, and where is it? इसका पहला हिस्सा queue log में है, और दूसरा office hours page में। Office hours page में जगह Thursday 9am के आगे लिखी है, इसलिए उसे ढूँढने के लिए पहले Thursday 9am पता होना चाहिए।
अब Retrieve, Read, Retrieve, Read वाला pattern चलाइए, जिसमें पहली Read का जवाब दूसरी search की query में जुड़ता है। K = 2 है, और retriever वही word overlap। मेरा example
पहली Retrieve: query में office, hour, least, crowded और where बचते हैं, और where किसी passage में नहीं है। Queue log और forum post को 2-2 मिलता है, इसलिए यही दोनों लौटते हैं।
पहली Read: मान लीजिए LLM queue log का data चुनकर लिखता है: Thursday 9am। जगह इन दोनों passages में नहीं है।
दूसरी Retrieve: query के आगे पहला जवाब, Thursday 9am, जोड़िए। अब thursday और 9am भी गिनती में आते हैं।
दूसरी Read: K = 2 पर queue log और office hours page मिलते हैं, यानी पड़ाव 1 वाला prompt। LLM लिखता है: Thursday 9am, Zoom पर।
Passage
पहली search
दूसरी search
Queue logoffice, hour, फिर thursday, 9am भी
2
4
Office hours pageoffice, फिर thursday, 9am भी
1
3
पुराना forum postleast, crowded
2
2
Syllabusदूसरी बार thursday
0
1
इस pattern का नाम ITER-RETGEN है। इसका paper भी पिछले जवाब और सवाल को मिलाकर अगली query बनाता है। paper सेRerank सिर्फ़ लौटी list का क्रम बदलता है, जबकि ITER-RETGEN नई query से दोबारा ढूँढता है।
इसकी एक हद भी है। पहली Read का जवाब गलत हो, तो दूसरी search भी गलत दिशा में जाती है। जैसे LLM forum post पर भरोसा करके Wednesday लिखे, तो दूसरी query में Thursday 9am आएगा ही नहीं।
Lecture में एक असली multi-hop सवाल भी है: Who is older, Jed Hoyer or John William Henry II? Slide पर इस सवाल पर एक model का trace है, जो lesson 17 में पूरा आएगा। पहली search Jed Hoyer के career वाला passage लाती है, जिसमें जन्म-तारीख नहीं है। अगली search John William Henry II की है, और उसका passage बताता है: born September 13, 1949। तीसरी search Jed Hoyer birth year की है, यानी हर search इस पर टिकी है कि पिछली बार पढ़कर क्या मिला।
Stanford की slide: Search-R1 नाम के model का trace। <search> वाली lines model की searches हैं, और <information> वाली lines लौटे passages।
Stanford की slide चार patterns दिखाती है, जो Gao और साथियों के survey (2024) से हैं:
DSP का Demonstrate module prompt में सवाल से पहले हल किए हुए examples रखता है, जैसे Q: When is the milestone due? A: Week 6, Thursday [P1]। मेरा example ऐसे examples को demonstrations कहते हैं, और इस तरीके को few-shot prompting। ये lesson 2 के से अलग है, जहाँ prompt में सिर्फ़ instruction थी।
Slide के modules वाले हिस्से में 10 modules हैं, और उनमें से 7 आप देख चुके हैं। बाकी तीन, यानी Search, Predict और Memory, गहरे version में आते हैं।
Stanford की slide का दायाँ हिस्सा: Modular RAG। ऊपर modules हैं, और नीचे चार patterns। ITER-RETGEN में आख़िरी Read से पहली Retrieve तक का तीर बताता है कि ये क्रम दोबारा चलता है।
Pattern इंसान पहले से लिखता है, इसलिए ITER-RETGEN में searches की गिनती तय होती है, चाहे सवाल को 1 search चाहिए या 3। Loop कब रुके और अगली query क्या हो, ये फ़ैसले lesson 16 और 17 में model खुद लेता है। हर extra loop एक LLM call और जोड़ता है।
यहाँ से Stanford वाला level
ऊपर के 5 पड़ाव आसान version जैसे ही हैं। आगे के 5 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। पहले survey की नज़र से Naive और Advanced RAG है, फिर slide के सारे modules। उसके बाद DSP और ITER-RETGEN के papers हैं, और आख़िर में आप दोनों slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।
6Survey में Naive और Advanced RAG: तीन दिक्कतें, precision और sets
Stanford की slide का diagram Gao और साथियों के एक survey से है। Survey वो paper है, जो किसी field के बहुत सारे papers पढ़कर उन्हें एक ढाँचे में रखता है। इस survey ने 100 से ज़्यादा RAG papers को तीन रूपों में बाँटा: Naive, Advanced और Modular RAG। paper से
Naive RAG के तीन stages और तीन दिक्कतें
Survey Naive RAG को तीन stages में लिखता है: indexing, retrieval और generation। इसे वो Retrieve-Read ढाँचा भी कहता है। Indexing में HTML, Word और Markdown जैसे formats के documents पहले सादे text में बदलते हैं। फिर text chunks में टूटता है, और हर chunk का embedding एक vector database में जाता है। paper से
Retrieval में query का embedding उसी encoder से बनता है, जिससे chunks के embeddings बने थे। ऐसा न हो, तो query और chunks के vectors अलग-अलग तरीके से बनेंगे, और उनका dot product कुछ नहीं बताएगा। Generation में query और चुने हुए chunks एक prompt में जाते हैं, ठीक पड़ाव 1 की तरह।
फिर survey Naive RAG की तीन दिक्कतें गिनाता है। नीचे हर दिक्कत के साथ हमारे corpus का एक example है: examples मेरे बनाए
दिक्कत
Survey क्या कहता है
हमारे corpus में
Retrieval
Precision और recall, दोनों कम: गलत chunks आते हैं, और ज़रूरी chunks छूटते हैं।
K = 2 पर forum post आया, और TA वाले सवाल पर office hours page छूटा।
Generation
Hallucination: जवाब में ऐसी बात, जो लौटे text में नहीं है।
LLM लिखे कि Thursday 9am वाला office hour Room 104 में है, जबकि passage में Zoom है।
Augmentation
Passages को जोड़ना मुश्किल: एक ही बात कई passages से आए, तो जवाब में दोहराव।
Queue log और office hours page, दोनों में Tuesday 4pm और Thursday 9am हैं।
पहली row में precision नया शब्द है। Precision बताता है कि लौटे passages में से कितना हिस्सा सही है। Least crowded वाले सवाल पर K = 2 पर queue log सही है, और forum post गलत। तो precision = 1 ÷ 2 = 0.5। Recall उल्टी तरफ़ से गिनता है: ज़रूरी passages में से कितने लौटे। TA वाले सवाल पर ज़रूरी passage 1 था, और लौटा 0, तो recall = 0 ÷ 1 = 0।
Survey एक चौथी बात भी लिखता है: मुश्किल सवाल पर original query से एक बार ढूँढना अक्सर काफ़ी नहीं होता। paper से पड़ाव 5 का multi-hop सवाल यही दिक्कत है।
Sets की भाषा में: expansion score नहीं घटाता, और rerank passage नहीं जोड़ता
पड़ाव 3 और 4 की दो बातें, expansion और rerank की हद, sets की भाषा में साफ़ साबित होती हैं। चीज़ों का एक group है, जिसमें हर चीज़ एक बार आती है। इसे { } में लिखते हैं, जैसे TA वाली query के शब्दों का set Q = {help, ta}। Set में कितनी चीज़ें हैं, उसे |Q| लिखते हैं, यानी |Q| = 2।
दो sets में जो चीज़ें common हैं, उनका set intersection कहलाता है, और उसे ∩ से लिखते हैं। Least crowded वाली query का set है {office, hour, least, crowded}। Queue log के शब्दों से इसका intersection {office, hour} है, और उसमें 2 चीज़ें हैं। Word overlap का score यही गिनती है:
score(Q, P) = | Q ∩ P |
यहाँ Q query के शब्दों का set है, और P passage के शब्दों का। Queue log के लिए |{office, hour}| = 2, और forum post के लिए |{least, crowded}| = 2।
दो sets को मिलाकर एक set बनाने को union कहते हैं, और उसे ∪ से लिखते हैं। Expansion यही करता है: query के set Q में जुड़े शब्दों का set E मिलाता है। TA वाली query में Q ∪ E = {help, ta} ∪ {office, hours} = {help, ta, office, hours}। Office hours page के लिए Q ∩ P खाली था, और (Q ∪ E) ∩ P = {office, hours} है।
अब सबूत देखिए। जो शब्द Q ∩ P में है, वो Q में भी है और P में भी। Q का हर शब्द Q ∪ E में भी है, इसलिए वो शब्द (Q ∪ E) ∩ P में भी है। मतलब पुराने intersection की हर चीज़ नए intersection में है, और नई चीज़ें जुड़ सकती हैं:
| (Q ∪ E) ∩ P | ≥ | Q ∩ P |
इसलिए expansion किसी भी passage का word overlap score घटा नहीं सकता। यही इसकी ताकत है, क्योंकि छूटा passage ऊपर आ सकता है। यही इसकी हद भी है, क्योंकि गलत passage का score भी नहीं घटता। waiting जोड़ने के बाद भी forum post 2 पर रहा।
Rerank के लिए लौटे passages का set R लीजिए, और ज़रूरी passages का set G। Rerank सिर्फ़ R की चीज़ों का क्रम बदलता है, इसलिए R वही रहता है, और |R ∩ G| भी। TA वाले सवाल पर R = { } है, यानी खाली set, और rerank के बाद भी खाली। Rerank recall नहीं बदलता, सिर्फ़ top-K का precision बदल सकता है। पड़ाव 4 में K = 2 पर पहले forum post था। Rerank के बाद office hours page आया, जो where वाले हिस्से के लिए ज़रूरी है।
Survey में pre-retrieval और post-retrieval के बाकी तरीके
Slide पर pre-retrieval में सिर्फ़ query के तीन steps हैं। Survey pre-retrieval में index सुधारना भी गिनता है, और हर step के कई रूप बताता है: paper से
Index सुधारना: chunks का size चुनना, sliding window, और , यानी chunk के साथ रखी extra जानकारी, जैसे तारीख। Survey लिखता है कि तारीख को वज़न दें, तो retriever पुरानी जानकारी से बचता है। हमारे forum post पर 2024 लिखा है, इसलिए ऐसा वज़न उसे नीचे भेजता। Chunks lesson 7 और 8 में आते हैं।
Expansion के रूप: Multi-Query एक query से कई queries बनाकर उन्हें साथ में चलाता है। Sub-Query मुश्किल सवाल को छोटे सवालों में तोड़ता है। Chain-of-Verification में LLM बढ़ाई हुई queries को जाँचता है।
Query बदलने के रूप: Rewrite आप पड़ाव 3 में देख चुके हैं। HyDE में LLM पहले एक मनगढ़ंत जवाब लिखता है, और उस जवाब के embedding से असली passages ढूँढता है। Step-back सवाल का एक आम रूप भी बनाता है, और दोनों से ढूँढता है। Survey का example: LLM शब्द का मतलब large language model भी हो सकता है, और कानून की एक degree भी।
Routing के रूप: Metadata router query से नाम या keywords निकालकर chunks के metadata से filter करता है। Semantic router query के मतलब से रास्ता चुनता है।
Rerank: नियमों से, या किसी model से। Survey एक और सलाह देता है: सबसे काम का text prompt के किनारों पर रखिए। वजह ये है कि LLM लंबे text के बीच वाले हिस्से पर कम ध्यान देता है। इसे कहते हैं, और ये lesson 18 में आता है।
Context छोटा करना: ज़्यादा documents डालने से noise बढ़ता है। LLMLingua जैसे तरीके एक छोटे model से कम काम के tokens हटाते हैं।
Summary वाले example में हर passage 500 से 100 tokens का हुआ, यानी 500 ÷ 100 = 5 गुना छोटा। तब 7,000 tokens की उसी जगह में 14 की जगह 7,000 ÷ 100 = 70 passages आ सकते हैं। मेरा हिसाब मतलब summary से या तो K बढ़ सकता है, या हर query सस्ती हो सकती है।
7Modular RAG के सारे modules, और survey के नए patterns
Slide के modules वाले हिस्से में दो घेरे हैं। अंदर वाले घेरे में RAG के चारों तरफ़ Retrieve, Rewrite, Rerank और Read हैं, यानी Advanced RAG के pattern वाले modules। बाहर वाले घेरे में Search, Routing, Predict, Demonstrate, Memory और Fusion हैं। Dashed lines बताती हैं कि modules आपस में किसी भी क्रम में जुड़ सकते हैं।
Retrieve और Read के boxes नारंगी किनारे वाले हैं, और बाकी नीले किनारे वाले। Patterns वाले हिस्से में भी यही रंग हैं, इसलिए नारंगी शायद Naive RAG के दो मूल modules दिखाता है। ये अंदाज़ा मेरा नीचे की table हर module का काम हमारे corpus पर दिखाती है:
Module
काम
हमारे corpus में
Retrieve
Index से top-K passages
Word overlap, K = 2
Read
Passages पढ़कर जवाब
Thursday 9am, Zoom पर
Rewrite
Query दोबारा लिखना
OH timings? से CS 329Z office hours schedule
Rerank
लौटी list दोबारा sort करना
Forum post 0.35 पर, सबसे नीचे
Routing
कौन सा source या रास्ता
Milestone वाला सवाल syllabus वाले index में
Fusion
कई lists मिलाना
दोनों lists से queue log और office hours page ऊपर
Demonstrate
Prompt में हल किए examples
Milestone वाला Q और A
Search
Search engine, database या knowledge graph में सीधे ढूँढना
Office hours एक database table में हों, तो LLM उसके लिए query लिखे
Predict
Retrieve की जगह LLM खुद context लिखे
LLM अपनी याद से CS 329Z के office hours लिखे
Memory
LLM का पहले लिखा text अगली retrieval को दिशा दे
पहली Read का Thursday 9am अगली search में
काम वाला column survey से है, और corpus वाले examples मेरे बनाए।
Survey के मुताबिक Search module LLM से code या query language भी लिखवाता है, ताकि वो database जैसे sources में ढूँढ सके। Predict module का मकसद retrieval का दोहराव और noise घटाना है। लेकिन हमारे course के office hours किसी LLM की training में नहीं थे, इसलिए यहाँ Predict गलत जवाब गढ़ेगा। Survey एक और module भी गिनाता है, Task Adapter, जो slide पर नहीं है। वो RAG को किसी खास काम के हिसाब से ढालता है। paper से
Modular RAG में modules का क्रम भी बदल सकता है। Survey कुछ नए patterns गिनाता है: paper से
Rewrite-Retrieve-Read: पहले query rewrite होती है। Rewrite करने वाला model LLM के जवाबों के feedback से सीखता है।
Generate-Read: Retrieve की जगह LLM खुद text लिखता है, यानी Predict module।
Recite-Read: Model अपने parameters से जानकारी “सुनाता” है, और फिर उसे पढ़कर जवाब लिखता है।
Hybrid retrieval: शब्दों वाली और vectors वाली search को मिलाना। ये lesson 14 में आता है।
DSP और ITER-RETGEN: एक module का output दूसरे module का काम बेहतर करता है। ये दोनों slide पर हैं, और अगले दो पड़ाव इन्हीं के papers हैं।
8DSP: frozen LM और retriever के बीच text का आना-जाना
DSP, यानी Demonstrate–Search–Predict, एक program है, जो frozen LM और frozen retriever के बीच text भेज-भेजकर मुश्किल सवाल हल करता है। इसे 2022 में Stanford के Khattab और साथियों ने बनाया। Paper LM यानी language model के लिए GPT-3.5 लेता है, और retriever के लिए ColBERTv2। Paper इन दोनों में से किसी को train नहीं करता। paper से
Paper का पहला example ये सवाल है: How many storeys are in the castle David Gregory inherited? इसके लिए पहले castle का नाम चाहिए, और फिर उसकी मंज़िलें। तीन systems इस पर अलग-अलग चलते हैं: paper से
अकेला LM: Castle Gregory नाम का एक castle गढ़ लेता है, और लिखता है कि उसमें तीन मंज़िलें हैं।
Retrieve-then-read, यानी Naive RAG: सवाल से सीधे ढूँढता है, और St. Gregory Hotel का passage पाता है। जवाब आता है: नौ मंज़िलें।
DSP: LM पहली query लिखता है, Which castle did David Gregory inherit?, और passage बताता है Kinnairdy Castle। दूसरी query उसकी मंज़िलें पूछती है, और जवाब आता है: five storeys।
DSP के तीन stages हैं, और slide पर इनके तीन modules: paper से
Demonstrate: Program के पास कुछ सवाल-जवाब जोड़े हैं, जैसे 16, लेकिन बीच की queries का कोई label नहीं। Program इन training सवालों पर खुद Search और Predict चलाता है। जिस सवाल पर उसका जवाब सही जवाब से मिलता है, उसका पूरा रास्ता, यानी queries और passages, demonstration बन जाता है।
Search: LM हर hop की query लिखता है, और retriever उसके passages लाता है। Multi-hop dataset HotPotQA पर hops 2 तय हैं।
Predict: LM demonstrations और passages पढ़कर आख़िरी जवाब लिखता है।
Demonstrate वाला step हमारे corpus पर देखिए। Training जोड़ा है: सवाल when is the project milestone due, और जवाब Week 6, Thursday 11:59pm। मेरा example
Search: query में project, milestone और due बचते हैं। Syllabus को 3 मिलता है, और project page को 2।
Predict: syllabus पढ़कर LM लिखता है Week 6, Thursday 11:59pm। ये सही जवाब से मिलता है।
इसलिए ये पूरा रास्ता, सवाल, syllabus और जवाब, एक demonstration बनता है। अगर जवाब न मिलता, तो program इस जोड़े को छोड़ देता।
किसी इंसान ने बीच के steps नहीं लिखे, उन्हें program ने सही जवाब से जाँचकर चुना। इस तरह के ढीले label को paper weak supervision कहता है। पड़ाव 5 का demonstration, Week 6, Thursday [P1], ऐसे ही बन सकता है।
DSP के नतीजे, और relative gain का गणित
Paper multi-hop dataset HotPotQA के 1,000 सवालों पर नापता है। Score है, यानी कितने % जवाब सही जवाब से हूबहू मिले। Lesson 5 में RAG-Sequence का NQ पर Exact Match 44.5 था। paper से
System
Exact Match (%)
अकेला LM, 16 examples के साथ
28.3
Self-ask, सुधरे हुए prompt के साथ
28.6
Retrieve-then-read
36.9
DSP
51.4
DSP और retrieve-then-read का फ़र्क दो तरह से लिखते हैं। पहला तरीका सीधा घटाना है: 51.4 − 36.9 = 14.5। दोनों numbers % में हैं, इसलिए इस फ़र्क को 14.5 percentage points कहते हैं। Paper दूसरा तरीका लेता है, जिसे relative gain कहते हैं: फ़र्क को पुराने number से भाग दीजिए।
फ़र्क: 51.4 − 36.9 = 14.5।
पुराने number से भाग: 14.5 ÷ 36.9 = 0.393।
% में बदलने के लिए 100 से गुणा: 0.393 × 100 = 39.3, यानी करीब 39%। जाँच: 36.9 × 1.393 = 51.4।
अकेले LM से यही हिसाब: (51.4 − 28.3) ÷ 28.3 = 23.1 ÷ 28.3 = 0.816, यानी करीब 82%। Self-ask से: (51.4 − 28.6) ÷ 28.6 = 0.797, यानी करीब 80%। Paper यही तीनों numbers लिखता है: 82%, 39% और 80%।
Relative gain पुराने number पर टिका है। एक ही 14.5 points का फ़र्क अलग-अलग पुराने numbers पर ऐसा दिखता है: हिसाब मेरा
पुराना number
14.5 ÷ पुराना number
Relative gain
10.0
1.450
145%
28.3
0.512
51%
36.9
0.393
39%
50.0
0.290
29%
भाग में नीचे वाला number जितना छोटा, उतना बड़ा relative gain। इसलिए कमज़ोर baseline से तुलना में % बहुत बड़ा दिख सकता है। Paper पढ़ते वक्त हमेशा दोनों असली numbers देखिए।
पहले सोचिए
Paper का एक और नतीजा: Open-SQuAD पर DSP 36.6 पर है, और retrieve-then-read 33.8 पर। Percentage points में फ़र्क कितना है, और relative gain कितना?
जवाब देखिए
फ़र्क 36.6 − 33.8 = 2.8 points है। Relative gain 2.8 ÷ 33.8 = 0.083, यानी करीब 8%, और paper भी 8% लिखता है। Open-SQuAD के सवालों पर एक search अक्सर काफ़ी होती है, इसलिए वहाँ फ़र्क छोटा है। ये वजह मेरी
9ITER-RETGEN: formula, नतीजे, और कई searches का गणित
ITER-RETGEN retrieval और generation को बारी-बारी चलाता है: हर बार LLM का जवाब और सवाल मिलकर अगली search की query बनते हैं। इसे 2023 में Shao और साथियों ने बनाया। पड़ाव 5 में आपने इसे हमारे corpus पर हाथ से चलाया था। अब वही हिसाब paper के formula में देखिए: paper से
yt = M( yt | prompt( Dyt−1 ‖ q , q ) ), ∀ 1 ≤ t ≤ T
नीचे की table हर symbol को पड़ाव 5 के numbers से जोड़ती है:
Symbol
मतलब
पड़ाव 5 में
q
सवाल
Which office hour is least crowded, and where is it?
t और T
t iteration का number है, और T कुल iterations। ∀ का मतलब है “हर एक के लिए”, यानी t = 1, 2, …, T हर एक पर।
T = 2, यानी t = 1 और t = 2
yt
Iteration t में LLM का जवाब। y0 खाली है, इसलिए पहली query सिर्फ़ q है।
Formula में “|” को “दिया होने पर” पढ़िए, जैसे lesson 4 की में। वहाँ p(भरा | Tuesday) = 0.80 का मतलब था: Tuesday दिया हो, तो भरा होने की probability। यहाँ M(yt | prompt) का मतलब है: ये prompt दिया हो, तो LLM जवाब yt लिखता है।
तो formula के दो iterations ठीक पड़ाव 5 के चार steps हैं। t = 1 पर query y0 ‖ q = q है, Dq में queue log और forum post आते हैं, और M लिखता है y1 = Thursday 9am। t = 2 पर query y1 ‖ q है, और D में queue log (4) और office hours page (3) आते हैं। आख़िरी जवाब yT = y2 है।
Paper का example और setup
Paper का example है: What is the height of the player who won the 2015 AFL Rising Star award? पहले iteration में retriever award वाला page लाता है, जिसमें विजेता Jesse Hogan का नाम है। LLM लिखता है कि Jesse Hogan 198 cm लंबा है, जो लौटे text में नहीं है। दूसरे iteration की query में Jesse Hogan का नाम है, इसलिए उसका अपना page आता है: 1.95 m। जवाब सुधरकर 1.95 m हो जाता है। paper से
Paper का setup ये है। LLM text-davinci-003 है, और retriever Contriever, जो एक dense retriever है। हर query पर top-5 paragraphs आते हैं, और prompt में 3 हल किए examples हैं। Paper ज़्यादातर datasets के पहले 500 सवाल नापता है, और Bamboogle के सारे 125। इनमें HotPotQA जैसे multi-hop datasets हैं। paper से
Paper Exact Match के साथ एक और score देता है, Acc†। Exact Match तभी सही गिनता है, जब जवाब हूबहू मिले। जैसे 1.95 m और 195 cm उसके लिए अलग जवाब हैं। ये example मेरा
इसलिए paper एक LLM से भी जँचवाता है कि जवाब में सही जवाब आ गया या नहीं, और उस score को Acc† लिखता है। Paper ने 80 ऐसे जवाब हाथ से जाँचे, जिन पर दोनों scores अलग थे, और 97.5% बार Acc† सही निकला। paper से
नतीजे: दूसरा iteration सबसे ज़्यादा जोड़ता है
HotPotQA पर
Exact Match
Acc†
Self-Ask
36.8
64.8
DSP
43.8
60.8
ITER-RETGEN, T = 1
39.2
65.5
ITER-RETGEN, T = 2
44.1
71.2
ITER-RETGEN, T = 3
45.2
71.4
ITER-RETGEN, T = 4
45.8
73.4
Paper से। T = 1 का मतलब है एक ही retrieval, यानी Naive RAG जैसा। Paper ने T = 7 तक नापा।
T = 1 से 2 पर Acc† 65.5 से 71.2 होता है, यानी 5.7 points। 2 से 3 पर सिर्फ़ 71.2 से 71.4, यानी 0.2 points। Paper भी यही लिखता है: दूसरा iteration सबसे बड़ा फ़ायदा देता है।
T = 2 पर ITER-RETGEN 2 LLM calls करता है, और 2 × 5 = 10 paragraphs पढ़ता है। Self-Ask HotPotQA पर औसतन 3.2 calls और 16.0 paragraphs लेता है, फिर भी उसका Acc† 64.8 है।
Paper ने 10 ऐसे सवाल देखे, जिन पर DSP गलत था और ITER-RETGEN सही। 4 पर DSP सही documents नहीं ला पाया, और 5 पर DSP की summary ही गलत थी।
कई searches में chances का गुणा
Multi-hop सवाल हर hop पर एक नई चूक का मौका देता है। मान लीजिए हर search 0.9 chance से सही passage लाती है। 100 सवालों में पहली search 90 पर सही होगी। उन 90 में से 90% पर दूसरी भी सही होगी, यानी 90 × 0.9 = 81 सवाल। numbers मेरे बनाए
तो दोनों के सही होने का chance 0.9 × 0.9 = 0.81 है। Lesson 4 का यही कहता है: p(A और B) = p(A) × p(B | A), जैसे वहाँ 0.5 × 0.8 = 0.40। यहाँ A पहली search का सही होना है, और B दूसरी का।
Hops
हिसाब
सब सही होने का chance
1
0.9
0.9
2
0.9 × 0.9
0.81
3
0.9 × 0.9 × 0.9
0.729
ITER-RETGEN में p(B | A) और भी ज़्यादा A पर टिका है। पहला जवाब Wednesday हो, तो दूसरी query में Thursday 9am आता ही नहीं, और दूसरी search का chance लगभग 0 हो जाता है। इसलिए हर extra hop accuracy का एक हिस्सा खाता है, और पहली गलती आगे तक जाती है। Lesson 18 इसे कहता है, और वहाँ 5 steps पर 0.9 का गुणा 0.59 है।
एक बार से ज़्यादा ढूँढने के तीन तरीके
Survey एक बार की retrieval से आगे के तीन तरीके गिनाता है: paper से
Iterative: retrieval और generation बारी-बारी चलते हैं, जैसे ITER-RETGEN। Iterations की गिनती पहले से तय होती है।
Recursive: query हर बार पिछले नतीजों से सुधरती है, और सवाल छोटे सवालों में टूटता जाता है।
Adaptive: LLM खुद तय करता है कि कब ढूँढना है और कब रुकना है, अक्सर खास tokens लिखकर। Self-RAG ऐसा है, और वो lesson 16 में आता है।
Slide का Search-R1 trace adaptive है। Model खुद <search> tag में query लिखता है, और search system लौटे passages <information> tag में जोड़ता है। Model <think> में सोचता है, और <answer> में जवाब लिखकर रुकता है। paper से Slide का title कहता है कि model ये फ़ैसले से सीखता है, और ये lesson 17 में आता है।
Trace में एक गड़बड़ भी है। तीसरी search Jed Hoyer birth year का नतीजा वही Jed Hoyer वाला document है, जो पहली search में आया था, और उसमें जन्म-तारीख नहीं है। फिर भी अगले think में model लिखता है कि Jed Hoyer December 7, 1973 को पैदा हुए। ये तारीख लौटे text से नहीं आई, और इसके नतीजे lesson 17 में आते हैं। Paper इस trace को सफल case मानता है, और लिखता है कि पहली query का कोई ख़ास मतलब नहीं था। paper से
10अब Stanford की slides खुद पढ़िए
नीचे इस lesson की दोनों Stanford slides हैं, बिना किसी बदलाव के। हर slide के नीचे कुछ सवाल हैं। पहले खुद जवाब सोचिए, फिर खोलिए। कोई बात अटके, तो जवाब में लिखे पड़ाव पर लौट जाइए। Phone पर slide छोटी दिखे, तो image पर click कीजिए, वो पूरे size में खुलेगी।
Stanford की Different Variants of RAG वाली slide, और नीचे उसके चारों हिस्से, बड़े करके।
Variants वाली slide पढ़िए
Advanced RAG में Pre-Retrieval वाला box Query वाली line पर है, Documents वाली line पर नहीं। इसका क्या मतलब है? Survey इसमें और क्या गिनता है?
जवाब देखिए
Slide के तीनों pre-retrieval steps query पर काम करते हैं: routing, rewriting और expansion। Index वाली line Naive RAG जैसी ही है। Survey pre-retrieval में index सुधारना भी गिनता है, जैसे chunks का size और तारीख वाला metadata। (पड़ाव 3 और 6)
Modules में अंदर वाले घेरे के चार modules कौन से हैं, और वो किस pattern से मिलते हैं? Predict module Retrieve से कैसे अलग है?
जवाब देखिए
Retrieve, Rewrite, Rerank और Read, यानी Advanced RAG का pattern। Retrieve index से passages लाता है, जबकि Predict में LLM खुद context लिखता है। हमारे course के office hours LLM को पता ही नहीं, इसलिए यहाँ Predict गलत जवाब गढ़ेगा। (पड़ाव 7)
DSP के नीचे [Khattab et al., 2022] और ITER-RETGEN के नीचे [Shao et al., 2023] लिखा है। HotPotQA पर किसका Exact Match ज़्यादा है, और ITER-RETGEN का तीर कितनी बार चलना सबसे फ़ायदेमंद रहा?
जवाब देखिए
ITER-RETGEN के paper में DSP का Exact Match 43.8 है, और ITER-RETGEN का T = 2 पर 44.1, यानी लगभग बराबर। Acc† पर फ़र्क बड़ा है, 60.8 बनाम 71.2। दूसरा iteration सबसे ज़्यादा जोड़ता है, 5.7 points, और उसके बाद फ़ायदा छोटा है। DSP के अपने paper में उसका Exact Match 51.4 था, लेकिन वहाँ LM और retriever अलग थे। (पड़ाव 8 और 9)
Stanford की Search-R1 वाली slide, और नीचे उसका trace दो हिस्सों में, बड़ा करके।
Search-R1 वाली slide पढ़िए
Trace में कौन से tags model लिखता है, और कौन सा tag search system? Ground Truth वाली line किस काम की है?
जवाब देखिए
Model <think>, <search> और <answer> लिखता है, और <information> में search system के लौटाए passages हैं। Ground Truth सही जवाब है, John William Henry II। आप model के <answer> को इसी से मिलाकर जाँचते हैं। (पड़ाव 9, और lesson 17)
Model ने कितनी searches कीं? किस search का नतीजा दोबारा आया, और क्या उसमें Jed Hoyer की जन्म-तारीख है?
जवाब देखिए
तीन searches। तीसरी search का नतीजा वही Jed Hoyer वाला document है, जो पहली search में आया था। उसमें जन्म-तारीख नहीं है, फिर भी अगला think December 7, 1973 लिखता है। ये तारीख retrieval से नहीं आई। (पड़ाव 5 और 9)
ये trace ITER-RETGEN से कैसे अलग है?
जवाब देखिए
ITER-RETGEN में searches की गिनती T पहले से तय है, और query हमेशा yt−1 ‖ q होती है। यहाँ model खुद तय करता है कि कितनी searches करनी हैं और query क्या हो, यानी ये adaptive है। Slide का title कहता है कि model ये फ़ैसले RL से सीखता है। (पड़ाव 9, और lessons 16 और 17)
इस lesson की 3 बातें
API वाला LLM frozen है, इसलिए lesson 5 वाली training नहीं चलती। RAG pipeline LLM से पहले के steps सुधारती है: query, retrieval और prompt।
Naive RAG एक बार index बनाता है, और हर query पर Retrieve और Read चलाता है। Expansion किसी passage का score नहीं घटाता, इसलिए छूटा passage ला सकता है। Rerank लौटे passages का set नहीं बदलता, इसलिए recall नहीं बढ़ाता।
Modular RAG modules को अलग-अलग क्रम में जोड़ता है। ITER-RETGEN पिछले जवाब से दोबारा ढूँढता है, और HotPotQA पर दूसरा iteration Acc† को 65.5 से 71.2 करता है। हर extra hop chances का गुणा करता है, जैसे 0.9 × 0.9 = 0.81।
बाकी lecture का नक्शा
Pipeline का हिस्सा
सवाल
Lessons
Indexing
Documents के टुकड़े कैसे बनें, और उनका context कैसे बचे?
7, 8, 9
Retrieval
तेज़ search कैसे हो, और शब्द या मतलब से कैसे ढूँढें?
10, 11, 12
नापना
Retriever कितना अच्छा है?
13
Post-retrieval
Fusion और rerank कैसे करें?
14, 15
Loop
Model खुद कब ढूँढे, क्या ढूँढे, कब रुके?
16, 17
Failures
सब कुछ होने के बाद भी कहाँ टूटता है?
18
इस lesson के नए शब्द
Frozen LLM
जिसके parameters आप नहीं बदल सकते, सिर्फ़ prompt भेज सकते हैं। जैसे GPT या Gemini, जो आप API से लेते हैं।
Pipeline
Steps की line, जिसमें हर step का output अगले का input है। जैसे Retrieve का output top-K passages हैं, और वही Read का input।
Naive RAG
सबसे सीधी pipeline: index, फिर हर query पर Retrieve और Read। बीच में कोई extra step नहीं।
Indexing time और query time
एक बार चलने वाले steps, और हर query पर चलने वाले steps। जैसे 60,000 passages के embeddings एक बार बनते हैं, और query का embedding हर बार।
Pre-retrieval
Retrieval से पहले query सुधारने वाले steps: routing, rewriting और expansion।
Query routing
तय करना कि किस index या source में ढूँढना है। जैसे “when is the project milestone due” syllabus वाले index में जाए।
Query rewriting
LLM से query को साफ़ search query में बदलवाना। जैसे “OH timings?” से “CS 329Z office hours schedule”।
Query expansion
Query में जुड़े हुए शब्द या दूसरे रूप जोड़ना। जैसे “help ta” में “office hours” जोड़ने से office hours page का score 0 से 2 होता है।
Post-retrieval
Retrieval के बाद लौटी list सुधारने वाले steps: rerank, summary और fusion।
Rerank और reranker
धीमा लेकिन सटीक model, जो लौटाए गए passages को दोबारा sort करता है। जैसे queue log और forum post के बराबर score में से forum post को नीचे भेजना।
Summary
Passages को prompt से पहले छोटा करना। जैसे 500 tokens का passage 100 का हो, तो 14 passages 7,000 की जगह 1,400 tokens लेते हैं। खतरा: Room 104 जैसी detail छूट सकती है।
Fusion
कई ranked lists को मिलाकर एक list बनाना। जैसे पहली list queue log, forum post, office hours page है, और दूसरी office hours page, queue log। जो दोनों में हैं, वो ऊपर आते हैं।
Advanced RAG
Naive RAG में pre-retrieval और post-retrieval steps जोड़कर बनी pipeline। जैसे Rewrite, Retrieve, Rerank, Read।
Modular RAG
Pipeline को modules में बाँटकर, उन्हें अलग-अलग क्रम में जोड़ना। जैसे Retrieve, Read, Retrieve, Read।
Pattern
Modules का एक तय क्रम, जैसे Retrieve, Read।
Demonstrations (few-shot)
Prompt में सवाल से पहले दिए गए हल किए हुए examples। जैसे “Q: When is the milestone due? A: Week 6, Thursday [P1]”।
Multi-hop question
ऐसा सवाल, जिसके लिए कई बार ढूँढना पड़े, क्योंकि जवाब के हिस्से अलग passages में हैं। जैसे least crowded office hour कहाँ है: पहले queue log, फिर office hours page।
Precision
लौटे passages में से कितना हिस्सा सही है। जैसे K = 2 पर queue log सही और forum post गलत, तो precision = 1 ÷ 2 = 0.5।
Relative gain
फ़र्क को पुराने number से भाग देकर % में लिखना। जैसे (51.4 − 36.9) ÷ 36.9 = 0.393, यानी करीब 39%। सीधा फ़र्क, 14.5, percentage points कहलाता है।
DSP
Demonstrate–Search–Predict: frozen LM और frozen retriever के बीच text भेजने वाला program, जो demonstrations खुद बनाता है। 2022 में Stanford के Khattab और साथियों ने बनाया। जैसे HotPotQA पर Exact Match 51.4।
ITER-RETGEN
Retrieval और generation बारी-बारी, जिसमें पिछला जवाब और सवाल मिलकर अगली query बनते हैं। 2023 में Shao और साथियों ने बनाया। जैसे Thursday 9am जोड़ने से office hours page का score 1 से 3 होता है।
Iterative, recursive और adaptive retrieval
एक से ज़्यादा बार ढूँढने के तीन तरीके। Iterative में तय गिनती तक बारी-बारी, recursive में सवाल को छोटे सवालों में तोड़कर, और adaptive में model खुद तय करता है। जैसे ITER-RETGEN iterative है, और Search-R1 का trace adaptive।