Lesson 5 · गहरा version

RAG model: retriever और generator एक साथ

RAG एक model है, जिसमें दो models जुड़े हैं। Retriever सवाल के लिए passages लाकर हर एक को वज़न देता है, और generator हर passage के साथ जवाब लिखता है। दोनों एक ही loss से साथ train होते हैं, और इस training को सिर्फ़ सवाल-जवाब के जोड़े चाहिए। RAG का पूरा नाम Retrieval-Augmented Generation है, और ये Lewis और साथियों का 2020 का model है।

इसकी ज़रूरत lesson 4 के आख़िरी सवाल में दिखी। वहाँ retriever ने पुराने forum post को 0.731 वज़न दिया, और queue log को सिर्फ़ 0.269। Generator के numbers वही रहे, फिर भी सही जवाब Thursday 9am का chance 0.685 से गिरकर 0.315 हो गया। गलती retriever की है, लेकिन training data में सिर्फ़ सवाल और जवाब लिखे हैं। जवाब queue log से आया, ये कहीं नहीं लिखा, और RAG इसी हालत में retriever को सिखा लेता है।

इस lesson की सीढ़ी

सीढ़ी में 10 पड़ाव हैं। पहले 5 आसान version जैसे ही हैं, और 6 से 10 आपको Stanford की slides के level तक ले जाते हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।

  1. RAG के दो models: retriever और generatorहर हिस्से का काम बता पाएँगे, और Stanford की RAG वाली slide पढ़ पाएँगे।
  2. Marginalization: passage का label नहीं चाहिएजवाब की probability हाथ से निकाल पाएँगे, और बता पाएँगे कि passage का label क्यों नहीं चाहिए।
  3. RAG-Sequence और RAG-Tokenदोनों तरीकों से probability निकाल पाएँगे, और बता पाएँगे कि नतीजे कब अलग आते हैं।
  4. एक loss से retriever और generator की trainingबता पाएँगे कि training किस passage का score बढ़ाती है, और कौन से हिस्से बदलते हैं।
  5. NQ पर नतीजेPaper की मुख्य table पढ़ पाएँगे, और बता पाएँगे कि lesson 6 की ज़रूरत क्यों है।
  6. यहाँ से Stanford वाला level
  7. Training के नियम का गणितScore पर loss की दर हाथ से निकाल पाएँगे, और बता पाएँगे कि वो prior − posterior क्यों है।
  8. एक loss से generator और query encoder तकदोनों पर दर निकाल पाएँगे, और paper के retriever वाले experiments पढ़ पाएँगे।
  9. RAG-Sequence और RAG-Token गहराई सेहर token का posterior निकाल पाएँगे, और decoding और K का असर समझा पाएँगे।
  10. असली पैमाना और पूरे नतीजेPaper के असली numbers और पूरी results table पढ़ पाएँगे।
  11. Stanford की slides खुद पढ़िएRAG वाली छहों Stanford slides की हर line समझा पाएँगे।

पहले से क्या चाहिए: Lesson 2 (retriever, top-K), Lesson 3 (vector, dot product, encoder, index) और Lesson 4 (marginalization, softmax, ∏, loss)। पड़ाव 6 से आगे lesson 4 के गहरे version का पड़ाव 9 (दर, negative marginal log-likelihood) भी काम आता है। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।

1RAG के दो models: retriever और generator

RAG के अंदर दो models हैं। Retriever pη(z|x) हर passage z को वज़न देता है, और generator pθ(y|x, z) सवाल x और एक passage पढ़कर जवाब y लिखता है। ये वही दो probabilities हैं, जो lesson 4 के formula में थीं। नीचे लिखे छोटे η (eta) और θ (theta) दोनों models के के नाम हैं, यानी वो numbers, जिन्हें training बदलती है।

Retriever: DPR

RAG का retriever DPR नाम का model है, जिसकी अपनी training lesson 12 में आती है। उसमें दो हैं, और दोनों BERT से बने हैं, जो Google का 2018 का एक encoder model है। Query encoder सवाल x का vector q(x) बनाता है, और passage encoder हर passage z का vector d(z)।

किसी passage का score इन दोनों vectors का है, जिसे d(z)⊤q(x) लिखते हैं। फिर scores को वज़नों में बदलता है, जिनका जोड़ 1 होता है। Lesson 4 में scores 1.0 और 0.0 से वज़न 0.731 और 0.269 बने थे। Stanford की slide यही बात ऐसे लिखती है:

pη(z|x) ∝ exp(d(z)⊤q(x))

यहाँ का मतलब है: हर passage का exp निकालिए, फिर सबको एक ही number से भाग दीजिए, ताकि जोड़ 1 हो।

Passages बहुत सारे हैं। Paper में Wikipedia के करीब 2.1 करोड़ passages हैं, हर एक 100 शब्दों का। paper से इनके vectors सवाल आने से पहले एक बार बनते हैं, और एक में रखे रहते हैं। सवाल आने पर सिर्फ़ query encoder चलता है, और फिर एक search सबसे बड़े K dot products वाले passages निकालती है। इस search को MIPS कहते हैं, यानी maximum inner product search, क्योंकि inner product dot product का ही दूसरा नाम है।

Generator: BART

Generator सवाल और एक passage पढ़कर जवाब लिखता है, lesson 1 के LLM की तरह एक बार में एक token। RAG का generator है, जो एक encoder-decoder model है। उसका encoder input text पढ़कर उसके vectors बनाता है, और decoder उन vectors को देखते हुए जवाब का एक-एक token लिखता है।

BART एक ही text पढ़ता है, इसलिए सवाल और passage को आगे-पीछे जोड़कर एक text बनाते हैं। दो texts को ऐसे जोड़ने को concatenate करना कहते हैं। Queue log के साथ input और output ऐसा दिखेगा: मेरा example

Input: question: Which office hour is least crowded? passage: Queue log, last 3 weeks: Tuesday 4pm office hour averaged 14 students waiting; Thursday 9am office hour averaged 3.
Output: Thursday 9am
सवाल xWhich office hour is least crowded?
Query encoder q(x)सवाल का vector
MIPSIndex के हर d(z) से dot product, top-K
z1 … zKहर एक का वज़न, softmax से
Generator pθहर z के साथ एक बार
Marginalizeजोड़कर p(y|x)
एक सवाल पर RAG का पूरा रास्ता। पहले चार boxes retriever हैं, और आख़िरी दो generator। Marginalize वाला box पड़ाव 2 में आता है।

इस ढाँचे की एक कीमत है। Generator हर passage के साथ अलग से चलता है, इसलिए K = 5 हो, तो एक सवाल पर generator 5 बार चलता है।

Stanford slide: RAG का पूरा ढाँचा, retriever और generator
Stanford की slide: RAG का ढाँचा। हरा box retriever pη है, जिसमें query encoder q, MIPS और document index d(z) हैं। नीला box generator pθ है। ऊपर का dashed arrow training है, जो पड़ाव 4 में आता है। Image पर click करने से वो पूरे size में खुलती है।

2Marginalization: passage का label नहीं चाहिए

RAG passage को एक छिपा हुआ choice मानता है, और जवाब की probability सारे लाए गए passages पर वज़न वाले जोड़ से निकालता है। ऐसे छिपे हुए choice को latent variable कहते हैं। जवाब किसी एक passage से आया, लेकिन किससे, ये data में नहीं लिखा।

Retriever को सीधे सिखाने के लिए हर सवाल के साथ उसका सही passage लिखा होना चाहिए। लाखों सवालों के लिए कोई इंसान इतने passages नहीं चुनता। Lesson 4 का इसी हालत का तरीका है: हर case की probability को उसके वज़न से गुणा कीजिए, फिर सब जोड़िए। वहाँ 0.5 × 0.8 + 0.5 × 0.1 = 0.45 था।

अब सवाल Which office hour is least crowded? पर देखिए। Retriever 3 passages लाया, यानी K = 3, और उनके scores 1.8, 1.1 और 0.0 हैं। Softmax में e1.8 = 6.05, e1.1 = 3.00 और e0 = 1 हैं, जिनका जोड़ 10.05 है। तो queue log का वज़न 6.05 ÷ 10.05 = 0.60 है, और इसी तरह बाकी दो के 0.30 और 0.10। numbers मेरे बनाए हैं

Generator हर passage के साथ Thursday 9am को एक probability देता है। हर row में वज़न और generator की probability का गुणा है:

Passage zवज़न p(z|x)p(“Thu 9am” | x, z)गुणा
Queue logThursday 9am पर average 3 students0.60.90.54
Office hours pageTuesday 4pm और Thursday 9am, कौन खाली है ये नहीं लिखा0.30.5?
पुराना forum postmidweek afternoons are usually the least crowded0.10.10.01
जोड़ = p(“Thu 9am” | x)?

दूसरी row आप निकालिए

Office hours page का वज़न 0.3 है, और उसके साथ generator 0.5 देता है। गुणा कितना है, और Thursday 9am का कुल chance कितना?

जवाब देखिए

0.3 × 0.5 = 0.15। कुल chance = 0.54 + 0.15 + 0.01 = 0.70।

Wednesday afternoon के लिए generator के numbers 0.05, 0.2 और 0.8 हैं, क्योंकि forum post midweek afternoons की बात करता है। उसका जोड़ 0.6 × 0.05 + 0.3 × 0.2 + 0.1 × 0.8 = 0.03 + 0.06 + 0.08 = 0.17 है। तो RAG Thursday 9am चुनता है, 0.70 बनाम 0.17।

यही हिसाब symbols में ऐसा लिखते हैं:

p(y|x) ≈ ∑z ∈ top-K pη(z|x) · pθ(y|x, z)

pη(z|x) वज़न हैं (0.6, 0.3, 0.1), pθ(y|x, z) generator के numbers हैं (0.9, 0.5, 0.1), और ∑ उनके गुणा जोड़ता है (0.70)। जोड़ सिर्फ़ top-K passages पर है, बाकी 2.1 करोड़ पर नहीं, इसलिए “=” की जगह लिखा है।

इस पूरे हिसाब में कहीं नहीं लिखा कि सही passage queue log है। Formula को सिर्फ़ सवाल x और जवाब y चाहिए, और passage जोड़ के अंदर छिपा रहता है। इसलिए RAG को train करने के लिए सवाल-जवाब के जोड़े काफ़ी हैं।

Retriever के scores बदलिए

Sliders retriever के scores हैं, और generator के numbers नहीं बदलते। Widget exact वज़न लेता है, इसलिए नीचे 0.70 की जगह 0.701 दिखता है। आख़िरी column पड़ाव 4 में आता है।

1.8 1.1 0.0
Passagep(z|x)“Thu 9am”“Wed”Training

अब “बिगड़ा retriever” दबाइए। Retriever अब forum post को 0.69 वज़न देता है, Wednesday afternoon 0.60 पर पहुँचता है, और Thursday 9am सिर्फ़ 0.27 पर रहता है। Generator के numbers वही हैं, इसलिए ये पूरा फ़र्क retriever के वज़नों से आया। मतलब RAG का जवाब retriever के वज़नों पर उतना ही टिका है, जितना generator के numbers पर।

इस जोड़ की एक हद भी है। सही passage top-K में आया ही नहीं, तो वो जोड़ में नहीं है, और training उसका वज़न नहीं बढ़ा सकती। Lesson 2 में इसे कहा था।

3RAG-Sequence और RAG-Token: वज़न वाला जोड़ कब लगे

RAG-Sequence हर passage के साथ पूरा जवाब लिखता है, फिर वज़न वाला जोड़ लगाता है। RAG-Token जवाब के हर token पर अलग से वज़न वाला जोड़ लगाता है। अब तक पूरा जवाब एक टुकड़ा था, लेकिन generator उसे एक-एक token करके लिखता है। जब जवाब के अलग हिस्से अलग passages में हों, तब दोनों तरीकों के नतीजे अलग आते हैं।

पूरे जवाब की probability उसके tokens की probabilities का गुणा है, जो lesson 4 का है। जैसे Thursday की probability 0.9 हो, और उसके बाद Zoom की 0.2, तो पूरे जवाब की 0.9 × 0.2 = 0.18।

अब सवाल लीजिए: Least crowded office hour, and where is it? जवाब के दो tokens हैं: Thursday और Zoom। Queue log बताता है कि Thursday सबसे खाली है, लेकिन जगह नहीं बताता। Office hours page में Thursday 9am on Zoom लिखा है, लेकिन ये नहीं कि कौन सा slot खाली है। numbers मेरे बनाए हैं

Passageवज़नp(Thursday | x, z)p(Zoom | x, z, Thursday)
Queue log0.60.90.2
Office hours page0.40.50.9

RAG-Sequence पहले हर passage के साथ पूरा जवाब लिखता है, फिर वज़न वाला जोड़ लगाता है:

  1. Queue log के साथ पूरा जवाब: 0.9 × 0.2 = 0.18।
  2. Office hours page के साथ पूरा जवाब: 0.5 × 0.9 = 0.45।
  3. वज़न वाला जोड़: 0.6 × 0.18 + 0.4 × 0.45 = 0.108 + 0.180 = 0.288।

Slide इसे ऐसे कहती है: pick one passage, generate the whole answer with it।

RAG-Token हर token पर पहले वज़न वाला जोड़ लगाता है, फिर tokens का गुणा करता है:

  1. Thursday: 0.6 × 0.9 + 0.4 × 0.5 = 0.54 + 0.20 = 0.74।
  2. Zoom: 0.6 × 0.2 + 0.4 × 0.9 = 0.12 + 0.36 = 0.48।
  3. गुणा: 0.74 × 0.48 = 0.355।

Slide पर इसका मतलब है: re-pick the passage at every token of the answer।

RAG-Token को ज़्यादा probability मिली, 0.355 बनाम 0.288। वो Thursday के लिए queue log पर और Zoom के लिए office hours page पर टिक सकता है। RAG-Sequence को पूरा जवाब एक ही passage से लिखना पड़ता है, और कोई अकेला passage दोनों बातें नहीं जानता।

दोनों formulas में वही चीज़ें हैं, बस ∑ और की जगह बदली है। ∏ का मतलब है नीचे लिखी range पर सबका गुणा, ठीक वैसे जैसे ∑ सबका जोड़ है। यहाँ yi जवाब का i-वाँ token है, और y<i उससे पहले के सारे tokens।

RAG-Sequence: p(y|x) ≈ ∑z p(z|x) ∏i p(yi | x, z, y<i)
RAG-Token: p(y|x) ≈ ∏i ∑z p(z|x) p(yi | x, z, y<i)

RAG-Sequence में ∏ अंदर है: पहले हर passage पर tokens का गुणा होता है (0.18 और 0.45), फिर ∑। RAG-Token में ∑ अंदर है: पहले हर token पर passages का जोड़ होता है (0.74 और 0.48), फिर ∏। पड़ाव 5 के नतीजों में दोनों तरीके करीब-करीब बराबर निकलते हैं।

Stanford slide: Deep Dive into RAG, formula और RAG-Sequence, RAG-Token
Stanford की slide: Deep Dive into RAG। ऊपर retriever और generator हैं, बीच में पड़ाव 2 का formula, और नीचे RAG-Sequence और RAG-Token की दो lines। अब आप इसकी हर line पढ़ सकते हैं।

पहले सोचिए

ऊपर वाले example में दोनों passages का वज़न 0.5-0.5 कर दीजिए। RAG-Sequence और RAG-Token, दोनों की probability निकालिए।

जवाब देखिए

RAG-Sequence: 0.5 × 0.18 + 0.5 × 0.45 = 0.315। RAG-Token: (0.5 × 0.9 + 0.5 × 0.5) × (0.5 × 0.2 + 0.5 × 0.9) = 0.70 × 0.55 = 0.385। RAG-Token फिर आगे है, क्योंकि दोनों tokens अब भी अलग passages से आते हैं।

4एक loss से retriever और generator की training

RAG की training सही जवाब की probability का −ln छोटा करती है, और यही एक loss retriever और generator, दोनों को बदलता है। एक loss से सारे हिस्सों को साथ train करने को end-to-end training कहते हैं। Data में सिर्फ़ सवाल-जवाब के जोड़े हैं, फिर भी इसी loss से retriever सीखता है कि किस passage को ज़्यादा वज़न दे।

lesson 4 वाला है: सही जवाब की probability p का −ln। पड़ाव 2 में Thursday 9am को 0.70 मिला था, तो loss = −ln 0.70 = 0.357। सारे training examples j पर ये losses जुड़ते हैं:

∑j − log p(yj | xj)

Slide इसे कहती है। Marginal इसलिए, क्योंकि p(y|x) खुद passages पर marginalization से बना है, और slide का log यही ln है।

किस passage का score बढ़ने से loss घटता है

नीचे की table में हर row एक score को 0.5 बढ़ाती है, और बाकी दो scores वैसे ही रहते हैं। यहाँ वज़न 3 decimals तक हैं, इसलिए पहली row में loss 0.355 है, 0.357 नहीं। हिसाब मेरा

किसका score 0.5 बढ़ावज़न: queue log, office hours, forump(“Thu 9am” | x)Loss
किसी का नहीं0.602, 0.299, 0.0990.7010.355
Queue log, 1.8 से 2.30.714, 0.215, 0.0720.7570.279
Office hours page, 1.1 से 1.60.504, 0.413, 0.0830.6680.403
Forum post, 0.0 से 0.50.565, 0.281, 0.1540.6640.409

Queue log का score बढ़ा, तो कुल chance 0.701 से 0.757 हुआ, और loss घटा। बाकी दोनों में से किसी का score बढ़ा, तो कुल chance घटा और loss बढ़ा, office hours page के 0.5 के बावजूद।

इसकी वजह weighted average में है। p(y|x) generator के numbers 0.9, 0.5 और 0.1 का weighted average है, यानी हर number को उसके वज़न से गुणा करके जोड़। Weighted average हमेशा सबसे छोटे और सबसे बड़े number के बीच रहता है, और जिस number का वज़न बढ़े, average उसी की तरफ़ खिसकता है।

Queue log को अलग रखकर देखिए। Office hours page और forum post के वज़न आपस में 3 : 1 हैं, यानी 0.75 और 0.25। उनका average 0.75 × 0.5 + 0.25 × 0.1 = 0.4 है। तो कुल chance = 0.6 × 0.9 + 0.4 × 0.4 = 0.54 + 0.16 = 0.70। Queue log का score बढ़ने पर भी ये 3 : 1 नहीं बदलता, क्योंकि softmax में बाकी दोनों के exps वही रहते हैं। इसलिए queue log का वज़न w हो, तो कुल chance w × 0.9 + (1 − w) × 0.4 है:

Queue log का वज़न wकुल chance
0.50.65
0.6, अभी0.70
0.70.75
0.80.80
1.00.90

Office hours page के साथ यही हिसाब उल्टा चलता है, क्योंकि उसका 0.5 बाकी दोनों passages के average 0.79 से कम है।

नियम ये है: जिस passage के साथ generator सही जवाब को कुल chance से ज़्यादा probability देता है, training उसका score बढ़ाती है। जिसके साथ कम देता है, उसका score training घटाती है। यहाँ कुल chance 0.70 है, इसलिए queue log (0.9) का score बढ़ेगा, और office hours page (0.5) और forum post (0.1) के scores घटेंगे। ये नियम slide पर नहीं है, ये गणित से निकलता है

अब बिगड़े retriever पर यही नियम चलाइए। वहाँ कुल chance 0.27 है, इसलिए queue log (0.9) और office hours page (0.5), दोनों के scores बढ़ेंगे, और forum post (0.1) का घटेगा। Data में queue log का नाम कहीं नहीं था, फिर भी training retriever को queue log की तरफ़ ले जाती है। पड़ाव 2 के widget का आख़िरी column यही नियम दिखाता है।

कौन से हिस्से train होते हैं

Training हर parameter को उस दिशा में थोड़ा खिसकाती है, जिसमें loss घटे, और ये दिशा बताता है। Loss से पीछे की तरफ़ चलकर हर parameter का gradient निकालने के तरीके को backpropagation कहते हैं, छोटे में backprop। RAG में ये gradient generator के parameters θ तक, और retriever में query encoder तक पहुँचता है।

Passage encoder और index नहीं बदलते, क्योंकि passage encoder बदलता, तो 2.1 करोड़ passages के vectors दोबारा बनाकर index फिर से बनाना पड़ता। paper से इसलिए training सिर्फ़ सवाल की तरफ़ से सुधार करती है। वो query encoder को ऐसे बदलती है, कि काम के passages से q(x) का dot product बढ़े। किसी passage का vector खराब बना हो, तो training उसे नहीं सुधार सकती।

पड़ाव 1 की slide पर ऊपर वाला dashed arrow यही कहता है: End-to-End Backprop through q and pθ। Arrow q और pθ तक जाता है, document index के d(z) तक नहीं।

पहले सोचिए

Widget में “तीनों बराबर” दबाइए, यानी हर passage का वज़न 1/3। Thursday 9am का कुल chance कितना है? Training किस passage का score बढ़ाएगी, किसका घटाएगी, और office hours page का क्या होगा?

जवाब देखिए

कुल chance (0.9 + 0.5 + 0.1) ÷ 3 = 0.50 है। Queue log (0.9) इससे ऊपर है, तो उसका score बढ़ेगा। Forum post (0.1) नीचे है, तो उसका घटेगा। Office hours page ठीक 0.5 देता है, यानी कुल chance के बराबर, इसलिए उसका score वैसा ही रहेगा।

5NQ पर नतीजे: RAG, T5-11B और DPR

Paper RAG को सवाल-जवाब के datasets पर नापता है। Natural Questions (NQ) में Google search पर लोगों के असली सवाल हैं, और उनके जवाब Wikipedia में हैं। paper से जवाब तभी सही गिनते हैं, जब वो सही जवाब से हूबहू मिले, और इस नाप को Exact Match कहते हैं। Score ऐसे सवालों का % है।

Table में दो किस्म के models हैं। Closed book model के पास कोई document नहीं होता, वो सिर्फ़ अपने parameters से जवाब देता है। Open book model पहले documents में ढूँढता है, फिर जवाब देता है।

Modelकिस तरह काNQ
T5-11BClosed book, 11 billion parameters34.5
REALMOpen book, passage में से जवाब का टुकड़ा उठाता है40.4
DPROpen book, passage में से जवाब का टुकड़ा उठाता है41.5
RAG-TokenOpen book, जवाब खुद लिखता है44.1
RAG-SequenceOpen book, जवाब खुद लिखता है44.5

T5-11B 34.5 पर है, और RAG-Sequence 44.5 पर, यानी 10 points आगे। 1,000 सवालों में ये 345 और 445 हूबहू सही जवाब हैं। मतलब documents वाला RAG, सिर्फ़ parameters वाले T5-11B से 1,000 में 100 सवाल ज़्यादा हूबहू सही करता है।

DPR वाली row का मतलब DPR retriever के ऊपर बना पूरा QA system है, जो passage में से जवाब का टुकड़ा उठाता है। RAG उसी तरह का retriever लेकर जवाब खुद लिखता है, और 41.5 से 44.5 पर पहुँचता है। RAG-Token, RAG-Sequence से सिर्फ़ 0.4 पीछे है।

RAG ने retriever को सवाल-जवाब के जोड़ों से सिखाया, लेकिन इसके लिए generator के parameters भी बदले। आज आप LLM अक्सर किसी company की API से लेते हैं, जैसे GPT या Gemini, और उसके parameters नहीं बदल सकते। Lesson 6 इसी हालत से शुरू होता है।

यहाँ से Stanford वाला level

ऊपर के 5 पड़ाव आसान version जैसे ही हैं। आगे के 5 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। पहले पड़ाव 4 वाले नियम का पूरा गणित आता है, फिर ये कि वही loss generator और query encoder तक कैसे पहुँचता है। उसके बाद RAG-Sequence और RAG-Token गहराई से, फिर paper का असली पैमाना, और आख़िर में आप slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।

6Training के नियम का गणित: score पर loss की दर

किसी score पर loss की दर बताती है कि score थोड़ा बढ़े, तो loss कितना बदलता है। Training हर score को इस दर की उल्टी दिशा में खिसकाती है। पड़ाव 4 के नियम ने सिर्फ़ दिशा बताई थी। ये दर दिशा के साथ ये भी बताती है कि किस score को कितना धक्का मिलेगा।

दर: input थोड़ा बदलिए, फिर बदलाव का भाग

किसी चीज़ की दर निकालने का तरीका सीधा है। Input को बहुत थोड़ा बदलिए, देखिए output कितना बदला, और उस बदलाव को input के बदलाव से भाग दीजिए। इस पड़ाव में exact वज़न 0.602, 0.299 और 0.099 चलते हैं, इसलिए कुल chance 0.701 है और loss 0.355। अब एक बार में एक score 0.01 बढ़ाइए: हिसाब मेरा

किसका score 0.01 बढ़ाLoss का बदलावबदलाव ÷ 0.01
Queue log−0.00171−0.171
Office hours page+0.00086+0.086
Forum post+0.00086+0.086

0.01 की जगह और छोटा बदलाव लीजिए, तो ये दरें −0.171, +0.086 और +0.085 पर टिक जाती हैं। जिस number पर दर टिकती है, उसे ∂𝓛/∂s लिखते हैं। ∂ का मतलब है कि सिर्फ़ यही एक score बदला, बाकी सब वैसे ही रहे, और ऐसी दर को कहते हैं। Minus का मतलब है कि queue log का score बढ़ने पर loss घटता है।

Posterior: जवाब देखने के बाद हर passage का हिस्सा

ये दरें पड़ाव 2 की table से सीधे निकलती हैं। उस table के गुणा वाले column में हर passage का कुल chance में हिस्सा था: 0.54, 0.15 और 0.01, कुल 0.70। हर हिस्से को कुल से भाग दीजिए: 0.54 ÷ 0.70 = 0.771, 0.15 ÷ 0.70 = 0.214 और 0.01 ÷ 0.70 = 0.014। Exact वज़नों से यही numbers 0.773, 0.213 और 0.014 आते हैं।

जवाब देखने के बाद के इन वज़नों को posterior कहते हैं, और इन्हें p(z|x, y) लिखते हैं। Retriever के अपने वज़न pη(z|x) जवाब देखने से पहले के हैं, और उन्हें prior कहते हैं। Prior सिर्फ़ सवाल देखता है, जबकि posterior ये भी देखता है कि किस passage के साथ सही जवाब कितनी आसानी से बनता है।

p(z|x, y) = pη(z|x) · pθ(y|x, z)p(y|x)

Queue log के लिए ऊपर 0.602 × 0.9 = 0.542 है, और नीचे 0.701, तो posterior 0.773 है। p(z|x, y) और pθ(y|x, z) अलग चीज़ें हैं, जैसे lesson 4 में p(full | Tuesday) और p(Tuesday | full) अलग थे।

अब दरों को देखिए: −0.171 = 0.602 − 0.773, +0.086 = 0.299 − 0.213, और +0.085 = 0.099 − 0.014। हर score पर loss की दर ठीक prior − posterior है।

∂𝓛 / ∂sz = pη(z|x) − p(z|x, y)

पड़ाव 4 का नियम इसी में छिपा है। Posterior ÷ prior = pθ(y|x, z) ÷ p(y|x) है। इसलिए posterior तभी prior से बड़ा होता है, जब उस passage के साथ generator का number कुल chance से बड़ा हो। Queue log के लिए 0.9 ÷ 0.701 = 1.284, और सच में 0.773 ÷ 0.602 = 1.284।

ये दर कहाँ से आती है: पाँच steps

Generator के numbers को az लिखिए: 0.9, 0.5 और 0.1। Formula तक lesson 4 का ln वाला नियम और दरों के तीन नियम पहुँचा देते हैं। हर step के साथ numbers से जाँच है:

  1. Loss को दो हिस्सों में तोड़िए। Softmax का वज़न es ÷ Z है, जहाँ Z = e1.8 + e1.1 + e0 = 10.054। इसलिए p(y|x) = u ÷ Z, जहाँ u = 6.050 × 0.9 + 3.004 × 0.5 + 1 × 0.1 = 7.047। Lesson 4 का नियम ln(a ÷ b) = ln a − ln b लगाइए, तो 𝓛 = −ln u + ln Z। जाँच: −1.953 + 2.308 = 0.355।
  2. es की दर खुद es है। जाँच: (e1.81 − e1.80) ÷ 0.01 = 6.08, यानी करीब e1.8 = 6.05।
  3. ln u की दर 1 ÷ u है। जाँच: (ln 7.057 − ln 7.047) ÷ 0.01 = 0.1418, और 1 ÷ 7.047 = 0.1419।
  4. जुड़ी हुई दरें गुणा होती हैं। इसे दरों वाला कहते हैं। Queue log का score बदले, तो u में सिर्फ़ e1.8 × 0.9 बदलता है, 5.445 की दर से। u बदले, तो ln u उसके 1 ÷ 7.047 गुना बदलता है। तो ln u की दर 5.445 ÷ 7.047 = 0.773 है, जो queue log का posterior है। इसी तरह ln Z की दर 6.05 ÷ 10.054 = 0.602 है, जो उसका prior है।
  5. दोनों हिस्से जोड़िए। 𝓛 = −ln u + ln Z में queue log की दर −0.773 + 0.602 = −0.171 है। हर passage के लिए यही हिसाब prior − posterior देता है।

Scores पर training का एक कदम

Training हर score को उसकी दर की उल्टी दिशा में खिसकाती है। Step का size 1 लीजिए, यानी हर score में से उसकी दर घटाइए: 1.8 + 0.171 = 1.971, 1.1 − 0.086 = 1.014, और 0.0 − 0.085 = −0.085। नए वज़न 0.661, 0.254 और 0.085 बनते हैं, कुल chance 0.701 से 0.731 होता है, और loss 0.355 से 0.314। हिसाब मेरा

मतलब training retriever के वज़नों को posterior की तरफ़ खींचती है: queue log का वज़न 0.602 से 0.661 हुआ, उसके posterior 0.773 की तरफ़। असली training ये कदम scores पर नहीं, parameters पर लेती है, जो पड़ाव 7 में आता है।

बिगड़े retriever में (scores 0, 0.7 और 1.9) prior 0.103, 0.208 और 0.689 हैं, और गुणा 0.093, 0.104 और 0.069, कुल 0.266। Posterior 0.349, 0.391 और 0.260 बनते हैं, इसलिए दरें −0.246, −0.183 और +0.430 हैं। Queue log और office hours page, दोनों ऊपर जाते हैं, और forum post को सबसे बड़ा धक्का नीचे की तरफ़ मिलता है।

पहले सोचिए

“तीनों बराबर” पर, यानी हर prior 1/3 पर, posterior और दरें निकालिए। Office hours page की दर कितनी है, और क्यों?

जवाब देखिए

गुणा 0.300, 0.167 और 0.033 हैं, कुल 0.50। Posterior 0.600, 0.333 और 0.067 हैं। दरें 0.333 − 0.600 = −0.267, 0.333 − 0.333 = 0, और 0.333 − 0.067 = +0.267 हैं। Office hours page की दर 0 है, क्योंकि उसका 0.5 कुल chance 0.50 के बराबर है, और तब posterior prior के बराबर रहता है।

7एक loss, दो models: generator और query encoder तक दर

वही loss generator को भी दर देता है, और query encoder को भी, और दोनों दरों में posterior फिर आता है। पड़ाव 6 में सब कुछ scores पर था। अब देखिए कि ये दरें दोनों models के parameters तक कैसे पहुँचती हैं, और passage encoder तक क्यों नहीं।

Generator पर दर: posterior जितना धक्का

Generator का number az उसके tokens की probabilities का गुणा है, और lesson 4 के नियम से ln az उनके ln का जोड़ है। इसलिए ln az पर आई दर सीधे हर token तक जाती है, और यहाँ वही दर देखिए। हर ln az को 0.01 बढ़ाइए, यानी az को e0.01 = 1.01005 से गुणा कीजिए: हिसाब मेरा

Generator का कौन सा numberदर, 0.01 के बदलाव सेPosterior
0.9, queue log के साथ−0.7740.773
0.5, office hours page के साथ−0.2140.213
0.1, forum post के साथ−0.0140.014

Generator के हर ln az पर loss की दर ठीक −posterior है। वजह पड़ाव 6 वाली है। ln az बदलने पर u का हिस्सा esz az उसी की दर से बदलता है, और ln u की दर 1 ÷ u है। उनका गुणा esz az ÷ u posterior है, और loss में −ln u है, इसलिए minus। Z में az नहीं है, इसलिए वो हिस्सा नहीं बदलता।

इसका मतलब ये है कि generator उस passage के साथ सही जवाब लिखना सबसे ज़्यादा सीखता है, जिसका posterior सबसे बड़ा है। Queue log के साथ Thursday 9am लिखने पर 0.773 का धक्का है, और forum post के साथ सिर्फ़ 0.014 का। इसलिए generator ये नहीं सीखता कि forum post पढ़कर भी Thursday 9am लिखे, जबकि वो बात forum post में है ही नहीं। ये मतलब हिसाब से निकाला है, slide पर नहीं

Query vector पर दर, और उस पर एक कदम

Retriever में score d(z)⊤q(x) है, और training के हाथ में सिर्फ़ q(x) है। अब q(x) को एक असली vector मानिए, जिसमें 2 numbers हैं, और passages के vectors भी 2-2 numbers के लीजिए। Office hours page का vector lesson 3 वाला ही है। vectors मेरे बनाए हैं

Text, और उसका vectorq(x) से dot product
सवाल, q(x)[1.0, 2.0]–
Queue log, d(z)[1.0, 0.4]1.0 × 1.0 + 2.0 × 0.4 = 1.8
Office hours page[0.9, 0.1]1.0 × 0.9 + 2.0 × 0.1 = 1.1
Forum post[0.4, −0.2]1.0 × 0.4 + 2.0 × (−0.2) = 0.0

q(x) का पहला number q1 0.01 बढ़े, तो हर score उस passage के पहले number × 0.01 बढ़ता है। वजह ये है कि dot product में q1 सिर्फ़ पहले numbers से गुणा होता है। इसलिए score की q1 पर दर उस passage का पहला number है। Chain rule से loss की q1 पर दर ऐसे बनती है:

  1. Queue log: score की दर −0.171, गुणा पहला number 1.0, यानी −0.171।
  2. Office hours page: 0.086 × 0.9 = 0.077।
  3. Forum post: 0.085 × 0.4 = 0.034।
  4. जोड़: −0.171 + 0.077 + 0.034 = −0.060।

दूसरे number के लिए यही हिसाब −0.068 + 0.009 − 0.017 = −0.077 देता है। तो loss की q(x) पर दर [−0.060, −0.077] है, और formula यही हिसाब ऐसे लिखता है:

∂𝓛 / ∂q(x) = ∑z ( pη(z|x) − p(z|x, y) ) d(z)

अब q(x) को इसकी उल्टी दिशा में step size 1 से खिसकाइए: [1.0 + 0.060, 2.0 + 0.077] = [1.060, 2.077]। नए scores 1.890, 1.161 और 0.009 हैं, वज़न 0.612, 0.295 और 0.093, कुल chance 0.707, और loss 0.355 से 0.346 हो जाता है।

Office hours page का score भी 1.1 से 1.161 बढ़ा, जबकि उसकी दर कहती थी कि वो घटे। सारे scores एक ही q(x) से बनते हैं, इसलिए training उन्हें अलग-अलग नहीं हिला सकती। फिर भी loss घटा, क्योंकि queue log का score सबसे ज़्यादा बढ़ा: 0.090, जबकि office hours page का 0.061।

Passage vectors क्यों नहीं बदलते

d(z) पर भी loss की दर होती है। Queue log के vector पर वो (prior − posterior) × q(x) = −0.171 × [1.0, 2.0] = [−0.171, −0.342] है। Lesson 12 में DPR की अपनी training passage encoder को ऐसी ही दर से बदलती है, क्योंकि तब कोई index नहीं बना होता।

RAG ये कदम नहीं लेता। Passage encoder BERTd बदलता, तो 2.1 करोड़ passages के vectors और index बीच-बीच में दोबारा बनाने पड़ते, जैसा REALM अपनी pretraining में करता है। Paper के हिसाब से इसके बिना भी नतीजे अच्छे रहे, इसलिए passage encoder और index fixed हैं। paper से

Toy से असली models तक

Toy में q(x) खुद बदला। असल में q(x) = BERTq(x) है, और यही chain rule BERTq की हर layer तक ले जाता है। Generator वाली दर BART के हर parameter तक पहुँचती है। Paper के हिसाब से दोनों BERT encoders के 11-11 करोड़ parameters हैं, और BART के 40.6 करोड़, कुल 62.6 करोड़। paper से Passage encoder के 11 करोड़ नहीं बदलते, इसलिए training करीब 51.6 करोड़ parameters बदलती है। हिसाब मेरा

Paper के experiments: retriever को रोककर, और BM25 लगाकर

Paper ने ये भी नापा कि retriever का सीखना कितना काम आता है। इसके लिए उसने बदले हुए models train किए। ऐसे experiment को ablation कहते हैं: model का एक हिस्सा हटाइए या रोकिए, और देखिए कि नतीजा कितना गिरा। Frozen वाले model में query encoder भी नहीं बदलता। BM25 वाले में DPR की जगह lesson 11 का BM25 है, और उसके scores softmax में जाते हैं। paper से

RetrieverRAG-TokenRAG-Sequence
BM2529.731.8
DPR, frozen37.841.2
DPR, जो सीखता है43.544.0

NQ पर Exact Match, dev set पर। इसलिए ये पड़ाव 5 के test वाले 44.1 और 44.5 से थोड़े अलग हैं।

एक खतरा भी है। Paper के शुरुआती experiments में कहानी लिखने जैसे कुछ कामों पर retriever हर सवाल के लिए वही passages लाने लगा। फिर generator ने passages को अनदेखा करना सीख लिया, और RAG अकेले BART जैसा हो गया। इसे retrieval collapse कहते हैं। Paper का अंदाज़ा है कि लंबे जवाबों में retriever तक पहुँचने वाली दरें कमज़ोर पड़ती हैं। paper से

8RAG-Sequence और RAG-Token गहराई से: posterior, decoding और K

दोनों तरीकों का फ़र्क posterior में दिखता है: RAG-Token हर token पर अलग posterior रख सकता है, और RAG-Sequence पूरे जवाब पर एक। Paper दोनों formulas ऐसे लिखता है, और हमारे Thursday-Zoom example में N = 2, y1 = Thursday और y2 = Zoom हैं: paper से

pRAG-Sequence(y|x) ≈ ∑z ∈ top-k(p(·|x)) pη(z|x) ∏i=1N pθ(yi | x, z, y1:i−1)
pRAG-Token(y|x) ≈ ∏i=1N ∑z ∈ top-k(p(·|x)) pη(z|x) pθ(yi | x, z, y1:i−1)

y1:i−1 का मतलब token 1 से token i − 1 तक, यानी पड़ाव 3 वाला y<i। Zoom के लिए ये सिर्फ़ Thursday है। top-k(p(·|x)) retriever के लाए k passages हैं, यहाँ queue log और office hours page।

हर token पर posterior

RAG-Token में हर token का अपना वज़न वाला जोड़ है, इसलिए हर token का अपना posterior भी है। Thursday पर queue log का 0.54 ÷ 0.74 = 0.730 है, और office hours page का 0.20 ÷ 0.74 = 0.270। Zoom पर ये 0.12 ÷ 0.48 = 0.25 और 0.36 ÷ 0.48 = 0.75 हैं। पहले token पर queue log आगे है, और दूसरे पर office hours page। RAG-Sequence में पूरे जवाब का एक ही posterior है: 0.108 ÷ 0.288 = 0.375 और 0.180 ÷ 0.288 = 0.625।

Paper का Figure 2 यही चीज़ एक असली example पर दिखाता है। Jeopardy में input Hemingway था, और RAG-Token ने लिखा: "The Sun Also Rises" is a novel by this author of "A Farewell to Arms"। Sun लिखते वक्त उस passage का posterior ऊँचा था, जिसमें The Sun Also Rises है, और A Farewell to Arms पर दूसरे passage का। हर नाम का पहला token लिखने के बाद posterior फैल जाता है, क्योंकि बाकी नाम BART अपने parameters से पूरा कर लेता है। paper से

जवाब एक ही token का हो, तो दोनों formulas एक हो जाते हैं, क्योंकि ∏ में बस एक term बचता है। FEVER के labels, जैसे supports, ऐसे ही एक token हैं, इसलिए वहाँ RAG-Sequence और RAG-Token बराबर हैं। paper से

जवाब लिखना: Thorough और Fast decoding

Training में सही जवाब पहले से पता है, इसलिए उसकी probability निकालना काफ़ी है। Test पर model को जवाब खुद लिखना है, और इसे decoding कहते हैं। RAG-Token हर token पर जोड़ी हुई probability लेता है, जैसे Thursday पर 0.74, और एक आम generator की तरह token by token लिखता है। QA में paper हर token पर सबसे बड़ी probability वाला token चुनता है, यानी lesson 1 वाली । paper से

RAG-Sequence की probability tokens में नहीं टूटती, क्योंकि उसका जोड़ पूरे जवाब के बाद लगता है। इसलिए paper उसका जवाब तीन steps में निकालता है: paper से

  1. हर passage के साथ generator अलग से एक जवाब लिखता है। ये जवाब उम्मीदवार हैं, और K passages से ज़्यादा से ज़्यादा K उम्मीदवार बनते हैं।
  2. हर उम्मीदवार के लिए generator उन passages के साथ दोबारा चलता है, जिनके साथ वो उम्मीदवार नहीं लिखा गया था। इससे हर passage के साथ उसकी probability मिलती है।
  3. हर उम्मीदवार का वज़न वाला जोड़ बनता है, और सबसे बड़े जोड़ वाला उम्मीदवार जवाब बनता है।

इस तरीके को Thorough decoding कहते हैं। Step 2 छोड़ दीजिए, यानी जिस passage के साथ उम्मीदवार नहीं बना, वहाँ उसकी probability 0 मान लीजिए, तो वो Fast decoding है। NQ पर RAG-Sequence 50 passages लेता है और Thorough decoding चलाता है, क्योंकि जवाब छोटे हैं। तब 50 उम्मीदवारों तक, हर एक के लिए 50 passages, यानी करीब 50 × 50 = 2,500 generator runs तक। लंबे जवाबों वाले कामों में paper ने Fast decoding रखी, क्योंकि Thorough से नतीजे नहीं सुधरे। 2,500 वाली गिनती मेरी है

कितने passages: K का असर

Training में K = 5 या 10 था, और दोनों में खास फ़र्क नहीं दिखा। Test पर paper K खुद चुनता है: NQ के लिए RAG-Token 15 passages लेता है, और RAG-Sequence 50। Paper का Figure 3 दिखाता है कि ज़्यादा passages लाने पर RAG-Sequence का NQ score बढ़ता है, और फिर करीब वहीं टिका रहता है। RAG-Token का score करीब 10 passages पर सबसे ऊपर पहुँचता है, और उसके बाद थोड़ा गिरता है। paper से

उसी figure का दूसरा graph answer recall दिखाता है, यानी कितने % सवालों में top-K के अंदर जवाब वाला passage है। हर K पर RAG के सीखे हुए retriever की line fixed DPR से ऊपर है, और BM25 की line दोनों से काफ़ी नीचे। मतलब end-to-end training के बाद retriever सही passages को ज़्यादा ऊपर लाता है, जो पड़ाव 6 का नतीजा है।

9Paper का असली पैमाना और पूरे नतीजे

हमारे example में 3 passages और 2 numbers वाले vectors थे, ताकि हिसाब हाथ से हो सके। Paper में mechanism वही है, सिर्फ़ numbers बड़े हैं: paper से

चीज़हमारा exampleRAG paper में
Passages3करीब 2.1 करोड़, December 2018 के Wikipedia के 100-100 शब्दों के टुकड़े
Vector की लंबाई2768, BERT-base का vectorये number lesson 12 से है
Index– में index, CPU memory में करीब 100 GBcompress करके 36 GB
K3training में 5 या 10, NQ के test पर 15 (RAG-Token) और 50 (RAG-Sequence)
Models–दो BERT-base, 11-11 करोड़ parameters, और BART-large, 40.6 करोड़
Trainingहाथ से8 GPUs, हर एक में 32 GB memory
NQ के सवाल1training में 79,169, test में 3,611

Test के 3,611 सवालों में RAG-Sequence का 44.5 मतलब करीब 1,607 हूबहू सही जवाब। Exact Match सख़्त है: वो Thursday 9 am और Thursday 9am को अलग मानता है। इसलिए 44.5 का मतलब ये नहीं कि बाकी 55.5% जवाब सच में गलत थे।

पूरी results table

पड़ाव 5 में सिर्फ़ NQ वाला column था। Slide की table में चार datasets हैं, जिन्हें phone पर पढ़ने के लिए यहाँ दो tables में बाँटा है:

ModelNQTQAआम / Wiki test
T5-11B34.5– / 50.1
T5-11B + SSM36.6– / 60.5
REALM40.4– / –
DPR41.557.9 / –
RAG-Token44.155.2 / 66.1
RAG-Sequence44.556.8 / 68.0
ModelWQCT
T5-11B37.4–
T5-11B + SSM44.7–
REALM40.746.8
DPR41.150.6
RAG-Token45.550.0
RAG-Sequence45.252.2

Exact Match (%), test set पर। TQA = TriviaQA, WQ = WebQuestions, CT = CuratedTrec।

DPR वाली row पूरा DPR QA system है। उसमें retriever के बाद एक BERT passages को दोबारा क्रम में लगाता है। फिर एक reader passage में से जवाब का टुकड़ा उठाता है। RAG के पास न ऐसा reranker है, न ऐसा reader, फिर भी वो NQ पर 41.5 से 44.5 पर है। paper से

Paper के मुताबिक़ जवाब लिखने का एक फ़ायदा ये है कि जिस passage में जवाब हूबहू नहीं है, उसके सुराग भी काम आते हैं। NQ के जिन सवालों में किसी लाए गए passage में सही जवाब नहीं था, उनमें भी RAG ने 11.8% जवाब सही लिखे। Passage में से टुकड़ा उठाने वाला model वहाँ 0% पर रहता। paper से

REALM और T5-11B + SSM एक खास pretraining से गुज़रे थे, जिसे कहते हैं, और RAG ने ऐसी pretraining नहीं की। लेकिन RAG का retriever DPR से शुरू होता है, जो NQ और TriviaQA के सवाल-passage जोड़ों पर पहले train हुआ था। यानी RAG की अपनी training को passage labels नहीं चाहिए, लेकिन उसका शुरुआती retriever labels से बना है। paper से

Paper एक और तुलना देता है। T5 के sizes में RAG के सबसे करीब T5-large है, जिसके 77 करोड़ parameters हैं, और वो NQ पर 28.9 पर है। ये RAG-Sequence के 44.5 से 15.6 points पीछे है। paper से

Jeopardy वाला test

Jeopardy में जवाब पहले मिलता है, और उसके लिए एक सवाल लिखना होता है। Paper ने 452 जोड़ों में अकेले BART और RAG-Token के लिखे सवाल लोगों को दिखाए। लोगों ने हर जोड़े में चुना कि कौन सा सवाल बेहतर है: paper से

लोगों का फ़ैसलाFactualitySpecificity
BART बेहतर7.1%16.8%
RAG बेहतर42.7%37.4%
दोनों अच्छे11.7%11.8%
दोनों खराब17.7%6.9%
कोई बहुमत नहीं20.8%20.1%

Jeopardy के सवालों में अक्सर दो अलग बातें होती हैं, जैसे Hemingway वाले सवाल में दो किताबें। इसलिए paper के अपने-आप वाले नाप पर यहाँ RAG-Token सबसे आगे रहा। paper से

10अब Stanford की slides खुद पढ़िए

नीचे Stanford की RAG वाली छह slides हैं, बिना किसी बदलाव के। हर slide के नीचे कुछ सवाल हैं। पहले खुद जवाब सोचिए, फिर खोलिए। कोई symbol अटके, तो जवाब में लिखे पड़ाव पर लौट जाइए। Phone पर slide छोटी दिखे, तो image पर click कीजिए, वो पूरे size में खुलेगी।

Stanford slide: RAG का ढाँचा
उसी slide का retriever वाला हिस्सा, बड़ा करके
उसी slide का generator वाला हिस्सा, बड़ा करके
उसी slide का ऊपर वाला dashed arrow, बड़ा करके
Stanford की RAG वाली slide, और नीचे उसके retriever, generator और training arrow वाले हिस्से, बड़े करके। बाईं तरफ़ तीन काम हैं: question answering, fact verification और Jeopardy वाले सवाल। नीचे लिखे REALM और DPR, पड़ाव 9 की table की open book rows हैं।

RAG के ढाँचे वाली slide पढ़िए

  1. Retriever के नीचे (Non-Parametric) और generator के नीचे (Parametric) लिखा है। Query encoder के भी parameters हैं, तो retriever non-parametric क्यों कहलाता है?

    जवाब देखिए

    Retriever की जानकारी passages के index में है, यानी में। Generator की जानकारी उसके parameters θ में है, यानी में। Query encoder के parameters सिर्फ़ ये तय करते हैं कि index में से क्या निकले। Paper भी index को non-parametric memory कहता है। (पड़ाव 1) paper से

  2. ऊपर का dashed arrow q और pθ पर रुकता है। वो Document Index के d(z) तक क्यों नहीं जाता?

    जवाब देखिए

    Training की दरें query encoder और generator तक जाती हैं। d(z) पर भी दर होती है, जैसे toy में queue log के vector पर [−0.171, −0.342], लेकिन RAG ये कदम नहीं लेता। d(z) बदलता, तो 2.1 करोड़ vectors और index दोबारा बनाने पड़ते। (पड़ाव 4 और 7)

  3. Documents z1 और z2 के नीचे बैंगनी हिस्सा है, और Jeopardy वाले input से एक line उन तक जाती है। ये क्या दिखाता है?

    जवाब देखिए

    बैंगनी हिस्सा input x है, उसी रंग का जिसमें Jeopardy वाला x है। Line x को हर passage तक ले जाती है, यानी x और z concatenate होकर generator में जाते हैं, हर passage के साथ अलग से। (पड़ाव 1)

Stanford slide: Deep Dive into RAG, formula के साथ
उसी slide की RAG-Sequence और RAG-Token वाली lines, बड़ी करके
Stanford slide: Deep Dive into RAG, training वाली line के साथ
उसी slide की training वाली line, बड़ी करके
Stanford की दो Deep Dive slides। पहली में formula और नीचे की दो lines हैं, दूसरी में training वाली line। दोनों के ज़रूरी हिस्से बड़े करके नीचे हैं। Formula के हर symbol की बात lesson 4 के गहरे version में है।

Deep Dive वाली slides पढ़िए

  1. RAG-Sequence वाली line कहती है pick one passage। क्या RAG-Sequence सच में एक passage चुनकर बाकी छोड़ देता है?

    जवाब देखिए

    नहीं। वो हर passage के साथ पूरा जवाब लिखता है, और सबका वज़न वाला जोड़ लेता है: 0.6 × 0.18 + 0.4 × 0.45 = 0.288। Pick one passage का मतलब है कि पूरा जवाब एक ही passage पर टिका है, इसलिए पूरे जवाब का एक posterior है, 0.375 और 0.625। (पड़ाव 3 और 8)

  2. लाल note कहता है कि हर passage के जवाब को retriever के भरोसे से तौलिए। जवाब देखने के बाद ये भरोसा कैसा दिखता है, और training उसका क्या करती है?

    जवाब देखिए

    Formula का भरोसा prior p(z|x) है। जवाब देखने के बाद वाला भरोसा posterior है, queue log के लिए 0.602 की जगह 0.773। Training prior को posterior की तरफ़ खींचती है, क्योंकि score पर loss की दर prior − posterior है। (पड़ाव 6)

  3. दूसरी slide कहती है Jointly train the retriever and generator। Retriever का कौन सा हिस्सा सच में train होता है?

    जवाब देखिए

    सिर्फ़ query encoder BERTq। Passage encoder BERTd और index fixed हैं, जबकि generator BART पूरा train होता है। 62.6 करोड़ में से करीब 51.6 करोड़ parameters बदलते हैं। (पड़ाव 4 और 7)

  4. Training वाली line में ∑j किन चीज़ों पर चलता है, और NQ के लिए कितने j हैं? क्या किसी j में passage लिखा है?

    जवाब देखिए

    हर training जोड़े (xj, yj) पर। NQ में 79,169 training सवाल हैं, और paper हर सवाल के हर सही जवाब को अलग जोड़ा बनाता है, इसलिए j इससे भी ज़्यादा हैं। किसी जोड़े में passage नहीं लिखा, इसीलिए p(yj|xj) passages पर marginalization से बनता है। (पड़ाव 2, 4 और 9) paper से

Stanford slide: Retriever: DPR
उसी slide का formula, बड़ा करके
उसी slide की top-k वाली line, बड़ी करके
Stanford slide: Generator: BART
उसी slide की तीनों lines, बड़ी करके
Stanford की retriever और generator वाली slides, और उनके हिस्से बड़े करके।

Retriever और generator वाली slides पढ़िए

  1. BERTd और BERTq कहाँ से आते हैं, और RAG की training में इनमें से कौन बदलता है? Lesson 12 के DPR से इसमें क्या फ़र्क है?

    जवाब देखिए

    दोनों DPR से आते हैं, जो NQ और TriviaQA के सवाल-passage जोड़ों पर पहले train हुआ था। RAG में सिर्फ़ BERTq बदलता है। DPR की अपनी training में दोनों बदलते हैं, क्योंकि तब index नहीं बना होता। (पड़ाव 7 और 9) paper से

  2. top-k(p(·|x)) में k कितना है? Training और NQ के test में इसकी value क्या है?

    जवाब देखिए

    k लाए गए passages की गिनती है, यानी पिछली slides वाला K। Training में 5 या 10, और NQ के test पर RAG-Token के लिए 15 और RAG-Sequence के लिए 50। (पड़ाव 8)

  3. Generator वाली slide कहती है x and z are concatenated, और ये भी कि कोई भी encoder-decoder चलेगा। ये दोनों बातें RAG के formula से कैसे जुड़ती हैं?

    जवाब देखिए

    Formula को generator से सिर्फ़ pθ(y|x, z) चाहिए। BART एक ही text पढ़ता है, इसलिए x और z जुड़कर एक input बनते हैं, जैसे पड़ाव 1 वाला queue log का input। K passages हों, तो K अलग inputs बनते हैं। जो भी encoder-decoder ये probability दे, वो इस जगह लग सकता है। (पड़ाव 1 और 2)

  4. Generator one token at a time लिखता है। K passages हों, तो RAG-Token और RAG-Sequence में generator जवाब कैसे लिखता है?

    जवाब देखिए

    दोनों में generator हर passage के साथ अलग चलता है, यानी K inputs पर। RAG-Token हर token पर K passages की probabilities जोड़कर एक ही जवाब लिखता है। RAG-Sequence हर passage के साथ अलग जवाब लिखता है, और Thorough decoding में हर उम्मीदवार को बाकी passages के साथ दोबारा जाँचता है। (पड़ाव 8)

Stanford slide: RAG Performance on Open-Domain QA
उसी slide की QA वाली table, बड़ी करके
उसी slide की लोगों के फ़ैसलों वाली table, बड़ी करके
Stanford की results वाली slide, और नीचे उसकी दोनों tables, बड़ी करके।

Results वाली slide पढ़िए

  1. DPR (41.5) और RAG-Seq. (44.5) के retriever एक ही तरह के हैं। फिर दोनों में फ़र्क कहाँ से आता है?

    जवाब देखिए

    DPR system passage में से जवाब का टुकड़ा उठाता है, और उसके साथ एक reranker भी है। RAG जवाब खुद लिखता है, और उसका query encoder जवाब वाले loss से और train हुआ। जिन सवालों में किसी passage में जवाब नहीं था, उनमें भी RAG ने 11.8% सही लिखे। (पड़ाव 5, 7 और 9)

  2. WQ column में bold 45.5 RAG-Token का है। क्या इसका मतलब है कि WQ के लिए RAG-Token साफ़ तौर पर बेहतर है?

    जवाब देखिए

    फ़र्क सिर्फ़ 45.5 − 45.2 = 0.3 है। WQ के test में 2,033 सवाल हैं, तो 0.3% करीब 6 सवाल है, और इतने छोटे फ़र्क को पक्का मानना मुश्किल है। (पड़ाव 9) हिसाब मेरा

  3. दाईं table के दोनों columns जोड़िए। क्या निकलता है, और RAG के बारे में ये table क्या कहती है?

    जवाब देखिए

    Factuality: 7.1 + 42.7 + 11.7 + 17.7 + 20.8 = 100.0। Specificity: 16.8 + 37.4 + 11.8 + 6.9 + 20.1 = 93.0, और paper इसकी वजह नहीं बताता। दोनों में सबसे बड़ी row RAG बेहतर वाली है: factuality में RAG, BART से 6.0 गुना ज़्यादा बार बेहतर निकला। (पड़ाव 9)

इस lesson की 3 बातें

  1. RAG passage को छिपा हुआ choice मानता है, और top-K passages पर वज़न वाला जोड़ लगाता है: p(y|x) ≈ ∑ pη(z|x) · pθ(y|x, z)। इसलिए RAG की अपनी training को सही passage के labels नहीं चाहिए।
  2. हर score पर loss की दर prior − posterior है, और generator के हर ln az पर −posterior। इसलिए training retriever के वज़नों को posterior की तरफ़ खींचती है, और generator उसी passage के साथ सबसे ज़्यादा सीखता है, जिसका posterior बड़ा है।
  3. RAG-Token हर token पर अलग posterior रख सकता है, और RAG-Sequence पूरे जवाब पर एक। Query encoder और generator train होते हैं, passage encoder और index नहीं। फिर भी सीखने वाला retriever NQ के dev set पर frozen retriever से 2.8 points आगे है, और BM25 से 12.2।

इस lesson के नए शब्द

RAG
Retrieval-Augmented Generation: retriever और generator को एक model में जोड़कर एक ही loss से साथ train करना। जैसे queue log लाकर उससे Thursday 9am लिखना।
Latent variable
छिपा हुआ choice, जो data में नहीं लिखा। RAG में ये choice है कि जवाब किस passage से आया। जैसे सवाल-जवाब के जोड़े में ये नहीं लिखा कि जवाब queue log से आया।
η और θ
Retriever (eta) और generator (theta) के parameters के नाम। इसीलिए retriever को pη(z|x) लिखते हैं, और generator को pθ(y|x, z)।
BERT
Google का 2018 का encoder model। RAG के retriever के दोनों encoders, query encoder और passage encoder, इसी से बने हैं।
MIPS
Maximum inner product search: index में सबसे बड़े dot product वाले K passages ढूँढना। जैसे 2.1 करोड़ passages में से सबसे ऊँचे 5 scores वाले passages।
Generator
सवाल और एक passage पढ़कर जवाब लिखने वाला model, pθ(y|x, z)। RAG में ये BART है। जैसे queue log के साथ Thursday 9am को 0.9।
Encoder-decoder
Encoder input के vectors बनाता है, और decoder उन्हें देखकर एक-एक token लिखता है। BART ऐसा model है।
Concatenate
दो texts को आगे-पीछे जोड़कर एक text बनाना। जैसे question: … के बाद passage: … जोड़ना।
RAG-Sequence
हर passage के साथ पूरा जवाब, फिर वज़न वाला जोड़। जैसे 0.6 × 0.18 + 0.4 × 0.45 = 0.288।
RAG-Token
हर token पर वज़न वाला जोड़, फिर tokens का गुणा। जैसे 0.74 × 0.48 = 0.355।
End-to-end training
एक ही loss से सारे हिस्सों को साथ train करना। RAG में query encoder और generator, दोनों उसी −ln p(y|x) से सीखते हैं। जैसे −ln 0.70 = 0.357।
Backpropagation
Loss से पीछे की तरफ़ चलकर हर parameter का gradient निकालने का तरीका, छोटे में backprop। RAG में ये generator और query encoder तक जाता है, passage encoder तक नहीं।
Exact Match
जवाब सही जवाब से हूबहू मिले, तभी सही। Score ऐसे सवालों का % है। जैसे NQ पर RAG-Sequence का 44.5।
Closed book और open book
सिर्फ़ parameters से जवाब, या पहले documents में ढूँढकर जवाब। जैसे NQ पर closed book T5-11B 34.5, और open book RAG-Sequence 44.5।
Posterior और prior
Prior pη(z|x) जवाब देखने से पहले passage का वज़न है। Posterior p(z|x, y) जवाब देखने के बाद का वज़न है, यानी कुल chance में उस passage का हिस्सा। जैसे queue log का prior 0.602 है, और posterior 0.773।
Ablation
Model का एक हिस्सा हटाकर या रोककर दोबारा नापना, ताकि उस हिस्से का असर दिखे। जैसे RAG-Sequence में query encoder रोकने पर NQ (dev) 44.0 से 41.2 पर आता है।
Thorough और Fast decoding
RAG-Sequence से जवाब लिखने के दो तरीके। हर passage के साथ एक उम्मीदवार बनता है। Thorough हर उम्मीदवार को हर passage के साथ जाँचता है, और Fast सिर्फ़ वहीं, जहाँ वो बना। जैसे NQ पर 50 passages के साथ Thorough में करीब 2,500 generator runs तक।
Retrieval collapse
Training में retriever का हर सवाल पर वही passages लाने लगना, जिसके बाद generator उन्हें अनदेखा करना सीख लेता है। जैसे paper में कहानी लिखने वाले काम पर।