Ollama-வில் num_predict வரம்பை அமைப்பது எப்படி?
Ollama-வில் num_predict மூலம் வெளியீட்டு tokens-களை கட்டுப்படுத்துவது எப்படி என அறியுங்கள். மூன்று இடங்களில் முன்னுரிமை பெறும் அமைப்பு மற்றும் done_reason-ஐ சரிபார்க்கும் முறை.
Ollama-வில் num_predict-ன் செயல்பாடு
num_predict என்பது Ollama-வின் ஒரு விருப்பத்தேர்வு (option) ஆகும். இது ஒரு பதிலில் ஒரு model அதிகபட்சமாக எத்தனை tokens-களை உருவாக்கலாம் என்பதை வரையறுக்கிறது. இது வெளியீட்டு tokens-களை மட்டுமே கணக்கிடும்; எனவே, prompt-க்கு இதில் கட்டணம் ஏதும் இல்லை. model இந்த வரம்பை எட்டும்போது, உருவாக்கம் (generation) அந்த இடத்திலேயே நின்றுவிடும். சில நேரங்களில் இது வார்த்தையின் பாதியிலேயே நின்றுவிடலாம். அப்போது வரும் பதிலில் done_reason என்பது length என அமைக்கப்பட்டிருக்கும்.
இதுவே இந்த அம்சத்தின் முழுமையான விளக்கம். இதில் உள்ள சிக்கல் என்னவென்றால், இந்த மதிப்பை அமைப்பதற்கு Ollama மூன்று வெவ்வேறு இடங்களை வழங்குகிறது. கோரிக்கைக்கு (request) மிக அருகில் உள்ள அமைப்பே செயல்பாட்டுக்கு வரும். "num_predict வேலை செய்யவில்லை" என்று வரும் பெரும்பாலான புகார்கள், ஒரு அடுக்கு மற்றொரு அடுக்கை அமைதியாக மீறிச் செயல்படுவதாலேயே ஏற்படுகின்றன.
num_predict என்பது num_ctx அல்ல
Ollama-வில் மற்ற எந்த ஜோடியை விடவும் இந்த இரண்டு விருப்பங்களே அதிகம் குழப்பத்தை ஏற்படுத்துகின்றன, மேலும் இந்த குழப்பம் உண்மையான பிழைத்திருத்த நேரத்தை வீணாக்குகிறது.
num_ctx என்பது ஒரு model எவ்வளவு வாசிக்க முடியும் என்பதைக் குறிக்கிறது. இது context window-ன் அளவாகும், இது prompt மற்றும் இதுவரை உருவாக்கப்பட்ட அனைத்தையும் உள்ளடக்கியது. இதை அதிகரிப்பது memory-ஐ அதிகம் பயன்படுத்தும், ஏனெனில் அந்த tokens-க்காக model வைத்திருக்கும் key/value cache, window-ன் அளவிற்கு ஏற்ப வளரும். உங்கள் hardware-க்கு ஏற்ப num_ctx-ஐ அமைத்தல் என்பது அதன் சொந்த தோல்வி முறைகளைக் கொண்ட ஒரு தனிப்பணியாகும்.
num_predict என்பது ஒரு model எவ்வளவு எழுத வேண்டும் என்பதைக் குறிக்கிறது. இது ஒரு நிறுத்த விதி (stopping rule), ஒதுக்கீடு (allocation) அல்ல. இதை அதிகரிப்பது RAM-ஐ விட நேரத்தை (wall-clock time) அதிகம் செலவழிக்கும், மேலும் முன்கூட்டியே எதுவும் ஒதுக்கப்படாது.
இவை ஓரிடத்தில் சந்திக்கின்றன. உருவாக்கப்பட்ட tokens, அவை உருவாகும்போது context window-க்குள் அமைகின்றன. Ollama v0.40.11-ல் பெரும்பாலான models-க்கு context shift இயல்பாகவே (default) செயல்படுத்தப்பட்டுள்ளது, எனவே window நிறைந்தால் பழைய tokens நீக்கப்பட்டு generation தொடரும். Shift முடக்கப்பட்டிருந்தால், அல்லது கோரிக்கையில் "shift": false அனுப்பப்பட்டிருந்தால், அல்லது model shift-ஐ ஆதரிக்கவில்லை என்றால், உங்கள் வரம்பை அடைந்ததால் மட்டுமல்லாமல், window நிறைந்ததாலும் பதில் நிறுத்தப்படலாம். Ollama இரண்டு நிகழ்வுகளிலும் length-ஐத் தெரிவிக்கிறது, எனவே அவற்றை வேறுபடுத்தும் எண் eval_count ஆகும், இது கீழே விரிவாக விளக்கப்பட்டுள்ளது.
Modelfile மூலம் ஒருமுறை அமைத்தல்
Modelfile-ஐப் பயன்படுத்தி, நீங்கள் உருவாக்கும் ஒரு model-ல் மதிப்பை நிரந்தரமாகச் சேர்க்கலாம். கோப்பை இவ்வாறு எழுதவும்:
FROM qwen3:8b
PARAMETER num_ctx 8192
PARAMETER num_predict 512பின்பு அதை build செய்து, நீங்கள் உருவாக்கியதைச் சரிபார்க்கவும்:
ollama create qwen3-capped -f Modelfile
ollama show --parameters qwen3-cappedollama show --parameters ஒவ்வொரு சேமிக்கப்பட்ட parameter-ஐயும் அதன் மதிப்புடன் தனித்தனி வரியாகக் காட்டும். அந்த வெளியீட்டில் num_predict இல்லை என்றால், அந்த model-ல் எந்தக் கட்டுப்பாடும் (cap) இல்லை என்று அர்த்தம்; அப்போது Ollama-வின் இயல்புநிலை (default) மதிப்பே பொருந்தும். ollama show --modelfile qwen3-capped முழு வரையறையையும் காட்டும். ஏற்கனவே உள்ள ஒரு model-ல் உள்ள parameters-ஐ நகலெடுக்க இதுவே விரைவான வழியாகும். இந்த முறையில் ஒரு capped model-ஐ உருவாக்குவதால் கூடுதல் disk space செலவாகாது. ஏனெனில், புதிய entry-ஆனது base model ஏற்கனவே பதிவிறக்கம் செய்த weight blobs-ஐயே மீண்டும் பயன்படுத்துகிறது, அவற்றை நகலெடுப்பதில்லை. Ollama அந்த blobs-ஐ எங்கே சேமிக்கிறது என்பதைத் தெரிந்துகொள்வது, VPS root disk நிரம்புவதற்கு முன்பே அவசியமாகும்.
ஒவ்வொரு caller-க்கும் கிடைக்க வேண்டிய ஒரு மதிப்பிற்கு இதுவே சரியான அடுக்கு (layer) ஆகும். இதுவே இறுதியானதாக இருக்கும் என்று நீங்கள் கருதினால், இது தவறான அடுக்கு, ஏனெனில் இது இறுதியானது அல்ல.
options object-ல் ஒவ்வொரு கோரிக்கைக்கும் ஏற்ப இதை அமைக்கவும்
ஒவ்வொரு generation endpoint-ம் ஒரு options object-ஐ எடுத்துக்கொள்கிறது, மேலும் num_predict அதற்குள் அமைகிறது:
curl http://localhost:11434/api/generate -d '{
"model": "qwen3:8b",
"prompt": "Explain what a reverse proxy does.",
"stream": false,
"options": { "num_predict": 128 }
}'/api/chat அதே options key-ஐ அதே பொருளுடன் பயன்படுத்துகிறது. இங்கே கொடுக்கப்படும் மதிப்பு அந்த ஒரு குறிப்பிட்ட அழைப்பிற்கு மட்டுமே பொருந்தும், மற்றவற்றிற்குப் பொருந்தாது. உங்கள் கருவிகள் பயன்படுத்தும் அடுக்கு இதுவே: ஒரு chat front end, ஒரு script, ஒரு SDK wrapper, அல்லது ஒரு coding agent. இவை அனைத்தும் ஒரு options object-ஐ அனுப்புகின்றன; இதற்காக உங்களுக்கு ஒரு பெட்டியை (box) காட்டினாலும் சரி, காட்டாவிட்டாலும் சரி.
/set parameter மூலம் ஒரு session-க்கு மட்டும் அமைத்தல்
ollama run-க்குள், interactive session அந்த session-ன் மீதமுள்ள பகுதிக்கு விருப்பங்களை அமைக்கிறது:
>>> /set parameter num_predict 256
>>> /show parameters/show parameters உங்கள் அடுத்த செய்தியுடன் session எதை அனுப்பும் என்பதைக் காட்டுகிறது, மாற்றங்கள் நடைமுறைக்கு வந்துவிட்டதை உறுதிப்படுத்த இதுவே வேகமான வழியாகும். நீங்கள் /bye என்று தட்டச்சு செய்யும் வரை இந்த மதிப்பு இருக்கும். இதைத் தக்கவைக்க, /save qwen3-capped தற்போதைய session-ஐ, அதன் parameters உட்பட, புதிய model-ஆக எழுதும். நீங்கள் இங்கே /set செய்யும் எதுவும் வேறு எந்த client-க்கும் செல்லாது.
எந்த அமைப்பு முன்னுரிமை பெறுகிறது மற்றும் உங்கள் அமைப்பு ஏன் புறக்கணிக்கப்பட்டதாகத் தெரிகிறது
இதற்கான வரிசைமுறை மிகச் சுருக்கமானது. கோரிக்கையுடன் (request) அனுப்பப்படும் விருப்பங்களே (options) மற்ற அனைத்தையும் விட முன்னுரிமை பெறும். கோரிக்கையில் எந்த மதிப்பும் இல்லாதபோது, மாடலின் Modelfile-ல் உள்ள PARAMETER num_predict வரிசை பயன்படுத்தப்படும். இவை இரண்டுமே இல்லையெனில், Ollama-வின் உள்ளமைக்கப்பட்ட இயல்புநிலை (default) பொருந்தும்.
/set parameter என்பது மூன்றாவது விதி அல்ல. ஊடாடும் அமர்வு (interactive session) ஒரு API client ஆகச் செயல்படுகிறது, எனவே நீங்கள் அங்கு அமைப்பது அந்த கோரிக்கையின் options ஆக அனுப்பப்படுகிறது. இதனால்தான் அது அந்த அமர்விற்கான Modelfile அமைப்பை மீறுகிறது (override).
இப்போது இது விளக்கும் தோல்வியைப் பார்ப்போம். நீங்கள் PARAMETER num_predict 512-ஐச் சேர்க்கிறீர்கள், மாடலை மீண்டும் உருவாக்குகிறீர்கள், ஆனால் பதில்கள் இன்னும் ஆயிரக்கணக்கான tokens வரை நீள்கின்றன. உங்கள் அமைப்பு சரியாக உள்ளது, ollama show --parameters-ம் அதை உறுதிப்படுத்துகிறது. இருப்பினும், ஒவ்வொரு கோரிக்கையிலும் அது மீறப்படுகிறது, ஏனெனில் client அதன் சொந்த options பொருளை (object) அதன் சொந்த எண்ணுடன் அனுப்புகிறது. இது பெரும்பாலும் நீங்கள் மாதங்களுக்கு முன்பு அமைப்புகள் திரையில் தட்டச்சு செய்து மறந்துபோன எண்ணாக இருக்கலாம். ollama show சேமிக்கப்பட்ட மாடலை மட்டுமே வாசிக்கும். HTTP வழியாக என்ன வருகிறது என்பதை அதனால் காட்ட முடியாது.
சர்வர் பக்கத்தை ஒரே கட்டளை மூலம் நிரூபியுங்கள். நீண்ட பதிலை உருவாக்கும் ஒரு கோரிக்கையை அனுப்பி, வரம்பை (cap) குறைவாகக் கட்டாயப்படுத்தி, இரண்டு புலங்களை (fields) வாசியுங்கள்:
curl -s http://localhost:11434/api/generate -d '{
"model": "qwen3-capped",
"prompt": "Describe the Linux boot process in detail.",
"stream": false,
"options": { "num_predict": 32 }
}' | jq '.done_reason, .eval_count'விரிவான பதில் 32 tokens-ஐத் தாண்டிச் செல்லும், எனவே "length" மற்றும் 32-ஐ எதிர்பார்க்கலாம். jq இல்லையெனில், முதலில் sudo apt install -y jq மூலம் அதை நிறுவவும். 32 என்பது உறுதியானது அல்ல, ஏனெனில் eval_count என்பது சர்வர் உண்மையில் உருவாக்கிய வெளியீட்டு tokens-ன் எண்ணிக்கை மட்டுமே. மாடல் முன்னதாகவே முடிந்துவிட்டால், உங்களுக்கு "stop" மற்றும் குறைவான எண்ணிக்கை கிடைக்கும்; இதற்கு இன்னும் அதிகமான தகவலைக் கேட்கும் ஒரு prompt-ஐப் பயன்படுத்த வேண்டும். உங்களுக்கு "length" மற்றும் 32 கிடைக்கும்போது, அந்த கோரிக்கையின் சொந்த மதிப்பு qwen3-capped-ல் சேமிக்கப்பட்ட 512-ஐ விட முன்னுரிமை பெற்றுள்ளது என்று அர்த்தம். இது சர்வர் ஒவ்வொரு கோரிக்கைக்கான விருப்பங்களையும் மதிக்கிறது என்பதைக் காட்டுகிறது. இது உங்கள் application என்ன அனுப்புகிறது என்பதைச் சொல்லாது, எனவே தேடல் client-ஐ நோக்கி நகர்கிறது. ஒரு கோரிக்கை குறித்த சர்வரின் சொந்த பதிவை அறிய, சூழலில் (environment) OLLAMA_DEBUG=1 உடன் அதை மறுதொடக்கம் செய்து, உங்கள் application அதனுடன் தொடர்பு கொள்ளும்போது journalctl -u ollama -f-ஐக் கவனிக்கவும்.
எதிர்மறை மதிப்புகள் மற்றும் நீங்கள் நகலெடுக்கக் கூடாத எண்கள்
num_predict எதிர்மறை மதிப்புகளையும் ஏற்கும், ஆனால் அவை எண்ணிக்கையைக் குறிக்காமல், ஒரு குறிப்பிட்ட நிலையை உணர்த்தும் குறியீடுகளாக (sentinels) செயல்படுகின்றன. ஒரு எதிர்மறை மதிப்பு "இதை கட்டுப்படுத்த வேண்டாம், தொடர்ந்து உருவாக்கு" என்று பொருள்படும். மற்றொன்று "மீதமுள்ள சூழலை (context) நிரப்பு" என்பதைக் குறிக்கப் பயன்படுத்தப்பட்டது. அக்டோபர் 2026 நிலவரப்படி, Ollama Modelfile குறிப்பு, இயல்புநிலை மதிப்பாக -1-ஐக் குறிப்பிடுகிறது, இது எல்லையற்ற உருவாக்கத்தைக் குறிக்கும். அதே அட்டவணையின் முந்தைய பதிப்புகள் சூழலை நிரப்புவதற்கு -2-ஐக் குறிப்பிட்டிருந்தன.
இவை அனைத்தும் பதிப்பைப் பொறுத்து மாறுபடும் என்பதால், கவனமாக இருக்கவும். ஏனெனில், இந்தத் தகவல் அவ்வப்போது மாற்றப்பட்டுள்ளது. இந்த உள்ளீடு -1 எனத் திருத்தப்படுவதற்கு முன்பு, நீண்ட காலமாக 128 இயல்புநிலை என ஆவணப்படுத்தப்பட்டிருந்தது. எனவே, பல வழிகாட்டிகள் இன்னும் பழைய எண்ணையே குறிப்பிடுகின்றன. இதன் செயல்பாடும் மாறியுள்ளது. அக்டோபர் 25, 2026 அன்று தற்போதைய வெளியீடாக உள்ள Ollama v0.40.11, GGUF மாதிரிகளை ஒரு upstream llama-server செயல்முறைக்கு அனுப்புகிறது. இதற்கு ஒரு வரையறுக்கப்பட்ட வரம்பு தேவைப்படுவதால், இது எந்தவொரு எதிர்மறை மதிப்பையும், மற்றும் num_ctx-ஐ விட பத்து மடங்கு அதிகமான எந்தவொரு வரம்பையும், num_ctx-ன் பத்து மடங்கு மதிப்பிற்கு மாற்றுகிறது. எனவே, "எல்லையற்றது" என்பது மேலே உள்ள qwen3-capped மாதிரிக்கு 81,920 tokens என்று பொருள்படும், மேலும் -2 இப்போது -1-லிருந்து மாறுபட்டு செயல்படுவதில்லை. நீங்கள் உண்மையில் இயக்கும் பதிப்பிற்கான Modelfile parameter reference-ஐப் படித்துவிட்டு, மேலே உள்ள eval_count சோதனையின் மூலம் அதன் செயல்பாட்டை உறுதிப்படுத்தவும். இந்த இடுகை உட்பட, எங்கு படித்தாலும், உங்கள் சொந்த கணினியில் நீங்கள் சரிபார்த்த மதிப்பே இறுதியானது.
CPU-மட்டும் கொண்ட VPS-ல் வெளியீட்டு நீளம் ஏன் முதன்மையான செலவாகிறது
Ollama-வை நீங்கள் கட்டுப்படுத்தும் கணினியில் இலவசமாக இயக்கலாம், எனவே உள்ளூர் உருவாக்கத்திற்கு (local generation) கட்டணம் ஏதுமில்லை, நீண்ட பதில்களுக்கான செலவு நேரமாக மட்டுமே கணக்கிடப்படுகிறது. உருவாக்கச் செயல்முறை இரண்டு வெவ்வேறு வேகங்களைக் கொண்ட இரண்டு நிலைகளைக் கொண்டது. Prompt tokens தொகுப்புகளாக (batches) ஒரே நேரத்தில் மதிப்பீடு செய்யப்படுகின்றன. Output tokens ஒவ்வொன்றாக உருவாக்கப்படுகின்றன, மேலும் ஒவ்வொரு token-க்கும் அது பயன்படுத்தும் weights-ன் மீது ஒரு pass தேவைப்படுகிறது. CPU-மட்டும் கொண்ட VPS-ல், அந்த pass நினைவக அலைவரிசையால் (memory bandwidth) கட்டுப்படுத்தப்படுகிறது, எனவே ஒரு prompt token-ஐ விட ஒரு generated token அதிக செலவை ஏற்படுத்துகிறது. அந்த pass, token பயன்படுத்தும் அனைத்து weights-களையும் படிக்க வேண்டும் (dense model-ல் அனைத்தும், Nemotron 3.5 Lightning போன்ற mixture-of-experts model-ல் அதன் 30B parameters-ல் சுமார் 3B-ஐ மட்டும் செயல்படுத்தும் routed experts). ஒவ்வொரு weight-ம் ஆக்கிரமிக்கும் bytes-ன் அளவு உங்கள் token வேகத்திற்கான உச்சவரம்பை நிர்ணயிக்கிறது, இதனால்தான் q4 build, அதே model-ன் q8 அல்லது fp16 பதிப்பை விட வேகமாக decode செய்கிறது.
Streaming இல்லாமல் ஒரு பதிலைக் கோரினால், எண்கள் தெளிவாகத் தெரியும்:
"prompt_eval_count": 11,
"prompt_eval_duration": 13074791,
"eval_count": 18,
"eval_duration": 52479709கால அளவுகள் நானோ விநாடிகளில் உள்ளன. அந்தத் தொகுப்பில், அக்டோபர் 2026 நிலவரப்படி Ollama API ஆவணத்தில் வெளியிடப்பட்ட மாதிரி பதில் உள்ளது (இது எந்தவொரு குறிப்பிட்ட server-ன் அளவீடும் அல்ல), 11 prompt tokens சுமார் 0.013 விநாடிகளையும், 18 output tokens சுமார் 0.052 விநாடிகளையும் எடுத்துக்கொண்டன. இது ஒரு prompt token-க்கு சுமார் 1.2 மில்லி விநாடிகள் மற்றும் ஒரு output token-க்கு 2.9 மில்லி விநாடிகள் ஆகும். எனவே, ஒரு வரி பதிலில் கூட, ஒவ்வொரு generated token-ம் வாசிக்கப்பட்ட ஒவ்வொரு token-ஐ விட இரண்டு மடங்குக்கும் மேலான செலவை ஏற்படுத்துகிறது, மேலும் நீண்ட பதில்களில் வெளியீட்டுப் பக்கமே நேரத்தை முழுமையாக எடுத்துக்கொள்கிறது. உங்கள் சொந்த உருவாக்க வேகம் என்பது eval_count-ஐ eval_duration-ஆல் வகுத்து விநாடிகளாக மாற்றியதாகும், மேலும் உங்கள் சொந்த வன்பொருளில் tokens per second-ஐ அளவிடுவது மற்ற எதையும் மாற்றியமைக்கும் முன் ஒருமுறை செய்ய வேண்டியது அவசியம். அந்த வேகம் கணினியைப் போலவே model-ஐயும் சார்ந்துள்ளது, எனவே நீண்ட பதில்கள் உண்மையான செலவாக இருந்தால், VPS-ல் Nemotron 3.5 Lightning போன்ற வேகமான decoding-க்காக உருவாக்கப்பட்ட model, குறைந்த வரம்பு (low cap) பாதுகாக்கும் நேரத்தை மீண்டும் பெற்றுத் தரும்.
கணிதமே மீதமுள்ளவற்றைத் தீர்மானிக்கிறது. விநாடிக்கு 8 tokens என்ற வேகத்தில், 2,000 tokens கொண்ட ஒரு பதில் கணினியை நான்கு நிமிடங்களுக்கு மேல் பிடித்து வைத்திருக்கும், மேலும் நீங்கள் ஒரு பத்தி மட்டுமே கேட்டீர்கள் என்பது அந்த model-க்குத் தெரியாது. ஒரு reasoning model, நீங்கள் கேட்ட வார்த்தைகளை எழுதுவதற்கு முன்பு அந்த நேரத்தின் ஒரு பகுதியைச் சிந்திக்கச் செலவிடுகிறது, அந்தச் சிந்தனையும் மற்ற அனைத்தையும் போலவே ஒரு நேரத்தில் ஒரு token-ஆகவே உருவாக்கப்படுகிறது, எனவே நீங்கள் கோரும் reasoning முயற்சி அதே கட்டணத்தில் மற்றொரு காரணியாகும். சில models சுழற்சியில் (loop) சிக்கி, ஏதேனும் ஒன்று அவற்றை நிறுத்தும் வரை ஒரு சொற்றொடரைத் திரும்பத் திரும்பக் கூறலாம். எந்த வரம்பும் இல்லையெனில், அந்த ஒற்றைக் கோரிக்கை num_ctx tokens-ஐ அடையும் வரை ஒரு core-ஐ பிஸியாக வைத்திருக்கும், ஏனெனில் context shift முழு window-வையும் முடிவடையாமல் தடுக்கிறது. num_predict என்பது அதை எல்லைப்படுத்தும் அமைப்பாகும், இது ஒரு சிறிய self-hosted Ollama VPS-ல் மிக முக்கியமானது, ஏனெனில் ஒரு நீண்ட கோரிக்கை முழு கணினியையும் ஆக்கிரமிக்கக்கூடும்.
வெளியீடு பாதியில் துண்டிக்கப்படுவது பெரும்பாலும் வரம்பினால் (cap) ஏற்படுவது, மாதிரி (model) பழுதடைந்ததல்ல
அறிகுறிகள் மாதிரி தோல்வியடைந்தது போலத் தோன்றும். வாக்கியத்தின் பாதியில் நின்றுவிடும் பதில். இறுதி அடைப்புக்குறி (closing brace) வராததால் parse ஆகாத JSON. மாதிரியையோ அல்லது அதன் quantisation-ஐயோ குறை கூறுவது இயல்பான எதிர்வினை. முதலில் பதிலைப் படியுங்கள்.
done_reason கேள்விக்கு நேரடியாகப் பதிலளிக்கிறது. stop என்பது எந்த வரம்புக்கும் முன்பே உருவாக்கம் முடிந்துவிட்டது என்று பொருள்; மாதிரி அதன் end-of-sequence token-ஐ வெளியிட்டதாலோ அல்லது உங்கள் stop விருப்பத்தில் உள்ள ஏதேனும் ஒரு string-உடன் வெளியீடு ஒத்துப்போனதாலோ இது நிகழ்கிறது, அந்தப் பொருத்தம் எங்கு முடிகிறதோ அங்கேயே பதில் முடிந்துவிடும். length என்பது இடவசதி தீர்ந்துவிட்டதால் உருவாக்கம் துண்டிக்கப்பட்டது என்று பொருள். length-ஐக் காணும்போது, eval_count-ஐ உங்கள் வரம்புடன் ஒப்பிட்டுப் பாருங்கள்: இரண்டும் சரியாகப் பொருந்தினால் num_predict அதை நிறுத்தியுள்ளது என்று அர்த்தம், சிறிய எண்ணாக இருந்தால் context window முதலில் நிரம்பிவிட்டது என்று பொருள், இது context shift ஆஃப் செய்யப்பட்டிருக்கும்போது மட்டுமே நிகழும்.
நீங்கள் stream செய்யும்போது, அந்தத் தகவல்கள் "done": true-ஐக் கொண்டுள்ள இறுதித் துண்டில் (chunk) வந்து சேரும். பல client libraries அந்தத் துண்டைத் தவிர்த்துவிட்டு, உங்கள் code-க்கு உரையை மட்டும் வழங்குகின்றன, இதனால்தான் ஒரு application-க்குள் இந்தத் துண்டிப்பு விளக்கமில்லாமல் தெரிவதும், curl-ன் கீழ் தெளிவாகத் தெரிவதும் நிகழ்கிறது. ஒரு library இதை மறைக்கிறது என்றால், server உண்மையில் என்ன சொன்னது என்பதைக் கண்டறிய curl-உடன் ஒரு கோரிக்கையை (request) அனுப்புங்கள்.
இன்னொரு விஷயம் வீணாகும் மதிய நேரத்தைத் தவிர்க்க உதவும். num_predict-ஐ அதிகரிப்பது மாதிரி அதிகமாக எழுதச் செய்யாது. அது ஒரு உச்சவரம்பை மட்டுமே நீக்குகிறது. ஒரு பதில் 200 tokens-ல் done_reason of stop உடன் முடிந்தால், மாதிரி முடிந்துவிட்டதாக முடிவு செய்துவிட்டது அல்லது உங்கள் stop strings-ல் ஒன்று பொருந்திவிட்டது என்று பொருள், எனவே வரம்பை அதிகரிப்பதால் எந்த மாற்றமும் இருக்காது. stop உடன் வரும் குறுகிய பதில்கள் prompting அல்லது stop-string தொடர்பான சிக்கல். length உடன் வரும் குறுகிய பதில்கள் வரம்பு (cap) தொடர்பான சிக்கல்.
மதிப்பைத் தேர்ந்தெடுத்தல்
- ஊடாடும் உரையாடல்களுக்கு (interactive chat), வரம்பை நிர்ணயிக்காமல் விட்டுவிட்டு, தேவையற்ற நீண்ட பதில்களை நிறுத்த Ctrl+C விசையைப் பயன்படுத்தவும். நீங்கள் திரையை நேரடியாகக் கண்காணித்துக் கொண்டிருக்கிறீர்கள்.
- ஸ்கிரிப்ட் மூலம் இயங்கும் பணிகளுக்கு, வரம்பை நிர்ணயிக்கவும். ஒரு லூப்பிற்குள் வரம்பற்ற generation-ஐ அனுமதித்தால், பத்து நிமிடங்களில் முடிய வேண்டிய batch job அடுத்த நாள் காலை வரை இயங்கிக் கொண்டிருக்கும்.
- கட்டமைக்கப்பட்ட வெளியீடுகளுக்கு (structured output), நீங்கள் எதிர்பார்க்கும் மிகப்பெரிய ஆவணத்தை விட சற்று அதிகமான வரம்பை அமைக்கவும். பிறகு,
done_reason-ஐlength-ன் ஒரு பிழையாகக் கருதி, வந்த தரவை parse செய்வதற்குப் பதிலாக மீண்டும் முயற்சிக்கவும். - ஒரு coding agent-க்கு, இந்த மதிப்பு அந்த agent-ன் சொந்த configuration-ல் இருக்க வேண்டும். ஏனெனில், ஒவ்வொரு கோரிக்கையின் போதும் அந்த agent தனது சொந்த விருப்பத்தேர்வுகளை அனுப்புகிறது. Ollama-வை ஒரு coding agent-க்கு சுட்டிக்காட்டுதல் பகுதியில் இந்த அமைப்புகள் எங்கு உள்ளன என்பது விளக்கப்பட்டுள்ளது.
இந்த வரம்பு வார்த்தைகளையோ அல்லது எழுத்துக்களையோ கணக்கிடாது, tokens-ஐ மட்டுமே கணக்கிடும். எனவே, இதை உத்தேசமாக கணிக்க வேண்டாம். வரம்பு இல்லாமல் ஒரு மாதிரிப் பதிலை உருவாக்கி, eval_count-ஐப் படித்து, அந்த வரம்பை அதைவிடச் சற்று அதிகமாக அமைக்கவும். ஒவ்வொரு model குடும்பமும் tokens-ஐ வெவ்வேறு விதமாகக் கையாளும். எனவே, ஒரு Llama model-க்கு ஏற்ற மதிப்பு, அதே VPS-ல் உள்ள ஒரு Qwen 3 model-ன் பதிலை வெட்டிவிடக்கூடும்.
FAQ
Ollama-வில் num_ctx மற்றும் num_predict ஆகியவற்றுக்கு இடையே உள்ள வேறுபாடு என்ன?
num_ctx என்பது context window-ன் அளவு ஆகும்; இது மாடல் எவ்வளவு தகவலை வாசிக்க முடியும் என்பதைத் தீர்மானிக்கிறது (prompt மற்றும் இதுவரை உருவாக்கப்பட்டவை). இது நினைவகத்தை (memory) அதிகம் பயன்படுத்தும், ஏனெனில் key/value cache இதனுடன் சேர்ந்து வளரும். num_predict என்பது ஒரு பதிலில் மாடல் எத்தனை tokens-ஐ எழுதலாம் என்பதைத் தீர்மானிக்கிறது. இது நினைவகத்தை விட நேரத்தை அதிகம் செலவிடும், மேலும் இதற்காக முன்கூட்டியே எதுவும் ஒதுக்கப்படுவதில்லை. உருவாக்கப்பட்ட tokens இரண்டின் கணக்கிலும் வரும் என்பதால், context shift முடக்கப்பட்டிருந்தால், ஏதேனும் ஒன்றால் பதில் பாதியிலேயே நிறுத்தப்படலாம்.
எனது num_predict அமைப்பு ஏன் புறக்கணிக்கப்பட்டதாகத் தெரிகிறது?
ஏனெனில், கோரிக்கையுடன் (request) அனுப்பப்படும் மதிப்பு, மாடலில் சேமிக்கப்பட்ட மதிப்பை விட முன்னுரிமை பெறும். ஒரு Modelfile-ல் PARAMETER num_predict 512-ஐ அமைத்துவிட்டு, அந்த மாடலை ஒரு chat front end அல்லது coding agent மூலம் இயக்கினால், client தனது சொந்த options பொருளை அனுப்பும்; அதன் எண்ணே வெற்றி பெறும். ollama show --parameters உங்கள் மதிப்பைத்தான் காட்டும், ஏனெனில் அது சேமிக்கப்பட்ட மாடலை மட்டுமே வாசிக்கும், HTTP வழியாக என்ன வருகிறது என்பதை அதனால் பார்க்க முடியாது. "options": {"num_predict": 32}-ஐப் பயன்படுத்தி curl உடன் ஒரு கோரிக்கையை அனுப்பி, நீண்ட பதில் தேவைப்படும் ஒரு prompt-ஐக் கொடுத்து, பின் done_reason மற்றும் eval_count-ஐச் சரிபார்க்கவும். eval_count மதிப்பு 32 ஆக உள்ள ஒரு length, கோரிக்கையில் உள்ள மதிப்பு சேமிக்கப்பட்ட மதிப்பை மீறியதைக் காட்டுகிறது. இது server சரியாகச் செயல்படுவதை உறுதிசெய்து, உங்கள் application-ல் பிழையைத் தேட வழிவகுக்கும். ஒரு சிறிய எண்ணிக்கையைக் கொண்ட stop என்பது மாடல் முன்னதாகவே முடிந்துவிட்டது என்று மட்டுமே பொருள், எனவே அதிகத் தகவலைக் கேட்கும் prompt-ஐக் கொண்டு மீண்டும் முயற்சிக்கவும்.
எனது வெளியீடு num_predict-ஆல் நிறுத்தப்பட்டதா என்பதை எப்படி அறிவது?
"stream": false உடன் கோரிக்கையை அனுப்பி done_reason-ஐ வாசிக்கவும். stop என்ற மதிப்பு, மாடல் தானாகவே முடிந்துவிட்டது அல்லது உங்கள் stop சரங்களில் ஒன்று முடித்துவிட்டது என்று பொருள். length என்ற மதிப்பு, அதற்கு இடம் போதவில்லை என்று பொருள். பின் eval_count-ஐ உங்கள் வரம்புடன் ஒப்பிடவும்: அவை சரியாகப் பொருந்தினால், num_predict அதை நிறுத்தியுள்ளது என்று அர்த்தம்; eval_count குறைவாக இருந்தால், context window முதலில் நிரம்பிவிட்டது என்று அர்த்தம். Streaming செய்யும்போது, இந்த இரண்டு புலங்களும் "done": true உடன் இறுதித் துண்டில் (chunk) வரும், ஆனால் பல client libraries உங்கள் குறியீட்டிற்கு வருவதற்கு முன்பே அதை நீக்கிவிடும்.
num_predict-ன் இயல்புநிலை (default) மதிப்பு என்ன?
கட்டுரைகளைப் பார்ப்பதை விட, உங்கள் சொந்த நிறுவலிலிருந்தே இதைப் படிக்கவும். அக்டோபர் 2026 நிலவரப்படி, Ollama Modelfile குறிப்பு இயல்புநிலையை -1 என்று குறிப்பிடுகிறது; அதாவது generation-க்கு வரம்பு இல்லை. 128 என்று நீண்ட காலம் ஆவணப்படுத்தப்பட்ட பிறகு அந்தப் பதிவு திருத்தப்பட்டது. Ollama v0.40.11-ல், அந்த வரம்பற்ற இயல்புநிலை, எந்தவொரு எதிர்மறை மதிப்பையும் போலவே, num_ctx-ன் பத்து மடங்கு அளவில் நின்றுவிடும். எதிர்மறை மதிப்புகள் எண்ணிக்கையைக் குறிக்காமல், ஒரு குறியீடாகவே (sentinel) செயல்படுகின்றன. அதே அட்டவணையின் பழைய பதிப்புகள் மீதமுள்ள context-ஐ நிரப்ப -2-ஐக் குறிப்பிட்டிருந்தன. உங்கள் பதிப்பிற்கான Modelfile parameter reference-ஐச் சரிபார்த்து, பின் ollama show --parameters மற்றும் ஒரு curl கோரிக்கை மூலம் அதை உறுதிப்படுத்தவும்.
num_predict-ஐ அதிகரிப்பது மாடலை நீண்ட பதில்களை எழுத வைக்குமா?
இல்லை. இது ஒரு உச்சவரம்பை மட்டுமே நீக்குகிறது. ஒரு பதில் stop-ல் done_reason என்று முடிந்தால், மாடல் முடிந்துவிட்டதாகக் கருதியது அல்லது உங்கள் stop சரங்களில் ஒன்று பொருந்தியது என்று பொருள்; எனவே வரம்பை அதிகரிப்பதால் எந்த மாற்றமும் இருக்காது. அத்தகைய சூழலில் நீளம் என்பது prompt தொடர்பான கேள்வி: ஒரு குறிப்பிட்ட அமைப்பு, பிரிவுகளின் எண்ணிக்கை அல்லது விரிவான விளக்கத்தைக் கேட்கவும். done_reason என்பது length என்று வரும்போது மட்டுமே num_predict-ஐ அதிகரிக்கவும்.