एक LLM बनाएँएडवांस्डपाठ 486 मिनट का पाठ

स्टेप 12 · Long context

4k से 1M tokens तक जाना सिर्फ एक ट्रिक नहीं है। यह चार ट्रिक्स हैं, और हर एक की अपनी कीमत होती है।

✦ ट्यूटर से पूछें🧪 लैब · 25 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

स्टेप 12 · Long context

4k से 1M tokens तक जाना सिर्फ एक ट्रिक नहीं है। यह चार ट्रिक्स हैं, और हर एक की अपनी कीमत होती है।

1/6
आसान शब्दों में
छोटा attention span सस्ता होता है। बहुत लंबा होने पर बहुत ज़्यादा memory खर्च होती है और ध्यान आसानी से भटक जाता है। दोनों समस्याओं को ठीक करना ज़रूरी है, सिर्फ पहली को नहीं।
आपके और long context के बीच दो अलग-अलग रुकावटें हैं, और लोग अक्सर सिर्फ पहली को ही सुलझाते हैं।
  1. 1

    रुकावट 1 · Compute और memory

    Sequence length के साथ attention quadratic तरीके से बढ़ता है, और KV cache इसके साथ linearly बढ़ता है। 1M tokens पर, दोनों बहुत भारी पड़ते हैं।
  2. 2

    रुकावट 2 · मॉडल ने इसे कभी देखा ही नहीं है

    4k sequences पर train की गई position encodings का मतलब अपने-आप 100k पर समझ नहीं आता। मॉडल पूरे आत्मविश्वास के साथ बकवास करने लगता है।
  3. 3

    रुकावट 3 · इसके पास जो है, यह उसका इस्तेमाल नहीं कर पाता

    भले ही 200k की window काम कर रही हो, बहुत लंबे inputs के बीच में retrieval की क्वालिटी अक्सर गिर जाती है। एक बड़ी window होने का मतलब यह नहीं है कि attention उस पर सही ढंग से बंटा हुआ है।

तकनीकें

तकनीकक्या ठीक करता हैकीमत
FlashAttentionखुद attention की memoryकुछ नहीं — इसे हमेशा इस्तेमाल करें
GQA / MQAKV cache का साइज़क्वालिटी में बहुत मामूली कमी
RoPE scaling (NTK, YaRN)Position extrapolationथोड़ी continued training की ज़रूरत होती है
Sliding-window attentionQuadratic लागतसटीक long-range attention खो देता है
Attention sinksStreaming स्थिरताArchitectural बदलाव
KV cache quantisationServing memoryAccuracy में थोड़ी कमी
Ring / sequence parallelलंबी sequences पर trainingजटिलता, interconnect पर दबाव

Context extension असल में कैसे काम करता है

Extending RoPE to a longer contextpython
def yarn_scaled_frequencies(head_dim, orig_max, target_max, base=10000.0):
    """Interpolate low-frequency dimensions, leave high-frequency ones alone."""
    scale = target_max / orig_max
    inv = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
    wavelen = 2 * math.pi / inv

    low, high = orig_max / 32, orig_max / 4        # boundary wavelengths
    # short wavelengths (local detail) keep their original frequency
    # long wavelengths (global position) get interpolated by the scale factor
    ratio = ((orig_max / wavelen) - low) / (high - low)
    ratio = ratio.clamp(0, 1)
    return inv / (scale * (1 - ratio) + ratio)

# then continue training on long documents for a few billion tokens --
# scaling the frequencies alone is not enough on its own
सावधान रहें
वही आखिरी बात वह हिस्सा है जिसे लोग छोड़ देते हैं। बिना किसी continued training के frequencies को rescale करने से एक ऐसा मॉडल मिलता है जो लंबे input को स्वीकार तो कर लेता है, लेकिन उस पर बहुत खराब तरीके से reasoning करता है। पब्लिश किए गए सभी long-context मॉडल्स में एक समर्पित long-context training फेज़ शामिल होता है।

ईमानदारी से टेस्ट करें

  • Needle in a haystack — किसी लंबे दस्तावेज़ में एक तथ्य छुपाएं और कई अलग-अलग गहराइयों व लंबाइयों पर उसके बारे में पूछें। यह बुनियादी बात है, और इसे पास करना आसान है।
  • Multi-needle — कई तथ्य जिन्हें आपस में जोड़ना ज़रूरी होता है। यह काफी कठिन है, और असली इस्तेमाल का कहीं बेहतर अंदाज़ा देता है।
  • Full-document reasoning — एक ऐसा सवाल जिसके जवाब के लिए ज़्यादातर input की ज़रूरत होती है। यहीं पर long-context के दावे अक्सर फेल हो जाते हैं।
  • लंबाई पर Latency और लागत — 500k-token का प्रॉम्प्ट प्रोसेस करना हर बार धीमा और महंगा होता है।
यह करें
इंजीनियरिंग का वह फैसला जिसे ज़्यादातर टीमें गलत समझती हैं: retrieval आमतौर पर एक विशाल context से बेहतर होता है। मॉडल से 500k पढ़वाने की तुलना में सही 4k tokens ढूंढना ज़्यादा सस्ता, तेज़ और सटीक होता है। Long context का इस्तेमाल तब करें जब काम को सचमुच पूरे स्ट्रक्चर की ज़रूरत हो — जैसे पूरा codebase, पूरा कॉन्ट्रैक्ट — इसे सर्च के विकल्प के तौर पर न इस्तेमाल करें।
ख़तरा
सिक्योरिटी के नज़रिए से देखें तो context का हर अतिरिक्त token किसी injected instruction के छुपने के लिए अतिरिक्त जगह है, और Module 5 वाली बात और भी अहम हो जाती है: बहुत लंबे context में, आपके सुरक्षा निर्देश उस पूरे हिस्से का बहुत छोटा अंश रह जाते हैं जो मॉडल पढ़ रहा होता है।

और देखें और पढ़ें

Long context in LLMsYouTube searchNeedle in a haystack evaluationYouTube search

लैब

एक ऐसा context extension जो सचमुच काम करता है, ईमानदारी से टेस्ट किया गया।

~25 min

समस्या

2k पर train किया गया एक मॉडल लें। RoPE को rescale करके इसे 8k तक बढ़ाएं। Single-needle retrieval के साथ टेस्ट करें — यह पास हो जाएगा। फिर multi-needle और full-document reasoning के साथ टेस्ट करें, जहाँ यह पास नहीं होगा।
शुरुआती कोडpython
# Single needle passes easily. These are the tests that discriminate.
def multi_needle(doc, facts, question):  ...   # answer requires 3+ facts combined
def full_doc(doc, question):             ...   # answer requires most of the input
Google Colab खोलें ↗इस कोड के लिए आपके अपने सेटअप की ज़रूरत है (एक मॉडल, एक GPU या अतिरिक्त पैकेज)। इसे Google Colab में चलाएं: File → Upload notebook।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1Needle-in-a-haystack 100% पर है और यूज़र्स कह रहे हैं कि long-context काम नहीं कर रहा। दोनों बातों का मिलान करें।दिखाएं
Needle टेस्ट हूबहू किसी एक हिस्से (verbatim span) के retrieval की जांच करता है, जो सबसे आसान long-context ऑपरेशन है और जिसे attention सबसे अच्छी तरह संभालता है। असली इस्तेमाल में दूर-दूर के कई हिस्सों को आपस में जोड़ने, बदलने वाली entities को ट्रैक करने और किसी चीज़ की गैर-मौजूदगी को पकड़ने की ज़रूरत होती है — ये सभी चीजें single-needle की तुलना में बहुत पहले खराब होने लगती हैं। 100% needle स्कोर का मतलब यह है कि window में जानकारी ढूंढी जा सकती है, इसका यह मतलब नहीं कि reasoning भी पूरी window में फैलकर काम कर रही है। पूरे दस्तावेज़ पर multi-hop सवालों से टेस्ट करें।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या मैं बस एक बड़ी max length सेट कर सकता हूँ?

आप नंबर सेट कर सकते हैं, और मॉडल उस सीमा से आगे फर्राटेदार बकवास पैदा करेगा जिसके लिए उसे train किया गया था। असली context extension के लिए frequency scaling के साथ-साथ सचमुच लंबे दस्तावेज़ों पर continued training की ज़रूरत होती है।

लंबे inputs के बीच में क्वालिटी क्यों गिर जाती है?

यह बार-बार देखा गया है और पूरी तरह से समझाया नहीं गया है। Training डेटा में long-range dependencies के बहुत कम उदाहरण होते हैं, और बहुत ज़्यादा दूरी पर position encodings कम स्पष्ट रूप से काम करती हैं। सुधार के उपाय मदद करते हैं; लेकिन यह असर पूरी तरह खत्म नहीं हुआ है।

Serving में long context की क्या लागत आती है?

KV cache, context length गुणा batch size के हिसाब से बढ़ता है। यह अक्सर इस बात पर सबसे बड़ी रुकावट बनता है कि एक GPU कितने यूज़र्स को serve कर सकता है, और यही वजह है कि GQA और cache quantisation इतने मायने रखते हैं।

क्या यहाँ state-space models बेहतर हैं?

उनका inference लीनियर टाइम में होता है और state का साइज़ तय रहता है, जो लंबी sequences के लिए बहुत आकर्षक है। फिलहाल वे कुछ सटीक recall खो देते हैं, यही वजह है कि attention layers को बीच-बीच में जोड़ने वाले hybrid मॉडल्स लोकप्रिय हैं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें