DPR एक retriever है, जो सवाल और हर passage को vector में बदलता है। फिर वो उन passages को चुनता है, जिनका सवाल के vector से dot product सबसे बड़ा हो। ये vectors दो encoders बनाते हैं, और दोनों encoders सवाल और सही passage के जोड़ों पर train होते हैं। DPR का पूरा नाम Dense Passage Retrieval है, और lesson 5 के RAG का retriever यही था।
इसकी ज़रूरत lesson 11 में दिखी थी। सवाल which office hour is least crowded पर BM25 ने 2024 के एक पुराने forum post को 2.749 देकर सबसे ऊपर रखा। जवाब queue log में है, जो 2.473 के साथ दूसरी जगह पर रहा, क्योंकि उसमें least और crowded शब्द नहीं हैं। DPR के encoders train होकर इस सवाल के vector को queue log के vector के पास लाते हैं।
इस lesson की सीढ़ी
सीढ़ी में 9 पड़ाव हैं। पहले 5 आसान version जैसे ही हैं, और 6 से 9 आपको Stanford की slides के level तक ले जाते हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।
पहले से क्या चाहिए: Lesson 3 (vector, dot product, encoder), Lesson 4 (exp, softmax, ln, loss, gradient) और Lesson 11 (BM25)। पड़ाव 6 से आगे Lesson 5 (θ, backpropagation, Exact Match) और Lesson 10 (HNSW) भी काम आते हैं। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।
1दो encoders और एक dot product
DPR में दो अलग encoders हैं: question encoder EQ सवाल का vector बनाता है, और passage encoder EP हर passage का। वो model है, जो text पढ़कर तय लंबाई का vector देता है। DPR के दोनों encoders पहले से से शुरू होते हैं, और DPR उन्हें सवाल-passage जोड़ों पर करता है।
Score दोनों vectors का है:
s(q, p) = EQ(q)⊤ EP(p)
यहाँ सिर्फ़ dot product लिखने का एक तरीका है, और Stanford की slide ऐसे ही लिखती है।
अब एक छोटे example पर देखिए। असली vector में 768 numbers होते हैं, यहाँ सिर्फ़ 4 हैं, ताकि आप हिसाब हाथ से कर सकें। vectors मेरे बनाए हैं
Text, और encoder से बना उसका vector
सवाल से dot product
सवाल: least crowded office hour[1.0, 0.5, 0.5, 1.0]
–
Queue log, जिसमें जवाब है[0.2, 0.4, 0.4, 0.4]
1.0
पुराना forum post[0.8, 1.0, 0.4, 0.5]
2.0
Homework 1 की announcement[0.5, 0.4, 0.6, 0.5]
1.5
Queue log का score ऐसे निकला: 1.0 × 0.2 + 0.5 × 0.4 + 0.5 × 0.4 + 1.0 × 0.4 = 1.0। Encoders अभी train नहीं हुए हैं, इसलिए गलत forum post 2.0 के साथ सबसे ऊपर है। पड़ाव 2 की training यही क्रम बदलती है।
DPR सवाल और passage को अलग-अलग पढ़ता है, और इसका फ़ायदा speed में है। उसका काम दो हिस्सों में बँटता है:
, यानी सवाल आने से पहले: passage encoder हर passage का vector एक बार बनाता है, और सबको एक में रखता है।
Online, यानी सवाल आने पर: question encoder सिर्फ़ एक बार चलता है। फिर index के vectors से dot product निकलते हैं, और सबसे बड़े k scores वाले passages लौटते हैं।
अगर एक ही model सवाल और passage को साथ पढ़ता, तो हर सवाल पर उसे हर passage के साथ अलग से चलना पड़ता। Lesson 5 के Wikipedia में करीब 2.1 करोड़ passages थे, यानी हर सवाल पर 2.1 करोड़ बार model चलता। DPR में model हर सवाल पर सिर्फ़ 1 बार चलता है। दो encoders वाले इस ढाँचे को bi-encoder कहते हैं।
Stanford की slide: DPR का offline और online हिस्सा। ऊपर offline हिस्सा है, और नीचे online। अब आप इसका हर box पढ़ सकते हैं। Image पर click करने से वो पूरे size में खुलती है।
पहले सोचिए
सवाल का vector दोगुना कर दीजिए, यानी [2.0, 1.0, 1.0, 2.0]। तीनों scores क्या होंगे, और क्या क्रम बदलेगा?
जवाब देखिए
Scores 2.0, 4.0 और 3.0 हो जाते हैं। Dot product के हर गुणा में एक number सवाल के vector से आता है। वो दोगुना हुआ, तो हर गुणा दोगुना हुआ, और उनका जोड़ भी: queue log के लिए 2.0 × 0.2 + 1.0 × 0.4 + 1.0 × 0.4 + 2.0 × 0.4 = 2.0। हर score दोगुना हुआ, लेकिन क्रम वही रहा, और forum post अब भी सबसे ऊपर है। पड़ाव 2 में ये बात काम आएगी।
2Contrastive loss: सही passage को गलत passages से आगे करना
Contrastive loss सही passage के score की तुलना गलत passages के scores से करता है। सही passage जितना आगे होता है, loss उतना छोटा होता है। DPR के दोनों encoders इसी loss को छोटा करने के लिए train होते हैं।
इस तुलना के लिए हर training सवाल के साथ दो तरह के passages चाहिए:
Positive
सवाल का सही passage। Training data में ये हर सवाल के साथ लिखा होता है। हमारे सवाल के लिए ये queue log है।
Negative
उसी सवाल के लिए गलत passage। हमारे example में forum post और Homework 1 की announcement।
तुलना इसलिए ज़रूरी है, क्योंकि retriever सिर्फ़ ऊपर वाले passages आगे भेजता है, यानी उसके लिए क्रम मायने रखता है। पड़ाव 1 के सवाल में आपने देखा कि सवाल का vector लंबा करने से सारे scores बढ़ते हैं, लेकिन क्रम वही रहता है। अगर training सिर्फ़ positive का score बढ़ाने को कहे, तो encoder यही आसान रास्ता ले सकता है।
अब पड़ाव 1 के scores पर loss निकालिए: queue log 1.0, forum post 2.0 और Homework 1.5। Loss तीन steps में निकलता है:
हर score का लीजिए: 2.72, 7.39 और 4.48। e एक खास number है, करीब 2.718, इसलिए e1.0 = 2.72 और e2.0 = 2.718 × 2.718 = 7.39। तीनों का जोड़ 14.59 है।
Positive का हिस्सा निकालिए: 2.72 ÷ 14.59 = 0.186।
इस हिस्से का −ln लीजिए: −ln 0.186 = 1.68। यही loss है। ln बताता है कि e को किस power तक उठाएँ, तो वो number मिले। जाँच: e−1.68 = 1 ÷ e1.68 = 1 ÷ 5.37 = 0.186।
Step 1 और 2 मिलकर हैं, और step 3 lesson 4 वाला है। Formula में यही तीन steps हैं:
𝓛 = − ln es+es+ + ∑ es−
ऊपर positive का escore है (2.72), और नीचे positive और सारे negatives के escore का जोड़ (14.59)।
पहले सोचिए
तीनों scores में 1 जोड़ दीजिए: 2.0, 3.0 और 2.5। Loss कितना होगा?
जवाब देखिए
1.68 ही। Score में 1 जोड़ने से escore 2.72 गुना हो जाता है, क्योंकि ea+1 = ea × e। जैसे e2.0 = e1.0 × 2.72 = 7.39। ऊपर और नीचे, दोनों 2.72 से गुणा होते हैं, और भाग में ये कट जाता है। इसलिए queue log का हिस्सा 0.186 ही रहता है।
नीचे की table में चार हालात हैं। आख़िरी दो rows training के दो stages हैं, और पड़ाव 3 बीच वाला stage इस्तेमाल करता है। scores मेरे बनाए हैं
Scores (queue log, forum post, Homework)
Queue log का हिस्सा
Loss
Training से पहले: 1.0, 2.0, 1.5
0.186
1.68
सवाल का vector दोगुना: 2.0, 4.0, 3.0
0.090
2.41
कुछ training के बाद: 3.0, 2.0, 0.5
0.690
0.372
Training के बाद: 5.0, 2.0, 0.5
0.943
0.059
सवाल का vector दोगुना करने पर loss 1.68 से बढ़कर 2.41 हो जाता है, क्योंकि forum post और आगे निकल गया। तो लंबे vector वाला आसान रास्ता यहाँ काम नहीं करता।
Training चलने पर queue log आगे निकलता है, और loss 1.68 से 0.372 और फिर 0.059 तक घटता है।
इसलिए encoders के पास loss घटाने का एक ही रास्ता है: queue log का score बाकी दोनों से ज़्यादा करना।
Contrastive loss खुद चलाइए
तीनों scores बदलिए। Loss तब छोटा होता है, जब queue log बाकी दोनों से काफ़ी ऊपर हो। तीनों को बराबर खिसकाइए, तो loss नहीं बदलता।
3Negatives: batch से और BM25 से
Contrastive loss को हर सवाल के लिए negatives चाहिए, और negatives जितने ज़्यादा, तुलना उतनी कड़ी। लेकिन हर negative को passage encoder से गुज़ारना पड़ता है, और ये महँगा है। DPR दो जगह से negatives लेता है, जिनमें ये खर्च कम है।
Batch के बाकी सवालों के positives
In-batch negatives का मतलब है: batch के बाकी सवालों के positives को इस सवाल के negatives मानना। Training सवालों को छोटे groups में चलाती है, जिन्हें batch कहते हैं। Batch के हर सवाल का positive उसी step में encode हो चुका होता है, इसलिए इन negatives पर कोई extra encoding नहीं लगती।
नीचे कुछ training के बाद का 3 सवालों वाला एक batch है। हर row में bold number उस सवाल का positive है, और उसी row के बाकी numbers उसके negatives। scores मेरे बनाए हैं
सवाल ↓ / passage →
Queue log
Syllabus
Office hours
Loss
Least crowded office hour?
3.0
1.0
0.5
0.197
When is the milestone due?
0.8
3.0
1.2
0.244
Where are office hours held?
0.3
2.5
2.0
?
तीसरी row आप निकालिए
Positive office hours page है, score 2.0। Negatives queue log (0.3) और syllabus (2.5) हैं। Loss कितना है, और ये row बाकी दो से अलग क्यों है?
जवाब देखिए
e0.3 = 1.35, e2.5 = 12.18 और e2.0 = 7.39, जिनका जोड़ 20.92 है। Office hours page का हिस्सा 7.39 ÷ 20.92 = 0.353 है, और loss = −ln 0.353 = 1.041। इस row में गलत syllabus (2.5) सही page (2.0) से ऊपर है, इसलिए इसका loss सबसे बड़ा है।
Paper में batch 128 सवालों का है, इसलिए हर सवाल को 127 in-batch negatives मिलते हैं। paper से
BM25 वाले hard negatives
Hard negative वो गलत passage है, जो सवाल से मिलता-जुलता दिखता है, लेकिन जिसमें जवाब नहीं होता। हमारे सवाल के लिए forum post ऐसा ही passage है। उसमें least और crowded, दोनों शब्द हैं, लेकिन भीड़ का कोई data नहीं है।
In-batch negatives ज़्यादातर आसान होते हैं, क्योंकि वो दूसरे सवालों के passages हैं। Hard negatives पर loss बड़ा आता है, और loss जितना बड़ा हो, training encoders को उतना ज़्यादा बदलती है। कुछ training के बाद queue log 3.0 पर है, और दोनों negatives की तुलना ऐसी दिखती है: scores मेरे बनाए हैं
Negative
Loss, सिर्फ़ इसी negative के साथ
Encoder क्या सीखता है
Homework की announcementआसान negative, score 0.5
0.079queue log का हिस्सा 0.924
लगभग कुछ नहीं, क्योंकि फ़र्क पहले से साफ़ है
Forum posthard negative, score 2.0
0.313, करीब 4 गुनाqueue log का हिस्सा 0.731
सवाल के शब्द काफ़ी नहीं, passage में भीड़ का data चाहिए
पहली row ऐसे निकली: e3.0 = 20.09 और e0.5 = 1.65, जिनका जोड़ 21.73 है। Queue log का हिस्सा 20.09 ÷ 21.73 = 0.924 है, और loss = −ln 0.924 = 0.079।
ऐसे passages ढूँढने के लिए DPR, BM25 का इस्तेमाल करता है। हर training सवाल के लिए वो BM25 के ऊपर वाले passages में से एक passage लेता है, जिसमें जवाब नहीं है। ये तरीका इसलिए काम करता है, क्योंकि BM25 वही गलती करता है जो encoders से छुड़वानी है। इस सवाल पर भी BM25 ने forum post को ही सबसे ऊपर रखा था।
ध्यान दीजिए: Hard negatives लेने से पहले labels check कीजिए। कभी BM25 के ऊपर वाले passage में सचमुच जवाब होता है, बस उसका label छूट गया होता है। तब encoder सही passage को नीचे धकेलना सीखता है।
4DPR, BM25 से कितना आगे है
DPR paper retriever को top-k retrieval accuracy से नापता है: कितने % सवालों में जवाब वाला passage top-k में आया। NQ dataset में Google पर लोगों के असली सवाल हैं। उस पर top-20 accuracy BM25 की 59.1% है, और DPR की 78.4%।
1,000 सवालों में ये 591 और 784 सवाल हैं। मतलब DPR के साथ 193 और सवालों में reader तक जवाब वाला passage पहुँचता है।
DPR 5 में से 4 datasets पर आगे है। SQuAD पर वो पीछे है, 63.2 बनाम 68.8, क्योंकि वहाँ लोगों ने passage पढ़कर सवाल लिखे थे। इसलिए उन सवालों में passage के ही शब्द हैं, और exact शब्द मिलाना BM25 का काम है। ये वजह paper में है
पाँचों datasets के numbers
Dataset
BM25
DPR
NQ
59.1
78.4
TriviaQA
66.9
79.4
WQ
55.0
73.2
TREC
70.9
79.8
SQuAD
68.8
63.2
Top-20 accuracy (%), test set पर। यहाँ DPR हर dataset पर अलग train हुआ है।
DPR को labeled जोड़े चाहिए, और paper ने ये भी नापा कि कितने। NQ पर सिर्फ़ 1,000 जोड़ों से train हुआ DPR भी BM25 से आगे है, और जोड़े बढ़ाने पर accuracy और बढ़ती है।
5DPR कहाँ कमज़ोर है
DPR पूरे corpus के पैमाने पर semantic match में जीतता है, लेकिन उसकी तीन कमज़ोरियाँ हैं:
Error 4012 जैसा code सिर्फ़ एक-दो passages में हो, तो BM25 उसे rare मानकर ऊपर रखता है। DPR का vector पूरे passage की बात समेटता है, और उसमें ऐसा एक code आसानी से दब जाता है। Lesson 15 इसी case से शुरू होता है।
Passage का vector सवाल देखे बिना बनता है, इसलिए सवाल और passage सिर्फ़ आख़िरी dot product पर मिलते हैं। Lesson 14 का reranker इसी कमी पर काम करता है।
Training के लिए labeled सवाल-passage जोड़े चाहिए, भले 1,000 ही हों।
BM25 की ताकत और कमज़ोरी इसकी उल्टी है। इसलिए lesson 14 BM25 और DPR, दोनों की lists मिलाता है।
यहाँ से Stanford वाला level
ऊपर के 5 पड़ाव आसान version जैसे ही हैं। आगे के 4 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। इनमें पहले slide के symbols और उनका गणित है, फिर पूरे batch का एक गुणा और paper के experiments। उसके बाद असली पैमाना है, और आख़िर में आप slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।
6Slide के symbols, और gradient का गणित
अब तक सब कुछ एक सवाल और उसके numbers पर था। Slide यही हिसाब symbols में लिखती है, ताकि वो batch के हर सवाल पर लागू हो। Slide का पूरा formula ये है:
नीचे की table हर symbol को हमारे example के number से जोड़ती है:
Symbol
मतलब
हमारे example में
qi
Batch का i-वाँ सवाल
least crowded वाला सवाल, i = 1
pi+
सवाल qi का positive
queue log
pi,j−
सवाल qi का j-वाँ negative। j, 1 से n तक चलता है।
j = 1 पर forum post, j = 2 पर Homework, और n = 2
EQ( · ; θQ)
Question encoder। “·” की जगह text आता है, और θQ उसके हैं, यानी वो numbers जिन्हें training बदलती है।
पड़ाव 1 का question encoder
EP( · ; θP)
Passage encoder, जिसके parameters θP हैं
पड़ाव 1 का passage encoder
hqi = EQ(qi) ∈ ℝd
सवाल का vector। का मतलब है d real numbers की list, और ∈ का मतलब “इसका हिस्सा है”।
[1.0, 0.5, 0.5, 1.0], यानी d = 4
s(qi, p) = EQ(qi)⊤EP(p)
Score, यानी दोनों vectors का dot product। Slide इसे inner-product similarity कहती है, और inner product dot product का ही दूसरा नाम है।
1.0, 2.0 और 1.5
exp(x)
ex, जहाँ e करीब 2.718 है
exp(1.0) = 2.72
∑j=1n
j = 1 से n तक सबका
7.39 + 4.48
log
Natural log, यानी ln
−ln 0.186
𝓛i
सवाल qi का loss
1.68
∇θQ𝓛i
θQ के हर parameter पर loss की दर, एक list में। ये नीचे step by step आता है।
–
Gradient: हर score पर loss की दर
Lesson 4 में का मतलब आया था: किस parameter को किस दिशा में बदलें, कि loss घटे। Parameters करोड़ों में हैं, इसलिए पहले यही बात तीन scores पर देखिए, जहाँ हिसाब छोटा है।
किसी चीज़ की दर निकालने का तरीका सीधा है। Input को बहुत थोड़ा बदलिए, और देखिए कि output कितना बदला। फिर उस बदलाव को input के बदलाव से भाग दीजिए। Training से पहले वाले scores 1.0, 2.0 और 1.5 पर loss 1.68 है। अब एक बार में एक score 0.01 बढ़ाइए:
किसका score 0.01 बढ़ा
Loss का बदलाव
बदलाव ÷ 0.01
Queue log (positive)
−0.0081
−0.81
Forum post
+0.0051
+0.51
Homework
+0.0031
+0.31
0.01 की जगह और छोटा बदलाव लीजिए, तो ये दरें −0.814, +0.506 और +0.307 पर टिक जाती हैं। जिस number पर दर टिकती है, वही gradient है। Minus का मतलब है कि queue log का score बढ़ने पर loss घटता है। Plus का मतलब है कि किसी negative का score बढ़ने पर loss बढ़ता है।
इस दर को ∂𝓛/∂s लिखते हैं: score s थोड़ा बदले, तो loss 𝓛 किस दर से बदलता है। ∂ का मतलब है कि सिर्फ़ यही एक score बदला, बाकी सब वैसे ही रहे। इसे partial derivative कहते हैं।
ये दरें softmax के हिस्सों जैसी क्यों हैं
ये दरें पड़ाव 2 के softmax वाले हिस्सों से मिलती हैं। −0.814 = 0.186 − 1 है, और 0.506 और 0.307 सीधे forum post और Homework के हिस्से हैं। ये संयोग नहीं है, और इसकी वजह पाँच छोटे steps में निकलती है:
Loss को दो हिस्सों में तोड़िए। Lesson 4 के दो नियम हैं: ln(a ÷ b) = ln a − ln b, और ln(ex) = x। इसलिए 𝓛 = −ln(es+ ÷ Z) = −s+ + ln Z, जहाँ Z सारे escore का जोड़ है, यानी 14.59। जाँच: −1.0 + ln 14.59 = −1.0 + 2.680 = 1.680।
es की दर खुद es है। जाँच: e1.01 − e1.00 = 2.7456 − 2.7183 = 0.0273, और 0.0273 ÷ 0.01 = 2.73, यानी करीब e1.0 = 2.72।
ln Z की दर 1 ÷ Z है। जाँच: ln 14.60 − ln 14.59 = 0.000685, और 0.000685 ÷ 0.01 = 0.0685, जो 1 ÷ 14.59 = 0.0685 के बराबर है।
दो जुड़ी हुई दरें गुणा होती हैं। Queue log का score बदले, तो Z में सिर्फ़ es+ बदलता है, 2.72 की दर से। Z बदले, तो ln Z उसके 1 ÷ 14.59 गुना बदलता है। इसलिए ln Z की दर 2.72 × (1 ÷ 14.59) = 0.186 है, जो queue log का हिस्सा है। जुड़ी हुई दरों को गुणा करने के इस नियम को chain rule कहते हैं। ये दरों वाला chain rule है, lesson 4 के probability वाले chain rule से अलग।
दोनों हिस्से जोड़िए। 𝓛 = −s+ + ln Z में queue log के लिए दर −1 + 0.186 = −0.814 है। Forum post के score पर −s+ वाला हिस्सा नहीं बदलता, इसलिए उसकी दर सिर्फ़ 7.39 ÷ 14.59 = 0.506 है।
मतलब हर negative की दर उसका अपना softmax वाला हिस्सा है। इसलिए training हर negative के score को उसके हिस्से जितने ज़ोर से नीचे धकेलती है। पड़ाव 3 में hard negative इसी वजह से ज़्यादा सिखाता था। कुछ training के बाद (3.0, 2.0, 0.5) forum post का हिस्सा 0.254 है, और Homework का सिर्फ़ 0.057।
एक कदम पीछे: सवाल के vector पर दर
Score से एक कदम पीछे सवाल का vector hq है, जिसमें 4 numbers हैं: q1 से q4। किसी passage का score q1p1 + q2p2 + q3p3 + q4p4 है। q1 को 0.01 बढ़ाइए, तो score p1 × 0.01 बढ़ता है। इसलिए score की q1 पर दर p1 है, यानी उस passage के vector का पहला number।
q1 बदलने से तीनों scores बदलते हैं, और हर score loss को अपनी दर से बदलता है। Chain rule से loss की q1 पर दर ऐसे निकलती है:
Queue log: score की दर −0.814, गुणा उसका पहला number 0.2, यानी −0.163।
Forum post: 0.506 × 0.8 = 0.405।
Homework: 0.307 × 0.5 = 0.154।
तीनों का जोड़: −0.163 + 0.405 + 0.154 = 0.396।
चारों numbers के लिए यही करने पर [0.396, 0.304, 0.061, 0.081] मिलता है हिसाब मेरा। इसे ∂𝓛/∂hq लिखते हैं, यानी hq के हर number के लिए एक दर। पहले दो numbers सबसे बड़े हैं, क्योंकि forum post के vector में यही दो numbers बड़े हैं, 0.8 और 1.0। Formula यही हिसाब ऐसे लिखता है:
∂𝓛 / ∂hq = (p+ − 1) hp+ + ∑j pj hpj
यहाँ p+ और pj softmax वाले हिस्से हैं, और hp+ और hpj passages के vectors। ऊपर के चार steps इसी formula का पहला number हैं।
अब सवाल के vector को इसकी उल्टी दिशा में थोड़ा खिसकाइए, यानी हर number में से उसकी दर का 0.5 गुना घटाइए। नया vector [0.802, 0.348, 0.469, 0.959] बनता है, और scores 0.871, 1.657 और 1.301 हो जाते हैं। Queue log का score भी थोड़ा गिरा, लेकिन forum post का उससे ज़्यादा गिरा। इसलिए दोनों का फ़र्क 1.0 से घटकर 0.786 रह गया, और loss 1.68 से 1.554 हो गया।
आख़िरी कदम: encoder के parameters तक
सवाल का vector खुद parameter नहीं है। उसे encoder बनाता है, और encoder के करोड़ों parameters हैं। Lesson 5 वाला यही chain rule पीछे की तरफ़ encoder की हर layer तक लगाता है। इससे हर parameter के लिए एक दर मिलती है। इन सारी दरों की list को ∇θQ𝓛i लिखते हैं, और को nabla पढ़ते हैं।
Training हर parameter को उसकी दर की उल्टी दिशा में थोड़ा खिसकाती है, ठीक वैसे जैसे ऊपर सवाल के vector को खिसकाया। ∇θQ𝓛i से question encoder बदलता है, और ∇θP𝓛i से passage encoder। पड़ाव 9 की slide पर यही दो लाल arrows हैं।
7पूरा batch एक गुणा में, और negatives पर paper के experiments
पड़ाव 3 की batch वाली table असल में एक matrix है। Matrix numbers की एक table है, जिसमें rows और columns होते हैं। Batch के सवालों के vectors को एक के नीचे एक रखिए, तो matrix Q बनती है: हर row एक सवाल का vector। उनके positives के vectors से इसी तरह matrix P बनती है।
P⊤ लिखने का मतलब है P की rows को columns बना देना, और इसे transpose कहते हैं। Q और P⊤ के गुणा का नियम ये है। नतीजे में row i और column j वाला number, Q की row i और P की row j का dot product है। 2 सवालों और 2 numbers वाले vectors पर देखिए: numbers मेरे बनाए
सवाल ↓ / positive →
p1 = [0, 2]
p2 = [1, 0]
q1 = [1, 2]
1×0 + 2×2 = 4
1×1 + 2×0 = 1
q2 = [2, 0]
2×0 + 0×2 = 0
2×1 + 0×0 = 2
ये 2 × 2 table ही S = QP⊤ है। Diagonal पर, यानी row 1 column 1 और row 2 column 2 पर, हर सवाल का अपना positive है: 4 और 2। बाकी cells उसके in-batch negatives हैं। Paper पूरे batch के scores इसी एक गुणा से निकालता है: paper से
S = Q P⊤
B सवालों के batch में S में B × B scores होते हैं। हर row पर अलग से contrastive loss लगता है, इसलिए एक step में B training examples बनते हैं। Paper में B = 128 है, यानी एक गुणा से 128 × 128 = 16,384 scores, और हर सवाल को 127 in-batch negatives।
Paper हर सवाल के साथ एक BM25 negative भी जोड़ता है। Batch के सारे 128 BM25 negatives, batch के हर सवाल के negatives बनते हैं। तो हर सवाल को 127 + 128 = 255 negatives मिलते हैं। Slide के formula का n DPR की असली training में यही 255 है। paper से
Paper के experiments: कौन से negatives कितने काम के
Paper ने NQ के dev set पर negatives के कई तरीके आज़माए। Dev set वो सवाल हैं, जिन पर researchers training के दौरान अपने फ़ैसले जाँचते हैं। 1-of-N में हर सवाल के अपने अलग negatives होते हैं, जो batch के बाकी सवालों के साथ share नहीं होते। In-batch में negatives batch के अंदर से आते हैं। paper से
तरीका
हर सवाल के negatives
Top-20 (%)
1-of-N, random passages
7
64.3
1-of-N, BM25 passages
7
63.3
1-of-N, दूसरे सवालों के positivesपूरे training data से
7
63.1
In-batch, batch 8
7
69.1
In-batch, batch 128
127
73.0
In-batch, batch 128, साथ में हर सवाल का 1 BM25 negative
127 + 128
78.0
1-of-N में negative की किस्म से top-20 पर लगभग फ़र्क नहीं पड़ता: तीनों 63 से 64 के बीच हैं।
वही 7 negatives batch के अंदर से आएँ, तो accuracy 63.1 से 69.1 हो जाती है। Paper की वजह ये है कि batch के अंदर एक ही गुणा से ज़्यादा जोड़े बनते हैं, यानी training examples बढ़ते हैं।
Batch 8 से 128 करने पर negatives 7 से 127 होते हैं, और accuracy 69.1 से 73.0।
हर सवाल का एक BM25 negative जोड़ने से accuracy 73.0 से 78.0 हो जाती है। दूसरा BM25 negative मदद नहीं करता: batch 32 पर एक के साथ 77.3, और दो के साथ 76.4।
ये dev set के numbers हैं। Test set पर final DPR का top-20 78.4 है, जो पड़ाव 4 में आया था।
8असली पैमाना और पूरे नतीजे
हमारे example में 3 passages और 4 numbers वाले vectors थे, ताकि हिसाब हाथ से हो सके। Paper में mechanism वही है, सिर्फ़ numbers बड़े हैं: paper से
चीज़
हमारा example
DPR paper में
Passages
3
21,015,324, Wikipedia के 100-100 शब्दों के टुकड़े
Vector की लंबाई d
4
768, BERT-base का output vector
Encoders
पड़ाव 1 वाले
दो अलग BERT-base
Batch
3 सवाल
128 सवाल
हर सवाल के negatives, यानी n
2
127 in-batch + 128 BM25 = 255
सारे passage vectors बनाना
हाथ से
8 GPUs पर करीब 8.8 घंटे
Index बनाना
–
FAISS में HNSW index, करीब 8.5 घंटे
Search की speed
–
995 सवाल per second, हर सवाल पर top 100BM25: 23.7 सवाल per second, एक CPU thread पर
vectors में तेज़ search की एक open-source library है। DPR ने उसमें lesson 10 वाला index लिया। Search तेज़ है, लेकिन index बनाना महँगा है। BM25 का inverted index करीब 30 minute में बनता है, जबकि DPR के vectors और index में मिलाकर 8.8 + 8.5 = 17.3 घंटे लगते हैं। Encoder बदले, तो ये सब दोबारा करना पड़ता है।
पूरे नतीजे
पड़ाव 4 में NQ पर top-20 accuracy आई थी: BM25 59.1% और DPR 78.4%। Top-5 पर फ़र्क और बड़ा है: BM25 42.9%, और DPR 65.2%। paper से नीचे पाँचों datasets हैं, साथ में BM25 और DPR दोनों के scores मिलाकर बना retriever भी:
Dataset
BM25
DPR
BM25 + DPR
NQ
59.1
78.4
76.6
TriviaQA
66.9
79.4
79.8
WQ
55.0
73.2
71.0
TREC
70.9
79.8
85.2
SQuAD
68.8
63.2
71.5
Top-20 accuracy (%), test set पर। यहाँ DPR हर dataset पर अलग train हुआ है।
Paper ने score के लिए dot product की जगह cosine और (L2) भी आज़माई। L2 के नतीजे dot product जितने ही रहे, और दोनों cosine से बेहतर थे। इसलिए DPR ने सबसे सीधा dot product रखा। paper से
DPR से पहले (2019) नाम का dense retriever भी BM25 से आगे निकला था। लेकिन ORQA ने retriever को पहले एक बनावटी काम पर अलग से pretrain किया था। उसमें model को एक sentence मिलता है, और उसे बताना होता है कि वो किस passage से निकला। DPR ने ऐसी extra pretraining नहीं की, उसने सिर्फ़ BERT और सवाल-passage जोड़े लिए।
फिर भी पूरे system में DPR आगे है। NQ पर DPR के साथ 41.5 है, ORQA के साथ 33.3, और BM25 के साथ 32.6। REALM भी extra pretraining करता है, और उसका Exact Match 39.2 और 40.4 है।
9अब Stanford की slides खुद पढ़िए
नीचे Stanford की DPR वाली चार slides हैं, बिना किसी बदलाव के। हर slide के नीचे कुछ सवाल हैं। पहले खुद जवाब सोचिए, फिर खोलिए। कोई symbol अटके, तो जवाब में लिखे पड़ाव पर लौट जाइए। Phone पर slide छोटी दिखे, तो image पर click कीजिए, वो पूरे size में खुलेगी।
Stanford की training वाली slide, और नीचे उसी का loss वाला हिस्सा, बड़ा करके।
Training वाली slide पढ़िए
hqi ∈ ℝd में d कितना है? हमारे example में कितना था, और DPR में कितना है?
जवाब देखिए
हमारे example में 4, और DPR में 768। d vector में numbers की गिनती है। (पड़ाव 6 और 8)
Loss के नीचे ∑ में n क्या है? हमारे example में n कितना था, और DPR की training में कितना?
जवाब देखिए
n एक सवाल के negatives की गिनती है। हमारे example में 2 थे, forum post और Homework। DPR में 127 + 128 = 255 हैं। (पड़ाव 6 और 7)
दोनों तरफ़ के लाल dashed arrows क्या कहते हैं? Lesson 5 के RAG से इसमें क्या फ़र्क है?
जवाब देखिए
Arrows पर ∇θQ𝓛i और ∇θP𝓛i लिखे हैं, यानी training दोनों encoders के parameters बदलती है। Lesson 5 के RAG में passage encoder नहीं बदलता था, क्योंकि तब 2.1 करोड़ passages के vectors दोबारा बनाने पड़ते।
DPR की training के दौरान कोई index नहीं होता। हर step में सिर्फ़ batch के passages encode होते हैं, इसलिए passage encoder भी बदल सकता है। Index training ख़त्म होने के बाद एक बार बनता है। (पड़ाव 1 और 6)
Stanford की results वाली slide, और नीचे उसकी table, बड़ी करके।
Results वाली slide पढ़िए
Top-20 में DPR किस dataset पर BM25 से पीछे है, और क्यों?
जवाब देखिए
SQuAD पर, 63.2 बनाम 68.8। वहाँ लोगों ने passage पढ़कर सवाल लिखे थे, इसलिए सवालों में passage के ही शब्द हैं, और ये BM25 के पक्ष में जाता है। (पड़ाव 4)
NQ पर BM25 और DPR का फ़र्क top-20 में कितना है, और top-100 में कितना?
जवाब देखिए
Top-20 में 78.4 − 59.1 = 19.3, और top-100 में 85.4 − 73.7 = 11.7। k बढ़ने पर फ़र्क घटता है, क्योंकि 100 passages में BM25 को भी अक्सर सही passage मिल जाता है। (पड़ाव 4 और 8)
Single और Multi का क्या मतलब है? Multi वाले DPR का SQuAD पर score 51.6 क्यों गिरा?
जवाब देखिए
Single में DPR हर dataset पर अलग train हुआ। Multi में एक ही DPR सारे datasets को मिलाकर train हुआ, लेकिन paper ने उसमें SQuAD नहीं डाला। इसलिए Multi वाला DPR SQuAD के सवालों पर train ही नहीं हुआ। paper से
Stanford की training data वाली slide, और नीचे उसका graph और table, बड़े करके।
Training data वाली slide पढ़िए
Graph में नीली line BM25 है, और नारंगी line सिर्फ़ 1,000 जोड़ों वाला DPR। नारंगी line कहाँ नीली से ऊपर है, और k = 100 पर क्या होता है?
जवाब देखिए
छोटे k पर नारंगी line साफ़ ऊपर है। k बढ़ने पर फ़र्क घटता है, और k = 100 पर दोनों लगभग बराबर हैं। ज़्यादा जोड़ों वाली lines हर k पर और ऊपर हैं। (पड़ाव 4)
Table में DPR के आगे 41.5 किस चीज़ का number है? और ORQA और REALM से ये तुलना ख़ास क्यों है?
जवाब देखिए
41.5, NQ पर पूरे system का Exact Match है, यानी कितने % जवाब हूबहू सही निकले। ORQA और REALM ने retriever के लिए extra pretraining की थी, और DPR ने नहीं की। फिर भी DPR उनसे आगे है। Slide की line No extra pretraining यही कहती है। (पड़ाव 8)
Slide कहती है कि DPR, REALM से आगे है। क्या ये table के हर column में सच है?
जवाब देखिए
नहीं। TREC पर Single वाला DPR 25.9 पर है, जबकि REALMWiki 46.8 पर। TREC सबसे छोटा dataset है, इसलिए उस पर अकेले train हुए DPR के पास कम जोड़े थे। Multi वाला DPR, जो सारे datasets मिलाकर train हुआ, TREC पर 49.4 तक पहुँचता है। Slide की heading NQ के numbers पर टिकी है। paper से
Table की बाकी rows, जैसे HardEM और GraphRetriever, दूसरे systems हैं। इस lesson के लिए उनके नाम ज़रूरी नहीं हैं।
Stanford की तुलना वाली slide: चार retrievers, और नीचे उसकी table, बड़ी करके। ColBERT और cross-encoder वाली rows lesson 14 और 15 में आती हैं।
तुलना वाली slide पढ़िए
DPR की row में “Precomputed offline: One vector per passage” का क्या मतलब है?
जवाब देखिए
Passage encoder सवाल आने से पहले हर passage का एक vector बनाकर index में रख देता है। सवाल आने पर सिर्फ़ question encoder चलता है। (पड़ाव 1)
Cross-encoder हर 1,000 passages पर 10,700 ms लेता है, और DPR दसियों ms। इतना फ़र्क क्यों है?
जवाब देखिए
Cross-encoder सवाल और passage को साथ पढ़ता है, इसलिए उसे हर passage के साथ model चलाना पड़ता है, और पहले से कुछ नहीं बनता। DPR में model हर सवाल पर एक बार चलता है, और बाकी काम dot products का है। Slide के नीचे लिखा है कि ये numbers अलग-अलग hardware पर नापे गए, इसलिए सिर्फ़ मोटा फ़र्क देखिए। (पड़ाव 1)
DPR की row में “Breaks on: Rare literals; needs labeled pairs” लिखा है। ये दोनों बातें किस पड़ाव में आईं?
जवाब देखिए
पड़ाव 5 में। Error 4012 जैसा rare code DPR के vector में दब जाता है, और training के लिए labeled सवाल-passage जोड़े चाहिए, भले 1,000 ही।
इस lesson की 3 बातें
DPR एक bi-encoder है: दो BERT encoders, और score उनके vectors का dot product। Passages के vectors offline index में बनते हैं, इसलिए हर सवाल पर question encoder सिर्फ़ एक बार चलता है।
Contrastive loss positive के score की तुलना negatives से करता है: softmax, फिर −ln। हर negative पर loss की दर उसका softmax वाला हिस्सा है, इसलिए hard negatives सबसे ज़्यादा सिखाते हैं।
पूरे batch के scores एक matrix गुणा S = QP⊤ से आते हैं, और एक BM25 negative top-20 को 73.0 से 78.0 करता है। बिना extra pretraining के DPR 5 में से 4 datasets पर BM25 से आगे है। लेकिन exact शब्दों वाले सवालों पर BM25 अब भी जीत सकता है।
इस lesson के नए शब्द
DPR
Dense Passage Retrieval: दो BERT encoders वाला bi-encoder retriever, जो सवाल-passage जोड़ों पर contrastive loss से train होता है। 2020 में Karpukhin और साथियों ने बनाया, और lesson 5 के RAG का retriever यही था।
Bi-encoder
सवाल और passage के लिए दो अलग encoders, और score उनका dot product। Passages पहले से encode होते हैं। जैसे 2.1 करोड़ passages हों, तब भी हर सवाल पर model 1 बार चलता है।
Pretraining
बहुत सारे आम text पर model की पहली, बड़ी training। जैसे BERT पहले आम text पर train होता है।
Fine-tuning
पहले से trained model को अपने काम के data पर और train करना। जैसे DPR, BERT को सवाल-passage जोड़ों पर train करता है।
Positive और negative passage
सवाल का सही passage (pi+), और गलत passages (pi,j−)। जैसे least crowded सवाल का positive queue log है, और negatives forum post और Homework।
Contrastive loss
Positive और negatives के scores पर softmax, फिर positive का −ln। ये सिर्फ़ scores के फ़र्क देखता है। जैसे scores 1.0, 2.0, 1.5 पर loss 1.68, और 5.0, 2.0, 0.5 पर 0.059।
Batch
Training में एक साथ चलने वाले सवालों का group। जैसे DPR में 128 सवालों का batch।
In-batch negatives
Batch के बाकी सवालों के positives को negatives की तरह इस्तेमाल करना। जैसे 128 के batch में हर सवाल को 127 negatives मिलते हैं।
Hard negative
सवाल से मिलता-जुलता, लेकिन गलत passage। DPR इन्हें BM25 के ऊपर वाले passages से लेता है। जैसे इस सवाल पर forum post।
∂ (partial derivative)
बाकी सब वैसा रखकर एक input थोड़ा बदलें, तो output किस दर से बदलता है। जैसे ∂𝓛/∂s+ = −0.814, यानी queue log का score 0.01 बढ़े, तो loss करीब 0.008 घटता है।
Chain rule (दरों वाला)
एक के बाद एक जुड़ी दरें गुणा होती हैं। जैसे queue log के score पर ln Z की दर 2.72 × (1 ÷ 14.59) = 0.186 है। Lesson 4 का probability वाला chain rule इससे अलग है।
ℝd
d real numbers की list, यानी d dimension वाला vector। जैसे [1.0, 0.5, 0.5, 1.0] ∈ ℝ4, और DPR के vectors ℝ768 में हैं।
∇ (nabla)
∇θ𝓛: θ के हर parameter पर loss की दर, एक list में। Training हर parameter को उसकी दर की उल्टी दिशा में थोड़ा खिसकाती है। जैसे तीन scores पर ये दरें −0.814, +0.506 और +0.307 थीं।
FAISS
Vectors में तेज़ search की open-source library। जैसे DPR ने इसमें 2.1 करोड़ vectors का HNSW index बनाया, जिसमें करीब 8.5 घंटे लगे।
ORQA
2019 का dense retriever, जिसने retriever को extra pretraining से सिखाया। जैसे NQ पर पूरे system का Exact Match ORQA के साथ 33.3, और DPR के साथ 41.5।
Top-k retrieval accuracy
कितने % सवालों में top-k में जवाब वाला passage है। जैसे NQ पर top-20 में DPR की 78.4%।