Lesson 6 · गहरा version

RAG pipeline: Naive, Advanced और Modular

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 तक ले जाते हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।

  1. Frozen LLM और pipelineबता पाएँगे कि API वाले LLM के साथ lesson 5 की training क्यों नहीं चलती।
  2. Naive RAG: indexing time और query timeहर query का खर्च गिन पाएँगे, और slide का Naive RAG वाला हिस्सा पढ़ पाएँगे।
  3. Pre-retrieval: retrieval से पहले query सुधारनाQuery expansion के बाद के scores हाथ से निकाल पाएँगे।
  4. Post-retrieval: लौटी list सुधारनाबता पाएँगे कि rerank छूटा passage क्यों नहीं लाता, और slide का Advanced RAG वाला हिस्सा पढ़ पाएँगे।
  5. Modular RAG: modules और patternsदो बार ढूँढने वाले pattern का हिसाब हाथ से कर पाएँगे, और slide का Modular RAG वाला हिस्सा पढ़ पाएँगे।
  6. यहाँ से Stanford वाला level
  7. Survey में Naive और Advanced RAGPrecision निकाल पाएँगे, और sets से साबित कर पाएँगे कि expansion score नहीं घटाता और rerank passage नहीं जोड़ता।
  8. Modular RAG के सारे modulesSlide के दसों modules का काम हमारे corpus पर बता पाएँगे।
  9. DSP का paper, और relative gainDemonstrations अपने आप बनने का तरीका और relative gain का हिसाब समझा पाएँगे।
  10. ITER-RETGEN: formula, नतीजे और chances का गुणाFormula के हर symbol को अपने numbers से जोड़ पाएँगे, और कई searches का chance निकाल पाएँगे।
  11. Stanford की slides खुद पढ़िएइस lesson की दोनों Stanford slides की हर line समझा पाएँगे।

पहले से क्या चाहिए: 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 वाला हिस्सा
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 जैसे हटाता है।

QueryRetriever ने क्या लौटायाK = 2 पर LLM को क्या मिला
when can I get help from a TAकुछ नहीं, हर passage का score 0।कुछ नहीं। Office hours page, जिसमें जवाब है, LLM तक नहीं पहुँचा।
which office hour is least crowdedQueue 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 pageoffice, hours02
Queue logoffice इसमें hour लिखा है, hours नहीं।01
बाकी चार passagesकोई नहीं00

अब 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 मेरे बनाए हैं

2

#PassageOverlapRerank

इन 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 मेरे बनाए हैं

PassageRetriever scoreReranker scoreK = 2 पर LLM तक?
Queue log20.92हाँ
Office hours page10.41हाँ
पुराना forum post20.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 वाला हिस्सा
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

  1. पहली Retrieve: query में office, hour, least, crowded और where बचते हैं, और where किसी passage में नहीं है। Queue log और forum post को 2-2 मिलता है, इसलिए यही दोनों लौटते हैं।
  2. पहली Read: मान लीजिए LLM queue log का data चुनकर लिखता है: Thursday 9am। जगह इन दोनों passages में नहीं है।
  3. दूसरी Retrieve: query के आगे पहला जवाब, Thursday 9am, जोड़िए। अब thursday और 9am भी गिनती में आते हैं।
  4. दूसरी Read: K = 2 पर queue log और office hours page मिलते हैं, यानी पड़ाव 1 वाला prompt। LLM लिखता है: Thursday 9am, Zoom पर।
Passageपहली searchदूसरी search
Queue logoffice, hour, फिर thursday, 9am भी24
Office hours pageoffice, फिर thursday, 9am भी13
पुराना forum postleast, crowded22
Syllabusदूसरी बार thursday01

इस 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: Jed Hoyer वाले सवाल पर model का trace
Stanford की slide: Search-R1 नाम के model का trace। <search> वाली lines model की searches हैं, और <information> वाली lines लौटे passages।

Stanford की slide चार patterns दिखाती है, जो Gao और साथियों के survey (2024) से हैं:

PatternModules का क्रममतलब
Naive RAGRetrieve, Readपड़ाव 2 वाली सीधी pipeline
Advanced RAGRewrite, Retrieve, Rerank, Readपड़ाव 3 और 4 के steps जोड़कर
DSPDemonstrate, Search, Predictहल किए हुए examples, फिर ढूँढना, फिर जवाब
ITER-RETGENRetrieve, Read, Retrieve, Readपहली Read के जवाब से दोबारा ढूँढना

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
Stanford slide के Modular RAG हिस्से में चार patterns
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 में
RetrievalPrecision और recall, दोनों कम: गलत chunks आते हैं, और ज़रूरी chunks छूटते हैं।K = 2 पर forum post आया, और TA वाले सवाल पर office hours page छूटा।
GenerationHallucination: जवाब में ऐसी बात, जो लौटे text में नहीं है।LLM लिखे कि Thursday 9am वाला office hour Room 104 में है, जबकि passage में Zoom है।
AugmentationPassages को जोड़ना मुश्किल: एक ही बात कई 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 से

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 में
RetrieveIndex से top-K passagesWord overlap, K = 2
ReadPassages पढ़कर जवाबThursday 9am, Zoom पर
RewriteQuery दोबारा लिखना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 ऊपर
DemonstratePrompt में हल किए examplesMilestone वाला Q और A
SearchSearch engine, database या knowledge graph में सीधे ढूँढनाOffice hours एक database table में हों, तो LLM उसके लिए query लिखे
PredictRetrieve की जगह LLM खुद context लिखेLLM अपनी याद से CS 329Z के office hours लिखे
MemoryLLM का पहले लिखा 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 से

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 से

DSP के तीन stages हैं, और slide पर इनके तीन modules: paper से

  1. Demonstrate: Program के पास कुछ सवाल-जवाब जोड़े हैं, जैसे 16, लेकिन बीच की queries का कोई label नहीं। Program इन training सवालों पर खुद Search और Predict चलाता है। जिस सवाल पर उसका जवाब सही जवाब से मिलता है, उसका पूरा रास्ता, यानी queries और passages, demonstration बन जाता है।
  2. Search: LM हर hop की query लिखता है, और retriever उसके passages लाता है। Multi-hop dataset HotPotQA पर hops 2 तय हैं।
  3. Predict: LM demonstrations और passages पढ़कर आख़िरी जवाब लिखता है।

Demonstrate वाला step हमारे corpus पर देखिए। Training जोड़ा है: सवाल when is the project milestone due, और जवाब Week 6, Thursday 11:59pm। मेरा example

  1. Search: query में project, milestone और due बचते हैं। Syllabus को 3 मिलता है, और project page को 2।
  2. Predict: syllabus पढ़कर LM लिखता है Week 6, Thursday 11:59pm। ये सही जवाब से मिलता है।
  3. इसलिए ये पूरा रास्ता, सवाल, 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 से

SystemExact Match (%)
अकेला LM, 16 examples के साथ28.3
Self-ask, सुधरे हुए prompt के साथ28.6
Retrieve-then-read36.9
DSP51.4

DSP और retrieve-then-read का फ़र्क दो तरह से लिखते हैं। पहला तरीका सीधा घटाना है: 51.4 − 36.9 = 14.5। दोनों numbers % में हैं, इसलिए इस फ़र्क को 14.5 percentage points कहते हैं। Paper दूसरा तरीका लेता है, जिसे relative gain कहते हैं: फ़र्क को पुराने number से भाग दीजिए।

  1. फ़र्क: 51.4 − 36.9 = 14.5।
  2. पुराने number से भाग: 14.5 ÷ 36.9 = 0.393।
  3. % में बदलने के लिए 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 पर ऐसा दिखता है: हिसाब मेरा

पुराना number14.5 ÷ पुराना numberRelative gain
10.01.450145%
28.30.51251%
36.90.39339%
50.00.29029%

भाग में नीचे वाला 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 और Tt iteration का number है, और T कुल iterations। ∀ का मतलब है “हर एक के लिए”, यानी t = 1, 2, …, T हर एक पर।T = 2, यानी t = 1 और t = 2
ytIteration t में LLM का जवाब। y0 खाली है, इसलिए पहली query सिर्फ़ q है।y1 = Thursday 9am, y2 = Thursday 9am, Zoom पर
‖दो texts को आगे-पीछे जोड़ना, यानी lesson 5 वाला y1 ‖ q = Thursday 9am which office hour …
DxText x को query बनाकर लौटे top-k passagesDq = {queue log, forum post}, Dy1‖q = {queue log, office hours page}
prompt(D, q)Passages और सवाल से बना promptपड़ाव 1 जैसा prompt
M( y | … )LLM, जो prompt दिया होने पर जवाब y लिखता हैFrozen LLM

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 MatchAcc†
Self-Ask36.864.8
DSP43.860.8
ITER-RETGEN, T = 139.265.5
ITER-RETGEN, T = 244.171.2
ITER-RETGEN, T = 345.271.4
ITER-RETGEN, T = 445.873.4

Paper से। T = 1 का मतलब है एक ही retrieval, यानी Naive RAG जैसा। Paper ने T = 7 तक नापा।

कई 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
10.90.9
20.9 × 0.90.81
30.9 × 0.9 × 0.90.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 से

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 slide: Different Variants of RAG, यानी Naive, Advanced और Modular RAG
उसी slide का Naive RAG हिस्सा, बड़ा करके
उसी slide का Advanced RAG हिस्सा, बड़ा करके
उसी slide के modules, बड़े करके
उसी slide के patterns, बड़े करके
Stanford की Different Variants of RAG वाली slide, और नीचे उसके चारों हिस्से, बड़े करके।

Variants वाली slide पढ़िए

  1. 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)

  2. 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)

  3. 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 slide: Search-R1 का trace, Jed Hoyer वाले सवाल पर
उसी trace का पहला हिस्सा: पहली दो searches, बड़ा करके
उसी trace का दूसरा हिस्सा: तीसरी search और जवाब, बड़ा करके
Stanford की Search-R1 वाली slide, और नीचे उसका trace दो हिस्सों में, बड़ा करके।

Search-R1 वाली slide पढ़िए

  1. 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)

  2. Model ने कितनी searches कीं? किस search का नतीजा दोबारा आया, और क्या उसमें Jed Hoyer की जन्म-तारीख है?

    जवाब देखिए

    तीन searches। तीसरी search का नतीजा वही Jed Hoyer वाला document है, जो पहली search में आया था। उसमें जन्म-तारीख नहीं है, फिर भी अगला think December 7, 1973 लिखता है। ये तारीख retrieval से नहीं आई। (पड़ाव 5 और 9)

  3. ये 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 बातें

  1. API वाला LLM frozen है, इसलिए lesson 5 वाली training नहीं चलती। RAG pipeline LLM से पहले के steps सुधारती है: query, retrieval और prompt।
  2. Naive RAG एक बार index बनाता है, और हर query पर Retrieve और Read चलाता है। Expansion किसी passage का score नहीं घटाता, इसलिए छूटा passage ला सकता है। Rerank लौटे passages का set नहीं बदलता, इसलिए recall नहीं बढ़ाता।
  3. Modular RAG modules को अलग-अलग क्रम में जोड़ता है। ITER-RETGEN पिछले जवाब से दोबारा ढूँढता है, और HotPotQA पर दूसरा iteration Acc† को 65.5 से 71.2 करता है। हर extra hop chances का गुणा करता है, जैसे 0.9 × 0.9 = 0.81।
बाकी lecture का नक्शा
Pipeline का हिस्सासवालLessons
IndexingDocuments के टुकड़े कैसे बनें, और उनका context कैसे बचे?7, 8, 9
Retrievalतेज़ search कैसे हो, और शब्द या मतलब से कैसे ढूँढें?10, 11, 12
नापनाRetriever कितना अच्छा है?13
Post-retrievalFusion और rerank कैसे करें?14, 15
LoopModel खुद कब ढूँढे, क्या ढूँढे, कब रुके?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।