Retriever को नापने का मतलब है: कुछ queries पर उसकी lists देखना, और गिनना कि सही passages कितने आए और कितने ऊपर आए। इसके लिए पहले हर query के सही passages लिखने पड़ते हैं, और फिर हर metric इन lists से एक number बनाता है।
Lesson 2 में recall मोटे तौर पर गिना था। अब एक retriever को उन्हीं 3 queries पर चलाइए। पहली query पर सही passage पहले rank पर आता है, दूसरी पर दूसरे rank पर, और तीसरी पर कहीं नहीं। Top-3 में 3 में से 2 queries पर सही passage पहुँचा, यानी 0.667।
फिर आप retriever सुधारते हैं, और दूसरी query का सही passage पहले rank पर आ जाता है। Prompt में एक ही passage जाए, तो अब उस query का जवाब भी बनेगा। फिर भी top-3 वाली गिनती 0.667 पर अटकी रहती है। ये lesson ऐसे numbers बनाता है, जो ये बदलाव देख सकें।
इस lesson की सीढ़ी
सीढ़ी में 10 पड़ाव हैं। पहले 5 आसान version जैसे ही हैं, और 6 से 10 आपको Stanford की slides के level तक ले जाते हैं। हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे।
पहले से क्या चाहिए: Lesson 2 (corpus के 6 passages, top-K, recall, recall ceiling), Lesson 3 (∑ का निशान) और Lesson 4 (ln)। पड़ाव 6 से आगे Lesson 8 (late chunking), Lesson 10 (ANN) और Lesson 12 (DPR, top-k accuracy) भी काम आते हैं। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।
1Relevance labels और sets: पहले सही passages लिखिए
Relevance labels वो list है, जिसमें कोई इंसान हर query के आगे उसके सही passages लिखता है। Retriever खुद नहीं बता सकता कि उसकी list सही है, इसलिए नापने से पहले किसी को passages पढ़कर ये list बनानी पड़ती है। हर passage को एक grade भी मिल सकता है। 3 यानी बहुत काम का, 1 यानी थोड़ा काम का, और 0 यानी काम का नहीं।
पूरे lesson में lesson 2 के corpus वाली यही 3 चलेंगी। मान लीजिए एक हर query पर 5 passages लौटाता है, और bracket में हर passage का grade है। ये retriever और grades मेरे बनाए हैं
Query
Retriever का क्रम (grade)
सही passages
q1: Least crowded office hour?
queue log (3), पुराना forum post (0), office hours page (1), syllabus (0), project page (0)
syllabus (0), Homework 1 announcement (0), project page (0), पुराना forum post (0), queue log (0)
office hours page, grade 2
q1 के दो सही passages हैं। Queue log में भीड़ का data है, और office hours page बताता है कि Thursday 9am वाला office hour Zoom पर है। असली जवाब queue log में है, इसलिए उसे grade 3 मिला, और office hours page को 1। q3 का सही passage retriever की list में कहीं नहीं है।
Sets: सही passages को छोटे नाम देना
Metrics के formulas इन lists को छोटे नाम देते हैं, और इसके लिए sets चाहिए। Set चीज़ों का एक group है, जिसे { } के अंदर लिखते हैं, और उसमें क्रम मायने नहीं रखता।
Query q के सही passages का set Rq लिखते हैं, जैसे Rq1 = {queue log, office hours page}। Retriever के ऊपर के k passages का set Topk(q) है। ये k lesson 2 वाला ही है, बस formulas में इसे छोटा लिखते हैं। तो Top3(q1) = {queue log, पुराना forum post, office hours page}। Sets के साथ तीन निशान और आते हैं:
∩ दो sets की वो चीज़ें देता है, जो दोनों में हैं। Rq1 ∩ Top3(q1) = {queue log, office hours page}, यानी q1 के दोनों सही passages top-3 में हैं।
∅ खाली set है, जिसमें कुछ नहीं। q3 पर {office hours page} ∩ {syllabus, Homework 1 announcement, project page} में कुछ भी common नहीं, इसलिए वो ∅ है।
|A| बताता है कि set A में कितनी चीज़ें हैं। |Rq1| = 2, और सारी queries के set Q के लिए |Q| = 3।
Labels की एक कीमत भी है। हर query के सही passages किसी इंसान को पढ़कर तय करने पड़ते हैं, और ये महँगा है। अगर वो कोई सही passage छोड़ दे, तो retriever उसे लाकर भी हर metric में हारता है।
2Hit@k और Failed@k: सही passage पहुँचा या नहीं
Hit@k हर query पर देखता है कि top-k में कोई सही passage है या नहीं, और फिर queries का औसत लेता है। अगर है, तो उस query को 1 मिलता है, नहीं तो 0। k = 3 पर q1 के top-3 में queue log और office hours page हैं, इसलिए 1। q2 के top-3 में syllabus है, इसलिए 1। q3 के top-3 में कोई सही passage नहीं, इसलिए 0।
तीनों queries के numbers जोड़िए: 1 + 1 + 0 = 2।
जोड़ को queries की गिनती से भाग दीजिए, यानी औसत लीजिए: 2 ÷ 3 = 0.667।
Hit@3 = 0.667, और ये शुरू वाला number है।
“सच हो तो 1, झूठ हो तो 0” वाले इस नियम का एक निशान है: । जैसे 𝟙[2 > 1] = 1, और 𝟙[2 > 3] = 0। Hit@k में शर्त ये है कि Rq ∩ Topk(q) खाली न हो, और इसे ≠ ∅ लिखते हैं, जहाँ ≠ का मतलब है “बराबर नहीं”। q3 पर ∩ खाली है, इसलिए 𝟙[Rq3 ∩ Top3(q3) ≠ ∅] = 0। Formula में ऊपर के दोनों steps यही हैं:
Hit@k = 1|Q|∑q ∈ Q 𝟙[Rq ∩ Topk(q) ≠ ∅]
q ∈ Q
Q की हर query q पर जोड़िए। ∈ का मतलब है “इस set में से एक”। यहाँ 1 + 1 + 0 = 2।
1 ÷ |Q|
Queries की गिनती से भाग, यानी औसत। यहाँ 2 ÷ 3 = 0.667।
Failed@k इसका उल्टा है: कितनी queries पर top-k में एक भी सही passage नहीं पहुँचा। हर query पर Hit का 1 या Failed का 1 लगता है, कभी दोनों नहीं, इसलिए Failed@k = 1 − Hit@k। यहाँ Failed@3 = 1 − 0.667 = 0.333, क्योंकि 3 में से 1 query, q3, fail हुई।
Hit@3 = 0.667 ही यहाँ lesson 2 की है, क्योंकि 3 में से 2 से ज़्यादा जवाब passages से नहीं बन सकते। यही numbers आगे दूसरे नामों से आते हैं। Lesson 8 का Failed@20 ही है, क्योंकि वहाँ हर query का एक सही chunk था। Lesson 12 की Hit@20 है।
अब शुरू वाला सुधार देखिए। q2 का syllabus rank 2 से rank 1 पर आया, लेकिन दोनों बार वो top-3 के अंदर है, इसलिए q2 को दोनों बार 1 मिला। Hit@k ये नहीं देखता कि top-k के अंदर सही passage कहाँ है। Stanford की slide भी Hit@k के नीचे यही लिखती है: Position in the top k does not matter।
k = 1 लें, तो ये सुधार दिखता है: Hit@1 पहले 1 ÷ 3 = 0.333 था, और सुधार के बाद 2 ÷ 3 = 0.667 है। लेकिन तब Hit@1 rank 2 और rank 5 में फ़र्क नहीं करता, क्योंकि दोनों पर 0 मिलता है। मतलब हर k पर Hit@k क्रम का बस एक टुकड़ा देखता है।
3MRR@k: पहला सही passage कितना ऊपर है
Reciprocal rank पहले सही passage के rank का उल्टा है, यानी 1 ÷ rank, और MRR इसी का queries पर औसत है। किसी number का उल्टा, यानी 1 को उस number से भाग। पहला सही passage rank 1 पर हो, तो 1 ÷ 1 = 1। Rank 2 पर हो, तो 1 ÷ 2 = 0.5, और rank 3 पर 1 ÷ 3 = 0.333। Top-k में कोई सही passage न हो, तो 0।
अब k = 3 पर तीनों queries देखिए। q1 का पहला सही passage queue log rank 1 पर है, तो 1। q2 का syllabus rank 2 पर है, तो 0.5। q3 के top-3 में कोई सही passage नहीं, तो 0।
तीनों reciprocal ranks जोड़िए: 1 + 0.5 + 0 = 1.5।
3 queries से भाग दीजिए: 1.5 ÷ 3 = 0.5।
इस औसत को MRR कहते हैं, यानी mean reciprocal rank, और यहाँ MRR@3 = 0.5। Formula में यही दो steps हैं:
MRR@k = 1|Q|∑q ∈ Q1rankq
rankq
Query q का पहला सही passage किस rank पर है: q1 पर 1, और q2 पर 2। q3 पर top-3 में कोई नहीं, इसलिए 0।
अब शुरू वाला सुधार देखिए। q2 का syllabus rank 1 पर आया, तो q2 का reciprocal rank 0.5 से 1 हो गया, और MRR@3 = (1 + 1 + 0) ÷ 3 = 0.667। Hit@3 नहीं हिला था, लेकिन MRR@3 0.5 से 0.667 पर गया।ये सुधार मेरा बनाया example है
MRR तब सबसे काम का है, जब एक सही passage काफ़ी हो, जैसे q2 पर, जिसकी पूरी तारीख syllabus में है। Lesson 14 और 15 के retrievers की तुलना भी MRR@10 से होती है।
लेकिन MRR सिर्फ़ पहला सही passage देखता है। q1 में office hours page rank 3 पर हो या top-3 से बाहर, q1 का reciprocal rank 1 ही रहता है। जबकि q1 के पूरे जवाब को दोनों passages चाहिए: queue log से समय, और office hours page से ये कि वो Zoom पर है।
4Recall@k: सारे सही passages में से कितने पहुँचे
Recall@k हर query पर गिनता है कि उसके सारे सही passages में से कितना हिस्सा top-k में आया, और फिर queries का औसत लेता है। q1 जैसी query पर एक सही passage काफ़ी नहीं है, क्योंकि reader को queue log से समय मिलता है और office hours page से जगह।
k = 3 पर q1 के 2 में से 2 सही passages मिले, q2 का 1 में से 1, और q3 का 1 में से 0।
हर query का हिस्सा: q1 पर 2 ÷ 2 = 1, q2 पर 1 ÷ 1 = 1, और q3 पर 0 ÷ 1 = 0।
औसत: (1 + 1 + 0) ÷ 3 = 0.667।
इस number को Recall@k कहते हैं। Lesson 2 में मोटे तौर पर आया था, जैसे 100 में से 60 सवालों पर सही passage मिला, तो 0.6। ये उसका पक्का रूप है।
k = 1 पर Recall और Hit का फ़र्क दिखता है। q1 के top-1 में सिर्फ़ queue log है, यानी 2 में से 1, तो 0.5। q2 और q3 पर 0। Recall@1 = (0.5 + 0 + 0) ÷ 3 = 0.167, जबकि Hit@1 = 0.333। Hit@1 ने q1 को पूरा 1 दिया, और Recall@1 ने सिर्फ़ आधा, क्योंकि office hours page छूट गया।
Recall@k = 1|Q|∑q ∈ Q|Rq ∩ Topk(q)||Rq|
|Rq ∩ Topk(q)|
Top-k में मिले सही passages की गिनती। k = 1 पर q1 के लिए |{queue log}| = 1।
|Rq|
उस query के कुल सही passages। q1 के लिए 2, तो q1 का हिस्सा 1 ÷ 2 = 0.5।
Recall@k की एक कमज़ोरी है: k बढ़ाने पर वो कभी नहीं घटता, क्योंकि top-k में passages सिर्फ़ जुड़ते हैं, निकलते नहीं। k = 1,000 पर recall बहुत ऊँचा दिखेगा, लेकिन lesson 2 के हिसाब से में करीब 14 passages ही समाते हैं। इसलिए Recall@k उसी k पर देखिए, जितने passages आप सच में prompt में डालते हैं। Recall@k भी top-k के अंदर का क्रम नहीं देखता: q1 पर queue log rank 1 पर हो या rank 3 पर, Recall@3 वही रहता है।
Lesson 10 में का recall exact search की list से तुलना करता है: exact top-10 में से 9 मिले, तो 0.9। Recall@k की तुलना इंसान के लिखे relevance labels से होती है।
Stanford की slide: MRR@k और Recall@k के formulas। अब आप इसकी हर line पढ़ सकते हैं। Image पर click करने से वो पूरे size में खुलती है।
5nDCG@k: ज़्यादा काम का passage ऊपर है या नहीं
nDCG@k हर grade को उसके rank के हिसाब से घटाकर जोड़ता है, फिर उस जोड़ को सबसे अच्छे क्रम वाले जोड़ से भाग देता है। इसलिए वो दो चीज़ें साथ देखता है: passage कितना काम का है, और कितना ऊपर है। अब तक के तीनों metrics में passage या तो सही था या गलत।
पहले सोचिए
q1 का क्रम उलट दीजिए: office hours page (1), पुराना forum post (0), queue log (3)। Hit@3, reciprocal rank और Recall@3 में से q1 पर कौन सा number बदलेगा?
जवाब देखिए
एक भी नहीं। Hit 1 है, reciprocal rank भी 1 है, क्योंकि office hours page भी सही है, और Recall 2 में से 2 है। लेकिन reader के लिए ये list बदतर है, क्योंकि भीड़ का data अब तीसरे rank पर है।
पहली कोशिश ये हो सकती है कि top-k के grades जोड़ दें। लेकिन पुराने क्रम में 3 + 0 + 1 = 4 है, और उलटे क्रम में 1 + 0 + 3 = 4, यानी जोड़ grade देखता है, क्रम नहीं। इसलिए हर grade को उसके rank के हिसाब से घटाते हैं, ताकि नीचे वाला passage कम गिने।
log2(rank + 1) से भाग
घटाने के लिए grade को (rank + 1) से भाग देते हैं। log2 x का मतलब है: 2 को किस power तक उठाएँ, कि x मिले। 21 = 2, 22 = 4 और 23 = 8, इसलिए log2 2 = 1, log2 4 = 2 और log2 8 = 3। 3 का log2 1 और 2 के बीच है, क्योंकि 3 भी 2 और 4 के बीच है: log2 3 = 1.585। जाँच: 21.585 = 3.000।
ये lesson 4 वाले जैसा ही है। वहाँ base e था, जो करीब 2.718 है, और यहाँ base 2 है। Rank में 1 इसलिए जोड़ते हैं, ताकि rank 1 पर भाजक log2 2 = 1 हो, और सबसे ऊपर वाला passage अपना पूरा grade रखे:
Rank
log2(rank + 1)
Grade का कितना हिस्सा गिनता है
1
log2 2 = 1
1 ÷ 1 = 1
2
log2 3 = 1.585
1 ÷ 1.585 = 0.631
3
log2 4 = 2
1 ÷ 2 = 0.5
अब q1 के पुराने क्रम का जोड़ निकालिए:
Rank 1, queue log: 3 ÷ 1 = 3।
Rank 2, पुराना forum post: 0 ÷ 1.585 = 0।
Rank 3, office hours page: 1 ÷ 2 = 0.5।
जोड़: 3 + 0 + 0.5 = 3.5।
उलटे क्रम में office hours page rank 1 पर है और queue log rank 3 पर: 1 ÷ 1 + 0 + 3 ÷ 2 = 1 + 1.5 = 2.5। अब क्रम दिखता है, क्योंकि 3.5 और 2.5 अलग हैं। इस जोड़ को कहते हैं, यानी discounted cumulative gain। Gain यानी grade, cumulative यानी जोड़, और discounted यानी rank के हिसाब से घटाया हुआ।
IDCG से भाग: हर query को 0 से 1 के बीच लाना
एक दिक्कत बाकी है: DCG कितना बड़ा हो सकता है, ये query पर टिका है। q1 के दो सही passages हैं, grade 3 और 1, इसलिए उसका DCG 3.631 तक जा सकता है। q3 का एक ही सही passage है, grade 2, इसलिए उसका DCG 2 से ऊपर नहीं जा सकता। सीधा औसत लें, तो ज़्यादा सही passages वाली queries का वज़न ज़्यादा रहेगा।
इसलिए हर query का DCG उसी query के सबसे अच्छे possible क्रम के DCG से भाग देते हैं, जिसे IDCG, यानी ideal DCG कहते हैं। q1 का सबसे अच्छा क्रम queue log (3), office hours page (1) है, इसलिए IDCG = 3 ÷ 1 + 1 ÷ 1.585 = 3.631। ये क्रम सारे labels से बनता है, retriever की list से नहीं, इसलिए q3 का IDCG 2 है।
अब पुराने क्रम का 3.5 ÷ 3.631 = 0.964 है, और उलटे क्रम का 2.5 ÷ 3.631 = 0.689। इस भाग को nDCG कहते हैं, जहाँ n का मतलब normalized है। ये 0 से 1 के बीच रहता है, और 1 का मतलब है कि इससे अच्छा क्रम हो ही नहीं सकता।
Hit, reciprocal rank और Recall ने उलटा क्रम नहीं पकड़ा, लेकिन nDCG 0.964 से 0.689 पर गिरा। Formula में यही हिसाब है, और फिर हर query के nDCG का औसत:
यहाँ relq,i rank i वाले passage का grade है, जो q1 के पुराने क्रम में 3, 0 और 1 है। बाकी दो queries पर भी यही हिसाब चलता है। q3 का सही passage top-3 में नहीं है, इसलिए उसका DCG 0 है, और nDCG भी 0।
Query, k = 3
DCG
IDCG
nDCG
q1queue log (3), forum post (0), office hours page (1)
3.5
3.631
0.964
q2project page (0), syllabus (3), Homework 1 (0)
?
3
?
q3syllabus (0), Homework 1 (0), project page (0)
0
2
0
दूसरी row आप निकालिए
q2 का सही passage syllabus (grade 3) rank 2 पर है। उसका DCG और nDCG कितना है? फिर तीनों queries का nDCG@3 निकालिए।
जवाब देखिए
DCG = 3 ÷ log2 3 = 3 ÷ 1.585 = 1.893। IDCG = 3 ÷ 1 = 3, क्योंकि सबसे अच्छे क्रम में syllabus rank 1 पर होता। nDCG = 1.893 ÷ 3 = 0.631।
nDCG@3 = (0.964 + 0.631 + 0) ÷ 3 = 0.532।
q1 का क्रम बदलिए
“ऊपर” दबाकर passage को एक rank ऊपर कीजिए, और k बदलिए। सही passages पर रंगीन border है। उलटा क्रम बनाइए, और nDCG 0.689 देखिए।
Metric (सिर्फ़ q1)
Value
Stanford की slide: Hit@k, Failed@k और nDCG@k के formulas। अब आप इसकी हर line पढ़ सकते हैं।
एक retriever, चार numbers
अब शुरू वाले retriever के चारों numbers एक साथ रखिए। List वही है और k = 3 है, फिर भी चार अलग numbers आते हैं:
Query
Hit@3
Reciprocal rank
Recall@3
nDCG@3
q1
1
1
1
0.964
q2
1
0.5
1
0.631
q3
0
0
0
0
औसत
0.667
0.5MRR@3
0.667
0.532
शुरू वाला सुधार अब फिर देखिए। q2 का syllabus rank 1 पर आए, तो उसका nDCG 3 ÷ 3 = 1 हो जाता है, और nDCG@3 = (0.964 + 1 + 0) ÷ 3 = 0.655। MRR@3 भी 0.667 होता है, जबकि Hit@3 और Recall@3 0.667 पर ही रहते हैं।
nDCG की कीमत ये है कि उसे grades चाहिए, जो सही-गलत वाले labels से भी महँगे हैं। Lesson 8 के late chunking वाले scores यही nDCG@10 थे, % में। हर metric अलग सवाल का जवाब देता है:
Metric
किस सवाल का जवाब देता है
कब लें
Hit@k, Failed@k
Reader को कम से कम एक सही passage मिला?
Recall ceiling नापने के लिए
MRR@k
पहला सही passage कितना ऊपर है?
जब एक सही passage काफ़ी हो
Recall@k
सारे सही passages में से कितने मिले?
जब जवाब कई passages में बँटा हो
nDCG@k
ज़्यादा काम के passages ऊपर हैं?
जब grades हों, और क्रम मायने रखता हो
पहले सोचिए
एक support bot के prompt में top-5 passages जाते हैं, और ज़्यादातर जवाब एक passage में हैं। Retriever A का पहला सही passage हर query पर rank 2 पर है। Retriever B का आधी queries पर rank 1 पर है, और आधी पर top-5 में नहीं। दोनों का MRR@5 और Hit@5 निकालिए। आप कौन सा लेंगे?
जवाब देखिए
MRR@5: A = 0.5, और B = (1 + 0) ÷ 2 = 0.5, यानी बराबर। Hit@5: A = 1.0, और B = 0.5।
A लीजिए। A हर query पर reader तक सही passage पहुँचाता है, और B आधी queries पर कुछ नहीं देता। सिर्फ़ MRR देखते, तो ये फ़र्क दिखता ही नहीं।
यहाँ से Stanford वाला level
ऊपर के 5 पड़ाव आसान version जैसे ही हैं। आगे के 5 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। पहले slides के हर symbol और sets के नियम आते हैं, फिर discount का गणित और ideal DCG। उसके बाद queries का औसत और nDCG@10 वाला chart है, फिर course के papers में ये metrics, और आख़िर में आप slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।
6Slides के symbols, और sets और 𝟙 के नियम
अब तक हर metric अलग-अलग आया। Stanford की दोनों slides पाँचों formulas एक ही भाषा में लिखती हैं: sets, 𝟙, और queries का औसत। नीचे की table हर symbol को हमारे example के number से जोड़ती है:
एक बात ध्यान में रखिए: lesson 3 में |a| vector की length था, लेकिन यहाँ |A| set की गिनती है। Bars एक जैसी दिखती हैं, और मतलब इस पर टिका है कि अंदर vector है या set।
Failed@k = 1 − Hit@k क्यों हमेशा सच है
Slide का Failed@k वाला formula Hit@k जैसा ही है, बस शर्त में ≠ ∅ की जगह = ∅ है। पहले इसे हमारे numbers पर सीधे चलाइए:
q1: Rq1 ∩ Top3(q1) = {queue log, office hours page}, जो खाली नहीं, इसलिए 𝟙[ = ∅] = 0।
q2: {syllabus}, ये भी खाली नहीं, इसलिए 0।
q3: ∅, इसलिए 1।
औसत: (0 + 0 + 1) ÷ 3 = 0.333।
ये 1 − 0.667 के बराबर है, और ये संयोग नहीं है। हर query पर दोनों शर्तों में से ठीक एक सच होती है: set या तो खाली है या नहीं। इसलिए हर query पर 𝟙[ = ∅] + 𝟙[ ≠ ∅] = 1, और तीनों queries पर इनका जोड़ 3 है। 3 को 3 से भाग दीजिए, तो Failed@k + Hit@k = 1 आता है। जाँच: 0.333 + 0.667 = 1।
Sets से निकलने वाली तीन बातें
पहली बात के लिए एक नया निशान चाहिए। का मतलब है कि A की हर चीज़ B में भी है, और A को B का subset कहते हैं। जैसे Top3(q1) ⊆ Top5(q1), क्योंकि top-5 में top-3 के तीनों passages हैं, और दो और।
Recall@k कभी नहीं घटता, और 1 से ऊपर नहीं जाता। Top3 ⊆ Top5 है, इसलिए Rq ∩ Top3 ⊆ Rq ∩ Top5, और बड़े set की गिनती छोटे से कम नहीं हो सकती। साथ ही Rq ∩ Topk ⊆ Rq, इसलिए ऊपर वाली गिनती नीचे वाली से बड़ी नहीं हो सकती।
एक सही passage वाली query पर Recall@k और Hit@k बराबर हैं। |Rq| = 1 हो, तो |Rq ∩ Topk| या तो 0 है या 1, और भाग 1 से होता है। q2 और q3 ऐसी ही queries हैं, और उनके Recall@3 और Hit@3 दोनों 1 और 0 हैं। Lesson 8 का 1 minus recall@20 इसी वजह से Failed@20 बनता है।
हर query पर reciprocal rank, Hit से बड़ा नहीं होता। 1 ÷ rankq ज़्यादा से ज़्यादा 1 है, और कुछ न मिले तो दोनों 0 हैं। इसलिए MRR@k ≤ Hit@k।
पहले सोचिए
सुधार से पहले वाली list पर MRR@1 और Hit@1 निकालिए। दोनों बराबर क्यों हैं?
जवाब देखिए
सिर्फ़ q1 का पहला passage सही है, इसलिए दोनों (1 + 0 + 0) ÷ 3 = 0.333 हैं। k = 1 पर पहला सही passage मिले, तो वो rank 1 पर ही होगा, यानी reciprocal rank या तो 1 है या 0। फ़र्क तभी आता है, जब k बड़ा हो।
एक किनारा भी है। किसी query का कोई सही passage corpus में हो ही नहीं, तो Rq = ∅ और |Rq| = 0 है। तब Recall में 0 से भाग आता है, जो हो नहीं सकता, और nDCG में IDCG भी 0 है। इसलिए test set की हर query का कम से कम एक सही passage होना चाहिए।
7Discount का गणित: log, harmonic series और ideal DCG
पड़ाव 5 में grade को log2(rank + 1) से भाग दिया था, जबकि MRR सीधे 1 ÷ rank लेता है। दोनों discounts को 10 ranks पर साथ रखिए, तो फ़र्क दिखता है:
Rank
1 ÷ rank
log2(rank + 1)
1 ÷ log2(rank + 1)
1
1
1
1
2
0.5
1.585
0.631
3
0.333
2
0.5
4
0.25
2.322
0.431
5
0.2
2.585
0.387
6
0.167
2.807
0.356
7
0.143
3
0.333
8
0.125
3.170
0.315
9
0.111
3.322
0.301
10
0.1
3.459
0.289
1 ÷ rank बहुत जल्दी गिरता है: rank 2 पर आधा, और rank 10 पर 0.1। 1 ÷ log2(rank + 1) धीरे गिरता है: आधा rank 3 पर होता है, और rank 10 पर भी 0.289 बचता है। मतलब nDCG नीचे के ranks को भी गिनता है, जबकि 1 ÷ rank वाला discount उन्हें लगभग छोड़ देता है।
Järvelin और Kekäläinen के 2002 वाले paper ने यही वजह लिखी है। Discount rank के साथ घटे, लेकिन rank से भाग जितनी तेज़ी से नहीं, ताकि आगे तक पढ़ने वाला user भी गिना जाए। उनका example ये है: log2 1024 = 10, इसलिए rank 1024 वाला document भी अपनी value का दसवाँ हिस्सा रखता है। 1 ÷ rank से वो सिर्फ़ 1 ÷ 1024 = 0.001 रखता। paper से
Harmonic series, और nDCG का भाजक
1, 1/2, 1/3, 1/4, … वाली list को कहते हैं, और MRR के reciprocal ranks यही numbers हैं। इनका जोड़ बहुत धीरे बढ़ता है: पहले 10 numbers का जोड़ 2.929 है, पहले 100 का 5.187, और पहले 1,000 का 7.485। यहाँ एक नियम दिखता है: पहले n numbers का जोड़ करीब ln n + 0.577 होता है, जहाँ 0.577 एक तय number है। जाँच: ln 1000 = 6.908, और 6.908 + 0.577 = 7.485।
यानी harmonic series का जोड़ log की तरह बढ़ता है। यही रिश्ता उल्टी तरफ़ से nDCG के भाजक में दिखता है। Log का एक नियम है, जो lesson 4 के ln में भी था: log2(a × b) = log2 a + log2 b। 4 = 2 × 1.5 × (4 ÷ 3) है, इसलिए:
log2 2 = 1, जो rank 1 का भाजक है।
log2 1.5 = 0.585, जो rank 1 से rank 2 तक का कदम है।
log2(4 ÷ 3) = 0.415, जो rank 2 से rank 3 तक का कदम है।
जोड़: 1 + 0.585 + 0.415 = 2 = log2 4, जो rank 3 का भाजक है।
Rank i पर भाजक log2(1 + 1 ÷ i) के कदम से बढ़ता है: 1, 0.585, 0.415, 0.322, और rank 10 पर 0.138। इन्हें harmonic series के 1, 0.5, 0.333, 0.25 और 0.1 से मिलाइए। हर कदम 1 ÷ i के बराबर या उससे थोड़ा बड़ा है। बड़े i पर ये करीब 1.443 ÷ i है, जैसे i = 100 पर दोनों 0.0144 हैं। यहाँ 1.443 = 1 ÷ ln 2 है।
इसलिए nDCG का भाजक harmonic series जैसे छोटे होते कदमों से बढ़ता है, जबकि 1 ÷ rank का भाजक हर rank पर पूरा 1 बढ़ता है। इसी वजह से log वाला discount धीरे गिरता है।
Paper का पहला formula
Slide वाला log2(i + 1) बाद का आम रूप है। 2002 के paper में भाजक logb i था, यानी rank का log, base b के साथ। Rank 1 पर log 0 होता है, इसलिए paper b से छोटे ranks पर discount नहीं लगाता। b = 2 पर rank 1 और rank 2, दोनों पूरा grade रखते हैं, क्योंकि log2 2 = 1। Rank 3 पर भाग log2 3 = 1.585 से होता है। paper से
Paper का अपना example grades 3, 2, 3 से शुरू होता है, और तीसरे rank तक DCG 3 + 2 + 3 ÷ 1.585 = 6.89 देता है। Paper में भी 6.89 छपा है। उसी formula से q1 पर पुराना क्रम (3 + 0 + 1 ÷ 1.585) ÷ (3 + 1) = 0.908 देता है, और उलटा क्रम (1 + 0 + 3 ÷ 1.585) ÷ 4 = 0.723। q1 वाला हिसाब मेरा
Slide वाले formula से यही numbers 0.964 और 0.689 थे। Numbers बदले, लेकिन दोनों formulas पुराने क्रम को बेहतर कहते हैं। इसलिए nDCG का कोई number तभी पढ़िए, जब पता हो कि वो किस formula से बना।
Paper ने base 2 को जल्दी रुकने वाले user का model कहा, और base 10 को आगे तक पढ़ने वाले का। उसने grades की जगह अलग gains भी आज़माए, जैसे grades 0, 1, 2 और 3 को 0, 1, 10 और 100 मानना। paper से q1 पर ऐसे gains से पुराना क्रम 0.999 देता है, और उलटा 0.507। वजह ये है कि अब grade 3 वाला queue log बाकी सबसे 100 गुना भारी है। हिसाब मेरा
Ideal DCG: सारे labels से, और k पर कटा हुआ
IDCG बनाने के दो नियम हैं, और दोनों हमारे example पर दिखते हैं।
सबसे अच्छा क्रम सारे labels से बनता है, retriever की list से नहीं। Paper भी यही लिखता है: ideal की गिनती topic के सारे सही documents पर टिकी है, किसी system की list पर नहीं। paper से इसीलिए q3 का IDCG 2 है, जबकि retriever office hours page लाया ही नहीं।
IDCG@k सबसे बड़े k grades ही लेता है। मान लीजिए किसी query के 4 सही passages हैं, grades 3, 3, 2 और 1। तब IDCG@3 = 3 + 3 ÷ 1.585 + 2 ÷ 2 = 5.893, और grade 1 वाला passage top-3 में जगह ही नहीं पाता। IDCG@4 = 6.323 होता है। grades मेरे बनाए
पहले सोचिए
q1 पर retriever सिर्फ़ queue log rank 1 पर लाता है, और बाकी चार passages गलत हैं। nDCG@3 कितना है? अगर IDCG retriever की list से बनता, तो क्या होता?
जवाब देखिए
DCG = 3 ÷ 1 = 3, और IDCG सारे labels से 3.631 है, इसलिए nDCG = 3 ÷ 3.631 = 0.826। अगर IDCG list से बनता, तो list का सबसे अच्छा क्रम भी सिर्फ़ 3 देता, और nDCG 3 ÷ 3 = 1 आता। तब office hours page छूटने की कोई सज़ा नहीं मिलती।
8Queries का औसत, % और points, और nDCG@10 वाला chart
पाँचों formulas आख़िर में 1 ÷ |Q| और ∑ से queries का औसत लेते हैं। इस औसत में हर query का वज़न बराबर है, इसलिए q1 और q3, दोनों 1 ÷ 3 हिस्सा देती हैं। इसीलिए पड़ाव 5 में पहले हर query को उसके IDCG से भाग दिया, और फिर औसत लिया।
बिना भाग दिए DCG का औसत लें, तो (3.5 + 1.893 + 0) ÷ 3 = 1.798 आता है। ये अच्छा है या बुरा, कहना मुश्किल है, क्योंकि DCG की कोई तय ऊपरी हद नहीं। ऊपर से जोड़ 5.393 में अकेले q1 के 3.5 हैं, यानी 0.649 हिस्सा। nDCG@3 = 0.532 को सीधे पढ़ सकते हैं: औसतन lists ने सबसे अच्छे क्रम वाले DCG का 53.2% कमाया।
फिर भी एक औसत बहुत कुछ छिपा सकता है। Retriever C हर query पर nDCG 0.5 देता है, और retriever D आधी queries पर 1 और आधी पर 0। दोनों का औसत 0.5 है, लेकिन D आधी queries पर reader को कुछ नहीं देता। मेरा example इसलिए औसत के साथ Failed@k भी देखिए, जो पड़ाव 5 वाले support bot का भी सबक था।
% और points
Papers अक्सर इन numbers को 100 से गुणा करके लिखते हैं, जैसे 0.532 को 53.2। Lesson 8 की table में 256 tokens वाले chunks का औसत naive पर 52.2 है, और late पर 54.0। अब “कितना बेहतर” के दो जवाब हैं:
सीधा फ़र्क: 54.0 − 52.2 = 1.8। इसे 1.8 कहते हैं।
पुराने number के हिसाब से: 1.8 ÷ 52.2 = 0.0345, यानी करीब 3.45% की बढ़त।
Paper दोनों लिखता है: 1.8% absolute और 3.46% relative। paper से Table के numbers एक decimal तक rounded हैं, इसलिए हाथ के 3.45% और paper के 3.46% में ऐसा छोटा फ़र्क आ सकता है। जब कोई कहे कि नया तरीका “3% बेहतर” है, तो पूछिए कि ये points हैं या relative।
Stanford का nDCG@10 वाला chart
Stanford की late chunking वाली slide के तीन charts, बड़े करके। नीली bars naive chunking हैं, और हरी late chunking।
ये charts lesson 8 के late chunking paper से हैं। हर bar एक dataset का nDCG@10 है, 100 से गुणा करके। उस dataset की हर query पर top-10 का nDCG निकला, और फिर सारी queries का औसत। इसलिए 60 वाली bar का मतलब है कि औसतन top-10 lists ने सबसे अच्छे क्रम वाले DCG का 60% कमाया।
Paper के relevance labels एक file में हैं, जिसमें हर query के सही documents के IDs हैं। लेकिन retriever chunks लौटाता है, documents नहीं। इसलिए paper हर chunk को उसके document से बदल देता है। कोई document list में कई बार आए, तो paper सिर्फ़ उसकी पहली जगह रखता है। paper से तब एक document दो ranks भरकर दो बार नहीं गिनता, ठीक वैसे जैसे set में एक चीज़ एक ही बार होती है।
x-axis पर chunk size है, 8 से 512 tokens तक, और हर अगला size पिछले का दोगुना है। y-axis पर nDCG@10 है, % में, 0 से 100 तक। तीनों datasets, WikiMultiHopQA, SummScreenFD और QMSum, LongEmbed नाम के benchmark से हैं, और encoder jina-embeddings-v2-small है। paper से Chart से सटीक numbers पढ़ना भरोसे का नहीं, इसलिए उसकी शक्ल पढ़िए:
हर chart में हर chunk size पर हरी bar नीली के बराबर या उससे ऊँची है। SummScreenFD पर 512 tokens पर दोनों लगभग बराबर हैं।
फ़र्क छोटे chunks पर सबसे बड़ा है। QMSum पर 8 tokens वाली नीली bar 40 की line से नीचे है, और हरी 60 से ऊपर।
WikiMultiHopQA पर हर bar 80 से ऊपर है। nDCG 100 से ऊपर नहीं जा सकता, इसलिए वहाँ सुधार की जगह ही कम है।
Late chunking छोटे chunks पर क्यों जीतता है, ये lesson 8 समझाता है। इस lesson के लिए इतना काफ़ी है कि हर bar उस dataset की सारी queries का औसत है। उस औसत का हर हिस्सा पड़ाव 5 वाला DCG ÷ IDCG है।
पहले सोचिए
किसी dataset की आधी queries पर nDCG@10 = 1 है, और आधी पर 0। उसकी bar कहाँ होगी? क्या bar देखकर आप इसे उस dataset से अलग कर पाएँगे, जिसकी हर query पर nDCG@10 = 0.5 है?
जवाब देखिए
Bar 50 पर होगी, क्योंकि (1 + 0) ÷ 2 = 0.5, और 0.5 × 100 = 50। दूसरा dataset भी 50 पर होगा, इसलिए bar से फ़र्क नहीं दिखता। इसके लिए हर query के numbers, या Failed@10 जैसा number चाहिए।
9Course के papers में ये metrics
Lessons 8, 12, 14 और 15 के retrieval numbers इसी lesson के metrics हैं। फ़र्क बस इतना है कि हर paper ने labels और k अपने तरीके से चुने, और number पढ़ने से पहले ये दोनों जानने चाहिए।
DPR: बिना इंसान के labels वाला Hit@20
DPR paper की top-k retrieval accuracy गिनती है कि कितने हिस्से सवालों में top-k passages के अंदर जवाब वाला text है। paper से यानी वहाँ Rq उन सारे passages का set है, जिनमें जवाब का text मौजूद है, और किसी इंसान ने passages नहीं चुने। इससे 2.1 करोड़ passages पर भी labels सस्ते बन जाते हैं।
इसकी कीमत ये है कि जवाब का text किसी और बात में आ जाए, तब भी passage सही गिनता है। जैसे q2 का जवाब Week 6 है, तो Week 6 वाला कोई भी passage सही गिनता, चाहे वो किसी और deadline के बारे में हो। मेरा example Lesson 12 के NQ numbers को Failed@20 में बदलिए: DPR का 100 − 78.4 = 21.6%, और BM25 का 100 − 59.1 = 40.9%। मतलब BM25 के साथ 40.9% सवालों पर top-20 में जवाब वाला passage होता ही नहीं, और reader तक कुछ नहीं पहुँचता।
MS MARCO: MRR@10, और MRR को सही पढ़ना
Lessons 14 और 15 के MRR@10 numbers MS MARCO dataset के हैं। ColBERT paper के मुताबिक उसमें Web pages के 88 लाख passages हैं, जो Bing पर 10 लाख असली queries के नतीजों से आए। हर query के साथ सिर्फ़ एक या बहुत कम passages सही marked हैं, और किसी passage को गलत mark नहीं किया गया। Official metric MRR@10 है। paper से
ये चुनाव पड़ाव 6 से समझ आता है। जब हर query का एक ही सही passage हो, तो Recall@k और Hit@k बराबर हैं। तब बचा हुआ सवाल बस इतना है कि वो passage कितना ऊपर है। लेकिन “गलत mark नहीं किया” का मतलब ये भी है कि बिना label वाला passage सही हो सकता है। Retriever ऐसा passage rank 1 पर लाए, तब भी उसे 0 मिलता है, जो पड़ाव 1 वाली labels की कीमत है।
MRR@10 = 0.349 जैसे number को “औसत rank करीब 1 ÷ 0.349 = 2.9” पढ़ने का मन करता है, लेकिन ये गलत है। Reciprocals का औसत, औसत rank का reciprocal नहीं होता। दो queries लीजिए, जिनके पहले सही passages rank 1 और rank 10 पर हैं: मेरा example
1 ÷ 0.55 = 1.82, जबकि असली औसत rank (1 + 10) ÷ 2 = 5.5 है।
वजह 1 ÷ x की शक्ल में है, जो पड़ाव 7 की table के पहले column में है। Rank 1 से 2 पर जाने में reciprocal rank 0.5 गिरता है। Rank 9 से 10 पर जाने में वो सिर्फ़ 1 ÷ 9 − 1 ÷ 10 = 0.011 गिरता है। इसलिए MRR ज़्यादातर ये नापता है कि पहला सही passage rank 1 या 2 पर है या नहीं। Rank 11 वाला passage MRR@10 में उतना ही गिनता है, जितना कभी न मिला passage, यानी 0।
ColBERT: Recall@1000, और reranking से न बदलने वाला recall
ColBERT paper पूरे 88 लाख passages में खुद ढूँढने वाले retrievers के लिए Recall@50, Recall@200 और Recall@1000 भी देता है। Paper के मुताबिक ये numbers उस retriever के लिए ज़रूरी हैं, जो बड़े collection को किसी अगले step के लिए छोटा करता है। paper से Lesson 15 में ColBERT का Recall@1000 96.8 था, और BM25 (Anserini) का 85.7, यानी 11.1 points ज़्यादा।
उसी table में एक row sets के नियम को सीधे दिखाती है। Official BM25 का Recall@1000 81.4 है, और BM25 के उन्हीं top-1000 को ColBERT से rerank करने पर भी Recall@1000 81.4 ही रहता है। paper से Rerank सिर्फ़ उन्हीं 1,000 passages का क्रम बदलता है, इसलिए Top1000 set वही रहता है, और |Rq ∩ Top1000| भी। खुद ढूँढने वाले ColBERT का Recall@50 82.9 है, जो official BM25 के Recall@1000 से भी ज़्यादा है।
यहाँ पड़ाव 4 वाला नियम ही लागू है: Recall@k उसी k पर देखिए, जितने passages अगला step पढ़ता है। 1,000 passages पढ़ने वाले reranker के लिए Recall@1000 मायने रखता है, और करीब 14 passages पढ़ने वाले reader के लिए Recall@14 जैसा number।
Lesson 10 वाला recall और Recall@k
दोनों recall एक ही शक्ल के भाग हैं: |A ∩ B| ÷ |B|, यानी जो मिलना चाहिए था, उसमें से कितना मिला। फ़र्क B में है। Lesson 10 के recall में B exact search के top-k vectors हैं, और A ANN की list। जैसे exact top-10 में से 9 मिले, तो 9 ÷ 10 = 0.9। Recall@k में B इंसान के labels वाला Rq है।
इसलिए ANN का recall 1.0 हो सकता है, और Recall@k फिर भी 0। मान लीजिए ANN ने वही vectors लौटाए, जो exact search लौटाती। अगर encoder ने सही passage का vector दूर रखा है, तो वो exact top-k में भी नहीं है। Lesson 10 की slide वाला trade a little recall for a lot of speed ANN वाला recall है।
10अब Stanford की slides खुद पढ़िए
नीचे इस lesson की दोनों Stanford slides हैं, और late chunking वाली slide, जिसके charts पड़ाव 8 में आए। हर slide के नीचे कुछ सवाल हैं। पहले खुद जवाब सोचिए, फिर खोलिए। कोई symbol अटके, तो जवाब में लिखे पड़ाव पर लौट जाइए। Phone पर slide छोटी दिखे, तो image पर click कीजिए, वो पूरे size में खुलेगी।
Stanford की पहली metrics slide, और नीचे उसके दोनों हिस्से, बड़े करके।
Hit@k, Failed@k और nDCG@k वाली slide पढ़िए
Hit@k के ऊपर हरे रंग में लिखा है 1 if any relevant passage is in the top k, else 0। Formula का कौन सा हिस्सा ये करता है, और q3 पर उसकी value क्या है?
जवाब देखिए
𝟙[Rq ∩ Topk(q) ≠ ∅]। q3 के top-3 में office hours page नहीं है, इसलिए ∩ खाली है, और value 0 है। (पड़ाव 2 और 6)
Failed@k की line के आख़िर में = 1 − Hit@k लिखा है। ये बराबरी हर retriever पर सच क्यों है?
जवाब देखिए
हर query पर set या तो खाली है या नहीं, इसलिए 𝟙[ = ∅] + 𝟙[ ≠ ∅] = 1। सारी queries पर जोड़कर |Q| से भाग दीजिए, तो Failed@k + Hit@k = 1। हमारे example में 0.333 + 0.667 = 1। (पड़ाव 6)
nDCG के नीचे Normalized by the ideal ranking's DCG लिखा है। q3 का IDCG 2 क्यों है, जबकि retriever office hours page लाया ही नहीं? और rank 2 पर Discounted by rank position grade का कितना हिस्सा छोड़ता है?
जवाब देखिए
Ideal क्रम सारे labels से बनता है, और q3 के labels में office hours page grade 2 के साथ है, इसलिए IDCG = 2 ÷ 1 = 2। Rank 2 पर भाजक log2 3 = 1.585 है, इसलिए grade का 0.631 हिस्सा गिनता है। (पड़ाव 5 और 7)
Stanford की दूसरी metrics slide, और नीचे उसके दोनों formulas, बड़े करके।
MRR@k और Recall@k वाली slide पढ़िए
Counts as 0 if not in the top k: q3 पर MRR@3 में क्या जुड़ता है? और rank 11 पर पड़े पहले सही passage के साथ MRR@10 में?
जवाब देखिए
दोनों में 0। q3 के top-3 में कोई सही passage नहीं, और rank 11 top-10 से बाहर है। इसलिए MRR@10 के लिए rank 11 और “कभी नहीं मिला” एक जैसे हैं। (पड़ाव 3 और 9)
Recall के हरे box पर Relevant passages found in the top k लिखा है, और गुलाबी box पर All relevant passages for the query। k = 1 पर q1 के लिए दोनों boxes में क्या है?
जवाब देखिए
हरा box |{queue log}| = 1 है, और गुलाबी box |{queue log, office hours page}| = 2। q1 का हिस्सा 1 ÷ 2 = 0.5 है, और तीनों queries का Recall@1 = 0.5 ÷ 3 = 0.167। (पड़ाव 4)
Average over all queries वाला हिस्सा पाँचों formulas में है। अगर test set की किसी query का कोई सही passage ही न हो, तो Recall में क्या दिक्कत आती है?
जवाब देखिए
तब |Rq| = 0, और 0 से भाग नहीं हो सकता। nDCG में भी IDCG 0 होता है। इसलिए test set की हर query का कम से कम एक सही passage होना चाहिए। (पड़ाव 6)
Stanford की late chunking वाली slide, और नीचे उसके तीन charts, बड़े करके। ऊपर की table lesson 8 पढ़ाता है।
nDCG@10 वाले charts पढ़िए
y-axis पर nDCG@10 [%] लिखा है। किसी bar का 60 पर होना nDCG के हिसाब से क्या कहता है?
जवाब देखिए
उस dataset की हर query पर top-10 का DCG ÷ IDCG निकला, उनका औसत 0.6 है, और chart उसे 100 से गुणा करके 60 दिखाता है। यानी औसतन lists ने सबसे अच्छे क्रम वाले DCG का 60% कमाया। (पड़ाव 5 और 8)
Paper के labels documents के हैं, और retriever chunks लौटाता है। nDCG@10 निकालने से पहले paper क्या करता है, और क्यों?
जवाब देखिए
हर chunk को उसके document से बदलता है, और कोई document कई बार आए, तो सिर्फ़ पहली जगह रखता है। वरना एक ही सही document कई ranks भरकर कई बार गिनता। (पड़ाव 8)
WikiMultiHopQA पर हरी और नीली bars का फ़र्क बाकी दो charts से छोटा क्यों दिखता है?
जवाब देखिए
वहाँ हर bar 80 से ऊपर है, और nDCG 100 से ऊपर नहीं जा सकता, इसलिए सुधार की जगह ही कम है। Late chunking कब मदद करता है, ये lesson 8 बताता है। (पड़ाव 8)
इस lesson की 3 बातें
हर metric के लिए relevance labels चाहिए: हर query के सही passages Rq, और कभी उनके grades। Sets और 𝟙 के नियमों से Failed@k = 1 − Hit@k निकलता है, और ये भी कि Recall@k k के साथ कभी नहीं घटता।
Hit@k पूछता है कि सही passage पहुँचा या नहीं, और MRR कि पहला सही passage कितना ऊपर है। Recall@k पूछता है कि कितने पहुँचे, और nDCG कि ज़्यादा काम का passage ऊपर है या नहीं। nDCG का log वाला discount 1 ÷ rank से धीरे गिरता है, इसलिए वो नीचे के ranks को भी गिनता है।
हर metric queries का बराबर वज़न वाला औसत है, और एक औसत कई तस्वीरें छिपा सकता है। Papers इसे अपने labels और k के साथ लेते हैं: DPR का Hit@20, MS MARCO का MRR@10, और ColBERT का Recall@1000।
इस lesson के नए शब्द
Relevance labels
हर query के लिए पहले से तय सही passages, कभी grades के साथ। जैसे q1 के लिए queue log (grade 3) और office hours page (grade 1)।
Set, ∩, ∅, |A|
चीज़ों का group, दो sets की common चीज़ें, खाली set, और set में कितनी चीज़ें हैं। जैसे |{queue log, office hours page}| = 2, और q3 पर Rq3 ∩ Top3(q3) = ∅।
𝟙[शर्त]
शर्त सच हो तो 1, नहीं तो 0। जैसे q3 के top-3 में कोई सही passage नहीं है, तो 𝟙[Rq3 ∩ Top3(q3) ≠ ∅] = 0।
Hit@k
कितने हिस्से queries में top-k में कम से कम एक सही passage है। जैसे k = 3 पर 3 में से 2 queries, यानी 0.667।
Failed@k
1 − Hit@k, यानी कितने हिस्से queries में top-k में एक भी सही passage नहीं। जैसे Failed@3 = 1 − 0.667 = 0.333।
MRR@k
पहले सही passage के rank का उल्टा (1 ÷ rank), queries का औसत, और top-k में न हो तो 0। जैसे ranks 1, 2 और कोई नहीं, तो (1 + 0.5 + 0) ÷ 3 = 0.5।
Recall@k
Top-k में मिले सही passages ÷ कुल सही passages, queries का औसत। जैसे k = 1 पर q1 में 2 में से 1 मिला, तो 0.5।
log2
2 को किस power तक उठाएँ कि number मिले। जैसे log2 4 = 2, और log2 3 = 1.585।
DCG और IDCG
हर rank का grade ÷ log2(rank + 1), फिर जोड़। IDCG सबसे अच्छे क्रम का DCG। जैसे q1 का क्रम queue log (3), forum post (0), office hours page (1): DCG 3.5, IDCG 3.631।
nDCG@k
DCG ÷ IDCG, 0 से 1 के बीच, जो grade और क्रम दोनों देखता है। जैसे q1 के उलटे क्रम पर 2.5 ÷ 3.631 = 0.689।
⊆ (subset)
A ⊆ B का मतलब है कि A की हर चीज़ B में भी है। जैसे Top3(q1) ⊆ Top5(q1), इसलिए Recall@5 कभी Recall@3 से कम नहीं होता।
Harmonic series
1 + 1/2 + 1/3 + …, यानी 1 ÷ rank वाले numbers, जो MRR में आते हैं। इनका जोड़ धीरे बढ़ता है, करीब ln n + 0.577, जैसे पहले 1,000 numbers का जोड़ 7.485।
Points (absolute फ़र्क)
दो % numbers का सीधा फ़र्क। जैसे 52.2 से 54.0 = 1.8 points, जबकि 52.2 के हिसाब से ये करीब 3.45% की बढ़त है।
QRels
Relevance labels की file: हर query के लिए सही documents के IDs। जैसे late chunking paper ने nDCG@10 इसी file से निकाला।