SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-22

Local LLM में reasoning effort सेटिंग कैसे काम करती है

जानें reasoning effort के स्तर local hardware पर मॉडल के सोचने का समय, tokens और context window कैसे बदलते हैं, और असली लागत मापने का सही तरीका क्या है।

Local LLM पर reasoning effort कैसे काम करता है

Reasoning effort एक ऐसी सेटिंग है जो मॉडल को यह बताती है कि उत्तर देने से पहले उसे कितनी देर तक सोचना है। यह केवल reasoning segment की लंबाई को बदलता है, और कुछ नहीं। डिस्क पर मौजूद weights हर स्तर पर समान रहते हैं, quantisation समान रहता है, और उत्तर एक ही forward pass से प्राप्त होता है। जो चीज बदलती है, वह यह है कि मॉडल पहले अपने scratchpad पर कितने tokens खर्च करता है।

यह अंतर महत्वपूर्ण है क्योंकि ये tokens कहाँ खर्च होते हैं, यह मायने रखता है। एक hosted API पर, reasoning tokens का बिल बनता है। आपके अपने VPS पर, इनकी कीमत आपके CPU या GPU पर generation time के रूप में और context window के भीतर जगह के रूप में चुकानी पड़ती है। यदि किसी मॉडल को उसके उच्चतम effort पर छोड़ दिया जाए, तो वह उत्तर का पहला शब्द आने से पहले अपने अधिकांश output को reasoning में खर्च कर सकता है। self-hosted hardware पर, यही अंतर दो सेकंड की प्रतिक्रिया और दो मिनट की प्रतिक्रिया के बीच का होता है।

लेवल कहाँ स्थित है: चैट टेम्पलेट, न कि वेट्स

एक थिंकिंग मॉडल को अपना अंतिम उत्तर देने से पहले एक रीजनिंग सेगमेंट उत्सर्जित करने के लिए प्रशिक्षित किया जाता है, जो आमतौर पर <think> और </think> टैग्स में घिरा होता है। एफर्ट लेवल एक ऐसा निर्देश है जिसे मॉडल का चैट टेम्पलेट प्रॉम्प्ट में लिखता है। वह टेम्पलेट एक Jinja फाइल है जो मॉडल के साथ आती है। यह reasoning_effort जैसे वेरिएबल को पढ़ती है और प्रत्येक मान के लिए एक अलग सिस्टम-लेवल लाइन रेंडर करती है, और मॉडल को उस लाइन के जवाब में अपने स्क्रैचपैड को छोटा या लंबा करने के लिए प्रशिक्षित किया गया था।

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

2026-10-12 को जाँचे जाने पर, Qwen3.8-27B मॉडल कार्ड तीन एफर्ट लेवल को डॉक्यूमेंट करता है: low, medium और xhigh, जिसमें xhigh डिफॉल्ट है। इसमें high जैसा कुछ नहीं है। थिंकिंग को स्वयं enable_thinking के साथ स्विच किया जाता है, जो डिफॉल्ट रूप से ऑन रहता है, और कार्ड preserve_thinking को भी डॉक्यूमेंट करता है, जो डिफॉल्ट रूप से ऑन रहता है, और यह बातचीत के इतिहास में पहले के टर्न्स से रीजनिंग को बनाए रखता है। gpt-oss इसके बजाय low, medium और high का उपयोग करता है। कई अन्य मॉडल परिवार केवल एक बूलियन मान स्वीकार करते हैं और कुछ नहीं। अपने द्वारा पुल किए गए सटीक वर्जन के लिए कार्ड पढ़ें, क्योंकि ये नाम कोई मानक नहीं हैं। VPS पर 27B मॉडल चलाना पहले आता है। यह पेज इस बारे में है कि उत्तर मिलने के बाद क्या सेट करना है।

VPS पर अधिक effort की लागत अधिक क्यों होती है

Output tokens. Reasoning tokens उत्पन्न किए गए tokens होते हैं। वे उसी decode loop से गुजरते हैं जिससे उत्तर गुजरता है, और उसी गति से चलते हैं जिस गति से आपका हार्डवेयर उन्हें process कर सकता है। मान लीजिए कि एक कार्य 200 tokens का उत्तर और 4,000 tokens की reasoning उत्पन्न करता है। आपने 4,200 tokens उत्पन्न किए और पाठक ने उनमें से 200 देखे। आपकी decode दर memory bandwidth, आपके द्वारा चुने गए quantisation और आपके thread count द्वारा निर्धारित होती है: llama.cpp के अपने tuning notes चेतावनी देते हैं कि --threads का मान आपके physical core count से अधिक होने पर CPU oversaturate हो सकता है और generation की गति बहुत धीमी हो सकती है। एक बार जब ये tune हो जाते हैं, तो एकमात्र विकल्प token count ही बचता है।

Wall clock. एक व्यक्ति उत्तर के पहले token की प्रतीक्षा करता है, क्योंकि उससे पहले सब कुछ एक खाली स्क्रीन या घूमता हुआ spinner होता है। Reasoning पहले emit की जाती है, इसलिए प्रतीक्षा का समय लगभग reasoning token count को आपकी decode दर से विभाजित करने पर प्राप्त होता है, जिसमें prompt processing का समय भी जुड़ जाता है। Reasoning की लंबाई दोगुनी करने पर वह प्रतीक्षा समय भी दोगुना हो जाता है।

Context. Reasoning tokens किसी भी अन्य token की तरह context window में जगह लेते हैं। preserve_thinking चालू होने पर, पहले turn का scratchpad पांचवें turn में भी prompt में रहता है, इसलिए जैसे-जैसे window दोनों तरफ से भरती है, prompt processing हर turn में धीमी होती जाती है। इसे रखने के लिए num_ctx बढ़ाना KV cache memory की लागत बढ़ाता है, जो GPU के बिना VPS पर system RAM होती है, जो शायद आपके पास अतिरिक्त न हो।

स्तर को कब बढ़ाएं और कब कम रखें

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

इसे तब कम रखें जब उत्तर पहले से ही इनपुट में मौजूद हो और कार्य केवल उसे स्थानांतरित करना हो। निष्कर्षण (extraction), वर्गीकरण (classification), टैगिंग, अनुवाद, पुनर्लेखन, सारांश और फॉर्मेटिंग सभी इसी श्रेणी में आते हैं। तर्क खंड (reasoning segment) मुख्य रूप से कार्य को दोहराता है, और यह मॉडल को अपनी सही पहली प्रवृत्ति को गलत साबित करने का अवसर देता है।

इसे किसी भी इंटरैक्टिव कार्य के लिए भी कम रखें। चैट बॉक्स या एडिटर में आप लूप में होते हैं, इसलिए एक तेज़ उत्तर जिसे आप सुधार सकें, उस धीमे उत्तर से बेहतर है जिसके लिए आपको प्रतीक्षा करनी पड़े। coding agent को local model पर पॉइंट करने के पीछे यही वास्तविक ट्रेड-ऑफ है: एक एजेंट कई छोटी कॉल करता है, और तर्क का शुल्क (reasoning tax) उनमें से प्रत्येक पर लगाया जाता है।

llama.cpp में लेवल कैसे सेट करें

llama.cpp वेरिएबल को सीधे टेम्पलेट में लिखता है, जिससे यह एक रनटाइम बन जाता है जहाँ आप सुनिश्चित हो सकते हैं कि लेवल पहुँच गया है। -m को उस GGUF की ओर पॉइंट करें जो आपके पास पहले से मौजूद है।

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf \
  --jinja \
  --reasoning-effort medium \
  --reasoning-format deepseek \
  -c 32768 \
  --host 127.0.0.1 --port 8080

--jinja मॉडल के अपने चैट टेम्पलेट का उपयोग करता है और वर्तमान बिल्ड्स में डिफ़ॉल्ट रूप से सक्षम होता है। --reasoning-effort में default, minimal, low, medium, high, xhigh या max स्वीकार किए जाते हैं, जहाँ default का अर्थ है कि टेम्पलेट के अपने डिफ़ॉल्ट को वैसे ही रहने दें। यह सूची llama.cpp की शब्दावली है, न कि मॉडल की, इसलिए केवल वही नाम पास करें जिसे कार्ड सूचीबद्ध करता है: यदि कोई लेवल टेम्पलेट में परिभाषित नहीं है, तो वह अनुरोध के समय टेम्पलेट त्रुटि उत्पन्न कर सकता है। --reasoning-format deepseek रीजनिंग को message.content से बाहर निकालकर message.reasoning_content में ले जाता है, जो इस विभाजन को अगले अनुभाग में मापने योग्य बनाता है।

थिंकिंग को छोटा करने के बजाय उसे बंद करने के लिए, टेम्पलेट वेरिएबल को स्वयं सेट करें:

llama-server -m ./qwen3.8-27b-Q4_K_M.gguf --jinja \
  --chat-template-kwargs '{"enable_thinking": false}'

--reasoning-budget एक अलग तंत्र है। यह रीजनिंग सेगमेंट को टोकन में सीमित करता है, जिसमें 0 इसे तुरंत समाप्त कर देता है और -1 इसे अप्रतिबंधित छोड़ देता है, बजाय इसके कि मॉडल से छोटा प्लान बनाने के लिए कहा जाए। दोनों फ्लैग सर्वर का डिफ़ॉल्ट सेट करते हैं। 2026-10-12 तक, llama-server का /v1/chat/completions अनुरोध बॉडी में reasoning_effort और chat_template_kwargs भी लेता है, जो उस एक कॉल के लिए टेम्पलेट को लेवल पास करता है, और none रीजनिंग को बंद कर देता है। इसलिए, एक प्रोसेस दो अलग-अलग एफर्ट लेवल सर्व कर सकती है।

vLLM उसी वेरिएबल को प्रति अनुरोध, OpenAI-compatible बॉडी के भीतर एक्सपोज़ करता है:

{"model": "Qwen/Qwen3.8-27B",
 "messages": [{"role": "user", "content": "Summarise this changelog in two lines."}],
 "chat_template_kwargs": {"reasoning_effort": "medium"}}

Ollama में लेवल कैसे सेट करें

Ollama का अपना एक फील्ड, think, /api/chat और /api/generate पर मौजूद है। यह true, false, या किसी लेवल के नाम को स्वीकार करता है। 2026-10-12 तक, ऐसे मॉडल के लिए जो थिंकिंग मेटाडेटा पब्लिश करता है, नाम मॉडल के अपने होते हैं: /api/show उन्हें thinking.values के अंतर्गत सूचीबद्ध करता है और उनके बगल में डिफ़ॉल्ट मान दिखाता है। यदि कोई ऐसा नाम दिया जाए जिसे मॉडल सूचीबद्ध नहीं करता, तो वह बिना किसी त्रुटि के डिफ़ॉल्ट मान पर वापस आ जाता है। जिन मॉडल्स में मेटाडेटा नहीं होता, वे Ollama के पुराने फिक्स्ड सेट low, medium, high और max का उपयोग करते हैं। यदि आप think को छोड़ देते हैं, तो मॉडल का अपना डिफ़ॉल्ट लागू होता है, जो Qwen3.8 के लिए 'थिंकिंग ऑन' है।

ollama run qwen3.8:27b --think=low "Draft a one line commit message for a README typo fix"
{"model": "qwen3.8:27b",
 "messages": [{"role": "user", "content": "Which HTTP status code means the request body was too large?"}],
 "think": "low",
 "stream": false}

रीज़निंग message.thinking में वापस आती है और उत्तर message.content में, जो आपके लिए पहले से ही अलग-अलग होते हैं। एक इंटरैक्टिव ollama run सत्र के भीतर, /set think और /set nothink इसे बिना रीस्टार्ट किए टॉगल करते हैं, और /set think low एक लेवल चुनता है।

अब ध्यान दें कि यह कहाँ चुपचाप विफल हो सकता है। Qwen3.8 का टेम्पलेट low, medium और xhigh को परिभाषित करता है। एक Ollama मॉडल अपने टैग के भीतर एक टेम्पलेट लेकर चलता है, न कि मूल रिपॉजिटरी की Jinja फ़ाइल, और Ollama किसी लेवल को तभी पास करता है यदि वह पैक्ड मॉडल उसे सूचीबद्ध करता है। पहले जांचें कि आपका टैग क्या विज्ञापन देता है:

curl -s http://localhost:11434/api/show -d '{"model": "qwen3.8:27b"}' | jq .thinking

कोई ऐसा नाम जो values में नहीं है, जैसे कि इस मॉडल के लिए high या max, इसके बजाय डिफ़ॉल्ट पर चलता है। यह न मानें कि यह काम कर गया। इसे मापने में लगभग एक मिनट का समय लगता है।

यह कैसे मापें कि लेवल वास्तव में लागू हुआ है या नहीं

एक ही प्रॉम्प्ट को एक से अधिक लेवल पर temperature को 0 पर सेट करके भेजें, फिर टोकन काउंट की तुलना करें। नीचे दिए गए तीन नाम वे हैं जिन्हें Qwen3.8 का कार्ड सूचीबद्ध करता है; यदि आपके टैग के लिए /api/show अलग नाम सूचीबद्ध करता है, तो उनका उपयोग करें। यहाँ jq बॉडी बनाता है ताकि आपको मैन्युअल रूप से कोट्स को एस्केप न करना पड़े।

for level in low medium xhigh; do
  body=$(jq -n --arg lvl "$level" '{
    model: "qwen3.8:27b",
    messages: [{role: "user", content: "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take? Answer in minutes."}],
    think: $lvl,
    stream: false,
    options: {temperature: 0, num_ctx: 8192}
  }')
  echo "== $level"
  curl -s http://localhost:11434/api/chat -d "$body" | jq '{
    thinking_chars: (.message.thinking // "" | length),
    answer_chars: (.message.content | length),
    eval_count: .eval_count,
    seconds: (.total_duration / 1e9),
    tok_per_sec: (.eval_count / (.eval_duration / 1e9))
  }'
done

eval_count उत्पन्न होने वाला प्रत्येक टोकन है, जिसमें रीजनिंग भी शामिल है, इसलिए दो लेवल के बीच का अंतर लगभग पूरी तरह से रीजनिंग का होता है। thinking_chars आपको सीधे स्प्लिट देता है। दो बातें सत्य होनी चाहिए: संख्याएं लेवल के बीच बदलनी चाहिए, और उत्तर निचले लेवल पर भी सही रहना चाहिए। यदि eval_count सभी तीन रन में शोर (noise) के भीतर रहता है, तो लेवल को अनदेखा किया जा रहा है। पहले /api/show के विरुद्ध नामों की जाँच करें, क्योंकि Ollama डिफ़ॉल्ट रूप से एक असूचीबद्ध नाम चलाता है; यदि वे मेल खाते हैं, तो समाधान एक ऐसा रनटाइम है जो लेवल को पास करता है।

कुल समय कहानी का केवल आधा हिस्सा है, इसलिए स्ट्रीमिंग करके और पहले नॉन-एम्प्टी content चंक पर रुककर पहले उत्तर टोकन तक के अंतर को मापें। इसके लिए jq और bc की आवश्यकता है।

start=$(date +%s.%N)
curl -sN http://localhost:11434/api/chat -d '{
  "model": "qwen3.8:27b",
  "messages": [{"role": "user", "content": "Explain what a reverse proxy does, in three sentences."}],
  "think": "low",
  "stream": true
}' |
while IFS= read -r line; do
  if [ -n "$(printf '%s' "$line" | jq -r '.message.content // ""')" ]; then
    echo "first answer token after $(echo "$(date +%s.%N) - $start" | bc)s"
    break
  fi
done

इसे low पर चलाएं और फिर से xhigh पर चलाएं। अंतर वह प्रतीक्षा समय है जिसे आप खरीद रहे हैं। llama.cpp पर वही संख्याएं रिस्पॉन्स के अंदर वापस आती हैं, जिसमें किसी शेल अरिथमेटिक की आवश्यकता नहीं होती:

curl -s http://localhost:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "local", "temperature": 0,
       "messages": [{"role": "user", "content": "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take?"}]}' | jq '{
  reasoning_chars: (.choices[0].message.reasoning_content // "" | length),
  answer_chars: (.choices[0].message.content | length),
  predicted_n: .timings.predicted_n,
  tok_per_sec: .timings.predicted_per_second
}'

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

क्या गलत होता है

उत्तर अधूरा है, या content खाली है जबकि thinking भरा हुआ है। जनरेशन लिमिट reasoning द्वारा समाप्त कर दी गई है। Ollama का num_predict पूरी जनरेशन को सीमित करता है, जिसमें reasoning भी शामिल है, और reasoning पहले आता है, इसलिए high effort पर 512 tokens की सीमा उत्तर शुरू होने से पहले ही रिस्पॉन्स को समाप्त कर सकती है। Ollama उस रिस्पॉन्स पर "done_reason": "length" रिपोर्ट करता है। सीमा बढ़ाएं या effort कम करें। num_predict टोकन की गणना कैसे करता है इस इंटरैक्शन को विस्तार से कवर करता है।

लेवल बदलने से कुछ नहीं होता। टोकन काउंट हर लेवल पर समान हैं। या तो रनटाइम वेरिएबल पास नहीं कर रहा है, टेम्पलेट इसे पढ़ नहीं रहा है, या Ollama पर नाम वह नहीं है जो टैग लिस्ट में है और यह डिफ़ॉल्ट पर वापस चला गया है। मूल रिपॉजिटरी में मौजूद टेम्पलेट के बजाय उस टेम्पलेट की जाँच करें जिसका उपयोग आपका रनटाइम वास्तव में कर रहा है। --jinja और --chat-template-kwargs के साथ llama.cpp वेरिएबल को मैन्युअल रूप से लिखता है, इसलिए यह एक अच्छा कंट्रोल है: यदि लेवल वहां काम करता है और कहीं और नहीं, तो मॉडल ठीक है और दूसरा रनटाइम इसे ड्रॉप कर रहा है।

लेवल का नाम अस्वीकार कर दिया गया है। रिक्वेस्ट के समय टेम्पलेट एरर, या अन्यथा स्वस्थ सर्वर के साथ पहले मैसेज पर विफलता का मतलब आमतौर पर यह है कि आपने ऐसा लेवल पास किया है जिसे टेम्पलेट परिभाषित नहीं करता है, जैसे कि ऐसे मॉडल को high देना जिसके कार्ड में केवल low, medium और xhigh सूचीबद्ध हैं। Ollama पर, बिना थिंकिंग मेटाडेटा वाला मॉडल केवल low, medium, high और max को स्वीकार करता है, और कुछ भी होने पर यह invalid think value एरर के रूप में वापस आता है।

मल्टी-टर्न चैट हर टर्न पर धीमी हो जाती है। पुरानी reasoning हिस्ट्री में रखी जा रही है। यदि मॉडल सपोर्ट करता है तो preserve_thinking को false पर सेट करें, या आपके द्वारा वापस भेजे जाने वाले मैसेज से thinking फील्ड को हटा दें। अन्यथा, प्रॉम्प्ट प्रोसेसिंग हर टर्न पर बढ़ती जाती है जबकि उत्तर की लंबाई समान रहती है।

आपके द्वारा सोचे गए सरल कार्य पर कम effort पर क्वालिटी गिर जाती है। कुछ एक्सट्रैक्शन वास्तव में एक्सट्रैक्शन नहीं होते हैं। यदि इनपुट को यूनिट कन्वर्जन या किसी नियम को क्रम में लागू करने की आवश्यकता है, तो यह एक reasoning कार्य है जिसका आउटपुट छोटा होता है। पूरे सर्वर के बजाय उस एक कॉल के लिए लेवल बढ़ाएं।

एक साथ दो स्तरों (levels) को चलाना

llama.cpp स्टार्टअप पर --reasoning-effort के साथ एक डिफ़ॉल्ट स्तर सेट करता है, लेकिन वर्तमान बिल्ड प्रति अनुरोध reasoning_effort भी स्वीकार करते हैं। इसलिए, एक प्रोसेस और वेट्स (weights) की एक कॉपी एक एडिटर को कम स्तर पर और एक नाइटली बैच जॉब को उच्च स्तर पर सेवा दे सकती है। यदि आप स्टार्टअप पर प्रत्येक स्तर को पिन करना पसंद करते हैं, तो दो पोर्ट्स पर दो प्रोसेस भी काम करती हैं। इसमें मेमोरी में वेट्स की दो कॉपियां रखने की लागत आती है, जब तक कि आप जॉब्स को समय के अनुसार अलग न कर दें। किसी भी स्थिति में, जॉब्स एक ही मशीन की डिकोड क्षमता साझा करती हैं। इसलिए, एक VPS पर सस्ता तरीका यह है कि जिस काम का कोई व्यक्ति इंतजार कर रहा है, उसके लिए कम प्रयास (low effort) का उपयोग करें, और जिसे कोई नहीं देख रहा है, उसके लिए एक निर्धारित उच्च प्रयास (higher effort) वाला रन रखें। जब कई उपयोगकर्ता एक लोकल मॉडल साझा करते हैं तो क्या होता है यहाँ भी लागू होता है: रीजनिंग टोकन डिकोड का काम हैं, इसलिए प्रयास बढ़ाने से आपकी प्रभावी समवर्तीता (concurrency) लगभग उसी अनुपात में कम हो जाती है जिस अनुपात में टोकन की संख्या बढ़ती है।

FAQ

मुझे डिफ़ॉल्ट रूप से किस reasoning effort level का उपयोग करना चाहिए?

मॉडल द्वारा प्रदान किए गए सबसे निचले स्तर से शुरुआत करें और इसे केवल उन कार्यों के लिए बढ़ाएं जिन्हें आपने विफल होते देखा है। कई थिंकिंग मॉडल उच्च डिफ़ॉल्ट के साथ आते हैं, और Qwen3.8-27B अक्टूबर 2026 तक डिफ़ॉल्ट रूप से अपने उच्चतम स्तर, xhigh, पर सेट रहता है। यह डिफ़ॉल्ट बेंचमार्क टेबल पर अच्छा दिखने के लिए चुना गया है, और बेंचमार्क टेबल समय के लिए शुल्क नहीं लेती हैं। अपने स्वयं के हार्डवेयर पर आप समय के रूप में भुगतान करते हैं, इसलिए उच्च स्तर को ऐसा विकल्प बनाएं जिसे आप प्रति कार्य चुनते हैं, न कि वह सेटिंग जिसे हर अनुरोध इनहेरिट करता है।

क्या reasoning tokens मेरी context window में गिने जाते हैं?

हाँ। वे आउटपुट में सामान्य टोकन हैं और बाकी सब चीज़ों के साथ context window में रहते हैं। क्या वे अगले टर्न पर वहां बने रहेंगे, यह रनटाइम और मॉडल पर निर्भर करता है। Qwen3.8 का कार्ड preserve_thinking को डॉक्यूमेंट करता है, जो डिफ़ॉल्ट रूप से चालू रहता है, और यह पिछली रीजनिंग को हिस्ट्री में रखता है, इसलिए एक लंबी बातचीत अपने द्वारा उत्पन्न हर scratchpad को साथ लेकर चलती है। इसे false पर सेट करें, या उन संदेशों से thinking फ़ील्ड को हटा दें जिन्हें आप रिप्ले करते हैं, और प्रॉम्प्ट प्रोसेसिंग का बढ़ना रुक जाएगा।

थिंकिंग लेवल बदलने से मेरे टोकन काउंट में कोई अंतर क्यों नहीं आता?

सेटिंग चैट टेम्पलेट तक नहीं पहुँच रही है। लेवल एक टेम्पलेट वेरिएबल है, इसलिए यह केवल तभी काम करता है जब रनटाइम इसे पास करे और पैकेज्ड टेम्पलेट इसे पढ़े। कुछ रनटाइम मूल रिपॉजिटरी की Jinja फ़ाइल के बजाय मॉडल के साथ अपना स्वयं का टेम्पलेट शिप करते हैं, और वेरिएबल को बिना किसी त्रुटि के हटा दिया जाता है। Ollama भी एक ऐसे लेवल नाम को चलाता है जिसे मॉडल अपने डिफ़ॉल्ट पर लिस्ट नहीं करता है, और यहाँ भी कोई त्रुटि नहीं दिखाई जाती है। इसे साबित करने के लिए, temperature को 0 पर रखकर सबसे निचले और उच्चतम स्तर पर एक ही प्रॉम्प्ट भेजें और eval_count की तुलना करें। यदि काउंट्स में अंतर नहीं है, तो लेवल को अनदेखा किया जा रहा है।

क्या कम reasoning effort मॉडल को कम सटीक बनाता है?

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

क्या यह लेख उपयोगी था?