CS 329Z · Engineering AI Agents · Lecture 3
RAG + Agents, पहली नींव से
ये lecture एक सवाल पर टिका है: LLM को सही जानकारी सही वक्त पर कैसे दें, और ये तरीका कहाँ टूटता है। यहाँ वो सवाल 18 lessons में बँटा है, और सारे तैयार हैं। हर lesson पिछले lessons पर बनता है, और हर नया शब्द वहीं समझाता है, जहाँ वो पहली बार आता है।
कैसे पढ़ें
- Lessons क्रम से पढ़ सकते हैं, लेकिन ये ज़रूरी नहीं। नीचे का नक्शा बताता है कि किस lesson से पहले क्या चाहिए। कोई नया शब्द अपने lesson से पहले बिना मतलब के नहीं आता। बाद के lessons में वो फिर आए, तो वहाँ उसके lesson का नाम होता है।
- हर lesson पहले बताता है कि नई चीज़ क्या है, फिर उसे एक असली गड़बड़ पर लगाता है, जैसे BM25 का पुराने forum post को queue log से ऊपर रखना। Lesson के ऊपर एक सीढ़ी है: हर पड़ाव के नीचे लिखा है कि उसके बाद आप क्या कर पाएँगे। जो पड़ाव पहले से आता है, उसे छोड़ सकते हैं।
- कई जगह “पहले सोचिए” वाला सवाल है, और कहीं-कहीं table की एक row आपको खुद निकालनी है। जवाब खोलने से पहले खुद हल कीजिए, कागज़ पर हिसाब लगाकर।
- Widgets में numbers बदलिए। हर widget में वही mechanism चलता है, जो lesson में समझाया है।
- जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click कीजिए। उसका मतलब वहीं खुल जाता है, और साथ में उस lesson का link भी होता है जहाँ वो पूरा समझाया है।
- हर lesson के दो versions हैं। आसान version मुख्य बात धीरे-धीरे सिखाता है। गहरा version Stanford की slides की हर line तक जाता है, और paper की वो बातें भी लेता है जिन पर slide टिकी है। दोनों English में भी हैं, और lesson के ऊपर के switch से आप कभी भी बदल सकते हैं।
मैंने माना है कि आप 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 की एक कमी से शुरू होता है।
- 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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पूरे 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करोड़ों 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 14Hybrid search और rerankingBM25 ने E2 को तीसरे rank पर रखा, dense ने पहले। दोनों lists को एक list में मिलाना है, और फिर ऊपर के passages को query के साथ पढ़कर उनका क्रम सुधारना है।Paraphrase, Literal, Hybrid search, Reciprocal rank fusion (RRF), Attention, Cross-encoder, Reranking, Shortlistआसान · गहरा
- 15ColBERT: हर token का अपना vectorQuery error 4012 पर एक vector वाले bi-encoder ने छोटे, गलत upload note को जवाब वाले लंबे FAQ से ऊपर रखा। हर token का अपना vector रखकर, और query के हर token का सबसे अच्छा match जोड़कर, सही passage ऊपर लाना है।Late interaction, MaxSim, ColBERT, Latency, FLOPs, Cascadeआसान · गहरा
- 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आसान · गहरा
- 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आसान · गहरा
- 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”।