CS 329Z · Engineering AI Agents · Lecture 3

RAG + Agents, पहली नींव से

ये lecture एक सवाल पर टिका है: LLM को सही जानकारी सही वक्त पर कैसे दें, और ये तरीका कहाँ टूटता है। यहाँ वो सवाल 18 lessons में बँटा है, और सारे तैयार हैं। हर lesson पिछले lessons पर बनता है, और हर नया शब्द वहीं समझाता है, जहाँ वो पहली बार आता है।

कैसे पढ़ें

मैंने माना है कि आप code पढ़ लेते हैं और school का गणित जानते हैं, लेकिन ML और statistics के शब्द आपके लिए नए हैं। कोई lesson बहुत आसान या बहुत भारी लगे, तो बताइए।

Lessons का नक्शा

ये नक्शा बताता है कि कौन सा lesson किस पर टिका है। हर line एक dependency है: नीचे वाले lesson को ऊपर वाला चाहिए। एक ही row के lessons एक-दूसरे पर नहीं टिके, इसलिए उन्हें किसी भी क्रम में पढ़ सकते हैं।

किसी lesson पर click कीजिए। नक्शा दिखाएगा कि उससे पहले क्या चाहिए, वो आगे क्या खोलता है, और कौन से lessons उससे आज़ाद हैं।

नींव: बाकी सब इन पर टिके हैं मुख्य रास्ता गहराई: पहली बार छोड़ सकते हैं

Lines हर lesson की “पहले से क्या चाहिए” line से बनी हैं। जो dependency किसी दूसरे रास्ते से पहले ही आ जाती है, उसकी line नहीं दिखाई। नींव, मुख्य और गहराई वाला बँटवारा मेरा है। गहराई वाले lessons पर आगे के दो ही lessons टिके हैं। Lesson 18 सबको जोड़ता है, और lesson 10 को lesson 9 से clustering और graph के शब्द चाहिए।

18 lessons

हर lesson पिछले lesson की एक कमी से शुरू होता है।

  1. 1LLM जवाब कैसे लिखता है, और कहाँ फँसता हैOffice hours वाले सवाल पर अकेले LLM ने queue log देखे बिना भरोसे से Wednesday लिखा। ये lesson दिखाता है कि LLM जवाब token by token कैसे बनाता है, और data न हो तो कहाँ फँसता है।LLM, Token, Vocabulary, Tokenizer, Probability, Next-token prediction, Parameters (weights), Training, Parametric knowledge, Knowledge cutoff, Prompt, Context window, Hallucinationआसान · गहरा
  2. 2Retrieval: जवाब लिखने से पहले ढूँढनाLLM सिर्फ़ उन्हीं बातों से जवाब लिखता है, जो उसके prompt में हैं, और prompt में 60,000 में से 14 passages ही समाते हैं। हर सवाल पर वो 14 passages चुनने का सबसे सीधा तरीका बनाना है।Corpus (collection), Document, Passage, Query, Retrieval, Citation, Non-parametric memory, Retriever, Score, Top-K, Word overlap, Stopwords, Reader, Zero-shot, Recall, Recall ceilingआसान · गहरा
  3. 3Text को numbers में बदलना: vectors और similarityQuery “when can I get help from a TA” और जवाब वाले office hours page में एक भी शब्द common नहीं है। इसलिए word overlap ने हर passage को 0 दिया। Text को vectors में बदलकर उनकी तुलना करनी है।Vector, Dimension, Dot product (inner product), ∑ (sigma), Length, Cosine similarity, Normalize, Embedding, Embedding model (encoder), Index, Offline और onlineआसान · गहरा
  4. 4Probability के औज़ार: RAG का formula पढ़ने की तैयारीRetriever का score 1.56 और LLM की probability 0.81 सीधे नहीं जुड़ते, लेकिन lesson 5 का RAG formula इन्हीं से जवाब की probability बनाता है। ये lesson वो औज़ार बनाता है, जिनसे आप वो formula हाथ से चला सकें।Conditional probability, p(A|B), Chain rule (probability वाला), ∏ (capital pi), Marginalization, ≈, exp और e, Softmax, ∝, d⊤q, Natural log, ln, Loss, Likelihood, Negative log-likelihood, Gradientआसान · गहरा
  5. 5RAG model: retriever और generator एक साथLesson 4 के आख़िर में retriever ने पुराने forum post को ज़्यादा वज़न दिया, और सही जवाब का chance 0.685 से 0.315 पर गिर गया। Retriever को सुधारना है, जबकि training data में सिर्फ़ सवाल और जवाब हैं।RAG, Latent variable, η और θ, BERT, MIPS, Generator, Encoder-decoder, Concatenate, RAG-Sequence, RAG-Token, End-to-end training, Backpropagation, Exact Match, Closed book और open bookआसान · गहरा
  6. 6RAG pipeline: Naive, Advanced और ModularAPI वाले LLM को आप train नहीं कर सकते, इसलिए lesson 2 की दोनों गलतियाँ लौट आती हैं। उन्हें LLM से पहले के steps में सुधारना है।Frozen LLM, Pipeline, Naive RAG, Indexing time और query time, Pre-retrieval, Query routing, Query rewriting, Query expansion, Post-retrieval, Rerank और reranker, Summary, Fusion, Advanced RAG, Modular RAG, Pattern, Demonstrations (few-shot), Multi-hop questionआसान · गहरा
  7. 7Chunking: document को retrieval के टुकड़ों में काटना40 pages का syllabus हर 50 tokens पर कटा, तो milestone की तारीख दो chunks में टूट गई। न काटें, तो पूरे syllabus के एक vector में milestone की 2 lines घुल जाती हैं।Word type और token in context, Static word embedding, Contextual embedding, Passage embedding, Multimodal embedding, Graph embedding, Mean pooling, Chunk, Fixed-size chunking, Overlap, Stride, Semantic chunking, Context-enriched chunking, Metadata, AI-driven dynamic chunkingआसान · गहरा
  8. 8Chunk का खोया context वापस लानाकाटने के बाद ACME वाले chunk में न company का नाम बचा, न quarter, इसलिए retriever उसे 49 मिलते-जुलते chunks से अलग नहीं कर पाता। Chunk को उसका खोया context वापस देना है।Context loss, Contextual retrieval, Failed retrievals@20, Naive chunking, Late chunking, Long-context encoderआसान · गहरा
  9. 9पूरे document पर फैले सवाल: RAPTOR और GraphRAG“सारी deadlines क्या हैं?” का जवाब तीन passages में बिखरा है, इसलिए top-K सिर्फ़ एक टुकड़ा ऊपर लाता है। Index में कई passages का सार चाहिए, ताकि पूरे document पर फैले सवाल का जवाब एक जगह मिले।Detail question और thematic question, Clustering, Cluster और centroid, Soft clustering, RAPTOR, Tree, node, leaf, root, Entity, Relation, Knowledge graph और edge, Community, GraphRAG, Query-focused summarizationआसान · गहरा
  10. 10करोड़ों vectors में तेज़ searchLesson 3 का retriever हर query पर index के हर vector से तुलना करता है। 10 करोड़ passages पर इसमें हर query करीब 7.7 seconds लेती है। कम vectors देखकर ज़्यादातर बार वही सबसे पास वाले vectors ढूँढने हैं।Exact search (brute force), Big-O, O(N·d), Nearest neighbors, ANN, दूरी, IVF, nprobe, Product quantization (PQ), Codebook, Proximity graph, Greedy search, HNSWआसान · गहरा
  11. 11BM25: rare शब्द, गिनती और length से बना scoreLesson 2 के word overlap ने queue log और पुराने forum post को बराबर 2 दिया। हर शब्द को rarity, गिनती और length से वज़न देकर ये tie तोड़ना है, और देखना है कि वो किस तरफ़ टूटता है।Term, Document frequency, n(q), IDF, TF-IDF, Term frequency, f(q, D), Saturation और k1, Length normalization, b और avgdl, BM25, Inverted index, Sparse और dense vectorआसान · गहरा
  12. 12DPR: सवाल-passage जोड़ों से train हुआ retrieverBM25 ने पुराने forum post को queue log से ऊपर रखा। दो encoders को सवाल-passage जोड़ों से train करके सही passage ऊपर लाना है।DPR, Bi-encoder, Pretraining, Fine-tuning, Positive और negative passage, Contrastive loss, Batch, In-batch negatives, Hard negative, Top-k retrieval accuracyआसान · गहरा
  13. 13Retriever को नापना: Hit@k, MRR, Recall@k और nDCGRetriever सुधरा, दूसरे सवाल का सही passage ऊपर आया, फिर भी top-3 वाली गिनती 0.667 पर अटकी रही। ऐसे numbers बनाने हैं, जो ये बदलाव देख सकें।Relevance labels, Set, ∩, ∅, |A|, 𝟙[शर्त], Hit@k, Failed@k, MRR@k, Recall@k, log2, DCG और IDCG, nDCG@kआसान · गहरा
  14. 14Hybrid search और rerankingBM25 ने E2 को तीसरे rank पर रखा, dense ने पहले। दोनों lists को एक list में मिलाना है, और फिर ऊपर के passages को query के साथ पढ़कर उनका क्रम सुधारना है।Paraphrase, Literal, Hybrid search, Reciprocal rank fusion (RRF), Attention, Cross-encoder, Reranking, Shortlistआसान · गहरा
  15. 15ColBERT: हर token का अपना vectorQuery error 4012 पर एक vector वाले bi-encoder ने छोटे, गलत upload note को जवाब वाले लंबे FAQ से ऊपर रखा। हर token का अपना vector रखकर, और query के हर token का सबसे अच्छा match जोड़कर, सही passage ऊपर लाना है।Late interaction, MaxSim, ColBERT, Latency, FLOPs, Cascadeआसान · गहरा
  16. 16Agentic RAG: ढूँढना एक फ़ैसला हैBM25 ने पुराने forum post को queue log से ऊपर रखा, और pipeline ने उसे बिना परखे prompt में भेज दिया। ढूँढना एक तय step की जगह हर कदम का फ़ैसला बने, और जो मिला उसे कोई परखे।Agent, Action और tool, Observation, Agentic RAG, Self-RAG, Reflection tokens, CRAG, Retrieval evaluator, Knowledge refinement, Thresholdआसान · गहरा
  17. 17Search-R1: कब और क्या search करें, ये सीखनाTraining data में सिर्फ़ सही जवाब था, search के steps नहीं। Model को कब और क्या search करना है, ये सिर्फ़ आख़िरी जवाब के reward से सीखना है।Reinforcement learning (RL), Policy, Rollout (trajectory), Reward, Search-R1, Advantage, PPO और value model, GRPO, Standard deviation, Reference LLM और KL penaltyआसान · गहरा
  18. 18RAG कहाँ टूटता है: ढूँढने, पढ़ने और loop की 9 failuresCitation सही दिखा, फिर भी जवाब गलत था, क्योंकि index में office hours page पुराना था। बाहर से हर गलत जवाब एक जैसा दिखता है, इसलिए पहले पहचानना है कि गलती ढूँढने में हुई, पढ़ने में, या agent के loop में।Stale index, Permission leak, Lost in the middle, Distraction, Evidence conflict, Compounding error, No stopping rule, Prompt injectionआसान · गहरा

Slides 2–8 course project के बारे में हैं, इसलिए किसी lesson में नहीं हैं।

अब तक के शब्द

सारे 18 lessons के नए शब्द, A से Z। हर शब्द उस lesson से link है, जहाँ वो समझाया है।

∑ (sigma)
नीचे लिखी range पर जोड़ते जाइए। जैसे i = 1 से 2 तक aibi का जोड़, यानी a1b1 + a2b2।
∏ (capital pi)
नीचे लिखी range पर सबका गुणा। जैसे तीन tokens पर 0.21 × 0.31 × 0.71 = 0.046।
≈
करीब बराबर। RAG के formula में सिर्फ़ top-K passages जुड़ते हैं, इसलिए जोड़ “करीब” बराबर है।
∝
के अनुपात में। आख़िर में सबको एक ही number से ऐसे भाग दीजिए कि जोड़ 1 हो। जैसे exps 2.718 और 1 से 0.731 और 0.269।
η और θ
Retriever (eta) और generator (theta) के parameters के नाम। इसीलिए retriever को pη(z|x) लिखते हैं, और generator को pθ(y|x, z)।
⌈x⌉ (ceiling)
x या उससे बड़ा सबसे छोटा पूरा number। जैसे ⌈23.75⌉ = 24, और chunks = ⌈(1,000 − 50) ÷ 40⌉ + 1 = 25।
दूरी
दो vectors के फ़र्क वाले vector की length। जैसे [0.8, 0.2] और [0.9, 0.1] का फ़र्क [0.1, −0.1] है, तो दूरी √(0.01 + 0.01) = 0.14।
∂ (partial derivative)
बाकी सब वैसा रखकर एक input थोड़ा बदलें, तो output किस दर से बदलता है। जैसे ∂𝓛/∂s+ = −0.814, यानी queue log का score 0.01 बढ़े, तो loss करीब 0.008 घटता है।
ℝ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 थीं।
𝟙[शर्त]
शर्त सच हो तो 1, नहीं तो 0। जैसे q3 के top-3 में कोई सही passage नहीं है, तो 𝟙[Rq3 ∩ Top3(q3) ≠ ∅] = 0।
⊆ (subset)
A ⊆ B का मतलब है कि A की हर चीज़ B में भी है। जैसे Top3(q1) ⊆ Top5(q1), इसलिए Recall@5 कभी Recall@3 से कम नहीं होता।
[CLS] और [SEP]
BERT के input के खास tokens। [CLS] सबसे आगे आता है, और cross-encoder में उसका आख़िरी vector पूरी जोड़ी की बात रखता है। [SEP] query और passage को अलग करता है, जैसे [CLS] query [SEP] passage [SEP]।
Ablation
Model का एक हिस्सा हटाकर या रोककर दोबारा नापना, ताकि उस हिस्से का असर दिखे। जैसे RAG-Sequence में query encoder रोकने पर NQ (dev) 44.0 से 41.2 पर आता है।
Action और tool
Agent का चुना काम, जैसे OH timings search करना। Tool वो program है, जो ये काम करता है, जैसे search engine।
Advanced RAG
Naive RAG में pre-retrieval और post-retrieval steps जोड़कर बनी pipeline। जैसे Rewrite, Retrieve, Rerank, Read।
Advantage
Rollout उम्मीद से कितना बेहतर या बुरा रहा। जैसे rewards 0, 0, 0, 1 में o4 का +1.73, और बाकी तीन का −0.58।
Agent
Loop में काम करने वाला LLM, जो action चुनता है, observation पढ़ता है, और अगला action तय करता है। जैसे OH timings की search खाली आई, तो agent ने नई query लिखी।
Agentic RAG
RAG, जिसमें ढूँढना agent का action है, pipeline का तय step नहीं। जैसे 17 × 3 पर 0 searches, और Jed Hoyer वाले सवाल पर 3।
AI-driven dynamic chunking
LLM से पूछकर काटना कि text में बात कहाँ बदलती है। हर document पर LLM calls लगती हैं।
ANN
Approximate nearest neighbor search: कम vectors देखकर ज़्यादातर बार सही neighbors ढूँढना। जैसे असली top-10 में से 9 मिलें, तो recall 0.9।
Attention
हर token बाकी tokens के vectors का वज़न वाला औसत लेकर अपना नया vector बनाता है, और वज़नों का जोड़ 1 होता है। जैसे crowded [0.5, 0.5] averaged [1.0, 0.0] को 0.6 वज़न दे, तो [0.8, 0.2] बनता है।
Backpropagation
Loss से पीछे की तरफ़ चलकर हर parameter का gradient निकालने का तरीका, छोटे में backprop। RAG में ये generator और query encoder तक जाता है, passage encoder तक नहीं।
BART
Text पढ़कर text लिखने वाला model, जिसमें करीब 400 million parameters हैं। RAG का generator यही है। जैसे Jeopardy test में अकेला BART सिर्फ़ 7.1% जोड़ों में ज़्यादा factual निकला।
Batch
Training में एक साथ चलने वाले सवालों का group। जैसे DPR में 128 सवालों का batch।
Beam search
हर कदम पर सबसे ऊँचे score वाले B अधूरे जवाब रखकर आगे बढ़ना। जैसे B = 2 पर queue log (2.15) और forum post (1.475) वाले जवाब अगले कदम तक रहते हैं, और Homework (0.425) छूटता है।
BERT
Google का 2018 का encoder model। RAG के retriever के दोनों encoders, query encoder और passage encoder, इसी से बने हैं।
Bi-encoder
सवाल और passage के लिए दो अलग encoders, और score उनका dot product। Passages पहले से encode होते हैं। जैसे 2.1 करोड़ passages हों, तब भी हर सवाल पर model 1 बार चलता है।
BIC
ln(N) · k − 2 ln(L̂): fit की likelihood और parameters की गिनती तौलकर clusters की गिनती चुनना, और सबसे छोटा BIC जीतता है। जैसे 6 passages पर K = 2 का BIC −23.64, और K = 3 का −20.11।
Big-O, O(N·d)
N या d बढ़ने पर खर्च किस हिसाब से बढ़ता है। जैसे O(N·d) में N दोगुना हो, तो खर्च भी दोगुना।
Bigram
साथ-साथ आने वाले दो शब्द। जैसे queue log में office hour, और forum post में least crowded।
BM25
हर query term का IDF × TF हिस्सा, सब terms का जोड़। जैसे forum post का 2.749, और queue log का 2.473।
Candidate generation
सस्ते तरीके से उम्मीदवार passages निकालना, ताकि महँगा हिसाब सिर्फ़ उन पर चले। जैसे ColBERT में हर query vector के top-1,000 token vectors, यानी ज़्यादा से ज़्यादा 32,000 passages।
Cascade
Retrievers की line, जिसमें हर अगला step कम passages पर ज़्यादा सटीक और महँगा काम करता है। जैसे करोड़ों से 1,000, फिर 50, फिर 5।
Chain rule (probability वाला)
p(A और B) = p(A) × p(B|A)। कई steps हों, तो सबका गुणा। जैसे p(Tuesday) × p(भरा | Tuesday) = 0.5 × 0.8 = 0.40। Lesson 12 का दरों वाला chain rule इससे अलग है।
Chain rule (दरों वाला)
एक के बाद एक जुड़ी दरें गुणा होती हैं। जैसे queue log के score पर ln Z की दर 2.72 × (1 ÷ 14.59) = 0.186 है। Lesson 4 का probability वाला chain rule इससे अलग है।
Chunk
Retrieval के लिए document का एक टुकड़ा, और retrieval की basic unit। जैसे 40 pages के syllabus का Grading वाला हिस्सा।
Citation
जवाब के साथ उसका source। जैसे “Thursday 9am [P3]” में [P3], यानी queue log।
Clipping और ε
Ratio को 1 − ε से 1 + ε के बीच रोकना, और फिर min से छोटा term लेना। जैसे ε = 0.2 और A = +1.73 पर ratio 1.5 का term 2.076 पर रुकता है।
Closed book और open book
सिर्फ़ parameters से जवाब, या पहले documents में ढूँढकर जवाब। जैसे NQ पर closed book T5-11B 34.5, और open book RAG-Sequence 44.5।
Cluster और centroid
Cluster एक group है, और centroid उसके vectors का औसत। जैसे [0.1, 0.9], [0.2, 0.8] और [0.15, 0.85] का centroid [0.15, 0.85]।
Clustering
Vectors को ऐसे groups में बाँटना कि एक group के vectors आपस में पास हों। जैसे syllabus [0.1, 0.9] और project page [0.2, 0.8] का cosine 0.99 है, तो दोनों एक group में।
Codebook
हर टुकड़े के नमूना vectors (codewords) की list। जैसे #0 [1, 0], #1 [0, 1], #2 [0.5, 0.5], #3 [0.7, 0.7]।
ColBERT
Late interaction वाला retriever, जो हर token का vector रखता है और MaxSim से score देता है। 2020 में Khattab और Zaharia ने बनाया। जैसे MS MARCO पर उसका Recall@1000 96.8 है।
Column vector और ⊤
Column vector के numbers ऊपर-नीचे लिखे होते हैं, और ⊤ (transpose) उसे row बना देता है। Row गुणा column dot product है। जैसे row [0.9, 0.1] गुणा column [0.8, 0.2] = 0.74।
Community
Graph का आपस में बहुत जुड़ा हिस्सा। जैसे Office hours, TAs, Room 104 और Zoom।
Compounding error
पहले कदम की गलती आगे के हर कदम में जाए। जैसे हर कदम 0.9 पर सही हो, तो 3 कदम 0.729, और 5 कदम 0.59।
Concatenate
दो texts को आगे-पीछे जोड़कर एक text बनाना। जैसे question: … के बाद passage: … जोड़ना।
Conditional probability, p(A|B)
B पता हो, तो A की probability। “|” को “given” पढ़िए। जैसे p(भरा | Tuesday) = 16 ÷ 20 = 0.80।
Context loss
काटने के बाद chunk ये न बता पाए कि वो किस document या विषय की बात है। जैसे The company’s revenue grew by 3% में company का नाम नहीं है।
Context window
Model एक बार में ज़्यादा से ज़्यादा कितने tokens पढ़ सकता है। Prompt और जवाब, दोनों इसमें आते हैं। जैसे 8,000 की window में 7,500 का prompt हो, तो जवाब के लिए 500 बचते हैं।
Context-enriched chunking
हर chunk के साथ metadata या summary रखना। जैसे हर chunk के ऊपर Source: CS 329Z syllabus, section: Grading।
Contextual embedding
हर token का अपने sentence के हिसाब से अलग vector। जैसे BERT। Late days may not be applied में late [0.1, 0.9] है, और late afternoon office hours में [0.9, 0.1]। मेरे numbers
Contextual retrieval
हर chunk के आगे LLM का लिखा 50–100 tokens का context जोड़कर index करना। जैसे From ACME Corp’s Q2 2023 SEC filing।
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।
Corpus (collection)
सारे documents का set। जैसे company के 2,000 documents, या इस course के 6 छोटे texts।
Cosine similarity
Dot product ÷ दोनों lengths का गुणा। सिर्फ़ दिशा देखता है, −1 से 1 के बीच। जैसे 0.74 ÷ (0.82 × 0.91) = 0.99।
CRAG
Corrective RAG: एक evaluator retrieval को Correct, Incorrect या Ambiguous कहता है, और उसी हिसाब से refinement, web search या दोनों चलते हैं। जैसे 0.4 वाला forum post Ambiguous है।
Critic
किसी और के लिखे या लाए को grade देने वाला model। जैसे Self-RAG में Llama 2 7B का critic training data में reflection tokens लगाता है, और CRAG की slide अपने evaluator को critic कहती है।
Cross-encoder
Query और passage को जोड़कर एक model में डालने वाला reranker, जो जोड़ी का सीधा score देता है। ये हर passage पर पूरा चलता है, जैसे BERT-base में 10.7 ms per passage।
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।
Decomposable similarity
ऐसा score, जो सवाल के vector और passage के vector से निकले, और passage का vector सवाल देखे बिना बने। तभी offline index बन सकता है। जैसे dot product, cosine और दूरी।
Demonstrations (few-shot)
Prompt में सवाल से पहले दिए गए हल किए हुए examples। जैसे “Q: When is the milestone due? A: Week 6, Thursday [P1]”।
Detail question और thematic question
जवाब एक जगह लिखा हो, या कई passages को मिलाकर बने। जैसे “milestone कब है?” और “सारी deadlines क्या हैं?”।
Dimension
Vector में कितने numbers हैं। जैसे [0.9, 0.1] का dimension 2 है, और BERT-base के vectors का 768।
Distant supervision
सिर्फ़ सवाल-जवाब वाले data के लिए paragraph अपने आप ढूँढना: retriever चलाइए, और जिन passages में जवाब का text हूबहू है, उन्हें रखिए। जैसे milestone वाले सवाल पर syllabus।
Distraction
मिलता-जुलता लेकिन बेकार passage reader को भटका दे। जैसे 2024 का पुराना forum post।
Document
Corpus की एक चीज़: web page, file या email। जैसे course का syllabus।
Document frequency, n(q)
कितने documents में term q है। जैसे milestone का n = 1, और office का 2।
Dot product (inner product)
एक ही जगह वाले numbers का गुणा, फिर सबका जोड़। जैसे [0.8, 0.2] और [0.9, 0.1]: 0.72 + 0.02 = 0.74।
DPR
Dense Passage Retrieval: दो BERT encoders वाला bi-encoder retriever, जो सवाल-passage जोड़ों पर contrastive loss से train होता है। 2020 में Karpukhin और साथियों ने बनाया, और lesson 5 के RAG का retriever यही था।
DrQA
2017 का retriever-reader system: fixed TF-IDF retriever पूरे Wikipedia से 5 articles लौटाता है, और neural reader उनमें से एक span चुनता है। जैसे Warsaw वाले सवाल पर 833,500।
DSP
Demonstrate–Search–Predict: frozen LM और frozen retriever के बीच text भेजने वाला program, जो demonstrations खुद बनाता है। 2022 में Stanford के Khattab और साथियों ने बनाया। जैसे HotPotQA पर Exact Match 51.4।
d⊤q
Vectors d और q का dot product लिखने का एक तरीका। जैसे office hours page [0.9, 0.1] और सवाल [0.8, 0.2] पर 0.74।
ef
HNSW की search में अब तक मिले सबसे पास वाले nodes की list का size। बड़ा ef यानी ज़्यादा दूरियाँ और ऊँचा recall। जैसे node 70 से ef = 3 पर नतीजा {75, 70, 80}।
Embedding
Trained model से बना text का vector। मिलती-जुलती बात वाले texts की दिशा मिलती-जुलती होती है, जैसे “help from a TA” और “run by the TAs”।
Embedding model (encoder)
Text पढ़कर तय लंबाई का embedding बनाने वाला model। जैसे query को [0.8, 0.2] जैसा vector देना।
Encoder-decoder
Encoder input के vectors बनाता है, और decoder उन्हें देखकर एक-एक token लिखता है। BART ऐसा model है।
End-to-end training
एक ही loss से सारे हिस्सों को साथ train करना। RAG में query encoder और generator, दोनों उसी −ln p(y|x) से सीखते हैं। जैसे −ln 0.70 = 0.357।
Entity
नाम वाली कोई चीज़: व्यक्ति, जगह, course, document या तारीख। जैसे Week 6, TAs, Room 104।
Evidence conflict
दो sources, या source और model के parameters, अलग बात कहें। जैसे Week 6 और Week 7।
Exact Match
जवाब सही जवाब से हूबहू मिले, तभी सही। Score ऐसे सवालों का % है। जैसे NQ पर RAG-Sequence का 44.5।
Exact search (brute force)
हर vector से तुलना करके पक्का सही top-k निकालना। जैसे 21 vectors हों, तो 21 दूरियाँ गिनना।
exp और e
exp(s) = es, जहाँ e करीब 2.718 है। हमेशा 0 से बड़ा, और ea+1 = ea × e। जैसे exp(1) = 2.718, exp(0) = 1, exp(−1) = 0.368।
Expected value, 𝔼[ · ]
हर नतीजे को उसकी probability से गुणा करके जोड़ना, यानी बहुत सारे rollouts पर औसत। जैसे 0.6 × 1 + 0.4 × 0 = 0.6।
F1
Precision और recall को मिलाने वाला नाप, 2PR ÷ (P + R)। जैसे P = 0.75 और R = 0.6 पर F1 = 0.667।
Failed retrievals@20
हर query का एक सही chunk हो, तो कितने % queries में वो top-20 में नहीं आया। छोटा बेहतर। जैसे 1,000 queries में 29 fail हों, तो 2.9%।
Failed@k
1 − Hit@k, यानी कितने हिस्से queries में top-k में एक भी सही passage नहीं। जैसे Failed@3 = 1 − 0.667 = 0.333।
FAISS
Vectors में तेज़ search की open-source library। जैसे DPR ने इसमें 2.1 करोड़ vectors का HNSW index बनाया, जिसमें करीब 8.5 घंटे लगे।
Fine-tuning
पहले से trained model को अपने काम के data पर और train करना। जैसे DPR, BERT को सवाल-passage जोड़ों पर train करता है।
Fixed-size chunking
तय गिनती के tokens पर काटना, चाहे बात बीच में टूटे। जैसे हर 50 tokens पर।
FLOPs
कितने गुणा और जोड़ लगे, यानी computer का काम। जैसे 3 numbers वाले dot product में 6 FLOPs, और 768 numbers वाले में 1,536।
Frozen LLM
जिसके parameters आप नहीं बदल सकते, सिर्फ़ prompt भेज सकते हैं। जैसे GPT या Gemini, जो आप API से लेते हैं।
Fusion
कई ranked lists को मिलाकर एक list बनाना। जैसे पहली list queue log, forum post, office hours page है, और दूसरी office hours page, queue log। जो दोनों में हैं, वो ऊपर आते हैं।
GAE
Generalized advantage estimation: हर कदम पर δ = reward + अगला अंदाज़ा − यह अंदाज़ा, और आगे के सारे δ का जोड़। γ = λ = 1 पर advantage = reward − V, जैसे 1 − 0.3 = 0.7।
Gaussian mixture model (GMM)
Bell curves का weighted जोड़: P(x) = ∑ πk 𝒩k(x)। ये हर passage को हर cluster की membership देता है। जैसे [0.6, 0.4] को office hours 0.904 और deadlines 0.096।
Generator
सवाल और एक passage पढ़कर जवाब लिखने वाला model, pθ(y|x, z)। RAG में ये BART है। जैसे queue log के साथ Thursday 9am को 0.9।
GiB
230 = 1,07,37,41,824 bytes, यानी GB से करीब 7% बड़ा। जैसे MS MARCO पर ColBERT का index 286 GiB है।
Gradient
हर parameter को किस दिशा में और कितना बदलें कि loss घटे, उसका हिसाब। जैसे lesson 1 में training ने parameters को उस दिशा में बदला, जिसमें Thursday की probability 0.10 से 0.12 हुई और loss 2.303 से 2.120।
Graph embedding
किसी network के node या relation का vector। जैसे node2vec। Course के graph में TA, office hours, और उनके बीच का runs वाला relation।
GraphRAG
Knowledge graph, उसकी communities और उनके सारों से global सवालों का जवाब। जैसे सारी deadlines वाला जवाब, जो Project और Homework 1 वाली communities से बनता है।
Greedy decoding और sampling
हर step पर सबसे ऊँची probability वाला token लेना greedy decoding है, और probability के हिसाब से random चुनना sampling। जैसे greedy हर बार Wednesday afternoon लिखता है, और sampling 100 में से करीब 21 बार Thursday से शुरू करता है।
Greedy search
हर कदम पर query के सबसे पास वाले neighbor पर जाना, अटकने तक। जैसे query 73 के लिए 70 से 75 पर जाना।
GRPO
Group के rewards के औसत और standard deviation से advantage। Value model नहीं चाहिए। जैसे 0, 0, 0, 1 पर औसत 0.25 और standard deviation 0.433।
Hallucination
भरोसे वाला, लेकिन गलत या बिना source वाला जवाब। जैसे log देखे बिना लिखा Wednesday afternoon।
Hard negative
सवाल से मिलता-जुलता, लेकिन गलत passage। DPR इन्हें BM25 के ऊपर वाले passages से लेता है। जैसे इस सवाल पर forum post।
Harmonic series
1 + 1/2 + 1/3 + …, यानी 1 ÷ rank वाले numbers, जो MRR में आते हैं। इनका जोड़ धीरे बढ़ता है, करीब ln n + 0.577, जैसे पहले 1,000 numbers का जोड़ 7.485।
Hit@k
कितने हिस्से queries में top-k में कम से कम एक सही passage है। जैसे k = 3 पर 3 में से 2 queries, यानी 0.667।
HNSW
Layers वाला proximity graph: ऊपर से greedy चाल, और अटकने पर एक layer नीचे। जैसे query 73 पर 4 कदम।
Hybrid search
दोनों retrievers, शब्दों वाला और dense, चलाकर उनकी lists मिलाना। जैसे BM25 की E1, E3, E2 और dense की E2, E1, E3 से एक list बनाना।
Hyperparameter
Formula या model का ऐसा number, जिसे training नहीं बदलती, और जिसे dev set पर आज़माकर चुनते हैं। जैसे BM25 के k1 और b, जिन्हें DPR paper ने 0.9 और 0.4 चुना।
i.i.d. और conditional embeddings
i.i.d.: हर chunk का vector दूसरे chunks से बिल्कुल अलग बनना, जैसे naive chunking में। Conditional: हर chunk का vector पूरे document को देखकर बनना, जैसे late chunking में It का [0.9, 0.1]।
IDF
ln((N − n + 0.5) ÷ (n + 0.5)), rare term का बड़ा वज़न। जैसे milestone का 1.299, और office का 0.588।
In-batch negatives
Batch के बाकी सवालों के positives को negatives की तरह इस्तेमाल करना। जैसे 128 के batch में हर सवाल को 127 negatives मिलते हैं।
Increasing function
ऐसा function, जिसमें बड़ा input हमेशा बड़ा output देता है, इसलिए क्रम नहीं बदलता। exp और ln ऐसे हैं। जैसे scores 1.56 और 0.74 से वज़न 0.499 और 0.220, उसी क्रम में।
Incremental re-indexing
पूरा index दोबारा बनाने की जगह सिर्फ़ नए और बदले passages के embeddings बनाना, और बदले document के पुराने passages हटाना। जैसे 60,000 की जगह 500 + 30 = 530 embeddings।
Index
Passages के पहले से बनाकर रखे embeddings की list। जैसे 60,000 passages के 60,000 vectors।
Index hot-swapping
Parameters छुए बिना documents का index बदलना, ताकि model की जानकारी बदले। जैसे 2018 के index से 2018 के leaders पर 68% सही जवाब, और 2016 के index से सिर्फ़ 4%।
Indexing time और query time
एक बार चलने वाले steps, और हर query पर चलने वाले steps। जैसे 60,000 passages के embeddings एक बार बनते हैं, और query का embedding हर बार।
Interaction matrix
Query के हर token और passage के हर token की similarity की table। जैसे FAQ वाली table में 6 × 2 = 12 dot products।
Inverted index
हर term के documents की list। जैसे office → office hours page, queue log।
ITER-RETGEN
Retrieval और generation बारी-बारी, जिसमें पिछला जवाब और सवाल मिलकर अगली query बनते हैं। 2023 में Shao और साथियों ने बनाया। जैसे Thursday 9am जोड़ने से office hours page का score 1 से 3 होता है।
Iterative, recursive और adaptive retrieval
एक से ज़्यादा बार ढूँढने के तीन तरीके। Iterative में तय गिनती तक बारी-बारी, recursive में सवाल को छोटे सवालों में तोड़कर, और adaptive में model खुद तय करता है। जैसे ITER-RETGEN iterative है, और Search-R1 का trace adaptive।
IVF
Inverted file index: vectors को clusters में बाँटकर query के पास वाले clusters ही देखना। जैसे 10 लाख vectors पर 11,000 तुलनाएँ।
k-means
Vectors को k clusters में बाँटने का तरीका: हर vector को सबसे पास वाले centroid को देना, फिर हर centroid को औसत बनाना। जैसे 6 passages पर 3 rounds में A = [0.817, 0.2] और B = [0.2, 0.8]।
KL divergence
ln(नई probability ÷ reference की probability) का औसत, नए model की probabilities से तौला हुआ। जैसे 0.2 और 0.8 से 0.9 और 0.1 पर 1.146, और 0.25 और 0.75 पर 0.007।
Knowledge cutoff
वो तारीख, जिस पर training रुकी। उसके बाद की बातें, और आपका private data, model में नहीं हैं। जैसे March 2026 की cutoff हो, तो Oct 2026 की announcement model में नहीं है।
Knowledge graph और edge
Entities (nodes) और relations (edges) का network। जैसे milestone और Week 6 के बीच एक edge, जिस पर “due” लिखा है।
Knowledge refinement
Documents को strips में तोड़ना, बेकार strips हटाना, और बाकी को क्रम से जोड़ना। जैसे milestone वाले सवाल पर syllabus की 3 में से 2 strips रहती हैं।
Late chunking
पहले पूरा document encode करना, फिर हर chunk के token vectors पर mean pooling। तब It is due Week 6 का vector [0.9, 0.1] बनता है।
Late interaction
Query और passage के token vectors अलग-अलग बनें, और सिर्फ़ scoring पर मिलें। जैसे ColBERT में passage के vectors offline बनते हैं, और dot products query आने पर।
Latency
Query भेजने से जवाब आने तक का समय, ms में। जैसे cross-encoder की latency 1,000 passages पर 10,700 ms है, और ColBERT rerank की 61 ms।
Latent variable
छिपा हुआ choice, जो data में नहीं लिखा। RAG में ये choice है कि जवाब किस passage से आया। जैसे सवाल-जवाब के जोड़े में ये नहीं लिखा कि जवाब queue log से आया।
Leiden और degree
Leiden graph को ऐसी communities में बाँटता है, जिनके अंदर edges ज़्यादा हों। Degree किसी node के edges की गिनती है। जैसे Project की degree 3 है।
Length
तीर की लंबाई: हर number का square, उनका जोड़, फिर square root। जैसे [0.8, 0.2] की length √(0.64 + 0.04) = 0.82।
Length normalization, b और avgdl
औसत से लंबे documents का TF हिस्सा घटाना, b जितना असर। जैसे avgdl = 16.17 और b = 0.75 पर दोगुने लंबे document का हिस्सा 0.710।
Likelihood
Model ने सही data को जो probability दी। जैसे सही जवाब को 0.12 दिया, तो likelihood 0.12।
Literal
ऐसा text, जो हूबहू मिलना चाहिए, जैसे error code E-4012 या order ID A77-310। Dense retriever इसे चूक सकता है, और BM25 इसे rare शब्द मानकर पकड़ता है।
LLM
Large language model: text पढ़कर आगे का text, एक बार में एक token, लिखने वाला model। जैसे Wednesday afternoon लिखने वाला model।
log2
2 को किस power तक उठाएँ कि number मिले। जैसे log2 4 = 2, और log2 3 = 1.585।
Long late chunking
Encoder की limit से लंबे document को overlap वाली बड़ी windows में पढ़कर late chunking करना। जैसे 20,000 tokens को 8,192 tokens की windows में, हर नई window 1,000 tokens पीछे से शुरू।
Long-context encoder
ऐसा encoder, जो एक बार में बहुत लंबा text पढ़ सके। जैसे 8,192 tokens, यानी करीब 10 pages।
Lookup table (ADC)
Query के हर टुकड़े का हर codeword से score पहले निकालकर table में रखना। तब हर passage का score बस table के numbers का जोड़ है। जैसे code (0, 1) का score 1 + 1 = 2.0।
Loss
Model कितना गलत है, उसका number। Training इसे छोटा करती है। जैसे सही जवाब की probability 0.5 हो, तो loss −ln 0.5 = 0.693।
Lost in the middle
LLM लंबे prompt के बीच की बात कम इस्तेमाल करता है (position bias)। जैसे 20 passages में पहली जगह पर 75.8% सही, और 10वीं पर 53.8%।
Map-reduce
हर टुकड़े पर अलग से एक ही काम (map), फिर नतीजे जोड़ना (reduce)। जैसे हर community से हिस्सा-जवाब और score, फिर score के क्रम में आख़िरी जवाब।
Marginalization
हर case का वज़न गुणा उस case में probability, फिर सारे cases का जोड़। जैसे 0.5 × 0.8 + 0.5 × 0.1 = 0.45।
Matrix और matrix-vector गुणा
Rows और columns वाली numbers की table, और उसकी हर row का किसी vector से dot product। जैसे हमारा 4 × 2 index गुणा query [0.8, 0.2] = [0.74, 0.26, 0.32, 1.56]।
MaxSim
Query के हर token का passage के tokens से सबसे बड़ा dot product, फिर सबका जोड़। जैसे course FAQ पर 0.9 + 0.95 = 1.85।
Mean pooling
कई token vectors का औसत लेकर एक vector बनाना। जैसे [0.9, 0.1], [0.7, 0.3] और [0.8, 0.2] का औसत [0.8, 0.2]।
Metadata
Data के बारे में data: नाम, section, तारीख। जैसे CS 329Z syllabus, Grading, 30 Sep 2026।
Min-max normalisation
हर list के scores को (x − min) ÷ (max − min) से 0 से 1 पर लाना। जैसे BM25 के 7.2, 3.1 और 1.0 से 1, 0.339 और 0। नतीजा list के min और max पर टिका है।
MIPS
Maximum inner product search: index में सबसे बड़े dot product वाले K passages ढूँढना। जैसे 2.1 करोड़ passages में से सबसे ऊँचे 5 scores वाले passages।
Modular RAG
Pipeline को modules में बाँटकर, उन्हें अलग-अलग क्रम में जोड़ना। जैसे Retrieve, Read, Retrieve, Read।
MRR@k
पहले सही passage के rank का उल्टा (1 ÷ rank), queries का औसत, और top-k में न हो तो 0। जैसे ranks 1, 2 और कोई नहीं, तो (1 + 0.5 + 0) ÷ 3 = 0.5।
Multi-hop question
ऐसा सवाल, जिसके लिए कई बार ढूँढना पड़े, क्योंकि जवाब के हिस्से अलग passages में हैं। जैसे least crowded office hour कहाँ है: पहले queue log, फिर office hours page।
Multimodal embedding
Text और image, दोनों के vectors एक ही space में। जैसे CLIP। Whiteboard पर लिखे office hours की photo और text office hours schedule के vectors पास आ सकते हैं।
Naive chunking
पहले काटना, फिर हर chunk को अकेले encode करना। तब It is due Week 6 का vector [0.5, 0.5] रहता है।
Naive RAG
सबसे सीधी pipeline: index, फिर हर query पर Retrieve और Read। बीच में कोई extra step नहीं।
Natural log, ln
e को किस power तक उठाएँ कि x मिले। ln(ex) = x, और ln(a × b) = ln a + ln b। जैसे ln(0.1) = −2.303।
nDCG@k
DCG ÷ IDCG, 0 से 1 के बीच, जो grade और क्रम दोनों देखता है। जैसे q1 के उलटे क्रम पर 2.5 ÷ 3.631 = 0.689।
Nearest neighbors
Query के सबसे पास वाले vectors। जैसे query 73 के पास वालों में 75 पहले आता है।
Negative log-likelihood
−ln p(सही जवाब)। सबसे आम loss। जैसे p = 0.12 पर −ln 0.12 = 2.120।
Negative marginal log-likelihood
सही जवाब की probability का −ln, जब वो probability passages पर marginalization से बनी हो, और सारे examples पर उसका जोड़। RAG का training loss। जैसे दो examples पर 0.378 + 0.693 = 1.071।
Neighbors चुनने का नियम (heuristic)
Candidate तभी जुड़ता है, जब वो पहले से जुड़े हर node की तुलना में नए node के ज़्यादा पास हो। जैसे X के लिए A और E2 जुड़ते हैं, और B और C छूटते हैं।
Next-token prediction
अब तक का text देखकर हर token को probability देना, एक चुनना, जोड़ना, और दोहराना। जैसे Wednesday, फिर afternoon, फिर full stop।
No stopping rule
Agent को रुकने की साफ़ शर्त न पता हो। जैसे एक सवाल पर 15 searches।
Non-parametric memory
Model के बाहर, corpus में रखी जानकारी। जैसे queue log: उसे बदलने के लिए training नहीं चाहिए।
Normalize
Vector के हर number को उसकी length से भाग देकर length 1 बनाना। दिशा वही रहती है। जैसे [0.8, 0.2] ÷ 0.82 = [0.97, 0.24]।
Normalizer, Z
Softmax में सारे exps का जोड़, जिससे भाग देने पर वज़नों का जोड़ 1 होता है। ∝ के पीछे यही भाग छिपा है। जैसे exps 2.718 और 1 पर Z = 3.718।
nprobe
IVF में कितने clusters देखने हैं। जैसे 1,000 clusters में nprobe = 10 हो, तो सिर्फ़ 10 clusters के vectors देखना।
Observation
Action का नतीजा, जो agent अगले कदम से पहले पढ़ता है। जैसे पहली search का नतीजा: हर passage का score 0।
Offline और online
Offline: query आने से पहले, एक बार, जैसे passages के embeddings बनाना। Online: हर query पर, जैसे query का embedding।
Open-domain QA
किसी भी विषय का सवाल, जिसका paragraph साथ नहीं मिलता, इसलिए system उसे पूरे corpus में खुद ढूँढता है। जैसे DrQA में Warsaw वाला सवाल, पूरे Wikipedia पर।
ORQA
2019 का dense retriever, जिसने retriever को extra pretraining से सिखाया। जैसे NQ पर पूरे system का Exact Match ORQA के साथ 33.3, और DPR के साथ 41.5।
Overlap
नया chunk पिछले chunk के आख़िरी कुछ tokens दोहराकर शुरू हो। L tokens की बात बचाने के लिए कम से कम L − 1। जैसे 7 शब्दों की तारीख के लिए 6।
Parameters (weights)
Model के अंदर के numbers, जिनसे हर अगले token की probability निकलती है। जैसे T5-11B में करीब 11 billion parameters हैं।
Parametric knowledge
Parameters में बँटी हुई जानकारी। Model इसका source नहीं बता सकता, और नई बात के लिए फिर से training चाहिए।
Paraphrase
वही बात अलग शब्दों में। जैसे upload failed और upload keeps failing। BM25 इसे चूकता है, क्योंकि वो एक जैसे शब्द गिनता है।
Passage
Document का छोटा टुकड़ा, जो retriever लौटाता है। जैसे syllabus का वो paragraph, जिसमें milestone की तारीख है।
Passage embedding
पूरे chunk का एक vector, जिसे retrieval का index रखता है। जैसे Sentence-BERT, DPR और E5 के vectors।
Pattern
Modules का एक तय क्रम, जैसे Retrieve, Read।
Permission leak
Retriever ऐसा passage लाए, जिसे इस user को देखने की इजाज़त नहीं। जैसे student को दूसरों के grades।
Pipeline
Steps की line, जिसमें हर step का output अगले का input है। जैसे Retrieve का output top-K passages हैं, और वही Read का input।
Points (absolute फ़र्क)
दो % numbers का सीधा फ़र्क। जैसे 52.2 से 54.0 = 1.8 points, जबकि 52.2 के हिसाब से ये करीब 3.45% की बढ़त है।
Policy
जो हर कदम पर फ़ैसला लेता है। यहाँ LLM, जो हर बार अगला token चुनता है: सोचना, <search> या <answer>।
Positive और negative passage
सवाल का सही passage (pi+), और गलत passages (pi,j−)। जैसे least crowded सवाल का positive queue log है, और negatives forum post और Homework।
Post-retrieval
Retrieval के बाद लौटी list सुधारने वाले steps: rerank, summary और fusion।
Posterior और prior
Prior pη(z|x) जवाब देखने से पहले passage का वज़न है। Posterior p(z|x, y) जवाब देखने के बाद का वज़न है, यानी कुल chance में उस passage का हिस्सा। जैसे queue log का prior 0.602 है, और posterior 0.773।
PPO और value model
RL का आम तरीका, जो आगे के reward का अंदाज़ा लगाने वाला अलग model (value model) train करता है। जैसे अंदाज़ा 0.25 और reward 1 हो, तो advantage +0.75।
Pre-filter और post-filter
Pre-filter मना वाले passages ranking से पहले हटाता है, और post-filter top-K निकालने के बाद। जैसे top-14 में 5 मना वाले हों, तो post-filter के बाद 9 बचते हैं।
Pre-retrieval
Retrieval से पहले query सुधारने वाले steps: routing, rewriting और expansion।
Precision
लौटे passages में से कितना हिस्सा सही है। जैसे K = 2 पर queue log सही और forum post गलत, तो precision = 1 ÷ 2 = 0.5।
Pretraining
बहुत सारे आम text पर model की पहली, बड़ी training। जैसे BERT पहले आम text पर train होता है।
Primacy और recency bias
LLM का prompt की शुरुआत (primacy) और आख़िर (recency) की बातें ज़्यादा इस्तेमाल करना। जैसे 20 passages में पहली जगह पर 75.8%, आख़िरी पर 63.2%, और 10वीं पर 53.8%।
Probability
0 से 1 के बीच का number, जो किसी बात का chance बताता है। सारे options का जोड़ 1 होता है। जैसे 20 में से 5 lectures में quiz हुआ, तो 5 ÷ 20 = 0.25।
Probability ratio
πθ(token) ÷ πold(token), यानी token की probability rollout बनाने वाले model के मुकाबले कितने गुना है। जैसे 0.55 ÷ 0.5 = 1.1।
Product quantization (PQ)
Vector को टुकड़ों में काटकर हर टुकड़े की जगह codeword का number रखना। जैसे [0.9, 0.1, 0.2, 0.8] बनता है code (0, 1)।
Prompt
वो text, जो आप model को अभी देते हैं: सवाल, instructions, और साथ के documents। जैसे queue log की line, जिससे Thursday 0.21 से 0.81 हुआ।
Prompt caching
LLM service prompt का बार-बार आने वाला हिस्सा पहली call के बाद याद रखती है, जैसे पूरा document। इसलिए अगली calls में वो हिस्सा सस्ता पड़ता है। Blog के मुताबिक तब contextual retrieval का खर्च हर 10 लाख document tokens पर $1.02 है।
Prompt injection
ढूँढे गए text में लिखी बात agent के लिए हुक्म बन जाए। जैसे post में छिपा Ignore previous instructions।
Proximity graph
ऐसा graph, जिसमें हर vector अपने पास वाले vectors से जुड़ा हो। जैसे 70 अपने पड़ोसी 65 और 75 से जुड़ा है।
QRels
Relevance labels की file: हर query के लिए सही documents के IDs। जैसे late chunking paper ने nDCG@10 इसी file से निकाला।
Query
वो सवाल, जिसके लिए ढूँढना है। जैसे “which office hour is least crowded”।
Query augmentation
Query को [mask] tokens से 32 tokens तक भरना। BERT इनके भी vectors बनाता है, और वो MaxSim में extra query tokens की तरह जुड़ते हैं।
Query expansion
Query में जुड़े हुए शब्द या दूसरे रूप जोड़ना। जैसे “help ta” में “office hours” जोड़ने से office hours page का score 0 से 2 होता है।
Query rewriting
LLM से query को साफ़ search query में बदलवाना। जैसे “OH timings?” से “CS 329Z office hours schedule”।
Query routing
तय करना कि किस index या source में ढूँढना है। जैसे “when is the project milestone due” syllabus वाले index में जाए।
Query-focused summarization
सवाल को ध्यान में रखकर सार लिखना। जैसे “सारी deadlines” पूछने पर Project community के सार से सिर्फ़ तारीखें आएँ।
RAG
Retrieval-Augmented Generation: retriever और generator को एक model में जोड़कर एक ही loss से साथ train करना। जैसे queue log लाकर उससे Thursday 9am लिखना।
RAG-Sequence
हर passage के साथ पूरा जवाब, फिर वज़न वाला जोड़। जैसे 0.6 × 0.18 + 0.4 × 0.45 = 0.288।
RAG-Token
हर token पर वज़न वाला जोड़, फिर tokens का गुणा। जैसे 0.74 × 0.48 = 0.355।
RAPTOR
Clusters के सारों से नीचे से ऊपर tree बनाना, और हर level पर ढूँढना। जैसे सारी deadlines वाला सवाल सार A से मिलता है।
Reader
Query और top-K passages पढ़कर जवाब लिखने वाला हिस्सा। आज अक्सर एक LLM। जैसे queue log पढ़कर “Thursday 9am” लिखना।
Reading comprehension
दिया हुआ text पढ़कर उसी पर पूछे सवाल का जवाब देना। Retriever के बाद reader का काम यही है। जैसे Ottoman empire वाला paragraph पढ़कर 32 बताना।
Recall
Retriever कितनी बार ज़रूरी passage ढूँढ पाता है। जैसे 100 सवालों में 60 पर, तो recall 60%।
Recall ceiling
Retriever का recall पूरे system की ऊपरी हद बन जाता है। Recall 60% है, तो reader कितना भी अच्छा हो, 100 में से 60 से ज़्यादा जवाब passages के दम पर नहीं आते।
Recall@k
Top-k में मिले सही passages ÷ कुल सही passages, queries का औसत। जैसे k = 1 पर q1 में 2 में से 1 मिला, तो 0.5।
Reciprocal rank fusion (RRF)
हर list में passage के rank से 1 ÷ (k + rank), फिर सारी lists का जोड़, जहाँ k = 60। जैसे E1: 1 ÷ 61 + 1 ÷ 62 = 0.03252।
Recursive chunking
Separators की सीढ़ी पर काटना: पहले paragraph, फिर line, फिर sentence, फिर space। जो टुकड़ा chunk size से बड़ा रहे, वही अगले separator पर कटता है। जैसे size 20 पर Grading section 19 और 7 शब्दों के दो chunks बनता है।
Reference LLM और KL penalty
Training से पहले वाले model की जमी हुई copy, और नए model को उससे दूर जाने से रोकने वाली penalty। जैसे <search> की probability 0.2 से 0.9 हो जाए, तो penalty बड़ी है।
Reflection tokens
Vocabulary में जोड़े गए खास tokens, जिन्हें model बाकी text की तरह लिखता है। जैसे Retrieve, Relevant या Irrelevant, और Supported या Partially।
Reinforcement learning (RL)
कोशिशें करके, हर कोशिश के reward से सीखना। जैसे 4 rollouts में 2 का reward 1 है, तो उन दोनों के tokens की probability बढ़ती है।
Rejection sampling
हर सवाल पर कई rollouts बनाना, और सिर्फ़ सही जवाब वालों पर fine-tune करना। जैसे paper में हर सवाल पर 5 rollouts, और 7 datasets का औसत 0.348।
Relation
दो entities का रिश्ता। जैसे (Project milestone, due, Week 6)।
Relative gain
फ़र्क को पुराने number से भाग देकर % में लिखना। जैसे (51.4 − 36.9) ÷ 36.9 = 0.393, यानी करीब 39%। सीधा फ़र्क, 14.5, percentage points कहलाता है।
Relevance labels
हर query के लिए पहले से तय सही passages, कभी grades के साथ। जैसे q1 के लिए queue log (grade 3) और office hours page (grade 1)।
Rerank और reranker
धीमा लेकिन सटीक model, जो लौटाए गए passages को दोबारा sort करता है। जैसे queue log और forum post के बराबर score में से forum post को नीचे भेजना।
Reranking
तेज़ retriever की shortlist को सटीक model से दोबारा score देकर sort करना। जैसे MS MARCO पर MRR@10 BM25 अकेले 16.7, और BERT-base से rerank के बाद 34.7।
Residual
Vector में से उसके cluster का centroid घटाने पर बचा फ़र्क। IVFADC इसी का code बनाता है। जैसे queue log [0.85, 0.2] − [0.817, 0.2] = [0.033, 0]।
Retrieval
Query के लिए काम के passages ढूँढकर prompt में रखना। जैसे queue log का passage सवाल के साथ prompt में जाए।
Retrieval collapse
Training में retriever का हर सवाल पर वही passages लाने लगना, जिसके बाद generator उन्हें अनदेखा करना सीख लेता है। जैसे paper में कहानी लिखने वाले काम पर।
Retrieval evaluator
सवाल और एक document पढ़कर confidence देने वाला हल्का model। जैसे K = 1 पर forum post को 0.4।
Retrieved token masking
Training का हिसाब सिर्फ़ model के लिखे tokens पर, और <information> के tokens बाहर। जैसे slide के trace में 430 में से 114 शब्द। Mask हटाने पर औसत 0.431 से 0.343।
Retriever
हर passage को score देकर top-K लौटाने वाला हिस्सा। जैसे इस lesson का word overlap वाला retriever।
Reward
Rollout के आख़िर में मिला number। जैसे जवाब हूबहू सही हो तो 1, नहीं तो 0।
Rollout (trajectory)
एक सवाल पर शुरू से आख़िरी जवाब तक की एक पूरी कोशिश। जैसे Hoyer वाले सवाल पर o1: दोनों तारीखें search कीं, फिर जवाब दिया।
Salient span masking (SSM)
Pretraining का extra दौर, जिसमें model Wikipedia के sentences में नाम और तारीखों की खाली जगह भरता है। जैसे इससे T5-11B का TriviaQA score 50.1 से 60.5 हुआ।
Saturation और k1
गिनती बढ़ने पर फ़ायदा धीरे-धीरे भरता है, k1 + 1 की छत तक। जैसे k1 = 1.2 पर f = 1, 2, 10 का हिस्सा 1.000, 1.375, 1.964।
Score
Passage query के लिए कितना काम का है, उसका number। जैसे word overlap में queue log का score 2।
Search-R1
LLM को RL से search के फ़ैसले सिखाने वाला तरीका, think, search, information और answer tags के साथ। Reward सिर्फ़ आख़िरी जवाब पर लगता है।
Segment score (Self-RAG)
हर हिस्से के critique हिस्सों का वज़न वाला जोड़: S = 1.0 × sIsRel + 1.0 × sIsSup + 0.5 × sIsUse। जैसे queue log वाले हिस्से का S = 0.9 + 0.875 + 0.5 × 0.75 = 2.15।
Self-RAG
Generator खुद reflection tokens लिखकर तय करता है कि कब ढूँढना है, और कौन सा हिस्सा रखना है। जैसे forum post वाले हिस्से पर Relevant और Partially।
Semantic chunking
Sentence या section जैसी logical boundaries पर काटना। जैसे syllabus को Grading, Office hours और Project वाली headings पर।
Set, ∩, ∅, |A|
चीज़ों का group, दो sets की common चीज़ें, खाली set, और set में कितनी चीज़ें हैं। जैसे |{queue log, office hours page}| = 2, और q3 पर Rq3 ∩ Top3(q3) = ∅।
Shortlist
Retriever के ऊपर के कुछ passages, जिन पर reranker चलता है। जैसे 60,000 passages में से top-100, जिन पर cross-encoder 1,070 ms लेता है।
Soft clustering
एक passage को एक से ज़्यादा clusters में रखना। जैसे FAQ page, जिसका cosine दोनों centroids से ऊँचा है (0.86 और 0.78)।
Softmax
हर score का exp, फिर सबके जोड़ से भाग। Scores को probabilities बनाता है। जैसे 2.0, 1.0, 0.1 से 0.659, 0.242, 0.099।
Sparse और dense vector
ज़्यादातर 0 वाला लंबा vector, और लगभग पूरा भरा छोटा vector। जैसे forum post के vector की 69 में से 55 जगहें 0 हैं।
SQuAD
Stanford Question Answering Dataset: Wikipedia के paragraphs पर लोगों के लिखे सवाल, और जवाब हमेशा paragraph का एक span। जैसे training में 87,599 सवाल।
Stale index
Document बदल गया, लेकिन index में पुराना passage और embedding पड़ा है। जैसे index में Tuesday 4pm, जबकि office hour Wednesday 2pm पर जा चुका।
Standard deviation
Numbers के फैलाव का नाप: औसत से फ़र्कों के squares का औसत, फिर square root। जैसे 0, 0, 0, 1 पर औसत 0.25, squares 0.5625, 0.0625, 0.0625, 0.0625, उनका औसत 0.1875, और square root 0.433।
Static word embedding
हर word type का एक ही vector, context कुछ भी हो। जैसे word2vec और GloVe। Late का vector दोनों sentences में [0.5, 0.5] रहता है। मेरे numbers
Stopwords
is, the, which जैसे बहुत आम शब्द, जिन्हें गिनती में नहीं लेते। “which office hour is least crowded” से which और is हटते हैं।
Stride
दो लगातार chunks की शुरुआत के बीच की दूरी: chunk size − overlap। जैसे 9 − 6 = 3।
Summary
Passages को prompt से पहले छोटा करना। जैसे 500 tokens का passage 100 का हो, तो 14 passages 7,000 की जगह 1,400 tokens लेते हैं। खतरा: Room 104 जैसी detail छूट सकती है।
Term
Search में query का एक शब्द। जैसे which office hour में office और hour।
Term frequency, f(q, D)
Term q document D में कितनी बार है। जैसे queue log में office की f = 2।
TF-IDF
Term की गिनती × ln(N ÷ n), BM25 से पुराना तरीका। जैसे N = 6, n = 2, f = 2 पर 2 × ln 3 = 2.20।
Thorough और Fast decoding
RAG-Sequence से जवाब लिखने के दो तरीके। हर passage के साथ एक उम्मीदवार बनता है। Thorough हर उम्मीदवार को हर passage के साथ जाँचता है, और Fast सिर्फ़ वहीं, जहाँ वो बना। जैसे NQ पर 50 passages के साथ Thorough में करीब 2,500 generator runs तक।
Threshold
पहले से तय limit, जिसके ऊपर या नीचे होने पर अलग action चलता है। जैसे CRAG में 0.6 से ऊपर Correct, और 0.2 से नीचे Incorrect।
Token
Text का छोटा टुकड़ा: शब्द, शब्द का हिस्सा, या punctuation। Model इन्हीं को पढ़ता और लिखता है। जैसे crowded के दो tokens: crowd और ed।
Tokenizer
Text को vocabulary के tokens में तोड़ने वाला program। जैसे Wednesdayy को Wednesday और y में।
Top-K
सबसे ज़्यादा score वाले K passages। जैसे K = 2 पर queue log और पुराना forum post।
Top-k retrieval accuracy
कितने % सवालों में top-k में जवाब वाला passage है। जैसे NQ पर top-20 में DPR की 78.4%।
Training
Parameters को थोड़ा-थोड़ा बदलना, ताकि text के असली अगले token की probability बढ़े। जैसे Office hours are on के बाद Thursday 0.10 से 0.12।
Tree traversal और collapsed tree
ऊपर से नीचे हर level पर top-k चुनना, या सारे nodes एक list में sort करके token limit तक लेना। जैसे deadlines वाले सवाल पर collapsed tree 100 tokens में 5 nodes लेता है, और A सबसे पहले।
Tree, node, leaf, root
Levels वाला ढाँचा: node एक box, leaf सबसे नीचे का node, और root सबसे ऊपर का। जैसे 6 chunks (leaves) के ऊपर 2 सार, और उनके ऊपर 1 root।
UMAP
Vectors को कम numbers में बदलना, ताकि पास वाले points पास रहें। जैसे RAPTOR के code में हर vector 10 numbers का बनता है।
Vector
तय लंबाई वाली numbers की list, जैसे [0.9, 0.1]। 2 numbers हों, तो plane पर एक तीर।
Vocabulary
Model के सारे tokens की तय list, जिसमें हर token का एक ID number है। जैसे उसमें Wednesday है, लेकिन Wednesdayy नहीं।
Win rate
दो systems की तुलना में कितने % फ़ैसले एक के पक्ष में गए, और 50% का मतलब बराबरी। जैसे 625 में से करीब 450 फ़ैसले, यानी 72%।
Word overlap
Query के कितने शब्द passage में भी हैं। सबसे आसान score। जैसे queue log में office और hour हैं, तो score 2।
Word type और token in context
Dictionary का एक शब्द, और किसी sentence में उसका एक इस्तेमाल। जैसे late एक word type है, और Late days may not be applied में उसका इस्तेमाल एक token in context।
Zero-shot
उस खास काम पर training के बिना, सिर्फ़ instruction पढ़कर काम करना। जैसे prompt में लिखा “Answer the question using the passage below”।