HI ▾

Uncensored Model Hubmodel_context_window_exceeded: कारण और समाधान

model_context_window_exceeded: कारण और समाधान

एक context window त्रुटि का अर्थ है कि आपका प्रॉम्प्ट और आपका माँगा हुआ जवाब मिलकर मॉडल की मेमोरी में अब नहीं समाते। यह लेख इस API (100,000 टोकन) पर सीमा, अपने प्रॉम्प्ट को मापने के तरीके और उस कोड की व्याख्या करता है जो विफल होने से पहले इतिहास को कम करता है।

अपडेट किया गया

चमकते हुए ब्लॉकों से भरा कांच का पात्र, अतिप्रवाह काटा गया, एक पूर्ण context window का प्रतिनिधित्व

मुख्य बिंदु

  1. विंडो 100,000 टोकन की है और यह प्रॉम्प्ट और कम्पलीशन को एक साथ गिनती है।
  2. चैट ऐप्स हर बारी में पूरा इतिहास पुनः भेजने के कारण इस सीमा को पार कर जाते हैं।
  3. भेजने से पहले टोकन गिनें या अनुमान लगाएं, और जवाब के लिए एक आरक्षित जगह रखें।
  4. पुराने टर्न्स को कम करने से लागत भी कम होती है, क्योंकि इनपुट $0.15 प्रति 1M टोकन पर बिल किया जाता है।

model_context_window_exceeded का अर्थ क्या है

स्ट्रिंग model_context_window_exceeded कुछ क्लाइंट्स, SDKs और APIs द्वारा एक विशिष्ट विफलता को लेबल करने का तरीका है: आपने जो टेक्स्ट भेजा है, और जवाब के लिए आवश्यक जगह, मिलकर उससे बड़े हैं जितना मॉडल एक अनुरोध में रख सकता है। संदेश का शब्दचयन टूल्स के बीच अलग-अलग होता है, इसलिए किसी नाम पर निर्भर रहने के बजाय क्लाइंट द्वारा दिखाई गई पूरी त्रुटि बॉडी पढ़ें। कारण हमेशा एक जैसा होता है।

इस API पर कॉन्टेक्स्ट विंडो 100,000 टोकन की है, और यह संख्या प्रॉम्प्ट और कम्पलीशन दोनों को मिलाकर कवर करती है। यदि आपका प्रॉम्प्ट 95,000 टोकन का उपयोग करता है, तो जवाब के लिए अधिकतम लगभग 5,000 टोकन शेष रहते हैं। यदि आप max_tokens को 8,000 पर सेट भी करते हैं, तो अनुरोध विंडो की अनुमति से अधिक मांग करता है। max_tokens फ़ील्ड वैकल्पिक है, और जब आप इसे छोड़ देते हैं, तो जवाब बस शेष जगह का उपयोग करता है।

इस तरह विफल होने वाला एक अनुरोध कम्पलीशन के बजाय एक त्रुटि लौटाता है। विफल अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए लिमिट पर पहुँचने से आपको केवल राउंड ट्रिप का ही नुकसान होता है। इसका समाधान आपके पक्ष से है: कम भेजें, या कम माँगें।

100,000 टोकन कितने बड़े होते हैं?

एक टोकन टेक्स्ट का एक हिस्सा होता है, जो अक्सर एक छोटा शब्द या एक लंबे शब्द का भाग होता है। साधारण अंग्रेजी लेखन के लिए एक अनुमानित नियम यह है कि चार अक्षरों के लिए एक टोकन, या लगभग तीन चौथाई शब्द। उस नियम के अनुसार 100,000 टोकन लगभग 75,000 शब्दों के बराबर होते हैं, जो एक मोटी किताब है। कोड, JSON, टेबल और गैर-अंग्रेजी टेक्स्ट अक्षर प्रति अधिक टोकन में विभाजित होते हैं, इसलिए समान अक्षर गणना बहुत बड़ी हो सकती है। किसी भी अंदाजे के नियम को एक गारंटी के बजाय एक योजना संख्या के रूप में देखें।

सटीक गणना मॉडल के अपने टोकनाइज़र से आती है। API प्रतिक्रिया में वास्तविक उपयोग रिपोर्ट करता है: usage ऑब्जेक्ट प्रॉम्प्ट और कम्पलीशन टोकन सूचीबद्ध करता है, और एक स्ट्रीमिंग प्रतिक्रिया उपयोग को अंत में भेजती है। यह सबसे विश्वसनीय डेटा है जो आपके पास है, इसलिए इसे लॉग करें।

सामग्रीअनुमानित आकार
दो वाक्यों का एक चैट संदेश40 से 60 टोकन
अंग्रेजी टेक्स्ट का एक पृष्ठ, 500 शब्दलगभग 670 टोकन
10,000 शब्दों का दस्तावेज़लगभग 13,000 टोकन
3 MB का JSON डंपअक्सर 100,000 टोकन से अधिक, भेजने के लिए बहुत बड़ा

अनुरोध बॉडी की भी 8 MB की सीमा है, जो टोकन से अलग सीमा है। बड़े इनपुट किसी भी एक पर विफल हो सकते हैं, और टोकन सीमा लगभग हमेशा पहली होती है जिसे आप पार करते हैं।

चैट ऐप्स लिमिट पर क्यों पहुँचते हैं

API कॉल के बीच कोई मेमोरी नहीं रखता है। संवाद जारी रखने के लिए, आपका कोड हर बार पूरी संदेश सूची भेजता है। हर बारी में उपयोगकर्ता संदेश और प्रत्युत्तर जुड़ते हैं, जिससे प्रॉम्प्ट हर आदान-प्रदान के साथ बढ़ता जाता है। एक बॉट जो एक घंटे तक ठीक काम करता है और फिर असफल होने लगता है, यह क्लासिक संकेत है।

एजेंट्स में भी वही होता है। हर टूल रिजल्ट हिस्ट्री में जुड़ जाता है, और एक फ़ंक्शन जो बड़ा रिकॉर्ड लौटाता है, एक अकेले चरण में हजारों टोकन जोड़ सकता है। रिट्रीवल सेटअप्स एक तीसरा स्रोत जोड़ते हैं: यदि आप हर प्रॉम्प्ट में बीस डॉक्यूमेंट खंड पेस्ट करते हैं, तो किसी भी हिस्ट्री होने से पहले प्रति अनुरोध बेस लागत पहले ही बड़ी होती है।

कुछ ठीक करने से पहले, यह पता लगाएं कि तीन में से कौन सा बढ़ रहा है। हर कॉल के बाद usage से प्रॉम्प्ट टोकन गणना प्रिंट करें। यदि यह हर बारी में लगभग समान मात्रा में बढ़ता है, तो यह इतिहास है। यदि यह विशिष्ट चरणों के बाद अचानक बढ़ता है, तो यह टूल आउटपुट या पुनर्प्राप्त पाठ है।

भेजने से पहले इतिहास कम करें

सबसे सरल और विश्वसनीय समाधान एक फ़ंक्शन है जो सबसे पुरानी बारी को हटा दे जब तक कि अनुमान बजट में फिट न हो जाए। सिस्टम संदेश को हमेशा रखें, और नवीनतम उपयोगकर्ता संदेश को हमेशा रखें। बजट में प्रत्युत्तर के लिए जगह छोड़नी चाहिए, इसलिए प्रॉम्प्ट के लिए 80,000 टोकन जैसे मान का उपयोग करें और शेष स्थान उत्तर के लिए छोड़ दें।

from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredmodelhub.com/v1",
    api_key="YOUR_API_KEY",
)

def estimate_tokens(text: str) -> int:
    return len(text) // 4 + 4  # rough: 4 characters per token plus overhead

def trim(messages, budget=80_000):
    system = [m for m in messages if m["role"] == "system"]
    rest = [m for m in messages if m["role"] not in ("system",)]
    total = sum(estimate_tokens(m["content"]) for m in system + rest)
    while total > budget and len(rest) > 1:
        dropped = rest.pop(0)  # oldest turn goes first
        total -= estimate_tokens(dropped["content"])
    return system + rest

history = [{"role": "system", "content": "You are a helpful assistant."}]

def ask(user_text):
    history.append({"role": "user", "content": user_text})
    resp = client.chat.completions.create(
        model="uncensored",
        messages=trim(history),
        max_tokens=2000,
    )
    reply = resp.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
    return reply

जब तक संभव हो, उपयोगकर्ता और सहायक बारी को जोड़े में रखें; एक जोड़े का एक हिस्सा हटाने से मॉडल भ्रमित हो सकता है। टूल संदेश भी इसी प्रकार हैं: एक role: "tool" संदेश उस सहायक बारी के साथ रहना चाहिए जिसने उसे मांगा था, इसलिए उन्हें एक साथ हटाएं। चूंकि अनुमान अनुमानित है, आपके बजट और वास्तविक विंडो के बीच 20 प्रतिशत का अंतर एक आरामदायक सुरक्षा अंतर प्रदान करती है।

पुराने टर्न्स को हटाने से बेहतर विकल्प

सारांश बनाएं, फिर जारी रखें

जब इतिहास एक थ्रेशोल्ड से अधिक हो जाए, तो सबसे पुराने आधे हिस्से को मॉडल को एक निर्देश के साथ भेजें कि उसे कुछ सौ शब्दों में सारांशित करें, और फिर उन बारियों को सिस्टम या उपयोगकर्ता संदेश के रूप में सारांश से बदल दें। विवरण खो जाता है लेकिन बातचीत का सिलसिला बना रहता है। इस चरण को प्रत्यक्ष उत्तर पथ के बाहर चलाएं ताकि उपयोगकर्ता उसका इंतजार न करे।

वे तथ्य पिन करें जो बने रहने चाहिए

नाम, निर्णयों और सेटिंग्स जैसे स्थायी नोट्स का एक छोटा ब्लॉक रखें और हर अनुरोध के शीर्ष पर उसे फिर से डालें। यह इस उम्मीद से बेहतर काम करता है कि पुराना टर्न अभी भी विंडो में है।

जो आप इनपुट करते हैं उसे छोटा करें

टूल परिणामों को केवल उन फ़ील्ड्स तक सीमित करें जो मायने रखते हैं। कम चंक पुनर्प्राप्त करें, और प्रत्येक चंक को प्रासंगिक पैराग्राफ़ तक काटें। एक बहुत लंबे दस्तावेज़ के लिए, उसे भागों में बांटें, प्रत्येक भाग को प्रोसेस करें, और अंतिम छोटी कॉल में परिणामों को जोड़ें।

max_tokens को जानबूझकर सेट करें

यदि जवाब आमतौर पर छोटे होते हैं, तो max_tokens को अपने प्रोडक्ट के अनुकूल एक मान पर कैप लगाएँ। कैप बजट की रक्षा करती है, लेकिन बहुत कम कैप जवाबों को मध्य वाक्य में काट देती है, इसलिए पहले लॉग में अपने वास्तविक जवाब की लंबाई देखें।

ट्रिमिंग से भी पैसा बचता है

इनपुट टोकन की लागत $0.15 प्रति 1M है, आउटपुट टोकन $0.50 प्रति 1M, प्रीपेड क्रेडिट से बिल किया जाता है। चैट हिस्ट्री को फिर से भेजता है, इसलिए प्रति संवाद लागत उसकी लंबाई से तेज़ी से बढ़ती है। एक चैट लें जहां हर आदान-प्रदान हिस्ट्री में 500 टोकन जोड़ता है और संवाद 100 टर्न चलता है।

  • ट्रिमिंग के बिना, nवाँ टर्न 500 x n टोकन भेजता है। 100 टर्न पर योग 500 x 5,050 = 2,525,000 इनपुट टोकन होता है, जिसकी लागत 2.525 x $0.15 = $0.379 है।
  • 20,000-टोकन की कैप के साथ, पहले 40 टर्न वैसे ही रहते हैं (500 x 820 = 410,000 टोकन)। शेष 60 टर्न प्रत्येक 20,000 भेजते हैं, जो 1,200,000 होता है। कुल 1,610,000 टोकन, या 1.61 x $0.15 = $0.242।

यह कैप यहाँ लगभग एक तिहाई बचाता है, और चैट जितनी लंबी होती जाती है, अंतर बढ़ता जाता है। चरम स्थिति में, एक पूर्ण 100,000-टोकन प्रॉम्प्ट की लागत 0.1 x $0.15 = $0.015 प्रति अनुरोध होती है। यह अकेले सस्ता है, लेकिन एक बॉट जो कई उपयोगकर्ताओं को सेवा देता है, इसमें यह जुड़ जाता है। मूल्य निर्धारण विवरण और टॉप-अप बोनस मूल्य निर्धारण पृष्ठ पर हैं, और क्रेडिट कभी समाप्त नहीं होता।

कोड में त्रुटि हैंडल करना

ट्रिमिंग के साथ भी विफलता की योजना बनाएँ। API त्रुटि को कैच करें, जाँचें कि क्या संदेश कॉन्टेक्स्ट लंबाई की ओर इशारा कर रहा है, अनुरोध को छोटा करें और एक बार रीट्राई करें। समान अनुरोध को रीट्राई न करें, क्योंकि वह उसी तरह विफल हो जाएगा।

from openai import BadRequestError

def safe_ask(messages, budget=80_000):
    try:
        return client.chat.completions.create(
            model="uncensored", messages=trim(messages, budget)
        )
    except BadRequestError as err:
        if "context" in str(err).lower() and budget > 10_000:
            return safe_ask(messages, budget // 2)
        raise

अत्यधिक आकार के अनुरोध के लिए वास्तविक स्थिति कोड और संदेश की जांच करें जो आपका क्लाइंट प्राप्त करता है, और परीक्षण को समायोजित करें; ऊपर दिया गया स्ट्रिंग मैच एक प्रारंभिक बिंदु है। रेट लिमिट अलग हैं: HTTP 429 rate_limited या concurrency के साथ का मतलब बहुत अधिक अनुरोध हैं, बहुत अधिक टोकन नहीं, और 429 Retry-After: 5 के साथ का मतलब अस्थायी ओवरलोड है। दस्तावेज़ अनुरोध फ़ील्ड्स की सूची देता है, बिना सेंसर वाले मॉडल की व्याख्या यह कवर करता है कि मॉडल क्या है, और आप कुंजी प्राप्त करके असली उपयोग संख्याओं के साथ इसकी जांच कर सकते हैं।

प्रश्न और उत्तर

एक अनुरोध में मैं कितने टोकन भेज सकता हूँ?

विंडो 100,000 टोकन की है, जो आपके प्रॉम्प्ट और कम्प्लीशन के बीच साझा है। जो प्रॉम्प्ट उपयोग करता है, वह जवाब के लिए अब उपलब्ध नहीं है।

क्या जब एक अनुरोध विंडो से अधिक हो जाता है तो मुझे चार्ज किया जाता है?

नहीं। विफल अनुरोधों के लिए चार्ज नहीं किया जाता है। आप केवल उन अनुरोधों के लिए टोकन के लिए भुगतान करते हैं जो पूरे होते हैं।

क्या मुझे max_tokens सेट करना चाहिए?

नहीं, यह वैकल्पिक है। इसके बिना, कम्पलीशन विंडो में शेष जगह का उपयोग कर सकती है। यदि आप प्रतिक्रिया की लंबाई और लागत पर कठोर सीमा चाहते हैं तो इसे सेट करें।

मैं टोकन की गणना कैसे सटीक रूप से करूं?

प्रत्येक प्रतिक्रिया में usage ऑब्जेक्ट पढ़ें, जो वास्तविक प्रॉम्प्ट और कम्पलीशन टोकन की रिपोर्ट करता है। भेजने से पहले अनुमानों के लिए, अंग्रेजी के लिए प्रत्येक टोकन के लिए चार अक्षरों का नियम काम करता है।

आपकी कुंजी बस एक फ़ॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।

API कुंजी पाएँ