Lesson 7 · गहरा version

Chunking: document को retrieval के टुकड़ों में काटना

Chunking का मतलब है लंबे document को छोटे टुकड़ों में काटना, ताकि retriever हर टुकड़े का एक vector बनाकर index में रख सके। इन टुकड़ों को chunk कहते हैं। Retriever यही chunks ढूँढता और लौटाता है, इसलिए Stanford की slide chunk को retrieval की basic unit कहती है।

Lesson 2 में सवाल when is the project milestone due का जवाब syllabus वाले passage में था: Week 6, Thursday 11:59pm। वो passage हमें पहले से कटा हुआ मिला था, लेकिन असली syllabus 40 pages का है। Lesson 6 की pipeline में index बनाने का पहला step उसे काटना है। हर 50 tokens पर काटिए, तो एक chunk …due Week 6, Thursday पर ख़त्म होता है, और 11:59pm. अगले chunk में चला जाता है। काटें ही नहीं, तो 40 pages के एक vector में milestone की 2 lines घुल जाती हैं।

इस lesson की सीढ़ी

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

  1. Chunk का vector: tokens के vectors का औसतMean pooling से chunk का vector हाथ से निकाल पाएँगे।
  2. Chunk का size: छोटा context खोता है, बड़ा औसत में घुलता हैदिखा पाएँगे कि बड़ा chunk सही बात रखकर भी पीछे क्यों जाता है।
  3. Overlap और stride: boundary पर कटी बात बचानाकिसी बात को बचाने लायक सबसे कम overlap गिन पाएँगे।
  4. मतलब से काटना: headings, metadata और LLMStanford की दोनों chunking slides पढ़ पाएँगे।
  5. यहाँ से Stanford वाला level
  6. Mean pooling का गणित: बात कितनी घुलती हैk विषयों और छोटे हिस्से वाली बात का cosine निकाल पाएँगे।
  7. Overlap का पूरा हिसाब: बात बचने का chance और chunks की गिनतीकम overlap पर बात बचने का chance और chunks की गिनती निकाल पाएँगे।
  8. तरीके अंदर से: Databricks guideRecursive splitting और sentence vectors से boundary हाथ से निकाल पाएँगे।
  9. Stanford की slides खुद पढ़िएChunking की तीनों Stanford slides की हर line समझा पाएँगे।

पहले से क्या चाहिए: Lesson 1 (token), Lesson 3 (vector, embedding, cosine) और Lesson 6 (indexing time)। पड़ाव 5 से आगे Lesson 13 (recall) भी काम आता है। जो पड़ाव आपको पहले से आता है, उसे छोड़कर अगले पर जाइए। जिस शब्द के नीचे बिंदुओं वाली line और ▾ हो, उस पर click करने से उसका मतलब खुलता है।

1Chunk का vector: tokens के vectors का औसत

Retrieval को हर chunk का एक vector चाहिए, और ये vector अक्सर chunk के सारे tokens के vectors का औसत होता है। Index हर chunk का यही एक vector रखता है। सवाल आने पर retriever सवाल के vector का हर chunk के vector से निकालता है, और सबसे बड़े cosine वाले chunks लौटाता है। Lesson 2 के छहों passages भी असल में chunks ही थे।

पहले देखिए कि tokens के vectors कहाँ से आते हैं। हर का अलग vector बनाता है, और उस vector पर आस-पास के शब्दों का भी असर होता है। इसे contextual embedding कहते हैं।

जैसे late शब्द दो sentences में आता है: Late days may not be applied और late afternoon office hours। मान लीजिए vector का पहला number office hours वाली बात दिखाता है, और दूसरा deadline वाली बात। तब contextual embedding में late के दो अलग vectors बनते हैं। पुराने static word embeddings, जैसे word2vec, हर word type का एक ही vector रखते थे। Word type यानी dictionary का एक शब्द, sentence कोई भी हो। numbers मेरे बनाए हैं

SentenceStatic: late का vectorContextual: late का vector
Late days may not be applied[0.5, 0.5][0.1, 0.9]
late afternoon office hours[0.5, 0.5][0.9, 0.1]

अब पूरे chunk का एक vector चाहिए, जिसे passage embedding कहते हैं। सबसे आम तरीका है chunk के सारे token vectors का औसत लेना: हर column के numbers जोड़िए, और tokens की गिनती से भाग दीजिए। इसे mean pooling कहते हैं। तीन tokens वाला एक छोटा chunk लीजिए: मेरा example

TokenVector
Office[0.9, 0.1]
hours[0.7, 0.3]
Tuesday[0.8, 0.2]
Mean pooling: हर column का औसत[0.8, 0.2]
  1. पहला column: 0.9 + 0.7 + 0.8 = 2.4, और 2.4 ÷ 3 = 0.8।
  2. दूसरा column: 0.1 + 0.3 + 0.2 = 0.6, और 0.6 ÷ 3 = 0.2।

तीनों tokens office hours की तरफ़ थे, इसलिए chunk का vector [0.8, 0.2] भी उसी तरफ़ है। Mean pooling हर token को बराबर वज़न देती है, और पड़ाव 2 में यही बात बड़े chunk को नुकसान पहुँचाती है।

पहले सोचिए

Chunk में एक token और जोड़िए: 4pm, जिसका vector [0.8, 0.2] है। अब chunk का vector क्या होगा, और उसमें कितने numbers होंगे?

जवाब देखिए

[0.8, 0.2], और उसमें अब भी 2 numbers हैं। पहला column: (0.9 + 0.7 + 0.8 + 0.8) ÷ 4 = 3.2 ÷ 4 = 0.8। दूसरा: (0.1 + 0.3 + 0.2 + 0.2) ÷ 4 = 0.8 ÷ 4 = 0.2। Tokens 3 हों या 300, औसत में numbers उतने ही रहते हैं, जितने हर token के vector में हैं। इसलिए हर chunk के vector में numbers की गिनती बराबर रहती है, और index सबकी तुलना कर पाता है।

Stanford की embeddings वाली slide यही बात कहती है। उसकी table में पाँच तरह के embeddings हैं, और ऊपर के तीन आपने अभी देखे: static word, contextual और passage। बाकी दो, और , image और network के vectors हैं। Slide की आख़िरी line retrieval की दो ज़रूरतें बताती है। पहली, हर chunk का एक vector, जिसकी तय हो। दूसरी, तुलना का एक तरीका, cosine या inner product।

Stanford slide: What Makes A Good Retriever? Embeddings, पाँच तरह के embeddings की table
Stanford की slide: What Makes A Good Retriever? Embeddings। Passage वाली row में एक vector एक chunk का है, और ये lesson उसी chunk के बारे में है। Image पर click करने से वो पूरे size में खुलती है।

2Chunk का size: छोटा context खोता है, बड़ा औसत में घुलता है

बड़ा chunk कई विषयों का औसत बन जाता है, और छोटा chunk अपना context खो देता है। इसलिए chunk का size इन दो उल्टी दिक्कतों के बीच का फ़ैसला है, और Stanford की slide दोनों गिनाती है।

बड़ा chunk: विषय औसत में घुल जाते हैं

मान लीजिए office hours वाली बात का vector [1, 0] है, और deadline वाली बात का [0, 1]। एक बड़े chunk में दोनों बातें बराबर हों, तो mean pooling का औसत [0.5, 0.5] बनता है। Query office hours का vector [1, 0] है। मेरा example

Lesson 3 वाला cosine दो vectors का dot product है, जिसे दोनों की के गुणा से भाग देते हैं। सिर्फ़ office hours वाले छोटे chunk [1, 0] का query से cosine 1 है, क्योंकि दोनों एक ही दिशा में हैं। बड़े chunk का cosine तीन steps में निकलता है:

  1. Dot product: 1 × 0.5 + 0 × 0.5 = 0.5।
  2. Length: query की length 1 है, और [0.5, 0.5] की √(0.5² + 0.5²) = √0.5 = 0.707। √ यानी square root, वो number जिसे खुद से गुणा करने पर अंदर वाला number मिले। जाँच: 0.707 × 0.707 = 0.5।
  3. Cosine: 0.5 ÷ (1 × 0.707) = 0.71।
ChunkVectorQuery से cosine
सिर्फ़ office hours वाला छोटा chunk[1, 0]1.00
Office hours और deadlines, दोनों वाला बड़ा chunk[0.5, 0.5]0.71

बड़े chunk में सही बात मौजूद है, फिर भी उसका cosine 1.00 से 0.71 पर गिर गया, क्योंकि deadline वाला विषय औसत में मिल गया। अब कोई दूसरा chunk, जिसका cosine 0.8 है, इससे ऊपर आ जाएगा। 40 pages के syllabus में office hours, deadlines, grading और project, सब हैं, इसलिए वहाँ cosine और गिरता है।

पहले सोचिए

एक chunk में तीन विषय बराबर हैं: [1, 0, 0], [0, 1, 0] और [0, 0, 1]। Mean pooling का vector क्या होगा, और query [1, 0, 0] से उसका cosine कितना होगा?

जवाब देखिए

औसत [1/3, 1/3, 1/3] है, और query से dot product 1/3। Length √(3 × 1/9) = √(1/3) = 0.577 है। Cosine = (1/3) ÷ (1 × 0.577) = 0.58। दो विषयों पर 0.71 था, और तीन पर 0.58, यानी विषय जितने ज़्यादा, cosine उतना नीचे।

छोटा chunk: context छूट जाता है

अब उल्टा कीजिए, और बहुत छोटे chunks बनाइए। Queue log में 19 शब्द हैं, और उसे 5-5 शब्दों के chunks में काटने पर ये 4 chunks बनते हैं:

Chunk 1 · 5 शब्द
Queue log, last 3 weeks:
Chunk 2 · 5 शब्द
Tuesday 4pm office hour averaged
Chunk 3 · 5 शब्द
14 students waiting; Thursday 9am
Chunk 4 · 4 शब्द
office hour averaged 3.

चौथे chunk में 3 तो है, लेकिन ये नहीं लिखा कि ये किस दिन का office hour है। Thursday 9am तीसरे chunk में चला गया, इसलिए चौथे chunk का vector भी ये नहीं जानता। Lesson 2 वाले सवाल which office hour is least crowded का जवाब अब किसी एक chunk में पूरा नहीं है।

Fixed-size chunking इन दोनों के बीच का रास्ता लेता है: हर chunk में tokens की एक तय गिनती। Stanford की slide इसके लिए 100 से 500 tokens का example देती है।

छोटे chunks बारीक सवालों के लिए अच्छे हैं, लेकिन अपना context खो देते हैं। बड़े chunks को ज़्यादा context मिलता है, लेकिन उनका एक vector कई विषयों का औसत बन जाता है। Lesson 8 छोटे chunk का खोया context लौटाता है, और lesson 9 बड़े सवालों के लिए chunks के ऊपर summaries का ढाँचा बनाता है।

3Overlap और stride: boundary पर कटी बात बचाना

Overlap में हर नया chunk पिछले chunk के आख़िरी कुछ tokens दोहराकर शुरू होता है, ताकि boundary पर कटी बात पूरी बचे। इसकी ज़रूरत इसलिए है, क्योंकि size कुछ भी चुनिए, कोई न कोई बात किसी boundary पर कटेगी। शुरू में 50 tokens पर milestone की तारीख ऐसे ही कटी थी। Stanford की slide 10 से 20% overlap की सलाह देती है।

दो लगातार chunks की शुरुआत के बीच की दूरी को stride कहते हैं: stride = chunk size − overlap। Chunk size 9 और overlap 6 हो, तो stride 3 है, और chunks शब्द 0, 3, 6, 9, … पर शुरू होते हैं।

अब नीचे के widget में syllabus का शुरू वाला हिस्सा काटिए। यहाँ हर शब्द को एक token मानिए, और गिनती 0 से कीजिए। Milestone वाली बात, milestone is due Week 6, Thursday 11:59pm., 7 शब्दों की है, और syllabus में शब्द 3 से शब्द 9 तक है। Chunk size 9 और overlap 0 पर पहला chunk शब्द 0 से 8 तक है, इसलिए 11:59pm. उससे छूट जाता है।

पहले सोचिए

Chunk size 9 ही रखिए, और overlap 0 से 6 तक बढ़ाइए। किस overlap पर तारीख पहली बार किसी एक chunk में पूरी आएगी? पहले अंदाज़ा लगाइए, फिर widget में देखिए।

जवाब देखिए

सिर्फ़ overlap 6 पर। तब stride 3 है, और दूसरा chunk शब्द 3 से 11 तक चलता है, जिसमें पूरी तारीख है। Overlap 1 से 5 तक कोई chunk शब्द 3 पर या उससे पहले शुरू होकर शब्द 9 तक नहीं पहुँचता।

Syllabus को chunks में काटिए

Underline वाली बात, milestone की तारीख, किसी एक chunk में पूरी होनी चाहिए। हल्के background वाले शब्द overlap हैं।

9 0

कितना overlap काफ़ी है

Overlap 6 ही क्यों चाहिए, ये आप गिनकर देख सकते हैं। 9 शब्दों का chunk शब्द 3 से 9 तक की बात तभी पूरी रखता है, जब वो शब्द 1, 2 या 3 पर शुरू हो। Chunks 0, stride, 2 × stride, … पर शुरू होते हैं। इन 3 जगहों में कोई शुरुआत तभी पक्की गिरती है, जब stride 3 या कम हो। Stride 4 पर शुरुआतें 0, 4, 8 हैं, और 1, 2, 3 तीनों छूट जाते हैं। Stride = 9 − overlap है, इसलिए overlap कम से कम 6 चाहिए।

यही गिनती हर size पर चलती है। Chunk size C हो और बात L शब्दों की, तो chunk के शुरू होने की C − L + 1 सही जगहें होती हैं। यहाँ ये 9 − 7 + 1 = 3 थीं। Stride, यानी C − overlap, इससे ज़्यादा न हो, तो यही नियम निकलता है: ये नियम slide पर नहीं है, गिनती से निकलता है

overlap ≥ L − 1, और chunk size ≥ L

यहाँ L = 7, तो overlap कम से कम 6 चाहिए। Chunk ही बात से छोटा हो, तो कोई overlap बात को एक chunk में नहीं ला सकता।

पहले सोचिए

Widget में chunk size 10 और overlap 0 कीजिए। तारीख पूरी दिखती है। क्या ये पक्का बचाव है?

जवाब देखिए

नहीं, ये किस्मत है। पहला chunk शब्द 0 से 9 तक है, और तारीख ठीक शब्द 9 पर ख़त्म होती है। Syllabus की शुरुआत में एक शब्द और होता, तो 11:59pm. शब्द 10 पर जाता, और अगले chunk में चला जाता। L − 1 वाला overlap बात की जगह कहीं भी हो, उसे बचाता है।

Overlap की कीमत

Overlap मुफ़्त नहीं है, क्योंकि दोहराए गए tokens दो chunks में जाते हैं। 1,000 tokens के document को 50 tokens के chunks में काटिए, तो बिना overlap 1,000 ÷ 50 = 20 chunks बनते हैं। 10 tokens के overlap पर, यानी 20% पर, stride 40 है। तब chunks token 0, 40, …, 960 पर शुरू होते हैं, क्योंकि 960 वाला chunk document के अंत तक पहुँच जाता है। ये 960 ÷ 40 + 1 = 25 chunks हैं।

यानी 20% overlap पर 25% ज़्यादा embeddings बनाने और index में रखने पड़ते हैं।

4मतलब से काटना: headings, metadata और LLM

Semantic chunking text को वहाँ काटता है, जहाँ text खुद बँटा है, जैसे sentence या section के आख़िर में। इसकी ज़रूरत इसलिए है, क्योंकि fixed-size chunking गिनती से काटता है, और text का ढाँचा नहीं देखता। Widget में chunk size 20 और overlap 0 कीजिए। दूसरा chunk final report is due Week 10. से शुरू होकर office hours वाली बात में चला जाता है, यानी एक chunk में दो विषय।

Syllabus के हर हिस्से की अपनी heading है: Grading, Office hours और Project। Headings पर काटना semantic chunking का सबसे सीधा रूप है। Widget में Headings पर काटिए दबाइए। Syllabus 3 chunks में बँटता है, जिनमें 26, 16 और 12 शब्द हैं, और हर chunk एक ही विषय का है। Chunks का size अब बराबर नहीं है, और यही इस तरीके की कीमत है।

छोटा chunk फिर भी अपना context खो सकता है। Late days may not be applied to the milestone. अकेले ये नहीं बताता कि बात किस course की है। Context-enriched chunking इसके लिए हर chunk के साथ extra जानकारी रखता है, जैसे metadata या एक छोटी summary।

Metadata यानी data के बारे में data: document का नाम, section और तारीख। Context-enriched chunk कुछ ऐसा दिख सकता है: मेरा example

[Source: CS 329Z syllabus, section: Grading, updated: 30 Sep 2026]
Late days may not be applied to the milestone.

अब छोटा chunk भी बताता है कि वो किस course और किस section का है। Lesson 8 इसी idea का सबसे असरदार रूप दिखाता है, जिसमें LLM हर chunk के लिए context लिखता है।

आख़िरी तरीका AI-driven dynamic chunking है। ये LLM से पूछता है कि text में बात कहाँ बदलती है, और वहीं काटता है। ये headings न होने पर भी चलता है। लेकिन हर document को एक बार LLM से गुज़ारना पड़ता है, और उसमें समय और पैसा लगता है।

तरीकाफ़ायदाकीमत
Fixed-sizeआसान, हर chunk बराबरबात बीच से टूट सकती है
Fixed-size + overlapटूटी बात दूसरे chunk में पूरीज़्यादा chunks, दोहराई हुई बातें
Semantic, जैसे headingsहर chunk एक विषय काChunks का size ऊपर-नीचे होता है
Context-enrichedछोटे chunk को भी context मिलता हैMetadata या summary बनानी पड़ती है
AI-drivenबिना headings के भी मतलब वाली boundariesहर document पर LLM calls, धीमा और महँगा

अब शुरू वाले सवाल पर लौटिए। Headings पर काटने से Grading वाले chunk में milestone की पूरी तारीख है, और उसमें एक ही विषय है। यानी टूटी तारीख और घुला हुआ vector, दोनों दिक्कतें इस document पर एक साथ हल हो जाती हैं। हर document में साफ़ headings नहीं होतीं, इसलिए बाकी तरीके भी काम आते हैं।

अब आप Stanford की दोनों chunking slides पढ़ सकते हैं। पहली slide चारों तरीके गिनाती है, और दूसरी हमारे syllabus को तीन तरह से काटती है।

Stanford slide: Chunking: Basic Unit in Retrieval, चार तरह की chunking
Stanford की slide: Chunking: Basic Unit in Retrieval। ऊपर fixed-size chunking और overlap हैं (पड़ाव 2 और 3), और नीचे बाकी तीन तरीके (पड़ाव 4)।
Stanford slide: Chunking: Same Text, Three Splits
Stanford की slide: Chunking: Same Text, Three Splits। ऊपर हमारा syllabus है। नीचे बाएँ 50 tokens पर टूटी तारीख है, बीच में overlap से बची तारीख, और दाएँ headings पर कटा और साफ़ करके दोबारा लिखा chunk।

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

ऊपर के 4 पड़ाव आसान version जैसे ही हैं। आगे के 4 पड़ाव आपको Stanford की slides के level तक ले जाते हैं। इनमें पहले mean pooling और overlap का पूरा गणित है, फिर slide के source, यानी Databricks guide, से तरीकों की अंदर की बातें। आख़िर में आप slides खुद पढ़ते हैं। हर गणित वहीं समझाया है, जहाँ वो पहली बार आता है।

5Mean pooling का गणित: बात कितनी घुलती है

Mean pooling हर token को 1/N वज़न देती है, इसलिए किसी बात का असर chunk में उसके हिस्से जितना ही होता है। पड़ाव 2 में ये दो विषयों पर दिखा था। इस पड़ाव में वही हिसाब किसी भी गिनती के विषयों और किसी भी हिस्से पर चलता है।

पहले mean pooling को symbols में लिखिए। Chunk में N tokens हैं, और token t का vector ht है। सारे vectors का लीजिए, और N से भाग दीजिए:

hchunk = 1N ∑t=1N ht

पड़ाव 1 में N = 3 था, h1 = [0.9, 0.1], h2 = [0.7, 0.3] और h3 = [0.8, 0.2], और नतीजा [0.8, 0.2]। जोड़ने और भाग देने से numbers की गिनती नहीं बदलती, इसलिए hchunk में उतने ही numbers रहते हैं, जितने हर ht में। BERT-base हर token का 768 numbers वाला vector देता है। इसलिए chunk 100 tokens का हो या 500 का, उसके vector में 768 numbers होते हैं।

हर model औसत नहीं लेता। Lesson 3 के मुताबिक DPR पूरे passage के लिए [CLS] नाम के एक खास token का vector लेता है, और Sentence-BERT mean pooling करता है। दोनों में vector की dimension तय रहती है, और slide की आख़िरी line यही शर्त माँगती है।

k बराबर विषय: cosine 1/√k

अब एक toy model लीजिए, जिसमें हर token का vector ठीक अपने विषय की दिशा में है। अलग विषयों की दिशाएँ एक दूसरे से 90° पर हैं, यानी उनका cosine 0 है मेरा model। मान लीजिए chunk में 4 विषय बराबर हिस्से में हैं। तब हर विषय का हिस्सा 1/4 है, और mean pooling का vector [0.25, 0.25, 0.25, 0.25] बनता है। पहले विषय की query [1, 0, 0, 0] है।

  1. Dot product: 1 × 0.25 = 0.25, क्योंकि query के बाकी numbers 0 हैं।
  2. Length: √(4 × 0.25²) = √(4 × 0.0625) = √0.25 = 0.5।
  3. Cosine: 0.25 ÷ (1 × 0.5) = 0.5।

k विषयों पर यही steps ऐसे चलते हैं। हर number 1/k है, इसलिए dot product 1/k है। Length √(k × 1/k²) = √(1/k) = 1/√k है। Cosine (1/k) ÷ (1/√k) है, और k = √k × √k होने से ये 1/√k बनता है:

cosine = 1√k
Chunk में बराबर विषय, kQuery से cosine, 1/√k
11.00
2, पड़ाव 2 वाला बड़ा chunk0.71
3, पड़ाव 2 का सवाल0.58
40.50
100.32
1000.10

Table में cosine पहले तेज़ी से गिरता है, फिर धीरे। k को 4 गुना करने पर √k 2 गुना होता है, इसलिए cosine आधा हो जाता है। जैसे k = 1 पर 1.00, और k = 4 पर 0.50।

पहले सोचिए

k = 4 पर cosine 0.50 है। k = 25 पर cosine कितना होगा, और 100 पर?

जवाब देखिए

k = 25 पर 1/√25 = 1/5 = 0.20, और k = 100 पर 1/10 = 0.10। 25 से 100 पर k 4 गुना हुआ, और cosine 0.20 से आधा होकर 0.10 हुआ।

थोड़े हिस्से वाली बात लगभग गायब हो जाती है

असली chunk में विषय बराबर नहीं होते। मान लीजिए chunk का f हिस्सा office hours की बात है, और बाकी 1 − f हिस्सा deadlines की। तब mean pooling का vector [f, 1 − f] है, और query [1, 0] से cosine ये है:

cosine = f√(f² + (1 − f)²)

f = 0.2 पर देखिए। Vector [0.2, 0.8] है, और query से dot product 0.2। Length √(0.04 + 0.64) = √0.68 = 0.825 है, इसलिए cosine 0.2 ÷ 0.825 = 0.24।

Office hours का हिस्सा, fQuery से cosine
11.00
0.90.99
0.50.71
0.20.24
0.10.11
0.010.01

f छोटा हो, तो 1 − f लगभग 1 है, और नीचे वाला √ भी लगभग 1। तब cosine लगभग f ही रह जाता है। यानी जो बात chunk का 1% है, उसका cosine भी करीब 0.01 है।

अब शुरू वाले 40 pages के syllabus पर लौटिए। मान लीजिए हर page पर 50 lines हैं, यानी कुल 2,000 lines, और milestone की बात 2 lines की है मेरे बनाए numbers। तब f = 2 ÷ 2,000 = 0.001, और इस toy model में query का पूरे syllabus वाले vector से cosine भी करीब 0.001 है। असली encoder के vectors इतने साफ़ नहीं होते, लेकिन mean pooling में छोटे हिस्से का वज़न छोटा ही रहता है।

ध्यान दीजिए: Slide जिस Databricks guide को cite करती है, वो एक और हद बताता है। Embedding models और LLMs, दोनों की input की एक तय हद होती है। ठीक size के chunks उस हद के अंदर रहते हैं Databricks guide से। इसलिए 40 pages को एक vector में डालना अक्सर मुमकिन भी नहीं होता।

6Overlap का पूरा हिसाब: बात बचने का chance और chunks की गिनती

Overlap L − 1 से कम हो, तब भी बात कभी-कभी पूरी बच जाती है, और इसका chance (C − L + 1) ÷ stride है। पड़ाव 3 में नियम पक्के बचाव का था। इस पड़ाव में दिखता है कि कम overlap पर कितना जोखिम है, और overlap की कीमत कितनी है।

कम overlap पर बात बचने का chance

पड़ाव 3 में आपने देखा कि chunk के शुरू होने की C − L + 1 सही जगहें होती हैं। Chunks हर stride शब्दों पर शुरू होते हैं। अब मान लीजिए बात document में कहीं भी शुरू हो सकती है, और हर जगह का chance बराबर है मेरा model। तब लगातार stride जगहों में से C − L + 1 जगहों पर बात किसी chunk में पूरी आती है।

Size 9 और overlap 0 पर stride 9 है, और सही जगहें 9 − 7 + 1 = 3। तो 9 में से 3 जगहों पर बात बचती है, यानी 3 ÷ 9 = 33.3%, और 66.7% बार वो कटती है। पड़ाव 3 में syllabus वाली तारीख इन्हीं 66.7% में थी। Size 10 और overlap 0 पर chance (10 − 7 + 1) ÷ 10 = 40% है, यानी पड़ाव 3 वाली किस्मत 40% की थी।

chance = min(1, C − L + 1C − overlap)

min(1, x) का मतलब है 1 और x में से छोटा, क्योंकि chance 1 से ज़्यादा नहीं हो सकता। Stride, यानी नीचे वाला C − overlap, C − L + 1 तक या उससे छोटा हो, तो chance 1 है। यही पड़ाव 3 का नियम overlap ≥ L − 1 है।

Chunk size C, overlapStride7 शब्दों की बात बचे
9, 093/9 = 33.3%
10, 0104/10 = 40%
9, 543/4 = 75%
9, 63100%
50, 0slide वाला 50 tokens का chunk5044/50 = 88%
50, 510% overlap4544/45 = 97.8%
50, 1020% overlap40100%

बिना overlap के 50 tokens वाले chunks में 7 tokens की बात 12% बार कटती है, यानी (L − 1) ÷ C = 6 ÷ 50। 10% overlap पर ये 2.2% रह जाता है, और 20% पर 0।

Slide की 10 से 20% वाली सलाह कब काफ़ी है

Slide कहती है कि 10 से 20% overlap पर chunk boundary पर कोई sentence नहीं खोता। Overlap tokens में r × C है, जहाँ r overlap का हिस्सा है, जैसे 20% के लिए 0.2। पड़ाव 3 के नियम से ये overlap + 1 tokens तक के sentences को पक्का बचाता है:

Chunk size10% overlap बचाता है20% overlap बचाता है
100 tokens11 tokens तकoverlap 1021 tokens तकoverlap 20
200 tokens21 tokens तकoverlap 2041 tokens तकoverlap 40
500 tokens51 tokens तकoverlap 50101 tokens तकoverlap 100

इसलिए slide की बात बड़े chunks पर सच है, लेकिन 100 tokens के chunks और 10% overlap पर 30 tokens का sentence कट सकता है। Slide का दावा chunk size और sentences की लंबाई पर टिका है।

पहले सोचिए

आपके documents में ज़्यादातर sentences 30 tokens से छोटे हैं, और chunk size 200 tokens है। कोई sentence न कटे, इसके लिए कम से कम कितना overlap चाहिए? ये chunk size का कितना % है?

जवाब देखिए

L = 30, तो overlap कम से कम 29 tokens। 29 ÷ 200 = 14.5%, जो slide के 10 से 20% वाले दायरे में है।

Chunks गिनने का formula, और overlap की कीमत

पड़ाव 3 में 1,000 tokens, chunk size 50 और stride 40 पर 25 chunks बने थे। आख़िरी chunk वहाँ शुरू होता है, जहाँ से 50 tokens document के अंत तक पहुँचें, यानी token 950 पर या उसके बाद। 40, 80, 120, … में ऐसा पहला number 960 है, और 0 से 960 तक 960 ÷ 40 + 1 = 25 शुरुआतें हैं। यही गिनती एक formula में आती है, जहाँ N document के tokens हैं:

chunks = ⌈N − Cstride⌉ + 1

⌈x⌉ का मतलब है x या उससे बड़ा सबसे छोटा पूरा number, जैसे ⌈23.75⌉ = 24 और ⌈19⌉ = 19। जाँच: (1,000 − 50) ÷ 40 = 23.75, तो 24 + 1 = 25 chunks। बिना overlap (1,000 − 50) ÷ 50 = 19, तो 19 + 1 = 20 chunks। ये formula तब के लिए है, जब document chunk से लंबा हो।

लंबे document पर chunks करीब N ÷ stride होते हैं। इसलिए overlap embeddings को करीब C ÷ stride गुना कर देता है। Overlap का हिस्सा r हो, तो stride = C × (1 − r), और ये गुणा 1 ÷ (1 − r) बनता है:

Overlap का हिस्सा, rEmbeddings कितने गुना, 1 ÷ (1 − r)
01.00
10%1.11
20%1.25
25%1.33
50%2.00
75%4.00

ये भाग शुरू में धीरे बढ़ता है, फिर तेज़ी से, क्योंकि नीचे वाला 1 − r 0 की तरफ़ जाता है। Slide की 10 से 20% वाली सलाह इसी कम कीमत वाले हिस्से में है: 11% से 25% ज़्यादा embeddings।

अब 40 pages के syllabus पर चलाइए। मान लीजिए हर page पर 500 tokens हैं, यानी N = 20,000 मेरा अंदाज़ा। Slide के 100 से 500 tokens वाले दोनों छोरों पर गिनती ये है:

Chunk size, overlapStrideChunks
100, 0100200
100, 20 (20%)80250⌈19,900 ÷ 80⌉ + 1 = 249 + 1
500, 050040
500, 100 (20%)40050⌈19,500 ÷ 400⌉ + 1 = 49 + 1

Overlap की एक और कीमत है। Overlap वाले tokens दो पड़ोसी chunks में होते हैं। इसलिए एक ही बात top-K में दो बार आ सकती है, और prompt की जगह खा सकती है।

7तरीके अंदर से: Databricks guide

Chunking वाली slide अपने तरीकों के लिए एक Databricks guide को cite करती है, जो हर तरीके को code के साथ समझाता है। ये guide Databricks community पर 2025 का एक technical blog है: The Ultimate Guide to Chunking Strategies for RAG Applications with Databricks। 10 से 20% वाली सलाह भी इसी guide में है। इस पड़ाव में guide की अंदर की बातें हमारे syllabus पर चलती हैं। जो बात guide में है लेकिन slide पर नहीं, उस पर Databricks guide से लिखा है।

Content के हिसाब से size और overlap

Slide सिर्फ़ 100 से 500 tokens का example देती है। Guide इसी को content की किस्म के हिसाब से बाँटता है: Databricks guide से

ContentChunk sizeOverlap
आम text200 से 500 tokens10 से 20%
Code या बहुत technical text100 से 200 tokens15 से 25%
कहानी जैसा लंबा text500 से 1,000 tokensList में नहींcode में 800 पर 100, यानी 12.5%

Guide ये भी कहता है कि पहले fixed-size chunking को कई sizes पर चलाइए, जैसे 100, 200, 500 और 1,000, और नतीजे नापिए। नापने के लिए वो context precision और context recall गिनाता है। पहला बताता है कि chunks में फ़ालतू text कितना कम है, और दूसरा कि सवाल की सारी ज़रूरी बातें आईं या नहीं। Guide में MongoDB की एक study का ज़िक्र है। उसमें Python docs के लिए करीब 100 tokens के chunks और करीब 15 tokens का overlap सबसे अच्छा रहा Databricks guide से। Recall को नापने का तरीका lesson 13 में है।

ध्यान दीजिए: Guide की सलाह tokens में है, लेकिन उसका code chunk_size को characters में गिनता है Databricks guide से। वो Python का len लेता है। अपने splitter में पहले check कीजिए कि size tokens में है, शब्दों में, या characters में।

Recursive splitting: बड़े separator से छोटे तक

Recursive chunking separators की एक सीढ़ी पर काटता है। पहले सबसे बड़े separator पर काटता है, और जो टुकड़ा फिर भी chunk size से बड़ा रहे, उसे अगले छोटे separator पर। Guide के code में ये सीढ़ी है: खाली line, फिर नई line, फिर . , फिर space, और आख़िर में कोई भी character Databricks guide से। खाली line paragraph का अंत है, और . sentence का। Code के लिए guide def और class जैसे separators सुझाता है।

हमारे syllabus पर chunk size 20 शब्द रखिए, और मान लीजिए हर section के बाद एक खाली line है मेरा example। तब पहले कट खाली lines पर लगते हैं, और तीन sections बनते हैं। Office hours में 16 और Project में 12 शब्द हैं, इसलिए दोनों एक-एक chunk बनते हैं। Grading में 26 शब्द हैं, जो 20 से ज़्यादा हैं, इसलिए वो sentences में कटता है:

  1. Sentences: Grading. (1 शब्द), milestone वाला sentence (9), late days वाला sentence (9), और final report वाला sentence (7)।
  2. इन्हें क्रम से जोड़िए, जब तक 20 पार न हो: 1 + 9 + 9 = 19। अगला sentence जोड़ने पर 26 होता, इसलिए पहला chunk 19 शब्दों पर रुकता है।
  3. दूसरा chunk final report वाला sentence है, 7 शब्दों का।

Milestone की तारीख पूरी है, और कोई sentence बीच से नहीं कटा। Widget में fixed size 20 पर पहला chunk The पर ख़त्म होता था, और final report अगले chunk में चला जाता था। Guide का semantic chunking वाला example भी असल में यही recursive splitter है। Databricks guide से

Sentence vectors से boundary ढूँढना

Headings न हों, तब भी आप विषय बदलने की जगह ढूँढ सकते हैं। Guide कहता है कि लगातार मिलते-जुलते टुकड़ों को आप एक chunk में जोड़ सकते हैं Databricks guide से। तरीका ये है: हर sentence का vector बनाइए, हर दो पड़ोसी sentences का cosine निकालिए, और जहाँ cosine अचानक गिरे, वहाँ काटिए। Syllabus के चार sentences के vectors ये मानिए: मेरे बनाए numbers

SentenceVectorअगले sentence से cosine
The project milestone is due…[0.1, 0.9]0.99
Late days may not be applied…[0.2, 0.8]0.99
The final report is due Week 10.[0.1, 0.9]0.22
Tuesday 4pm in Room 104…[0.9, 0.1]–
  1. Final report और Tuesday वाले sentence का dot product: 0.1 × 0.9 + 0.9 × 0.1 = 0.18।
  2. दोनों की length √(0.01 + 0.81) = √0.82 = 0.906।
  3. Cosine: 0.18 ÷ (0.906 × 0.906) = 0.18 ÷ 0.82 = 0.22।

पहले दो cosines 0.99 हैं। जैसे milestone और late days के लिए 0.74 ÷ (0.906 × 0.825) = 0.74 ÷ 0.747 = 0.99। 0.5 जैसी कोई हद रखिए, तो सिर्फ़ तीसरे और चौथे sentence के बीच कट लगता है, यानी ठीक Office hours वाली heading पर। Headings के बिना भी वही split मिला। इसकी कीमत हर sentence पर एक encoder call है, और हद का फ़ैसला आपको खुद करना है, क्योंकि guide कोई हद नहीं देता।

Metadata, summaries और filter

Guide के context-enriched example में हर chunk के साथ उसके पड़ोसी chunks की summary जुड़ती है, एक तरफ़ एक chunk और दूसरी तरफ़ एक। ये summary एक LLM लिखता है, और prompt Provide a brief summary of the following text से शुरू होता है Databricks guide से। Guide के मुताबिक section का नाम, document की किस्म और तारीख जैसा metadata filter करने में भी काम आता है।

हमारे corpus पर ये filter सीधा दिखता है। हर chunk के metadata में तारीख हो, तो retriever ranking से पहले 2025 से पुराने chunks हटा सकता है। तब 2024 वाला पुराना forum post ranking तक पहुँचता ही नहीं। Guide इसकी कीमत भी बताता है: storage और memory बढ़ती है, और ध्यान न दें, तो एक ही बात कई chunks में बार-बार आती है। Databricks guide से

Lesson 8 इसी idea का सबसे असरदार रूप दिखाता है। Lesson 18 metadata की तारीख से पुराने और आपस में टकराते sources पकड़ता है।

LLM से chunking की कीमत

Guide के AI-driven example में पूरा document एक prompt में LLM को जाता है, और साथ में ये instructions: Databricks guide से

LLM जवाब में chunks के texts की एक JSON list लौटाता है।

इसका मतलब है कि LLM पूरा document पढ़ता है, और पूरा document दोबारा लिखता है। 20,000 tokens के syllabus पर ये करीब 20,000 input tokens और 20,000 output tokens हैं, यानी 40,000 tokens का काम। Fixed-size chunking में LLM का कोई काम ही नहीं है। Guide के code में जवाब की हद max_tokens = 4000 है, इसलिए करीब 4,000 tokens से लंबा document एक call में पूरा वापस नहीं आ सकता। Databricks guide से

Guide खुद इसकी तीन कमियाँ गिनाता है। नतीजा LLM पर टिका है, compute और API calls महँगी हैं, और हर बार एक जैसे chunks पाना मुश्किल है।

Guide दो और तरीके गिनाता है, जो slide पर नहीं हैं। Adaptive chunking मुश्किल हिस्सों को छोटे chunks देता है, और आसान हिस्सों को बड़े। Hierarchical chunking section, subsection और paragraph के कई levels रखता है Databricks guide से। Lesson 9 का RAPTOR chunks के ऊपर summaries के levels बनाता है।

पहले सोचिए

आपके पास company की HR policy है। उसमें साफ़ headings हैं, और हर section 150 से 400 tokens का है। आप कौन सा तरीका लेंगे, और क्यों?

जवाब देखिए

Headings पर काटना, यानी semantic chunking। Sections पहले से एक-एक विषय के हैं, और उनका size guide के आम text वाले 200 से 500 tokens के करीब है। साथ में section का नाम और तारीख metadata में रख दीजिए, ताकि छोटा chunk भी अपना context बताए, और पुरानी policy filter हो सके। LLM chunking की यहाँ ज़रूरत नहीं, क्योंकि boundaries पहले से साफ़ हैं।

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

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

Stanford slide: What Makes A Good Retriever? Embeddings, पाँच तरह के embeddings की table
उसी slide की आख़िरी line, बड़ी करके
Stanford की embeddings वाली slide, और नीचे उसकी आख़िरी line, बड़ी करके। Table की हर row lesson 3 के गहरे version में पढ़िए। यहाँ सवाल chunk वाले हिस्से पर हैं।

Embeddings वाली slide पढ़िए

  1. आख़िरी line हर chunk का fixed-dimension vector माँगती है। Headings पर कटे Grading chunk में 26 शब्द हैं, और Project chunk में 12। Mean pooling के बाद दोनों के vectors में कितने numbers होंगे?

    जवाब देखिए

    दोनों में उतने ही, जितने हर token के vector में: हमारे toy में 2, और BERT-base में 768। N vectors का औसत लेने पर numbers की गिनती नहीं बदलती, बस N से भाग लगता है। (पड़ाव 1 और 5)

  2. Passage वाली row कहती है कि एक vector एक chunk का है। Headings पर काटने पर हमारे syllabus के index में कितने vectors होंगे, और size 9, overlap 6 वाले fixed-size chunks पर कितने?

    जवाब देखिए

    Headings पर 3 vectors, और size 9, overlap 6 पर 16, क्योंकि stride 3 पर 54 शब्दों में 16 chunks बनते हैं। Widget में दोनों गिनतियाँ दिखती हैं। (पड़ाव 3 और 4)

Stanford slide: Chunking: Basic Unit in Retrieval
उसी slide का fixed-size chunking वाला हिस्सा, बड़ा करके
उसी slide के बाकी तीन तरीके, बड़े करके
Stanford की slide: Chunking: Basic Unit in Retrieval। ऊपर दाएँ की तस्वीर एक बड़े document को sections में, और हर section को chunks में बाँटती है। नीचे fixed-size वाला हिस्सा और बाकी तीन तरीके, बड़े करके।

Chunking वाली slide पढ़िए

  1. Too large: one vector averages many topics। 10 बराबर विषयों वाले chunk का किसी एक विषय की query से cosine कितना है?

    जवाब देखिए

    1/√10 = 0.32। एक विषय वाले chunk पर ये 1.00 होता। पड़ाव 5 के toy model में विषय जितने ज़्यादा, cosine उतना नीचे। (पड़ाव 2 और 5)

  2. Overlap वाली line 10 से 20% overlap पर कहती है कि boundary पर कोई sentence नहीं खोता। 100 tokens के chunks और 10% overlap पर 30 tokens का sentence बचेगा?

    जवाब देखिए

    पक्का नहीं। 10% overlap 10 tokens है, जो 11 tokens तक के sentences बचाता है। 30 tokens के लिए 29 का overlap चाहिए, यानी 29%। पड़ाव 6 के model में stride 90 पर ये sentence (100 − 30 + 1) ÷ 90 = 78.9% बार बचता है, और 21.1% बार कटता है। (पड़ाव 3 और 6)

  3. Context-enriched और AI-driven, दोनों में LLM लग सकता है। दोनों में LLM का काम कैसे अलग है?

    जवाब देखिए

    Context-enriched में boundaries पहले जैसी रहती हैं, और LLM हर chunk के साथ जुड़ने वाली summary लिखता है। AI-driven में LLM खुद boundaries तय करता है, और guide के example में पूरा document chunks के रूप में दोबारा लिखता है। (पड़ाव 4 और 7)

Stanford slide: Chunking: Same Text, Three Splits
उसी slide का syllabus text, बड़ा करके
उसी slide के तीनों तरीके, बड़े करके
Stanford की slide: Chunking: Same Text, Three Splits। नीचे उसका syllabus text और तीनों तरीके, बड़े करके।

तीन splits वाली slide पढ़िए

  1. बीच वाले column में दोनों chunks में कौन से शब्द दोहराए गए हैं? Milestone वाली पूरी बात किस chunk में है, और क्या ये overlap हर बार काफ़ी होगा?

    जवाब देखिए

    Slide पर due Week 6, Thursday 11:59pm. दोनों chunks में दिखता है, यानी कम से कम 5 शब्द, क्योंकि “…” के पीछे और शब्द भी हो सकते हैं। पूरी बात, यानी milestone से 11:59pm तक, पहले chunk में है।

    7 शब्दों की बात को हर जगह पक्का बचाने के लिए overlap कम से कम 6 चाहिए। इसलिए slide एक ऐसा case दिखाती है जहाँ बात बची, गारंटी नहीं। (पड़ाव 3 और 6)

  2. दाएँ column का chunk बाकी दोनों से कैसे अलग है?

    जवाब देखिए

    वो Grading वाली heading पर कटा है, इसलिए उसमें पूरा section और एक ही विषय है। साथ ही किसी ने उसका text साफ़ करके दोबारा लिखा है: Thursday की जगह Thu, और Late days: not allowed on the milestone। यानी ये headings पर काटना और chunk को दोबारा लिखना, दोनों साथ हैं। (पड़ाव 4 और 7)

  3. Slide के ऊपर वाले text में 26 शब्द हैं। Widget जैसे fixed size 20 पर ये कैसे कटता, और headings पर कैसे?

    जवाब देखिए

    Size 20 पर पहला chunk शब्द 0 से 19 तक है, और The पर ख़त्म होता है। दूसरा chunk final report is due Week 10. है। तारीख पूरी बची, लेकिन final report वाला sentence टूट गया। Headings पर पूरा text एक ही chunk है, क्योंकि ये पूरा Grading section है। (पड़ाव 3 और 4)

इस lesson की 3 बातें

  1. Retrieval को हर chunk का एक vector चाहिए, और ये अक्सर contextual token vectors का औसत होता है, यानी mean pooling। Tokens कितने भी हों, vector की dimension वही रहती है।
  2. Mean pooling में किसी बात का असर उसके हिस्से जितना है। k बराबर विषयों पर cosine 1/√k है, और 1% हिस्से वाली बात का cosine करीब 0.01।
  3. Overlap L − 1 हो, तो L tokens की बात पक्की बचती है, और कम हो, तो बचने का chance (C − L + 1) ÷ stride है। Overlap embeddings को करीब 1 ÷ (1 − r) गुना करता है, और headings या sentence vectors पर काटने से बात टूटती ही नहीं।

इस lesson के नए शब्द

Word type और token in context
Dictionary का एक शब्द, और किसी sentence में उसका एक इस्तेमाल। जैसे late एक word type है, और Late days may not be applied में उसका इस्तेमाल एक token in context।
Static word embedding
हर word type का एक ही vector, context कुछ भी हो। जैसे word2vec और GloVe। Late का vector दोनों sentences में [0.5, 0.5] रहता है। मेरे numbers
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
Passage embedding
पूरे chunk का एक vector, जिसे retrieval का index रखता है। जैसे Sentence-BERT, DPR और E5 के vectors।
Multimodal embedding
Text और image, दोनों के vectors एक ही space में। जैसे CLIP। Whiteboard पर लिखे office hours की photo और text office hours schedule के vectors पास आ सकते हैं।
Graph embedding
किसी network के node या relation का vector। जैसे node2vec। Course के graph में TA, office hours, और उनके बीच का runs वाला relation।
Mean pooling
कई token vectors का औसत लेकर एक vector बनाना। जैसे [0.9, 0.1], [0.7, 0.3] और [0.8, 0.2] का औसत [0.8, 0.2]।
Chunk
Retrieval के लिए document का एक टुकड़ा, और retrieval की basic unit। जैसे 40 pages के syllabus का Grading वाला हिस्सा।
Fixed-size chunking
तय गिनती के tokens पर काटना, चाहे बात बीच में टूटे। जैसे हर 50 tokens पर।
Overlap
नया chunk पिछले chunk के आख़िरी कुछ tokens दोहराकर शुरू हो। L tokens की बात बचाने के लिए कम से कम L − 1। जैसे 7 शब्दों की तारीख के लिए 6।
Stride
दो लगातार chunks की शुरुआत के बीच की दूरी: chunk size − overlap। जैसे 9 − 6 = 3।
Semantic chunking
Sentence या section जैसी logical boundaries पर काटना। जैसे syllabus को Grading, Office hours और Project वाली headings पर।
Context-enriched chunking
हर chunk के साथ metadata या summary रखना। जैसे हर chunk के ऊपर Source: CS 329Z syllabus, section: Grading।
Metadata
Data के बारे में data: नाम, section, तारीख। जैसे CS 329Z syllabus, Grading, 30 Sep 2026।
AI-driven dynamic chunking
LLM से पूछकर काटना कि text में बात कहाँ बदलती है। हर document पर LLM calls लगती हैं।
Recursive chunking
Separators की सीढ़ी पर काटना: पहले paragraph, फिर line, फिर sentence, फिर space। जो टुकड़ा chunk size से बड़ा रहे, वही अगले separator पर कटता है। जैसे size 20 पर Grading section 19 और 7 शब्दों के दो chunks बनता है।
⌈x⌉ (ceiling)
x या उससे बड़ा सबसे छोटा पूरा number। जैसे ⌈23.75⌉ = 24, और chunks = ⌈(1,000 − 50) ÷ 40⌉ + 1 = 25।