SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-26

Ollamaలో num_predictతో output పొడవు పరిమితం చేయడం

Ollama num_predict output tokens సంఖ్యను పరిమితం చేస్తుంది. దీన్ని సెట్ చేసే మూడు చోట్ల ఏది గెలుస్తుందో, responseలో done_reason విలువను ఎలా చదవాలో తెలుసుకోండి.

Ollamaలో num_predict చేసే పని

num_predict అనేది ఒక ప్రతిస్పందనలో మోడల్ గరిష్ఠంగా ఎన్ని tokens రూపొందించవచ్చో పరిమితం చేసే Ollama option. ఇది output tokens ను మాత్రమే లెక్కిస్తుంది. అందువల్ల prompt ఈ పరిమితిలోకి రాదు. మోడల్ ఈ పరిమితిని చేరుకున్నప్పుడు generation అక్కడే ఆగిపోతుంది. కొన్నిసార్లు పదం మధ్యలో కూడా ఆగవచ్చు. అప్పుడు ప్రతిస్పందనలో done_reason విలువ length గా ఉంటుంది.

ఈ feature యొక్క పని ఇంతే. అయితే విలువను సెట్ చేయడానికి Ollamaలో మూడు వేర్వేరు స్థానాలు ఉన్నాయి. request కు అత్యంత సమీపంలో ఉన్న setting అమలవుతుంది. ఒక layer మరొక layer setting ను నిశ్శబ్దంగా override చేయడం వల్లనే దాదాపు అన్ని "num_predict does nothing" నివేదికలు వస్తాయి.

num_predict అనేది num_ctx కాదు

Ollamaలో ఈ రెండు options ను ఇతర ఏ జంటకన్నా ఎక్కువగా తప్పుగా అర్థం చేసుకుంటారు. ఈ గందరగోళం వల్ల troubleshooting కోసం నిజమైన సమయం వృథా అవుతుంది.

num_ctx ద్వారా model ఎంత చదవగలదో నిర్ణయించబడుతుంది. ఇది context window పరిమాణం. ఇందులో prompt తో పాటు ఇప్పటివరకు ఉత్పత్తి అయిన మొత్తం content ఉంటుంది. దీన్ని పెంచితే memory వినియోగం పెరుగుతుంది. కారణం, ఈ tokens కోసం model నిల్వ చేసే key/value cache window పరిమాణంతో పెరుగుతుంది. మీ hardware కోసం num_ctx పరిమాణాన్ని నిర్ణయించడం అనేది వేరే పని. దీనికి ప్రత్యేకమైన failure modes ఉంటాయి.

num_predict ద్వారా model ఎంత రాయగలదో నిర్ణయించబడుతుంది. ఇది allocation కాదు; ఆపే నియమం. దీన్ని పెంచితే RAM కంటే wall-clock time ఎక్కువగా ఖర్చవుతుంది. ముందుగానే ఏదీ reserve చేయబడదు.

ఈ రెండు ఒకే చోట కలుస్తాయి. Generated tokens ఉత్పత్తి అవుతున్నప్పుడు context window లోకి చేరుతాయి. Ollama v0.40.11లో చాలా models కోసం context shift defaultగా on ఉంటుంది. అందువల్ల window నిండినప్పుడు పాత tokens తొలగించబడతాయి, generation కొనసాగుతుంది. Shift offలో ఉంటే, request "shift": false పంపడం వల్ల లేదా model shiftingకు మద్దతు ఇవ్వకపోవడం వల్ల, మీ cap చేరకముందే window నిండిన కారణంగా కూడా reply ఆగిపోవచ్చు. రెండు సందర్భాల్లోనూ Ollama length ను report చేస్తుంది. కాబట్టి ఈ రెండింటిని వేరు చేసే సంఖ్య eval_count. దీని గురించి క్రింద మరింత వివరంగా ఉంది.

Modelfile తో ఒకసారి అమర్చండి

Modelfile మీరు సృష్టించే model లో ఆ విలువను స్థిరంగా చేర్చుతుంది. ఫైల్‌ను రాయండి:

FROM qwen3:8b
PARAMETER num_ctx 8192
PARAMETER num_predict 512

తర్వాత దాన్ని build చేసి, మీరు build చేసినదాన్ని తిరిగి చదవండి:

ollama create qwen3-capped -f Modelfile
ollama show --parameters qwen3-capped

ollama show --parameters నిల్వ చేసిన ప్రతి parameter ను దాని value తో ఒక్కో line గా చూపుతుంది. ఆ output లో num_predict లేకపోతే, model లో ముందే నిర్ణయించిన పరిమితి లేదు. అప్పుడు Ollama యొక్క స్వంత default వర్తిస్తుంది. ollama show --modelfile qwen3-capped మొత్తం definition ను చూపుతుంది. ఇప్పటికే ఉన్న model లో చేర్చబడిన parameters ను copy చేయడానికి ఇదే వేగవంతమైన మార్గం. ఈ విధంగా పరిమితి ఉన్న model ను సృష్టించడానికి దాదాపు అదనపు disk space అవసరం లేదు. కొత్త entry, base model ఇప్పటికే download చేసిన weight blobs ను copy చేయకుండా వాటినే మళ్లీ ఉపయోగిస్తుంది. VPS root disk నిండిపోకముందే Ollama ఆ blobs ను ఎక్కడ ఉంచుతుందో తెలుసుకోవడం ఉపయోగకరం.

ప్రతి caller వారసత్వంగా పొందాలని మీరు కోరుకునే విలువకు ఇది సరైన స్థాయి. అయితే ఇది తుది స్థాయి అని భావిస్తే, ఇది సరైన స్థాయి కాదు. ఎందుకంటే ఇది తుది స్థాయి కాదు.

అభ్యర్థనకు అనుగుణంగా 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 ను అదే అర్థంతో ఉపయోగిస్తుంది. ఇక్కడ ఇచ్చిన విలువ ఆ ఒక్క call కు మాత్రమే వర్తిస్తుంది; మరేదానికీ వర్తించదు. మీ tools ఉపయోగించే layer ఇదే: chat front end, script, SDK wrapper లేదా coding agent. అవి మీకు దాని కోసం ప్రత్యేక box చూపించినా, చూపించకపోయినా, అన్నీ ఒక options object ను పంపుతాయి.

/set parameterతో ఒక session కోసం దీన్ని సెట్ చేయండి

ollama run లో interactive session మిగిలిన భాగానికి options ను సెట్ చేస్తుంది:

>>> /set parameter num_predict 256
>>> /show parameters

/show parameters మీ తదుపరి message తో session ఏమి పంపుతుందో చూపిస్తుంది. అందువల్ల మార్పు అమలైందో లేదో నిర్ధారించడానికి ఇది వేగవంతమైన మార్గం. మీరు /bye టైప్ చేసే వరకు ఈ value కొనసాగుతుంది. దీన్ని నిలుపుకోవడానికి /save qwen3-capped ప్రస్తుత session ను, parameters సహా, కొత్త model గా వ్రాస్తుంది. ఇక్కడ మీరు /set చేసే ఏదీ ఇతర client కు చేరదు.

ఏ సెట్టింగ్ అమలవుతుంది, మీది ఎందుకు పట్టించుకోనట్లుగా కనిపిస్తుంది

క్రమం సులభం. అభ్యర్థనతో పంపిన options అన్నింటికంటే ముందు అమలవుతాయి. మోడల్‌ యొక్క Modelfile లోని PARAMETER num_predict లైన్, అభ్యర్థనలో విలువ లేనప్పుడు ఉపయోగించే fallback. రెండూ లేకపోతే Ollama లోని built-in default అమలవుతుంది.

/set parameter మూడవ నియమం కాదు. interactive session ఒక API client. కాబట్టి అక్కడ మీరు సెట్ చేసిన విలువ ఆ అభ్యర్థనకు సంబంధించిన options గా పంపబడుతుంది. అందుకే అది ఆ session కోసం Modelfile విలువను override చేస్తుంది.

ఇది వివరించే సమస్య ఇప్పుడు చూద్దాం. మీరు PARAMETER num_predict 512 జోడించి మోడల్‌ను మళ్లీ build చేస్తారు. అయినా replies వేలాది tokens వరకు కొనసాగుతాయి. మీ setting ఉంది. ollama show --parameters దాన్ని నిర్ధారిస్తుంది. అయితే ప్రతి అభ్యర్థనలో అది override అవుతోంది. కారణం client తన స్వంత options object ను, తన స్వంత సంఖ్యతో పంపడం. ఆ సంఖ్యను మీరు నెలల క్రితం settings screen లో టైప్ చేసి, తరువాత మర్చిపోయి ఉండవచ్చు. ollama show stored model ను చదువుతుంది. HTTP ద్వారా చేరే విషయాన్ని అది చూపించలదు.

Server వైపు పరిస్థితిని ఒకే command తో నిర్ధారించండి. పొడవైన సమాధానం వచ్చేలా ఒక అభ్యర్థన పంపండి, 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 తో install చేయండి. 32 ఖచ్చితంగా వస్తుందని హామీ లేదు. ఎందుకంటే eval_count అనేది server వాస్తవంగా సృష్టించిన output tokens సంఖ్య మాత్రమే. మోడల్ ముందుగానే పూర్తయితే "stop" మరియు తక్కువ count వస్తాయి. అప్పుడు మరింత వివరంగా సమాధానం ఇవ్వమని అడిగే prompt ఉపయోగించాలి. "length" మరియు 32 వస్తే, అభ్యర్థనలోని స్వంత విలువ qwen3-capped లో నిల్వ చేసిన 512 కంటే పైచేయి సాధించింది. దీని ద్వారా server per-request options ను గౌరవిస్తుందని తెలుస్తుంది. అయితే మీ application ఏమి పంపుతుందో ఇది చెప్పదు. కాబట్టి పరిశీలన client వైపు కొనసాగాలి. ఒక అభ్యర్థన గురించి server స్వయంగా ఇచ్చే వివరాలు చూడాలంటే, environment లో OLLAMA_DEBUG=1 తో దాన్ని మళ్లీ ప్రారంభించి, మీ application దానితో మాట్లాడుతున్నప్పుడు journalctl -u ollama -f ను monitor చేయండి.

ప్రతికూల విలువలు మరియు మీరు కాపీ చేయకూడని సంఖ్యలు

num_predict ప్రతికూల విలువలను కూడా స్వీకరిస్తుంది. అవి count‌లుగా కాకుండా sentinel‌లుగా పంపబడతాయి. ఒక ప్రతికూల విలువ అంటే “దీనికి పరిమితి పెట్టవద్దు, generation కొనసాగించు” అని అర్థం. మరొకటి “మిగిలిన context‌ను నింపండి” అనే అర్థాన్ని కలిగి ఉంది. October 2026 నాటికి Ollama Modelfile reference default‌ను -1గా చూపుతోంది. ఇది infinite generation‌ను సూచిస్తుంది. అదే పట్టికలోని పాత versions context‌ను నింపడానికి -2ను కూడా చూపించాయి.

ఇవన్నీ versionపై ఆధారపడినవిగా పరిగణించండి, ఎందుకంటే ఈ ప్రవర్తన మారింది. Reference చాలా కాలం default‌ను 128గా document చేసింది. Entry తరువాత -1గా సరిదిద్దబడింది. అందువల్ల అనేక guides ఇప్పటికీ పాత సంఖ్యను చూపిస్తున్నాయి. ప్రవర్తన కూడా మారింది. October 25, 2026 నాటి ప్రస్తుత release అయిన Ollama v0.40.11, GGUF models‌ను upstream llama-server process‌కు పంపుతుంది. ఆ process‌కు finite budget అవసరం. అందువల్ల ఇది ఏదైనా negative valueను, అలాగే num_ctx కంటే పది రెట్లు ఎక్కువైన ఏ cap‌నైనా, num_ctx కంటే పది రెట్లుగా మార్చుతుంది. కాబట్టి పై qwen3-capped modelకు “Infinite” అంటే 81,920 tokens. -2 ఇక -1 కంటే భిన్నంగా ప్రవర్తించదు. మీరు అమలు చేస్తున్న version‌కు సంబంధించిన Modelfile parameter reference చదవండి. తరువాత పై eval_count check‌తో ప్రవర్తనను నిర్ధారించండి. మీ స్వంత boxలో మీరు ధృవీకరించిన విలువ, ఈ postలో చదివిన విలువతో సహా, ఎక్కడైనా చదివిన విలువ కంటే నమ్మదగినది.

CPU-only VPSలో output పొడవే ప్రధాన ఖర్చు

మీ నియంత్రణలో ఉన్న machineపై Ollama ను ఉచితంగా నడపవచ్చు, కాబట్టి local generation కు usage meter ఉండదు; దానికి బదులుగా దీర్ఘ సమాధానం సమయం రూపంలో ఖర్చవుతుంది. Generation రెండు దశల్లో జరుగుతుంది. ఈ రెండు దశల వేగాలు చాలా భిన్నంగా ఉంటాయి. Prompt tokens ను batchesలో, ఒకేసారి అనేక tokens గా evaluate చేస్తారు. Output tokens ను ఒక్కొక్కటిగా ఉత్పత్తి చేస్తారు. ప్రతి token కోసం అది ఉపయోగించే weights పై ఒక pass అవసరం. CPU-only VPSలో ఆ pass memory bandwidthతో పరిమితమవుతుంది. అందువల్ల ఒక generated token ఖర్చు ఒక prompt token కంటే చాలా ఎక్కువ. ఆ pass token ఉపయోగించే ప్రతి weight ను చదవాలి. Dense modelలో అన్ని weights చదవాలి. Nemotron 3.5 Lightning వంటి mixture-of-experts modelలో tokenకు route అయిన experts మాత్రమే చదవాలి; ఇది 30B parametersలో సుమారు 3B parametersను activate చేస్తుంది. అందువల్ల ప్రతి weight ఆక్రమించే bytes సంఖ్య మీ token rateకు గరిష్ఠ పరిమితిని నిర్ణయిస్తుంది. అందుకే అదే modelను q8 లేదా fp16లో నడిపిన దానికంటే q4 build వేగంగా decode చేస్తుంది.

Streaming లేకుండా response అడిగితే సంఖ్యలు స్పష్టంగా కనిపిస్తాయి:

"prompt_eval_count": 11,
"prompt_eval_duration": 13074791,
"eval_count": 18,
"eval_duration": 52479709

Durations nanosecondsలో ఉన్నాయి. ఆ block అక్టోబర్ 2026 నాటికి Ollama API documentationలో ప్రచురించిన sample response. ఇది ఏదైనా నిర్దిష్ట serverపై చేసిన measurement కాదు. అందులో 11 prompt tokensకు సుమారు 0.013 seconds పట్టగా, 18 output tokensకు సుమారు 0.052 seconds పట్టింది. అంటే prompt tokenకు సుమారు 1.2 milliseconds, output tokenకు 2.9 milliseconds పట్టాయి. కాబట్టి ఒకే పంక్తి replyలో కూడా ప్రతి generated token చదివిన ప్రతి token కంటే రెండింతలకంటే ఎక్కువ ఖర్చవుతుంది. దీర్ఘ సమాధానంలో clockను నింపేది output భాగమే. మీ generation rate అనేది eval_count ను eval_duration తో భాగించి, దాన్ని secondsగా మార్చిన విలువ. ఏదైనా tuning చేయడానికి ముందు మీ స్వంత hardwareపై tokens per secondను కొలవడం ఉపయోగకరం. ఆ rate machineపై మాత్రమే కాకుండా modelపై కూడా ఆధారపడి ఉంటుంది. కాబట్టి దీర్ఘ సమాధానాలే నిజమైన ఖర్చు అయితే, VPSపై Nemotron 3.5 Lightning వంటి వేగవంతమైన decoding కోసం రూపొందించిన model, తక్కువ cap కాపాడే సమయాన్ని కొంత తిరిగి పొందుతుంది.

మిగిలిన లెక్కను arithmetic స్పష్టం చేస్తుంది. సెకనుకు 8 tokens వేగంతో 2,000-token సమాధానం machineను నాలుగు నిమిషాలకంటే ఎక్కువసేపు busyగా ఉంచుతుంది. మీరు paragraph కోరుకున్నారని modelకు తెలియదు. Reasoning model మీరు అడిగిన పదాలను రాయడానికి ముందు తన budgetలో కొంత భాగాన్ని ఆలోచించడానికి ఉపయోగిస్తుంది. ఆ ఆలోచన కూడా మిగతా వాటిలాగే ఒక్కో tokenగా ఉత్పత్తి అవుతుంది. అందువల్ల మీరు అడిగే reasoning effort అదే ఖర్చుపై మరో నియంత్రణగా ఉంటుంది. కొన్ని models ఏదైనా వాటిని ఆపే వరకు ఒక phraseను మళ్లీ మళ్లీ రాస్తూ loop అవుతాయి. Cap లేకపోతే, context shift పూర్తి window ముగియకుండా నిరోధిస్తుంది కాబట్టి, ఆ single request num_ctx tokensకు పది రెట్లు చేరుకునే వరకు ఒక coreను busyగా ఉంచుతుంది. దాన్ని పరిమితం చేసే setting num_predict. చిన్న self-hosted Ollama VPSలో ఇది ప్రత్యేకంగా ముఖ్యం, ఎందుకంటే అక్కడ ఒక దీర్ఘ request మొత్తం machine వనరులను ఆక్రమించవచ్చు.

కుదించబడిన output సాధారణంగా పరిమితి వల్లే ఉంటుంది, మోడల్ విఫలమైనందువల్ల కాదు

లక్షణాలు మోడల్ విఫలమైనట్లుగా కనిపిస్తాయి. వాక్యం మధ్యలోనే ఆగిపోయిన సమాధానం. ముగింపు brace రాకపోవడం వల్ల parse కాని JSON. వెంటనే మోడల్ లేదా quantisation ను తప్పుపట్టాలని అనిపిస్తుంది. ముందుగా response ను పరిశీలించండి.

done_reason సమాధానం ప్రశ్నకు నేరుగా ఇచ్చిందని సూచిస్తుంది. stop అంటే generation ఎటువంటి పరిమితిని చేరకముందే ముగిసిందని అర్థం. మోడల్ తన end-of-sequence token ను పంపి ఉండవచ్చు, లేదా మీ stop option లోని strings లో ఒకదానికి output సరిపడి ఉండవచ్చు. ఆ match కనిపించిన చోటే reply ముగుస్తుంది. length అంటే అందుబాటులో ఉన్న స్థలం పూర్తయినందున generation మధ్యలోనే కత్తిరించబడిందని అర్థం. length కనిపించినప్పుడు eval_count ను మీ cap తో పోల్చండి: రెండూ సరిగ్గా సమానంగా ఉంటే num_predict దాన్ని ఆపింది. అంతకంటే చిన్న సంఖ్య ఉంటే ముందుగా context window నిండిపోయింది. context shift ఆపివేసినప్పుడు మాత్రమే ఇది జరుగుతుంది.

మీరు stream చేసినప్పుడు, ఈ fields చివరి chunk లో వస్తాయి. ఆ chunk లో "done": true ఉంటుంది. అనేక client libraries ఈ chunk ను విస్మరించి, మీ code కు text మాత్రమే అందిస్తాయి. అందుకే application లో అదే truncation కారణం తెలియనిదిగా కనిపిస్తుంది, కానీ curl కింద స్పష్టంగా కనిపిస్తుంది. library దాన్ని దాచిపెడితే, server నిజంగా ఏమి చెప్పిందో తెలుసుకోవడానికి curl తో ఒక request పంపండి.

మరొక విషయం తెలుసుకుంటే సమయం వృథా కాకుండా ఉంటుంది. num_predict ను పెంచడం వల్ల మోడల్ ఎక్కువగా రాయదు. అది కేవలం ఒక ceiling ను తొలగిస్తుంది. reply 200 tokens వద్ద done_reason of stop తో ముగిస్తే, మోడల్ పని పూర్తయిందని నిర్ణయించి ఉండవచ్చు లేదా మీ stop strings లో ఒకటి match అయి ఉండవచ్చు. అప్పుడు పెద్ద cap వల్ల ఎలాంటి మార్పు ఉండదు. stop ఉన్న చిన్న సమాధానాలు prompting లేదా stop-string సమస్యను సూచిస్తాయి. length ఉన్న చిన్న సమాధానాలు cap సమస్యను సూచిస్తాయి.

విలువను ఎంచుకోవడం

  • ఇంటరాక్టివ్ chat కోసం దీనికి పరిమితి పెట్టకుండా ఉంచండి. నియంత్రణ తప్పిన సమాధానాన్ని ఆపడానికి Ctrl+C నొక్కండి. మీరు ఏమైనప్పటికీ స్క్రీన్‌ను గమనిస్తూనే ఉంటారు.
  • Script ద్వారా నడిచే పనులకు దీనిని సెట్ చేయండి. Loop లో పరిమితి లేని generation ఉంటే, పది నిమిషాల్లో పూర్తవ్వాల్సిన batch job మరుసటి ఉదయం కూడా నడుస్తూనే ఉంటుంది.
  • Structured output కోసం, మీరు ఆశించే అతిపెద్ద చెల్లుబాటు అయ్యే document కంటే cap ఎక్కువగా ఉండేలా సెట్ చేయండి. తరువాత done_reason of length ను తీవ్రమైన లోపంగా పరిగణించి, తిరిగి వచ్చినదాన్ని parse చేయడానికి బదులుగా retry చేయండి.
  • Coding agent కోసం, విలువ agent స్వంత configuration లో ఉండాలి, ఎందుకంటే ప్రతి requestలో agent తన స్వంత options ను పంపుతుంది. Coding agent ను Ollama కు సూచించడం ఆ settings ఎక్కడ ఉంటాయో వివరిస్తుంది.

ఈ cap tokens ను లెక్కిస్తుంది; words లేదా characters ను కాదు. అందువల్ల దీనిని అంచనా వేయవద్దు. ముందుగా cap లేకుండా ఒక ప్రతినిధి సమాధానాన్ని generate చేసి, eval_count ను చదవండి. తరువాత limit ను దాని కంటే తగినంత ఎక్కువగా సెట్ చేయండి. Model families tokens ను వేర్వేరుగా tokenise చేస్తాయి. అందువల్ల Llama model కు సరిపోయే విలువ, అదే VPS లోని Qwen 3 model నుంచి వచ్చిన అదే సమాధానాన్ని truncate చేయవచ్చు.

FAQ

num_ctx మరియు num_predict మధ్య తేడా ఏమిటి?

num_ctx అనేది context window పరిమాణం. అంటే మోడల్ ఎంత చదవగలదో అది నిర్ణయిస్తుంది: prompt తో పాటు ఇప్పటివరకు రూపొందించిన మొత్తం output కూడా ఇందులో ఉంటుంది. దీనికి memory అవసరం, ఎందుకంటే key/value cache పరిమాణం దీనితో పాటు పెరుగుతుంది. num_predict ఒక response లో మోడల్ రాయగల గరిష్ఠ token సంఖ్యను నిర్ణయిస్తుంది. దీనికి memory కంటే సమయం ఎక్కువగా అవసరం, అలాగే ముందుగానే ఏదీ reserve చేయబడదు. రూపొందించిన tokens రెండింటి పరిమితిలోనూ లెక్కించబడతాయి. కాబట్టి context shift ఆఫ్‌లో ఉంటే reply ను వీటిలో ఏ పరిమితి అయినా ముందుగానే ఆపవచ్చు.

నా num_predict setting పట్టించుకోనట్లుగా ఎందుకు కనిపిస్తోంది?

Request తో పంపిన value, model లో నిల్వ చేసిన value ను override చేస్తుంది. Modelfile లో PARAMETER num_predict 512 ఉంచి, ఆ model ను chat front end లేదా coding agent నుంచి నడిపితే, client తన స్వంత options object ను పంపుతుంది. అందులోని సంఖ్యే అమలవుతుంది. ollama show --parameters మాత్రం మీరు ఇచ్చిన value నే చూపిస్తుంది, ఎందుకంటే అది నిల్వ చేసిన model ను చదువుతుంది; HTTP ద్వారా వచ్చిన value ను చూడలదు. "options": {"num_predict": 32} ఉపయోగించి curl తో ఒక request పంపండి. దీని prompt కు దీర్ఘమైన సమాధానం అవసరమయ్యేలా ఉండాలి. తరువాత done_reason మరియు eval_count ను చదవండి. eval_count 32గా ఉన్న length request లోని value నిల్వ చేసిన value ను override చేసిందని చూపిస్తుంది. దీని ద్వారా server సరిగ్గా పనిచేస్తోందని నిర్ధారించవచ్చు. తరువాత పరిశీలనను మీ application వైపు మళ్లించాలి. తక్కువ count ఉన్న stop అంటే model ముందుగానే పూర్తిచేసిందని మాత్రమే అర్థం. ఎక్కువ output కోరే prompt తో మళ్లీ ప్రయత్నించండి.

నా output ను num_predict కత్తిరించిందో లేదో ఎలా తెలుసుకోవాలి?

"stream": false తో request పంపి done_reason ను చదవండి. stop విలువ అంటే model స్వయంగా పూర్తిచేసిందని లేదా మీ stop strings లో ఒకటి generation ను ముగించిందని అర్థం. length విలువ అంటే అందుబాటులో ఉన్న పరిమితి పూర్తయిందని అర్థం. తరువాత eval_count ను మీ cap తో పోల్చండి. రెండూ ఖచ్చితంగా సమానంగా ఉంటే num_predict దాన్ని ఆపింది. eval_count తక్కువగా ఉంటే context window ముందుగా నిండిపోయింది. Streaming సమయంలో రెండు fields చివరి chunk లో "done": true తో వస్తాయి. మీ code వాటిని చూడకముందే అనేక client libraries వాటిని తొలగిస్తాయి.

num_predict యొక్క default value ఏమిటి?

ఏదైనా article కంటే మీ స్వంత install నుంచి value ను చదవండి. October 2026 నాటికి Ollama Modelfile reference default ను -1 గా పేర్కొంటుంది. అంటే generation కు cap ఉండదు. చాలా కాలం 128 అని documentation ఇచ్చిన తర్వాత ఆ entry సరిచేయబడింది. Ollama v0.40.11 లో ఈ open-ended default, ఇతర negative values లాగే, వాస్తవానికి పది రెట్లు num_ctx వద్ద ఆగుతుంది. Negative values counts కాకుండా sentinels గా పనిచేస్తాయి. అదే table యొక్క పాత versions లో మిగిలిన context ను నింపడానికి -2 కూడా పేర్కొనబడింది. మీ version కోసం Modelfile parameter reference చూడండి. తరువాత ollama show --parameters మరియు ఒక curl request తో దాన్ని నిర్ధారించండి.

num_predict పెంచితే model ఎక్కువ పొడవైన సమాధానాలు రాస్తుందా?

లేదు. ఇది కేవలం ఒక ceiling ను తొలగిస్తుంది. stop యొక్క done_reason తో reply ముగిస్తే, model పూర్తయిందని నిర్ణయించిందని లేదా మీ stop strings లో ఒకటి సరిపోలిందని అర్థం. పెద్ద cap పెట్టినా మార్పు ఉండదు. ఆ పరిస్థితిలో output పొడవు prompting పై ఆధారపడి ఉంటుంది. నిర్దిష్ట structure, section count లేదా వివరాల స్థాయిని అడగండి. done_reason, length గా వచ్చినప్పుడు మాత్రమే num_predict ను పెంచండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?