Lesson 15 · गहरा version

ColBERT: हर token का अपना vector

ColBERT एक retriever है, जो passage के हर token का अलग vector रखता है। Query के हर token के लिए वो passage में सबसे अच्छा match ढूँढता है, और इन matches के scores जोड़कर passage का score बनाता है। Passages के सारे token vectors सवाल आने से पहले बन जाते हैं, इसलिए ColBERT तेज़ भी रहता है। इसे Khattab और Zaharia ने 2020 में बनाया।

इसकी ज़रूरत lesson 12 के आख़िर में दिखी थी: error 4012 जैसा rare code passage के एक vector में दब जाता है। Query error 4012 पर जवाब एक लंबे FAQ में है, लेकिन एक vector वाला bi-encoder एक छोटे, गलत passage को ऊपर रखता है। Lesson 14 का cross-encoder ये गलती ठीक करता है, लेकिन हर passage पर 10.7 ms लेता है।

इस lesson की सीढ़ी

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

  1. एक vector में 4012 दब जाता हैऔसत vector हाथ से निकाल पाएँगे, और बता पाएँगे कि गलत passage ऊपर क्यों आया।
  2. MaxSim: query के हर token का सबसे अच्छा matchMaxSim की table हाथ से भर पाएँगे, और Stanford की ColBERT वाली दो slides पढ़ पाएँगे।
  3. कीमत: 100 गुना vectors, लेकिन बहुत कम कामLatency और FLOPs पढ़ पाएँगे, और ColBERT की तुलना cross-encoder से numbers में कर पाएँगे।
  4. Cascade: सस्ता step पहले, सटीक step आख़िर मेंचारों retrievers को एक line में लगा पाएँगे, और Stanford की तुलना वाली slide पढ़ पाएँगे।
  5. यहाँ से Stanford वाला level
  6. MaxSim का पूरा गणितSlide के formula का हर symbol अपने numbers से जोड़ पाएँगे, और बता पाएँगे कि max की जगह औसत क्यों नहीं चलता।
  7. Query और passage को मिलाने के चार ढाँचेSlide के चारों diagrams पढ़ पाएँगे, और paper का ablation समझा पाएँगे।
  8. ColBERT के encoders अंदर से, और training[Q], [D], [mask], 128 numbers और training का loss समझा पाएँगे।
  9. कीमत का हिसाब: bytes, FLOPs और 61 msIndex का size bytes में, और FLOPs गुणा गिनकर निकाल पाएँगे।
  10. End-to-end search के दो stagesबता पाएँगे कि ColBERT 88 लाख passages में 458 ms में कैसे ढूँढता है।
  11. Stanford की slides खुद पढ़िएColBERT की चारों Stanford slides की हर line समझा पाएँगे।

पहले से क्या चाहिए: Lesson 3 (dot product, cosine), Lesson 7 (token के vectors, mean pooling), Lesson 13 (MRR@k, Recall@k) और Lesson 14 (cross-encoder, reranking)। पड़ाव 5 से आगे Lesson 10 (IVF, PQ, दूरी) और Lesson 12 (contrastive loss, दर) भी काम आते हैं। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।

1एक vector में 4012 दब जाता है

Bi-encoder पूरे passage को एक vector में समेटता है, और लंबे passage में एक ज़रूरी token उस vector में दब सकता है। बहुत से bi-encoders ये vector से बनाते हैं। Lesson 7 में इसका मतलब था: सारे token vectors का हर number जोड़िए, और tokens की गिनती से भाग दीजिए। जैसे [0.9, 0.1] और [0.7, 0.3] का औसत [0.8, 0.2] है।

अब query error 4012 लीजिए, जिसमें 2 tokens हैं। हर token के vector में 3 numbers हैं। पहला number बताता है कि token error या upload की बात कितनी करता है, दूसरा code 4012 की बात कितनी, और तीसरा बाकी विषयों की। Query के tokens हैं error = [1, 0, 0] और 4012 = [0, 1, 0]। vectors मेरे बनाए हैं

Course के लंबे FAQ में grading, late days और Zoom की बातें हैं, और एक line error 4012 का हल बताती है। छोटे upload note में बस इतना है कि upload errors होते रहते हैं। असली FAQ में सैकड़ों tokens होंगे, यहाँ हिसाब के लिए 6 हैं।

TextTokens और उनके vectorsऔसत vector
Queryerror [1, 0, 0], 4012 [0, 1, 0][0.5, 0.5, 0]
Course FAQ6 tokens, जवाब इसी मेंgrading, late, days, zoom: हर एक [0, 0, 1]। error [0.9, 0, 0.1], 4012 [0.1, 0.95, 0][0.167, 0.158, 0.683]
Upload note3 tokens, 4012 नहींupload [0.8, 0.1, 0.1], errors [0.95, 0.05, 0], happen [0.5, 0, 0.5][0.75, 0.05, 0.2]

FAQ का औसत तीन numbers में ऐसे बना:

  1. पहला number: सिर्फ़ error और 4012 का पहला number 0 नहीं है। 0.9 + 0.1 = 1.0, और 1.0 ÷ 6 = 0.167।
  2. दूसरा number: सिर्फ़ 4012 का 0.95 है, और 0.95 ÷ 6 = 0.158।
  3. तीसरा number: चार tokens के 1, और error का 0.1, यानी 4.1। फिर 4.1 ÷ 6 = 0.683।

तीसरा number सबसे बड़ा है, यानी FAQ का vector ज़्यादातर बाकी विषयों की तरफ़ है। अब lesson 3 वाला लीजिए, जो दो vectors का dot product उनकी लंबाइयों के गुणा से भाग देकर देता है। जैसे [1, 0] और [1, 1] का cosine 1 ÷ (1 × 1.414) = 0.707 है। Query के औसत से FAQ के औसत का cosine 0.32 आता है, और upload note के औसत का 0.73।

इसलिए गलत upload note ऊपर आया, और जवाब वाला FAQ नीचे। FAQ में 4012 था, लेकिन औसत में उसका हिस्सा 6 में से 1 ही रहा। Lesson 14 ने ऐसी हालत में से BM25 को साथ लिया था। ColBERT दूसरा रास्ता लेता है: वो tokens का औसत लेता ही नहीं।

2MaxSim: query के हर token का सबसे अच्छा match

ColBERT passage के हर token का अपना vector रखता है, और query के हर token का vector भी अलग रखता है। ये lesson 7 वाले token vectors ही हैं, यानी हर token का vector उसके आस-पास के शब्दों के असर से बनता है। फ़र्क बस इतना है कि ColBERT इनका औसत नहीं लेता।

Lesson 12 के DPR की तरह document encoder ये vectors बनाकर एक में रखता है, यानी सवाल आने से पहले। सवाल आने पर query encoder सिर्फ़ query के tokens के vectors बनाता है।

Score दो steps में बनता है। पहले query के हर token के लिए passage के हर token से लीजिए, और सबसे बड़ा रखिए। फिर query के सारे tokens के ये सबसे बड़े numbers जोड़िए। इस score को MaxSim कहते हैं।

पहले सोचिए

औसत में grading, late, days और zoom ने 4012 को दबा दिया था। क्या MaxSim में भी ये चार tokens FAQ का score घटाएँगे?

जवाब देखिए

नहीं। Query के दोनों tokens से इन चारों का dot product 0 है, और MaxSim हर query token का सिर्फ़ सबसे बड़ा dot product रखता है। FAQ में दोनों के लिए 0 से बड़ा match है, इसलिए ये चार tokens जोड़ में आते ही नहीं।

नीचे की table में हर row FAQ का एक token है, और हर column query का एक token। हर cell उनका dot product है, और हर column का सबसे बड़ा cell रंगा है।

FAQ का tokenQuery का error [1, 0, 0]Query का 4012 [0, 1, 0]
grading, late, days, zoomहर एक [0, 0, 1]00
error[0.9, 0, 0.1]0.90
4012[0.1, 0.95, 0]0.10.95
Column का सबसे बड़ा0.90.95

जैसे query के error और FAQ के 4012 का dot product: 1 × 0.1 + 0 × 0.95 + 0 × 0 = 0.1। Error वाले column में सबसे बड़ा number 0.9 है, और 4012 वाले में 0.95। इसलिए FAQ का MaxSim = 0.9 + 0.95 = 1.85 है।

Upload note की table इसी तरह बनती है:

Upload note का tokenQuery का error [1, 0, 0]Query का 4012 [0, 1, 0]
upload[0.8, 0.1, 0.1]0.80.1
errors[0.95, 0.05, 0]0.950.05
happen[0.5, 0, 0.5]0.50
Column का सबसे बड़ा0.950.1

Upload note का MaxSim = 0.95 + 0.1 = 1.05 है, इसलिए अब जवाब वाला FAQ ऊपर है: 1.85 बनाम 1.05। Upload note में 4012 से मिलने वाला कोई token नहीं है, इसलिए 4012 वाले column में उसका max सिर्फ़ 0.1 है।

Formula में यही दो steps हैं। Stanford की slide passage को d लिखती है, document से:

Sq,d = ∑i ∈ q maxj qi · dj
qi
Query के token i का vector। जैसे error = [1, 0, 0]।
dj
Passage के token j का vector। जैसे FAQ का 4012 = [0.1, 0.95, 0]।
maxj
Passage के सारे tokens j में से सबसे बड़ा dot product। FAQ पर error वाले column में 0.9।
∑i ∈ q
Query के हर token i का max, फिर उनका । ∈ का मतलब है “इसका हिस्सा”। FAQ पर 0.9 + 0.95 = 1.85।

इस तरीके में query और passage के tokens अलग-अलग encode होते हैं, और सिर्फ़ आख़िरी step पर, यानी scoring पर, मिलते हैं। इसे late interaction कहते हैं, और ColBERT इसी पर बना retriever है। Stanford की slide यही परिभाषा लिखती है:

Stanford slide: Late Interaction, MaxSim का formula और चार ढाँचे
Stanford की slide: Late Interaction। ऊपर परिभाषा है, और बीच में MaxSim का formula। नीचे लाल घेरे वाला (d) ColBERT है, (a) lesson 12 जैसा bi-encoder, और (c) lesson 14 जैसा cross-encoder।
Stanford slide: ColBERT का ढाँचा, query encoder, document encoder, MaxSim और score
Stanford की slide: ColBERT का ढाँचा। Query encoder fQ query के tokens के vectors बनाता है, और document encoder fD passage के, Offline Indexing वाले box में। हर MaxSim box एक query token का max है, और ∑ उनका जोड़।

पहले सोचिए

Query में तीसरा token जोड़िए: upload = [1, 0, 0]। Upload note का MaxSim अब कितना होगा, और FAQ का कितना?

जवाब देखिए

नए token के upload note से dot products 0.8, 0.95 और 0.5 हैं। सबसे बड़ा 0.95 है, upload से नहीं, errors से। Upload note का MaxSim = 1.05 + 0.95 = 2.0। FAQ पर नए token का max 0.9 है, इसलिए FAQ 1.85 + 0.9 = 2.75 पर है, और अब भी आगे है।

MaxSim table खुद चलाइए

Passage और query चुनिए। यहाँ हर row query का token है, और हर column passage का।

ColBERT की एक हद भी है। उसमें passage के vectors query देखे बिना बनते हैं, जबकि cross-encoder में query के tokens से passage के tokens को देखते हैं। इसलिए पुरानी राय और असली data जैसा फ़र्क, जो दोनों को साथ पढ़ने पर दिखता है, cross-encoder बेहतर पकड़ सकता है।

3कीमत: 100 गुना vectors, लेकिन बहुत कम काम

हर token का vector रखने की कीमत index में है: vectors की गिनती passages से नहीं, tokens से बढ़ती है। मान लीजिए 60,000 passages हैं, और हर एक में करीब 100 tokens। Bi-encoder 60,000 vectors रखता है, और ColBERT 60,000 × 100 = 60 लाख, यानी 100 गुना vectors। Bytes में फ़र्क इससे कम है, क्योंकि ColBERT के vectors छोटे होते हैं। मेरा example

इसके बदले क्या मिलता है, ये दो चीज़ों से नापते हैं। पहली चीज़ है latency: query भेजने से जवाब आने तक का समय, ms में। जैसे lesson 14 का cross-encoder 1,000 passages पर 10,700 ms लेता है, तो उसकी latency 10,700 ms है।

दूसरी चीज़ computer का काम है, जिसे FLOPs में गिनते हैं, यानी कितने गुणा और जोड़ लगे। हमारे vectors में 3 numbers हैं, इसलिए एक dot product में 3 गुणा और 3 जोड़ हैं, यानी 6 FLOPs। FAQ के MaxSim में 2 × 6 = 12 dot products थे, इसलिए 12 × 6 = 72 FLOPs लगे।

Stanford की slide ColBERT को MS MARCO पर नापती है। Lesson 14 में आया था कि उसमें Bing search के असली सवाल और 88 लाख passages हैं। Rerank वाली rows में model BM25 के top-1,000 को दोबारा sort करता है। lesson 13 का है: पहले सही passage के rank का उल्टा, जैसे rank 2 पर 0.5। Table इसे 100 से गुणा करके लिखती है।

MethodMRR@10LatencyFLOPs per query
BM25 (official)16.7––
BERT-base cross-encoder, rerank34.710,700 ms97T
ColBERT, rerank34.961 ms7B
ColBERT, end-to-end36.0458 ms–

T यानी trillion, यानी 1012, और B यानी billion, यानी 109। इसलिए 97T ÷ 7B = 97,000 ÷ 7 = करीब 13,900। मतलब rerank में ColBERT का काम cross-encoder से करीब 13,900 गुना कम है, और MRR@10 लगभग बराबर है: 34.9 बनाम 34.7। Latency भी 10,700 ms की जगह 61 ms है।

फ़र्क इसलिए है कि cross-encoder हर passage के साथ BERT पूरा चलाता है। ColBERT query पर BERT एक बार चलाता है, और passages के vectors पहले से बने हैं, इसलिए हर passage पर बस MaxSim बचता है।

End-to-end वाली row में ColBERT किसी और की list पर नहीं टिकता, बल्कि खुद पूरे 88 लाख passages में ढूँढता है। इसमें 458 ms लगते हैं, और MRR@10 36.0 आता है। इसका बड़ा फ़ायदा shortlist में है। बताता है कि सही passages में से कितना हिस्सा top-1,000 में आया, जैसे 2 में से 1 आया तो 0.5। ColBERT का Recall@1000 96.8 है, और BM25 (Anserini नाम के toolkit वाला) का 85.7, यानी 11.1 points ज़्यादा।

4Cascade: सस्ता step पहले, सटीक step आख़िर में

अब आपके पास चार retrievers हैं: BM25, DPR, ColBERT और cross-encoder। Stanford की ये slide चारों को एक table में रखती है:

Stanford slide: Fast vs Slow Retrievers, चार retrievers की तुलना
Stanford की slide: Fast vs Slow Retrievers। Columns बताते हैं कि पहले से क्या बनता है, एक query का समय, और retriever कहाँ जीतता और कहाँ हारता है। ColBERT की row आप पढ़ चुके हैं: हर token का vector, 458 ms, और tokens से बढ़ता index।

असली systems इन्हें एक line में लगाते हैं। सबसे सस्ता retriever पूरे corpus से लंबी shortlist निकालता है, और हर अगला step कम passages पर ज़्यादा महँगा और सटीक काम करता है। इस line को cascade कहते हैं। एक cascade ऐसा दिख सकता है: मेरा example

BM25 + DPRकरोड़ों में से top-1,000, RRF से
ColBERT rerank1,000 में से top-50
Cross-encoder50 में से top-5
LLM5 passages पढ़कर जवाब

हर step का खर्च उसकी list के size से तय होता है। ColBERT 1,000 passages को करीब 61 ms में rerank करता है। Cross-encoder 50 passages पर 50 × 10.7 = 535 ms लेता है, जबकि पूरे 1,000 पर उसे 10,700 ms लगते।

हर step पिछले step की shortlist पर टिका है, इसलिए पहले step का recall पूरे cascade की छत है। ये lesson 14 वाली है। सही passage पहले step की 1,000 की list में नहीं आया, तो बाद का कोई step उसे नहीं ला सकता। इसीलिए पहले step में BM25 और DPR, दोनों हैं, और उनकी lists को मिलाता है।

पहले सोचिए

आपका corpus product manuals का है, और users अक्सर model numbers से ढूँढते हैं, जैसे XR-2209। Cascade के पहले step से BM25 हटा दें, तो क्या होगा?

जवाब देखिए

पहले step में सिर्फ़ DPR बचेगा, जो rare literals चूकता है। XR-2209 वाले passages shortlist में ही नहीं आएँगे, और बाद का कोई reranker उन्हें वापस नहीं ला सकता।

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

ऊपर के 4 पड़ाव आसान version जैसे ही हैं। आगे के 6 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। इनमें पहले MaxSim का पूरा गणित है, फिर query और passage को मिलाने के चार ढाँचे, और ColBERT के encoders अंदर से। उसके बाद index के bytes और FLOPs गिनते हैं, फिर end-to-end search के दो stages देखते हैं, और आख़िर में आप slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।

5MaxSim का पूरा गणित: हर symbol, max बनाम औसत, और score की हद

पड़ाव 2 में दो tables थीं, एक FAQ की और एक upload note की। Slide का formula वही हिसाब हर query और हर passage पर लागू करता है:

Stanford slide का MaxSim formula, बड़ा करके
Stanford की late interaction वाली slide का formula, बड़ा करके।

नीचे की table हर symbol को हमारे numbers से जोड़ती है। पड़ाव 2 की tables में हर column एक i था, और हर row एक j।

Symbolमतलबहमारे example में
Sq,dQuery q और passage d का scoreFAQ पर 1.85, upload note पर 1.05
i ∈ qi query के tokens पर चलता है। ∈ का मतलब है “इसका हिस्सा”।i = 1 पर error, i = 2 पर 4012
jPassage के tokens का numberFAQ में j = 1 से 6 तक, upload note में 1 से 3 तक
qiQuery के token i का vector। Bold अक्षर का मतलब है कि ये एक number नहीं, vector है।q1 = [1, 0, 0]
djPassage के token j का vectorFAQ का पाँचवाँ token 4012 है, तो d5 = [0.1, 0.95, 0]
qi · djदोनों का dot product, यानी table का एक cellq1 · d5 = 0.1
maxjएक i के लिए सारे j में से सबसे बड़ा celli = 1 पर 0.9
∑i ∈ qसारे i के max का जोड़0.9 + 0.95 = 1.85

Max की जगह औसत लें, तो गलत passage लौट आता है

Max की जगह हर column का औसत भी ले सकते थे। ये भी सस्ता है, और paper ने इसे आज़माया भी। paper से हमारे numbers पर ये ऐसे चलता है:

  1. FAQ, error वाला column: (0 + 0 + 0 + 0.9 + 0.1 + 0) ÷ 6 = 1.0 ÷ 6 = 0.167।
  2. FAQ, 4012 वाला column: (0 + 0 + 0 + 0 + 0.95 + 0) ÷ 6 = 0.158। FAQ का score 0.167 + 0.158 = 0.325 है।
  3. Upload note: error वाला column (0.8 + 0.95 + 0.5) ÷ 3 = 0.75, और 4012 वाला (0.1 + 0.05 + 0) ÷ 3 = 0.05। Score 0.75 + 0.05 = 0.8 है।

Upload note 0.8 के साथ फिर ऊपर है, और FAQ 0.325 पर। ये numbers जाने-पहचाने हैं: 0.167 और 0.158 FAQ के औसत vector के पहले दो numbers हैं, और 0.75 और 0.05 upload note के। ऐसा dot product के एक नियम की वजह से है: a · (b + c) = a · b + a · c। जैसे [1, 0, 0] · ([0.9, 0, 0.1] + [0.1, 0.95, 0]) = [1, 0, 0] · [1.0, 0.95, 0.1] = 1.0, और अलग-अलग निकालें, तो भी 0.9 + 0.1 = 1.0।

औसत भी जोड़ और फिर भाग ही है। इसलिए “पहले dot products, फिर उनका औसत” और “पहले औसत vector, फिर dot product” एक ही number देते हैं। Query के दोनों tokens का ये जोड़ फिर query के औसत vector में बदल जाता है:

∑i औसतj (qi · dj) = 2 × (query का औसत) · (passage का औसत)

यहाँ 2 query के tokens की गिनती है। FAQ पर 2 × 0.1625 = 0.325, और upload note पर 2 × 0.4 = 0.8। ये 0.1625 और 0.4 वही dot products हैं, जिनसे पड़ाव 1 का cosine बना था। वो cosine पूरा ऐसे निकलता है:

  1. Query के औसत [0.5, 0.5, 0] की लंबाई: √(0.5² + 0.5²) = √0.5 = 0.707।
  2. FAQ के औसत की लंबाई: √(0.167² + 0.158² + 0.683²) = √0.520 = 0.721। Cosine: 0.1625 ÷ (0.707 × 0.721) = 0.1625 ÷ 0.510 = 0.32।
  3. Upload note के औसत की लंबाई: √(0.75² + 0.05² + 0.2²) = √0.605 = 0.778। Cosine: 0.4 ÷ (0.707 × 0.778) = 0.4 ÷ 0.550 = 0.73।

मतलब औसत वाला MaxSim असल में पड़ाव 1 का एक vector वाला तरीका ही है, बस लंबाई से भाग दिए बिना। Max इसीलिए ज़रूरी है: वो हर query token के लिए passage का एक ही token चुनता है, और बाकी tokens का असर हटा देता है। Paper के experiment में भी औसत वाला ColBERT साफ़ पीछे रहा, जो पड़ाव 6 में आता है।

Score की ऊपरी हद, और query tokens पर जोड़

ColBERT हर vector को लंबाई 1 पर लाता है। paper से Lesson 3 वाले में vector के हर number को उसकी लंबाई से भाग देते हैं। जैसे [3, 4] की लंबाई 5 है, तो वो [0.6, 0.8] बनता है। लंबाई 1 वाले दो vectors का dot product ठीक उनका cosine है, जो −1 और 1 के बीच रहता है।

इसलिए हर max ज़्यादा से ज़्यादा 1 है, और query में 32 vectors हों, तो S ज़्यादा से ज़्यादा 32 है। Paper हर query को ठीक 32 vectors देता है, जो पड़ाव 7 में आता है।

हमारे toy vectors की लंबाई ठीक 1 नहीं है। जैसे FAQ के error [0.9, 0, 0.1] की लंबाई √(0.81 + 0 + 0.01) = √0.82 = 0.906 है। Normalize करने पर वो [0.994, 0, 0.110] बनता है। तब MaxSim FAQ पर 1.99 और upload note पर 1.12 आते हैं, यानी क्रम वही रहता है। हिसाब मेरा

Formula query के tokens पर जोड़ लेता है, औसत नहीं। औसत लेने से हर score query के tokens की गिनती से भाग होता, जैसे FAQ 1.85 ÷ 2 = 0.925 और upload note 1.05 ÷ 2 = 0.525। एक query के सारे passages एक ही number से भाग होते हैं, इसलिए क्रम नहीं बदलता, ठीक lesson 12 के दोगुने vector की तरह।

6Query और passage को मिलाने के चार ढाँचे, और paper के experiments

Slide के नीचे चार diagrams हैं। हर diagram में हरे boxes query के tokens हैं, नीले boxes passage के, और सबसे ऊपर का s score है। चारों में फ़र्क ये है कि query और passage के tokens कब और कैसे मिलते हैं।

Stanford slide के चार diagrams: representation-based, query-document interaction, all-to-all और late interaction
Stanford की late interaction वाली slide के चारों diagrams, बड़े करके।

Diagram (b) एक table पर चलता है, जिसे interaction matrix कहते हैं। इसमें query के हर token और passage के हर token की similarity होती है। पड़ाव 2 की दोनों tables ऐसी ही थीं: FAQ वाली में 6 rows और 2 columns, यानी 12 numbers।

ढाँचाQuery और passage कैसे मिलते हैंइस course में
(a) Representation-basedDSSM, SNRMदोनों का एक-एक vector, और आख़िर में उनका एक score।Lesson 12 का DPR, और पड़ाव 1 का mean pooling।
(b) Query-document interactionDRMM, KNRM, Conv-KNRMपहले interaction matrix। फिर उस पर CNN, match kernels या MLP जैसा छोटा सीखा हुआ model।पड़ाव 2 जैसी table, लेकिन max और जोड़ की जगह model।
(c) All-to-all interactionBERTदोनों एक ही model में। हर layer में हर token हर token से attention में मिलता है।Lesson 14 का cross-encoder।
(d) Late interactionColBERTQuery के tokens आपस में मिलते हैं, और passage के tokens आपस में। दोनों सिर्फ़ MaxSim पर मिलते हैं।ColBERT।

Diagrams की lines यही दिखाती हैं। (c) में हरे और नीले boxes के बीच हर layer पर lines हैं। इसलिए passage का हर vector query पर टिका है, और पहले से कुछ नहीं बन सकता। (d) में MaxSim के नीचे lines हरे boxes के आपस में हैं, और नीले boxes के आपस में, लेकिन दोनों के बीच नहीं। इसलिए passage के vectors query के बिना बनते हैं, और ColBERT उन्हें offline index में रख सकता है।

(b) और (d), दोनों interaction matrix जैसा हिसाब करते हैं, लेकिन (d) का max एक और काम आसान करता है। किसी query token का max ढूँढना, यानी पूरे index में उसके सबसे पास वाला token vector ढूँढना, lesson 10 वाला vector search है। इसलिए ColBERT ज़्यादातर passages को बिना score किए छोड़ सकता है, और paper इसे pruning-friendly कहता है। (b) का सीखा हुआ model पूरी table देखे बिना score नहीं दे सकता। paper से पड़ाव 9 यही इस्तेमाल करता है।

Paper के experiments: ColBERT का कौन सा हिस्सा कितना ज़रूरी है

Paper ने ColBERT के हिस्से एक-एक करके बदले, और हर बार MS MARCO के dev set पर MRR@10 नापा। Lesson 5 वाले का यही मतलब है: एक हिस्सा हटाइए, और देखिए कि नतीजा कितना गिरता है। खर्च बचाने के लिए ज़्यादातर models BERT की 12 में से सिर्फ़ पहली 5 layers पर बने। paper से

Paper के graph में [A] और [B] सबसे नीचे हैं, और लगभग बराबर। [C] उनसे ऊपर है, लेकिन [D] से नीचे, और [E] और [F] सबसे ऊपर हैं। Graph से पक्के numbers पढ़ना ठीक नहीं, लेकिन क्रम साफ़ है: एक vector और औसत, दोनों पूरे ColBERT से काफ़ी पीछे हैं। [B] का [A] के पास होना पड़ाव 5 से मेल खाता है। वहाँ औसत similarity एक vector वाले dot product में बदल गई थी। ये तुलना मेरी है

7ColBERT के encoders अंदर से, और training

Slide में दो encoders दिखते हैं, fQ और fD, लेकिन paper में दोनों एक ही BERT हैं। Query के आगे [Q] नाम का एक खास token जुड़ता है, और passage के आगे [D]। इनसे BERT को पता रहता है कि वो किसका vector बना रहा है। paper से

Stanford slide का ColBERT diagram, बड़ा करके
Stanford की ColBERT ढाँचे वाली slide का diagram, बड़ा करके।

Query encoder चार steps में चलता है: paper से

  1. Query के tokens के आगे [CLS] और [Q] जुड़ते हैं। फिर बची जगह में [mask] tokens भरकर query को 32 tokens लंबा बनाते हैं। Query 32 से लंबी हो, तो पहले 32 tokens रहते हैं।
  2. BERT हर token का contextual vector बनाता है, जिसमें 768 numbers होते हैं।
  3. एक linear layer हर vector को 128 numbers का बनाता है।
  4. हर vector को लंबाई 1 पर normalize करते हैं।

Passage encoder भी ऐसे ही चलता है, बस उसमें [Q] की जगह [D] है, और [mask] नहीं जुड़ते। आख़िर में वो comma और full stop जैसे punctuation के vectors हटा देता है, ताकि हर passage के vectors कम रहें।

Query augmentation: [mask] tokens से query को लंबा करना

[mask] BERT का एक खास token है, जिसके पीछे कोई शब्द नहीं होता। BERT हर [mask] का vector भी बनाता है, और ये vector query के असली tokens को देखकर बनता है। इसलिए ये vectors query के extra tokens की तरह MaxSim में हिस्सा लेते हैं। Paper इसे query augmentation कहता है। उसके मुताबिक ये query में नए शब्द जोड़ने, या पुराने शब्दों का वज़न बदलने का सीखा हुआ तरीका है। paper से

पड़ाव 2 के सवाल में query में तीसरा token upload जोड़ा था। तब हर passage के score में एक max और जुड़ा: FAQ में 0.9, और upload note में 0.95। [mask] वाला हर vector भी ऐसा ही एक और max जोड़ता है, बस उसका vector BERT तय करता है। पड़ाव 6 के ablation में इसके बिना वाला model [C] साफ़ नीचे रहा।

Linear layer: 768 से 128 numbers

Linear layer एक से गुणा है। नतीजे का हर number input vector का matrix की एक row से dot product है, ठीक lesson 3 के matrix-vector गुणा की तरह। छोटे पैमाने पर 3 numbers से 2 numbers देखिए, जहाँ matrix की rows [1, 0, 0.5] और [0, 1, 0.5] हैं। matrix मेरी बनाई FAQ के error [0.9, 0, 0.1] पर:

  1. पहला number: [1, 0, 0.5] · [0.9, 0, 0.1] = 0.9 + 0 + 0.05 = 0.95।
  2. दूसरा number: [0, 1, 0.5] · [0.9, 0, 0.1] = 0 + 0 + 0.05 = 0.05।

नया vector [0.95, 0.05] है, और इसमें 2 rows × 3 numbers = 6 गुणा लगे। ColBERT में matrix की 128 rows हैं, और हर row में 768 numbers, इसलिए हर token पर 128 × 768 = 98,304 गुणा लगते हैं। Matrix के numbers training सीखती है। Paper ने 128 इसलिए चुना, क्योंकि छोटे vectors index की जगह घटाते हैं, और पड़ाव 8 में इसका हिसाब है। paper से

Training: एक सही और एक गलत passage

ColBERT की training lesson 12 जैसी है। हर example तीन चीज़ों का है: query q, एक सही passage d+ और एक गलत passage d−। ColBERT दोनों के MaxSim निकालता है, और उन पर softmax और −ln वाला loss लगाता है। ये lesson 12 का है, एक negative के साथ। Batch में 32 ऐसे examples होते हैं। paper से

MaxSim scores 1.85 और 1.05 पर, जहाँ FAQ सही passage है और upload note गलत, loss ऐसे निकलता है:

  1. Lesson 12 की तरह हर score का लीजिए, जहाँ e करीब 2.718 है: e1.85 = 6.36, और e1.05 = 2.86। दोनों का जोड़ 9.22 है।
  2. FAQ का हिस्सा: 6.36 ÷ 9.22 = 0.690।
  3. Loss: −ln 0.690 = 0.371। जाँच: e−0.371 = 0.690।

Late interaction का अपना कोई parameter नहीं है, क्योंकि max और जोड़ कुछ नहीं सीखते। Training सिर्फ़ BERT, linear layer और [Q] और [D] के vectors बदलती है। paper से

Loss से training किन tokens तक पहुँचती है, ये lesson 12 वाली बताती है: एक input थोड़ा बदलिए, और output का बदलाव देखिए। FAQ के error वाले column में तीन तरह के cells हैं:

कौन सा cell 0.01 बढ़ाColumn का maxदर
error वाला, 0.9 से 0.910.9 से 0.911
4012 वाला, 0.1 से 0.110.9 ही0
grading वाला, 0 से 0.010.9 ही0

इसलिए हर query token के लिए training सिर्फ़ उस passage token तक पहुँचती है, जिसने max दिया। इस query पर FAQ के error और 4012 के vectors को दर मिलती है, और grading, late, days और zoom को 0।

8कीमत का हिसाब: index के bytes, FLOPs और 61 ms

Index के bytes: vectors × numbers × bytes

Index की जगह तीन numbers का गुणा है: vectors की गिनती, हर vector के numbers, और हर number के bytes। Lesson 10 में एक आम number 4 bytes का था, यानी 32 bits। Paper 16 bits वाले, यानी 2 bytes के numbers भी आज़माता है। paper से पड़ाव 3 के 60,000 passages पर, 4 bytes हर number के साथ: हिसाब मेरा

चीज़Bi-encoder, 768 numbersColBERT, 128 numbers
Vectors60,00060,00,000
हर vector के bytes768 × 4 = 3,072128 × 4 = 512
कुल bytes18.4 करोड़, यानी 184 MB307.2 करोड़, यानी 3.07 GB

Vectors 100 गुना हैं, लेकिन हर vector 768 ÷ 128 = 6 गुना छोटा है। इसलिए bytes में फ़र्क 100 ÷ 6 = करीब 16.7 गुना है, और जाँच: 3.07 GB ÷ 184 MB = 16.7। 2 bytes वाले numbers लें, तो ColBERT का index आधा, यानी 1.54 GB रह जाता है। मतलब index का size tokens की गिनती के साथ सीधा बढ़ता है: tokens दोगुने, तो bytes भी दोगुने। Stanford की slide इसी बात को Index size: tokens, not documents कहती है।

Paper MS MARCO के index का size GiB में देता है। 1 GiB = 230 = 1,07,37,41,824 bytes है, यानी lesson 10 वाले GB से करीब 7% बड़ा। paper से

Settingहर vector के bytesIndexMRR@10
Rerank, cosine128 × 4 = 512286 GiB34.9
Rerank, L2128 × 2 = 256143 GiB34.8
End-to-end, L2128 × 2 = 256154 GiB36.0
Rerank, cosine24 × 2 = 4827 GiB33.9

पहली row से vectors गिनिए: 286 × 1,07,37,41,824 ÷ 512 = करीब 60 करोड़ token vectors। इन्हें 88 लाख passages से भाग दें, तो हर passage में औसतन करीब 68 vectors हैं। दूसरी row में 143 GiB ÷ 256 bytes से भी यही 60 करोड़ आता है। ये हिसाब मानता है कि पूरी जगह vectors की है। End-to-end वाली row 143 से 11 GiB बड़ी है, और मेरे अंदाज़े से ये फ़र्क पड़ाव 9 वाले search index का है। मेरा हिसाब, paper की table से

एक vector per passage वाला 768 numbers का index इन्हीं 88 लाख passages पर 88 लाख × 3,072 = 2,703 करोड़ bytes, यानी 25.2 GiB लेता। 286 GiB उसका करीब 11 गुना है। हिसाब मेरा Paper की आख़िरी row सबसे सस्ती है: 24 numbers, हर number 2 bytes, और कुल 27 GiB। ये 286 GiB से 10.6 गुना छोटी है, और MRR@10 सिर्फ़ 34.9 से 33.9 पर आता है।

FLOPs गिनना: query का BERT एक बार, MaxSim हर passage पर

पड़ाव 3 में FAQ के MaxSim के 72 FLOPs गिने थे: 12 dot products, और हर एक में 3 गुणा और 3 जोड़। असली ColBERT में यही गिनती बड़े numbers से होती है: मेरा हिसाब, औसत 68 vectors per passage मानकर

  1. Query के 32 vectors और passage के करीब 68 vectors, यानी 32 × 68 = 2,176 dot products।
  2. हर dot product में 128 गुणा, यानी 2,176 × 128 = 2,78,528 गुणा, और इतने ही जोड़। एक passage पर करीब 5.6 लाख FLOPs।
  3. 1,000 passages पर 5.6 लाख × 1,000 = 56 करोड़ FLOPs, यानी करीब 0.56B।

Table में ColBERT के कुल 7B FLOPs हैं, यानी MaxSim उनका छोटा हिस्सा है। Passages के vectors offline बने थे, इसलिए बाकी का बड़ा हिस्सा query के 32 tokens को BERT से गुज़ारने का है। ये बँटवारा मेरा अंदाज़ा है

Cross-encoder में एक passage पर ही 97T ÷ 1,000 = 97B FLOPs लगते हैं, क्योंकि वहाँ हर passage के साथ पूरा BERT चलता है। ये हिसाब lesson 14 के गहरे version में आया था।

Paper बताता है कि ये फ़र्क rerank होने वाले passages की गिनती k के साथ बढ़ता है। k = 10 पर BERT को ColBERT से करीब 180 गुना FLOPs चाहिए, k = 1,000 पर 13,900 गुना, और k = 2,000 पर 23,000 गुना। paper से इसकी वजह ऐसे निकलती है: हिसाब मेरा

  1. Cross-encoder हर passage पर बराबर काम करता है, इसलिए k = 10 पर उसके FLOPs 10 × 97B = 970B हैं।
  2. ColBERT के FLOPs उसका 180वाँ हिस्सा हैं: 970B ÷ 180 = करीब 5.4B।
  3. k = 1,000 पर ColBERT 7B पर है, और 7 ÷ 5.4 = 1.3।

मतलब 100 गुना passages पर ColBERT का काम सिर्फ़ करीब 1.3 गुना हुआ, क्योंकि query का BERT हर हाल में एक बार चलता है। Cross-encoder का काम उसी दौरान 100 गुना हुआ।

61 ms कहाँ खर्च होते हैं

Paper के मुताबिक ColBERT के 61 ms में query को encode करना और MaxSim सिर्फ़ 13 ms लेते हैं। बाकी 61 − 13 = 48 ms passages के vectors को memory से इकट्ठा करके GPU तक पहुँचाने में जाते हैं। ये समय एक Tesla V100 GPU पर नपा। 10,700 ÷ 61 = करीब 175, और paper इसे 170 गुना से ज़्यादा तेज़ कहता है। paper से

Rerank वाला ColBERT BM25 की list पर टिका है, इसलिए उसका पूरा समय BM25 जोड़कर बनता है। Anserini का BM25 एक CPU thread पर 62 ms लेता है, इसलिए 62 + 61 = 123 ms। Paper अपने पहले graph में यही जोड़ लेता है। paper से End-to-end ColBERT के 458 ms में कोई BM25 नहीं है, उसमें पड़ाव 9 के दोनों stages हैं।

9End-to-end search: पहले उम्मीदवार passages, फिर उन पर पूरा MaxSim

88 लाख passages में से हर एक का पूरा MaxSim बहुत महँगा है। Index में करीब 60 करोड़ token vectors हैं। 32 query vectors के साथ हर query पर 32 × 60 करोड़ × 128 = करीब 2.5 trillion गुणा लगते। हिसाब मेरा इसलिए paper दो stages में ढूँढता है, और दोनों ColBERT के ही vectors पर चलते हैं: paper से

  1. Candidate generation, यानी उम्मीदवार निकालना: query के हर vector के लिए index में सबसे पास वाले token vectors ढूँढिए। हर मिला vector किसी passage का है, इसलिए उसका passage उम्मीदवार बनता है।
  2. पूरा MaxSim: सिर्फ़ इन उम्मीदवार passages पर पड़ाव 2 वाला MaxSim निकालिए, और उन्हें sort कीजिए।

ये एक छोटा cascade है, जो ColBERT के अंदर चलता है: सस्ता stage पहले, और पूरा हिसाब आख़िर में।

हमारे दो passages के साथ Homework 1 की announcement भी जोड़िए। उसके 3 tokens हैं: homework [0.1, 0, 0.9], due [0, 0, 1] और friday [0, 0, 1]। अब index में 6 + 3 + 3 = 12 token vectors हैं। vectors मेरे बनाए हैं Stage 1 में हर query vector अपने 2 सबसे बड़े dot products वाले token vectors लाता है:

Query का vectorसबसे पास के 2 token vectorsउनके passages
error [1, 0, 0]upload note का errors (0.95), FAQ का error (0.9)Upload note, FAQ
4012 [0, 1, 0]FAQ का 4012 (0.95), upload note का upload (0.1)FAQ, upload note

उम्मीदवार FAQ और upload note हैं। Homework announcement का कोई भी token query के किसी token से 0.1 से ज़्यादा dot product नहीं देता। इसलिए वो उम्मीदवार नहीं बना, और उसका MaxSim कभी नहीं निकला। Stage 2 में FAQ को 1.85 और upload note को 1.05 मिलते हैं, ठीक पड़ाव 2 की तरह।

इस छोटे example में stage 1 ने 2 × 12 = 24 dot products लिए, और stage 2 ने 2 × (6 + 3) = 18। यहाँ stage 1 हर vector देखता है, इसलिए कुछ नहीं बचा। असली index में stage 1 हर vector नहीं देखता: paper से

Clusters बराबर हों, तो हर query vector 10 ÷ 2,000 = 0.5% vectors देखता है, यानी 60 करोड़ में से करीब 30 लाख। Stage 2 में 32,000 उम्मीदवारों पर भी 32,000 × 2,78,528 = करीब 8.9 billion गुणा लगते हैं, जो 2.5 trillion से करीब 280 गुना कम है। हिसाब मेरा Faiss यहाँ सारे CPU cores पर चलता है, और दोनों stages मिलाकर 458 ms लगते हैं। paper से

End-to-end में paper similarity के लिए cosine की जगह L2 दूरी लेता है, क्योंकि उसका faiss index L2 पर तेज़ था। इसीलिए table में ColBERTL2 लिखा है। paper से lesson 10 की है। लंबाई 1 वाले vectors पर दूरी² = 2 − 2 × cosine होती है, इसलिए दोनों एक ही क्रम देते हैं। जाँच: [1, 0] और [0.6, 0.8] का cosine 0.6 है, और दूरी² = 0.4² + 0.8² = 0.8 = 2 − 1.2।

फिर भी table में L2 वाला rerank 34.8 पर है, और cosine वाला 34.9 पर। मेरी समझ से ये दो अलग train हुए models हैं, और L2 वाला हर number 2 bytes में रखता है।

End-to-end के नतीजे

Paper की end-to-end table में हर retriever 88 लाख passages में से खुद top-1,000 लाता है। MRR@10 (Dev) MS MARCO के official dev set पर है, जिसमें करीब 7,000 सवाल हैं। paper से

RetrieverMRR@10Recall@50Recall@1000
BM25 (official)16.7–81.4
BM25 (Anserini)62 ms18.759.285.7
docTTTTTquery87 ms27.775.694.7
ColBERTL2, rerank34.875.381.4
ColBERTL2, end-to-end458 ms36.082.996.8

Table की बाकी rows भी BM25 पर ही चलती हैं, लेकिन index बनाने से पहले passages को बदलती हैं। doc2query और docTTTTTquery हर passage में एक model से बने कुछ सवाल जोड़ देते हैं। DeepCT, BERT से हर शब्द का वज़न तय करता है। paper से

Slide पर MRR@10 के दो और columns भी हैं। Eval official evaluation set है, जिसके labels Microsoft अपने पास रखता है। Local Eval paper का अपना 5,000 सवालों का set है, जो MS MARCO के extra labeled सवालों से लिया गया। paper से

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

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

Stanford slide: Late Interaction: Score Tokens, Not Documents
उसी slide की परिभाषा वाली line, बड़ी करके
Stanford की late interaction वाली slide, और नीचे उसकी परिभाषा वाली line, बड़ी करके। Formula और diagrams पड़ाव 5 और 6 में बड़े करके दिखे थे।

Late interaction वाली slide पढ़िए

  1. परिभाषा कहती है encode query and passage independently। Diagram (c) में ये बात सच क्यों नहीं है?

    जवाब देखिए

    (c) में हरे और नीले boxes के बीच हर layer पर lines हैं, यानी attention query और passage के tokens को मिलाता है। इसलिए passage का हर vector query पर टिका है, और पहले से नहीं बन सकता। (पड़ाव 6)

  2. Formula में ∑ और max की जगह बदल दीजिए। यानी passage के हर token के लिए query के tokens में से max, फिर passage के tokens पर जोड़। FAQ और upload note को अब कितना मिलेगा?

    जवाब देखिए

    FAQ में चार tokens के max 0 हैं, error का 0.9 और 4012 का 0.95, यानी 1.85। Upload note में upload का 0.8, errors का 0.95 और happen का 0.5, यानी 2.25। हिसाब मेरा अब गलत upload note आगे है, क्योंकि जोड़ में हर passage token एक term बनता है। Slide का formula query के tokens पर जोड़ता है, इसलिए हर passage को उतने ही terms मिलते हैं, जितने query में tokens हैं। (पड़ाव 2 और 5)

  3. Diagram (d) में MaxSim के नीचे हरे और नीले boxes के बीच कोई line नहीं है। इसका ColBERT की speed से क्या रिश्ता है?

    जवाब देखिए

    Passage के vectors query देखे बिना बनते हैं, इसलिए ColBERT उन्हें offline index में रख सकता है। सवाल आने पर सिर्फ़ query का BERT चलता है, और बाकी MaxSim है। (पड़ाव 2 और 6)

Stanford slide: General Architecture of ColBERT
Stanford की ColBERT ढाँचे वाली slide। उसका diagram पड़ाव 7 में बड़ा करके दिखा था।

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

  1. Offline Indexing वाला grey box सिर्फ़ document की तरफ़ क्यों है?

    जवाब देखिए

    Passage के vectors query के बिना बनते हैं, इसलिए सवाल से पहले बन सकते हैं। Query सवाल आने पर ही पता चलती है, इसलिए उसका encoder online चलता है। (पड़ाव 2)

  2. Slide पर तीन MaxSim boxes हैं। Paper की असली query में कितने होते, और क्यों?

    जवाब देखिए

    32, क्योंकि paper हर query को [mask] tokens से 32 tokens तक भरता है, और हर query vector का अपना एक MaxSim है। (पड़ाव 7)

  3. fQ और fD दो अलग boxes हैं। Paper में ये असल में कितने अलग हैं?

    जवाब देखिए

    दोनों एक ही BERT हैं। फ़र्क बस इतना है: query के आगे [Q] जुड़ता है, और passage के आगे [D]। Query में [mask] भरते हैं, और passage से punctuation के vectors हटते हैं। (पड़ाव 7)

Stanford slide: ColBERT vs. Other Approaches, दो tables
उसी slide की ऊपर वाली end-to-end table, बड़ी करके
उसी slide की नीचे वाली rerank table, बड़ी करके
Stanford की ColBERT vs. Other Approaches वाली slide, और नीचे उसकी दोनों tables, बड़ी करके। ऊपर वाली end-to-end search की है, और नीचे वाली rerank की।

ColBERT vs. Other Approaches वाली slide पढ़िए

  1. नीचे वाली table में KNRM के FLOPs 592M (0.085×) हैं, यानी ColBERT से कम। फिर भी ColBERT को बेहतर क्यों कहते हैं?

    जवाब देखिए

    KNRM का MRR@10 सिर्फ़ 19.8 है, और ColBERT का 34.9। 592M ÷ 7B = 0.085, यानी KNRM सस्ता है, लेकिन बहुत कम सटीक। KNRM ढाँचा (b) का पुराना model है, और उसमें BERT नहीं है। (पड़ाव 6 और 8)

  2. ऊपर वाली table में ColBERTL2 (re-rank) का Recall@1000 81.4 है, और end-to-end का 96.8। ये फ़र्क कहाँ से आता है?

    जवाब देखिए

    Rerank वाला ColBERT official BM25 के top-1,000 को sort करता है, इसलिए उसका recall BM25 के 81.4 पर रुक जाता है। End-to-end वाला candidate generation से पूरे 88 लाख passages में खुद ढूँढता है। (पड़ाव 9)

  3. ऊपर वाली table में Latency column में ColBERT end-to-end के आगे 458 है, और re-rank के आगे –। नीचे वाली table में ColBERT के आगे 61 क्यों है?

    जवाब देखिए

    नीचे की 61 ms सिर्फ़ rerank का समय है, BM25 के बिना। ऊपर की table पूरी search का समय देती है। Rerank वाले ColBERT का पूरा समय 62 + 61 = 123 ms बनता, और end-to-end के 458 ms में दोनों stages हैं। (पड़ाव 8 और 9)

Stanford slide: Fast vs Slow Retrievers
उसी slide की ColBERT वाली row, बड़ी करके
Stanford की तुलना वाली slide, और नीचे उसकी ColBERT वाली row, बड़ी करके। Lesson 11, 12 और 14 ने बाकी rows पढ़ी थीं।

तुलना वाली slide की ColBERT row पढ़िए

  1. Breaks on में लिखा है Index size: tokens, not documents। हमारे 60,000 passages पर ये कितने bytes बनता है?

    जवाब देखिए

    60 लाख vectors × 512 bytes = 3.07 GB, जबकि bi-encoder का index 184 MB है, यानी करीब 16.7 गुना। Vectors 100 गुना हैं, लेकिन हर vector 6 गुना छोटा। (पड़ाव 3 और 8)

  2. 458 ms end-to-end को middle क्यों कहा है, जबकि rerank वाला ColBERT 61 ms लेता है?

    जवाब देखिए

    458 ms में ColBERT पूरे 88 लाख passages में खुद ढूँढता है, candidate generation और पूरे MaxSim के साथ। 61 ms सिर्फ़ BM25 की 1,000 passages वाली list का rerank है। 458 ms, BM25 के 62 ms से धीमा है, और cross-encoder के 10,700 ms से बहुत तेज़। (पड़ाव 8 और 9)

  3. Wins on में Token-level evidence at scale लिखा है। हमारे example में token-level evidence क्या था?

    जवाब देखिए

    FAQ के 4012 token ने अपने अलग vector से query के 4012 को 0.95 का match दिया। औसत में यही token दब गया था। ColBERT ये match 88 लाख passages के पैमाने पर भी ढूँढ लेता है। (पड़ाव 2 और 9)

इस lesson की 3 बातें

  1. एक vector वाला bi-encoder लंबे passage के एक ज़रूरी token को औसत में दबा सकता है। Error 4012 पर FAQ का cosine 0.32 रहा, और गलत upload note का 0.73। MaxSim में max की जगह औसत लें, तो यही गलती लौटती है, 0.325 बनाम 0.8।
  2. ColBERT हर token का 128 numbers का, लंबाई 1 वाला vector रखता है। MaxSim query के हर vector का सबसे बड़ा dot product जोड़ता है। Index tokens के साथ बढ़ता है: MS MARCO पर 286 GiB, यानी मेरे हिसाब से करीब 60 करोड़ vectors।
  3. Rerank में ColBERT cross-encoder जितना सटीक है, और करीब 13,900 गुना कम FLOPs लेता है, क्योंकि query का BERT एक बार चलता है। End-to-end में candidate generation और फिर पूरा MaxSim Recall@1000 को 96.8 तक ले जाते हैं।

इस lesson के नए शब्द

Late interaction
Query और passage के token vectors अलग-अलग बनें, और सिर्फ़ scoring पर मिलें। जैसे ColBERT में passage के vectors offline बनते हैं, और dot products query आने पर।
MaxSim
Query के हर token का passage के tokens से सबसे बड़ा dot product, फिर सबका जोड़। जैसे course FAQ पर 0.9 + 0.95 = 1.85।
ColBERT
Late interaction वाला retriever, जो हर token का vector रखता है और MaxSim से score देता है। 2020 में Khattab और Zaharia ने बनाया। जैसे MS MARCO पर उसका Recall@1000 96.8 है।
Latency
Query भेजने से जवाब आने तक का समय, ms में। जैसे cross-encoder की latency 1,000 passages पर 10,700 ms है, और ColBERT rerank की 61 ms।
FLOPs
कितने गुणा और जोड़ लगे, यानी computer का काम। जैसे 3 numbers वाले dot product में 6 FLOPs, और 768 numbers वाले में 1,536।
Cascade
Retrievers की line, जिसमें हर अगला step कम passages पर ज़्यादा सटीक और महँगा काम करता है। जैसे करोड़ों से 1,000, फिर 50, फिर 5।
Interaction matrix
Query के हर token और passage के हर token की similarity की table। जैसे FAQ वाली table में 6 × 2 = 12 dot products।
Query augmentation
Query को [mask] tokens से 32 tokens तक भरना। BERT इनके भी vectors बनाता है, और वो MaxSim में extra query tokens की तरह जुड़ते हैं।
GiB
230 = 1,07,37,41,824 bytes, यानी GB से करीब 7% बड़ा। जैसे MS MARCO पर ColBERT का index 286 GiB है।
Candidate generation
सस्ते तरीके से उम्मीदवार passages निकालना, ताकि महँगा हिसाब सिर्फ़ उन पर चले। जैसे ColBERT में हर query vector के top-1,000 token vectors, यानी ज़्यादा से ज़्यादा 32,000 passages।