SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-25

Ollama num_ctx: நீண்ட prompt துண்டிக்காமல் அமைப்பது எப்படி

Ollama-வின் சிறிய default context window நீண்ட prompt-ஐ அமைதியாக துண்டிக்கிறது. Request அல்லது server அளவில் num_ctx அமைத்து, அதிகரிப்பதற்கு முன் KV cache RAM-ஐ கணக்கிடுங்கள்.

num_ctx என்ன செய்கிறது, உங்கள் நீண்ட prompt ஏன் துண்டிக்கப்பட்டது

Ollama context length என்பது, load செய்யப்பட்ட model ஒரே நேரத்தில் memory-ல் வைத்திருக்கக்கூடிய tokens-ன் எண்ணிக்கையாகும். num_ctx அதை அமைக்கும் option ஆகும். Model குறிப்பிடும் அதிகபட்ச அளவைவிட மிகவும் குறைவான default-ஐ Ollama தேர்வு செய்கிறது. அதனால் model அதை வாசிப்பதற்கு முன்பே நீண்ட prompt துண்டிக்கப்படுகிறது. இது நடந்தது என்பதை response எதுவும் தெரிவிக்காது.

Ollama model library-யில் Llama 3.1 8B-க்கு 128k context window என்று குறிப்பிடப்பட்டுள்ளது. Stock server அதனை வழங்காது. Ollama-வின் சொந்த documentation-ல் வெவ்வேறு pages-ல் வெவ்வேறு defaults உள்ளன: FAQ 4096 tokens என்று கூறுகிறது; Modelfile reference-ல் num_ctx-ன் default 2048 என்று கூறுகிறது; context length page-ல், available VRAM (video RAM) அடிப்படையில் default தேர்வு செய்யப்படும் என்று கூறுகிறது: 24 GiB-க்கு குறைவாக இருந்தால் 4k, 24 GiB முதல் 48 GiB வரை இருந்தால் 32k, 48 GiB மற்றும் அதற்கு மேல் இருந்தால் 256k. இவை ஒவ்வொன்றும் ஏதோ ஒரு build-க்கு உண்மையாக இருந்துள்ளன. இந்த முரண்பாட்டிலிருந்து பெற வேண்டிய பயனுள்ள பாடம் இதுதான்: எந்த page-ஐயும், இதில் உள்ள இந்த page-ஐயும் கூட, நம்புவதற்குப் பதிலாக உங்கள் சொந்த running server-ல் உள்ள மதிப்பைப் பார்க்கவும்.

Truncation அமைதியாக நடக்கிறது. ஏனெனில் model தொடர்ந்து பதில் அளிக்கிறது, மேலும் அந்தப் பதில் நன்றாகவும் தோன்றுகிறது. ஆனால் அது உங்கள் input-ன் இறுதிப் பகுதியை அடிப்படையாகக் கொண்டு எழுதப்பட்டது. ஒரு document-ன் முதல் பாதியைத் தவறவிடும் summary, model தரம் குறைவாக இருப்பது போலத் தோன்றும். பொதுவாக காரணம் சிறிய context window ஆகும்.

உங்கள் server-ல் நடைமுறையில் உள்ள Ollama context length-ஐச் சரிபார்த்தல்

எந்தவொரு build-லும் வேலை செய்யும் சரிபார்ப்பு முறை prompt_eval_count ஆகும்; இது server செயலாக்கிய prompt tokens-ன் எண்ணிக்கையைக் காட்டுகிறது. context கொள்ளளவை விட அதிகமான தரவை அனுப்பினால், அந்த எண்ணிக்கை குறிப்பிட்ட வரம்பில் நின்றுவிடும்.

sudo apt update && sudo apt install -y jq
LONG=$(python3 -c "print('the quick brown fox jumps over the lazy dog. ' * 2000)")
jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:4096}}' |
  curl -s http://localhost:11434/api/generate -d @- |
  jq '{prompt_eval_count, prompt_eval_duration}'

அந்த prompt சுமார் 18,000 சொற்களைக் கொண்டது, எனவே இது 4096 tokens-ஐ விட மிக அதிகம். prompt_eval_count ஆனது உண்மையான token எண்ணிக்கைக்குப் பதிலாக 4096-க்கு அருகிலேயே முடிவுகளைத் தரும், ஏனெனில் server மீதமுள்ளவற்றை நீக்கிவிட்டது. இதை "num_ctx":16384 உடன் மீண்டும் இயக்கினால், எண்ணிக்கை உயரும். உங்கள் build தரவை நீக்குவதற்குப் பதிலாக error-ஐக் காட்டினால், அதுவும் அதே முடிவைத்தான் உறுதிப்படுத்துகிறது, ஆனால் கூடுதல் எச்சரிக்கையுடன்.

ollama ps

CONTEXT நிரல் (column), அதை அச்சிடும் build-களில், தற்போது இயங்கும் model-ன் context length-ஐக் காட்டுகிறது. அதற்கு அருகிலுள்ள PROCESSOR நிரல், model எங்குள்ளது என்பதைக் காட்டுகிறது. GPU இல்லாத VPS-ல் 100% CPU என்பது இயல்பானது. GPU உள்ள கணினியில் 30%/70% CPU/GPU போன்ற பிரிப்பு ஏற்பட்டால், weights மற்றும் cache ஆகியவை VRAM-ல் பொருந்தவில்லை என்று பொருள்; இதற்கு வழக்கமாக num_ctx அதிகரிக்கப்பட்டதே காரணமாக இருக்கும்.

journalctl -u ollama --no-pager | grep -i n_ctx | tail -n 5

Inference runner தனது context அளவை n_ctx அடங்கிய வரியில் அச்சிடுகிறது. ஒவ்வொரு release-க்கும் இதன் வாசகம் மாறக்கூடும், எனவே இந்த வரி இல்லை என்றால், அது ஏதோ ஒரு பிழை என்று கருதாமல், பெயர் மாற்றப்பட்டிருக்கலாம் என்று கருதுங்கள்.

num_ctx-ஐ அமைப்பதற்கான நான்கு இடங்கள்

கோரிக்கையில் (In the request). "options": {"num_ctx": 16384}-ஐ /api/generate அல்லது /api/chat-க்கு அனுப்பவும். இது மற்ற அனைத்து அமைப்புகளையும் விட முன்னுரிமை பெறும், மேலும் இது அந்த ஒரு குறிப்பிட்ட அழைப்பிற்கு மட்டுமே பொருந்தும். ஏற்றப்பட்டிருக்கும் model இயங்கும் மதிப்பை விட இந்த மதிப்பு வேறாக இருந்தால், server முதலில் model-ஐ மீண்டும் ஏற்றும். இதை பதிலில் உள்ள load_duration-ல் நீங்கள் காணலாம்: அது பூஜ்ஜியத்திற்கு அருகில் இருந்து சில நொடிகள் வரை உயரும். model நீண்ட நேரம் செயலற்று இருந்து, தானாகவே நீக்கப்பட்ட பிறகும் இதே காத்திருப்பு நேரம் ஏற்படும். எனவே, ஒரு context அளவை நீங்கள் முடிவு செய்தவுடன், keep_alive மூலம் model-ஐ நினைவகத்தில் வைத்திருப்பது நல்லது.

ஊடாடும் அமர்வில் (In the interactive session). ollama run-க்குள், /set parameter num_ctx 16384 எனத் தட்டச்சு செய்யவும். இது அந்த அமர்வுக்கு மட்டுமே நீடிக்கும்.

Modelfile-ல். இது அந்த மதிப்பை ஒரு பெயரிடப்பட்ட model-க்குள் பதித்துவிடும், எனவே client-ல் எந்த மாற்றமும் செய்யாமலேயே அனைத்து client-களும் இதைப் பயன்படுத்திக்கொள்ளலாம்.

FROM llama3.1:8b
PARAMETER num_ctx 16384
ollama create llama3.1-16k -f ./Modelfile
ollama run llama3.1-16k

Server-ல். OLLAMA_CONTEXT_LENGTH என்பது, சொந்தமாக num_ctx-ஐக் கொண்டிருக்காத அனைத்து கோரிக்கைகளுக்கும் இயல்புநிலை மதிப்பை அமைக்கும். systemd-ன் கீழ், unit file-ஐத் திருத்துவதற்குப் பதிலாக ஒரு drop-in கோப்பைச் சேர்க்கவும்.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"
sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama ps

நீங்கள் மற்றவர்களின் client-ஐ பிழைத்திருத்தம் (debug) செய்யும்போது, இந்த முன்னுரிமை வரிசை மிக முக்கியமானது. num_ctx-ஐக் கொண்ட ஒரு கோரிக்கை, server-ன் இயல்புநிலை அமைப்பை விட முன்னுரிமை பெறும். எனவே, ஒரு chat front end அல்லது ஒரு agent தனது சொந்த சிறிய மதிப்பை அனுப்பினால், அது உங்கள் systemd மாற்றத்தை அமைதியாக நீக்கிவிடும். நீங்கள் ஒரு coding agent-ஐ உங்கள் Ollama server-க்கு இணைக்கும்போது, server-ஐக் குறை கூறுவதற்கு முன்பு அந்த client என்ன அனுப்புகிறது என்பதைச் சரிபார்க்கவும்.

நீங்கள் ஏன் num_ctx-ஐ model maximum-க்கு மட்டும் அமைக்க முடியாது

Attention முறையில் ஒவ்வொரு token-மும் அதற்கு முன் உள்ள ஒவ்வொரு token-ஐயும் பார்க்கிறது. முந்தைய tokens-க்கு கணக்கிடப்பட்ட keys மற்றும் values மீண்டும் ஒவ்வொரு புதிய token-க்கும் கணக்கிடப்படாமல் சேமிக்கப்படுகின்றன. அந்த storage-ஐ KV cache (key/value cache) என்கிறோம். Model load ஆகும்போதே முழு num_ctx-க்காக இது allocate செய்யப்படுகிறது; conversation வளரும்போது படிப்படியாக allocate செய்யப்படுவதில்லை. எனவே one line prompt இருந்தாலும் பெரிய context அதன் memory-ஐ பயன்படுத்தும்.

ஒவ்வொரு layer-மும் ஒவ்வொரு token-க்கும் ஒவ்வொரு key/value head-க்கு ஒரு key vector மற்றும் ஒரு value vector வைத்திருக்கும். எனவே கணக்கை ஒரே வரியில் எழுதலாம்:

kv_bytes_per_token = 2 * layers * kv_heads * head_dim * bytes_per_value

2 என்பது keys மற்றும் values தனித்தனியாக எண்ணப்படுவதைக் குறிக்கிறது. மீதமுள்ள எண்களை உங்கள் சொந்த model-இலிருந்து எடுத்துக்கொள்ளுங்கள்.

curl -s http://localhost:11434/api/show -d '{"model":"llama3.1:8b"}' |
  jq '.model_info | {ctx: ."llama.context_length", layers: ."llama.block_count", heads: ."llama.attention.head_count", kv_heads: ."llama.attention.head_count_kv", embed: ."llama.embedding_length"}'

Llama 3.1 8B, 32 layers மற்றும் 8 key/value heads இருப்பதாகக் காட்டுகிறது. Head dimension என்பது embed-ஐ heads-ஆல் வகுத்ததற்கு சமம். எனவே இங்கு 4096 / 32 = 128. சில models இதை நேரடியாக llama.attention.key_length என வெளியிடும். Default cache f16 values-ஐ வைத்திருக்கும். ஆகவே bytes_per_value என்பது 2. 2 32 8 128 2 என்பதன் முடிவு 131,072 bytes. இதனால் context-இல் உள்ள ஒவ்வொரு token-க்கும் 128 KiB cache தேவைப்படுகிறது. Context length-ஆல் பெருக்கும்போது இதன் memory cost தெளிவாகத் தெரியும்.

விளக்கப்படம்Llama 3.1 8B at f16: KV cache and total RAM by context length, in GiB
இந்த விளக்கப்படத்தின் தரவு
[
  {
    "label": "4k",
    "kv_cache_gib": 0.5,
    "total_ram_gib": 5.1
  },
  {
    "label": "8k",
    "kv_cache_gib": 1,
    "total_ram_gib": 5.6
  },
  {
    "label": "16k",
    "kv_cache_gib": 2,
    "total_ram_gib": 6.6
  },
  {
    "label": "32k",
    "kv_cache_gib": 4,
    "total_ram_gib": 8.6
  },
  {
    "label": "64k",
    "kv_cache_gib": 8,
    "total_ram_gib": 12.6
  },
  {
    "label": "128k",
    "kv_cache_gib": 16,
    "total_ram_gib": 20.6
  }
]

அந்த 6 rows, மேலுள்ள formula-விலிருந்து பெறப்பட்ட arithmetic முடிவுகள்; அவை measurements அல்ல. Total column, October 2026-ல் Ollama library llama3.1:8b-க்காகக் குறிப்பிட்ட 4.9 GB download-ஐ சேர்க்கிறது. அது 4.6 GiB ஆகும். Compute buffers மற்றும் server process-க்குத் தேவையான memory இதில் சேர்க்கப்படவில்லை. இதை குறைந்தபட்ச மதிப்பாகக் கருதுங்கள்.

இதன் அளவுமாற்றமே முக்கியம். 8k context-ல் cache 1 GiB செலவாகும். Weights-ஐ ஒப்பிடும்போது இது மிகக் குறைவு. Model-ன் முழு 128k context-ல் cache 16 GiB செலவாகும். இது weights-ன் மூன்று மடங்குக்கும் அதிகம். மொத்தம் சுமார் 20.6 GiB தேவைப்படும். எனவே 4 GB VPS இந்த model-ஐ பயனுள்ள context அளவில் load செய்ய முடியாது. 8 GB VPS-ல் 8k context சிரமமின்றி இயங்கும். 16 GB VPS-ல் மீதமுள்ள system resources-க்குப் போதுமான இடத்துடன் 32k context அடையலாம். Weights அதிகரிக்கும்போது இந்த எல்லைகள் அனைத்தும் மேலே நகரும். ஆகவே இந்த 8B model-க்கு பதிலாக பெரிய model-ஐ தேர்வு செய்வதை பரிசீலித்தால், 8 முதல் 64 GB வரையிலான memory-ல் context-க்காக weights எவ்வளவு குறைந்த இடத்தை விடுகின்றன என்பதை, CPU-only VPS-ல் Qwen-ன் 27B tag-க்காக செய்யப்பட்ட அதே கணக்குகள் காட்டுகின்றன.

KV cache பொருந்தாதபோது என்ன நடக்கும்

CPU-only VPS-ல் process memory-ஐ தொடர்ந்து அதிகரிக்கும். Model load ஆகும் போதும், நீண்ட request இயங்கும் போதும் அதை monitor செய்யவும்.

free -m
ps -eo rss,comm --sort=-rss | head -n 5

RSS (resident set size) kilobytes-ல் காட்டப்படும். free -m-ல் பயன்படுத்தப்பட்ட swap அதிகரிக்கத் தொடங்கினால், context அளவைக் குறைக்கவும். Swap-ல் இருக்கும் KV cache generation-ஐ ஒவ்வொரு token-க்கும் பல seconds தாமதப்படுத்தும். காரணம், ஒவ்வொரு புதிய token-மும் முழு cache-ஐ வாசிக்க வேண்டும்.

Machine-ல் memory முழுமையாக தீர்ந்துவிட்டால், kernel ஒரு process-ஐ kill செய்யும். பொதுவாக அதிக memory வைத்திருக்கும் process-ஐ தேர்ந்தெடுக்கும்.

sudo dmesg | grep -i "killed process"

Out of memory: Killed process 1234 (ollama) என்று காட்டும் வரி, kernel தேர்ந்தெடுத்த process Ollama என்பதைக் குறிக்கும். Memory-ஐ பயன்படுத்தி முடித்த process அதுவே என்று அவசியமில்லை. Ollama மட்டுமே பெரிய process ஆக இயங்கும் machine-ல், பொருந்தாத அளவுக்கு பெரிய context இருப்பதே வழக்கமான காரணம். num_ctx-ஐ குறைப்பதற்கு முன் வேறு என்ன இயங்கிக் கொண்டிருந்தது என்பதைச் சரிபார்க்கவும். Ollama பெரும்பாலும் அந்த நிலை வருவதற்கு முன்பே மறுக்கும். அப்போது request தோல்வியடையும்; அது தேவைப்பட்ட memory அளவையும், அப்போது free-ஆக இருந்த memory அளவையும் message-ல் குறிப்பிடும்.

GPU machine-ல் failure அமைதியாக நடக்கும். சில layers system RAM-க்கு spill ஆகும். ollama ps CPU மற்றும் GPU இடையிலான split-ஐ காட்டும். Throughput கடுமையாகக் குறையும். இந்தக் குறைவு உங்கள் hardware-ஐ பொறுத்தது. எனவே, வேறு ஒருவரின் machine-ல் கிடைத்த figure-ஐ நம்பாமல், ஒவ்வொரு context setting-லும் உங்கள் சொந்த machine-ல் ஒரு second-க்கு உருவாகும் tokens-ஐ அளவிடவும்.

Prefill நேரம் prompt-ஐ விட வேகமாக அதிகரிக்கிறது

முதல் output token தோன்றுவதற்கு முன்பு, உங்கள் input-ல் செய்யப்படும் வேலையே prefill ஆகும். ஒவ்வொரு prompt token-ம் தனக்கு முன்னால் உள்ள அனைத்து token-களையும் கவனிப்பதால், மொத்த வேலையும் input நீளத்தின் வர்க்கத்திற்கு (square) ஏற்ப அதிகரிக்கிறது. Prompt-ன் அளவை இருமடங்கு ஆக்கினால், முதல் token-க்காக காத்திருக்கும் நேரம் இருமடங்கை விட அதிகமாகும்.

பதிலிலேயே அளவீடு இருப்பதால், நீங்கள் அதை அப்படியே நம்ப வேண்டியதில்லை.

jq -n --arg p "$LONG" '{model:"llama3.1:8b", prompt:$p, stream:false, options:{num_ctx:16384}}' |
  curl -s http://localhost:11434/api/generate -d @- |
  jq '{tokens: .prompt_eval_count, prefill_seconds: (.prompt_eval_duration/1000000000)}'

அதை ஒரு குறுகிய prompt-உடனும், பின்னர் ஒரு நீண்ட prompt-உடனும் இயக்கி, ஒவ்வொரு முறையிலும் tokens-ஐ seconds-ஆல் வகுக்கவும். CPU-only VPS-ல், நீண்ட-context request-இன் மிக மெதுவான பகுதி பொதுவாக prefill ஆகும். குறுகிய prompt-இல் கணக்கிடப்பட்ட tokens per second அளவு, நீண்ட prompt-இன் செயல்திறனை முன்கூட்டியே கணிக்காது. முன்புறத்தில் உள்ள ஏதேனும் timeout காலத்தைவிட prefill நீண்டால், நீண்ட prompt-க்கு பதிலாக context deadline exceeded திரும்புவது வழக்கமாகும். ஆகவே context-ஐக் குறைப்பதற்கு முன், எந்த layer கைவிட்டது என்பதை கண்டறியவும்.

Concurrency-ல் தான் இது அதிக பாதிப்பை ஏற்படுத்துகிறது. சேவை செய்யப்படும் ஒவ்வொரு கோரிக்கைக்கும் தனித்தனி cache தேவைப்படுகிறது. எனவே, மேலே உள்ள வரைபடத்தில் உள்ள memory என்பது server-க்கு அல்ல, ஒவ்வொரு கோரிக்கைக்கும் உரியது. ஒரு நீண்ட கோரிக்கை server-ஐ ஆக்கிரமித்துக்கொண்டால், சிறிய கோரிக்கைகள் வரிசையில் காத்திருக்க வேண்டியிருக்கும். OLLAMA_NUM_PARALLEL-ஐ கவனமாக அமைக்கவும். இரண்டையும் ஒரே நேரத்தில் அதிகரிப்பதற்கு முன்பு ஒரு self-hosted LLM எத்தனை concurrent பயனர்களுக்கு சேவை செய்ய முடியும் என்பதைப் படிக்கவும்.

சிறிய cache மூலம் context-ஐ மீட்டெடுக்கவும்

Formula-வில் உள்ள bytes_per_value என்பது நீங்கள் கட்டுப்படுத்தும் setting ஆகும். Ollama-வின் FAQ-யில் OLLAMA_KV_CACHE_TYPE ஆவணப்படுத்தப்பட்டுள்ளது. அதில் f16 default ஆகும்; q8_0, f16 பயன்படுத்தும் memory-யின் சுமார் பாதியை மட்டுமே பயன்படுத்தும்; q4_0, அதில் சுமார் நான்கில் ஒரு பகுதியைப் பயன்படுத்தும். q8_0-க்கான துல்லியமான அளவு பாதியை விடச் சிறிது அதிகம்: llama.cpp ஒவ்வொரு 32 values கொண்ட block-ஐ 32 one-byte values மற்றும் two-byte scale ஆக சேமிக்கிறது. ஆகவே, 34 bytes தேவைப்படும்; f16-க்கு 64 bytes தேவைப்படும். எனவே q8_0-க்கு மாறினால், 32k row-க்கு 4 GiB என்பதற்குப் பதிலாக சுமார் 2.1 GiB மட்டுமே தேவைப்படும். Weights-ஐ quantise செய்வது இதே memory budget-ன் மறுபுறத்தில் memory-ஐ விடுவிக்கும். நீங்கள் அந்த trade-off-ஐ விரும்பினால், VPS-ல் பொருந்தும் GLM tag quantisation நிலைகள் ஒவ்வொன்றாகப் பரிசோதிக்கப்படுகிறது. Flash Attention enabled நிலையில் மட்டுமே cache quantise செய்யப்படும் என்று அதே FAQ கூறுகிறது. அதை கட்டாயமாக enable செய்ய OLLAMA_FLASH_ATTENTION=1 பயன்படுத்தலாம்.

[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"

ஊகிக்காமல் உறுதிப்படுத்தவும்: service-ஐ restart செய்து, முன்பு பயன்படுத்திய அதே num_ctx-ல் model-ஐ load செய்யவும். பின்னர் RSS-ஐ ஒப்பிடவும். Support என்பது model மற்றும் backend ஆகியவற்றைப் பொறுத்தது. ஆகவே setting-ஐ மாற்றியும் எந்த மாற்றமும் இல்லையெனில், உங்கள் combination ஆதரிக்கப்படாமல் இருக்கலாம். Cache type ஒரு global option ஆகும். எனவே server-ல் இயங்கும் ஒவ்வொரு model-மும் அதையே பயன்படுத்தும். Quality குறித்து, q8_0 பொதுவாகக் கவனிக்கத்தக்க பாதிப்பை ஏற்படுத்தாது என்று FAQ கூறுகிறது. ஆனால் q4_0 அதிக precision-ஐ இழக்கும். குறிப்பாக பெரிய context sizes-ல் இந்த பாதிப்பு தெளிவாகத் தெரியும். எனவே அதைப் பயன்படுத்துவதற்கு முன், உங்கள் சொந்த prompts மூலம் q4_0-ஐச் சோதிக்கவும். இந்த knobs காரணமாகவே நீங்கள் இங்கு வந்திருந்தால், Ollama மற்றும் llama.cpp இவற்றை வெவ்வேறு விதமாக வெளிப்படுத்துகின்றன.

num_ctx-ஐத் தேர்ந்தெடுப்பதற்கான வழிமுறை

  1. /api/show-லிருந்து மாதிரியின் (model) அதிகபட்ச context, அதன் layer எண்ணிக்கை மற்றும் key/value head எண்ணிக்கை ஆகியவற்றை வாசிக்கவும்.
  2. சூத்திரத்தைப் பயன்படுத்தி ஒரு token-க்கான bytes அளவைக் கணக்கிட்டு, நீங்கள் விரும்பும் context அளவால் பெருக்கவும்.
  3. அதனுடன் weight அளவைக் கூட்டி, கிடைக்கும் RAM-உடன் ஒப்பிடவும். கணினியின் பிற செயல்பாடுகளுக்காகக் குறைந்தது 1 GiB RAM-ஐ ஒதுக்கி வைக்கவும்.
  4. மதிப்பை அமைத்து, மாதிரியை ஏற்றி (load), ollama ps மற்றும் prompt_eval_count மூலம் என்ன அளவு பயன்படுத்தப்பட்டது என்பதை உறுதிப்படுத்தவும்.
  5. free -m-ஐக் கவனித்தபடி உங்கள் உண்மையான பணிச்சுமையை (workload) இயக்கவும். swap memory பயன்பாடு தொடங்கினால், context அளவை பாதியாகக் குறைக்கவும்.

பெரும்பாலான பணிகளுக்கு மக்கள் ஒதுக்கும் அளவை விடக் குறைவான context-ஏ போதுமானது. ஒரு நீண்ட அறிக்கையைச் சுருக்க 16k போதுமானது. ஐந்து document chunks-ஐ இணைக்கும் retrieval front end அரிதாகவே 8k-ஐத் தாண்டும். முழு கோப்புகளையும் வாசிக்கும் coding agent-க்கு மட்டுமே 64k அல்லது அதற்கு மேற்பட்ட அளவு தேவைப்படும். அத்தகைய சூழலில், context-க்கு ஏற்ப கணினியின் அளவைத் தீர்மானிக்க வேண்டும். server புதியது என்றால், Ollama-வை VPS-ல் நிறுவுதல் என்ற வழிகாட்டியில் தொடங்கி, மாதிரிகள் சரியாக ஏற்றப்பட்ட பிறகு context-ஐச் சீரமைக்கவும்.

FAQ

Ollama-ல் இயல்புநிலை context length என்ன?

இது build மற்றும் hardware-ஐப் பொறுத்து மாறும். எனவே ஊகிப்பதைவிடச் சரிபார்க்கவும். Ollama-வின் FAQ 4096 tokens எனக் குறிப்பிடுகிறது. Modelfile reference, num_ctx default 2048 எனக் குறிப்பிடுகிறது. Context length பக்கம் கிடைக்கும் VRAM-ஐ அடிப்படையாகக் கொண்டு தேர்ந்தெடுக்கப்படும் இயல்புநிலையை குறிப்பிடுகிறது: 24 GiB-க்கு குறைவாக இருந்தால் 4k, 24 GiB முதல் 48 GiB வரை இருந்தால் 32k, 48 GiB மற்றும் அதற்கு மேல் இருந்தால் 256k. CPU-only VPS பொதுவாக குறைந்த அளவையே பயன்படுத்தும். அந்த column உள்ள build-களில் பயன்படுத்தப்பட்ட context-ஐ ollama ps காட்டும். API response-ல் உள்ள prompt_eval_count, எல்லா build-களிலும் அது பயன்படுத்தப்பட்டதை உறுதிப்படுத்தும்.

எனது நீண்ட prompt-ன் தொடக்கத்தை Ollama ஏன் புறக்கணிக்கிறது?

Prompt-ன் நீளம் context window-ஐ விட அதிகமாக இருந்ததால் இது நடக்கிறது. Model அதைப் பார்க்கும் முன் server அதன் ஒரு பகுதியை வெட்டிவிட்டது. எந்த error-உம் திரும்பவில்லை. அதே prompt-ஐ பெரிய num_ctx உடன் மீண்டும் அனுப்பவும். Response-ல் prompt_eval_count அதிகரிக்கிறதா என்பதைப் பார்க்கவும். அந்த எண்ணில் மாற்றம் இல்லையெனில், உங்களுக்கும் server-க்கும் இடையில் உள்ள ஏதோ ஒரு layer num_ctx-ஐ தானாக அமைக்கிறது. Chat front end-கள் மற்றும் agent framework-களில் இது பொதுவானது.

பெரிய num_ctx-க்கு எவ்வளவு கூடுதல் RAM தேவைப்படும்?

Context length-ஐ ஒவ்வொரு token-க்கான cache cost-ஆல் பெருக்கவும். அந்த cost 2 * layers * kv_heads * head_dim * bytes_per_value ஆகும். f16-ல் Llama 3.1 8B-க்கு ஒவ்வொரு token-க்கும் 128 KiB தேவைப்படும். எனவே 32k tokens-க்கு weights-க்கு மேலாக 4 GiB தேவைப்படும். முழு 128k-க்கு 16 GiB தேவைப்படும். Model load ஆகும்போது cache allocate செய்யப்படும். எனவே prompts குறுகியதாக இருந்தாலும் பெரிய num_ctx அந்த memory-ஐ பயன்படுத்தும்.

பெரிய context window Ollama-வை மெதுவாக்குமா?

ஆம், இரண்டு காரணங்களால். Prompt length-ன் square-க்கு ஏற்ப prefill வேலை அதிகரிக்கும். எனவே நீண்ட input-க்கு முதல் token வருவதற்கான தாமதம், அதன் நீளம் காட்டுவதைவிட அதிகமாக இருக்கும். பெரிய cache memory-க்காகவும் போட்டியிடும். GPU machine-ல் இது சில layers-ஐ system RAM-க்கு மாற்றும். CPU machine-ல் இது machine-ஐ swap பயன்படுத்தும் நிலைக்கு தள்ளும். நீங்கள் முழுமையாகப் பயன்படுத்தாத பெரிய num_ctx கூட memory-ஐ பயன்படுத்தும். ஆனால் prefill நேரத்தை அது அதிகரிக்காது.

ஒரு model-க்கு num_ctx-ஐ நிரந்தரமாக அமைக்க முடியுமா?

ஆம். FROM llama3.1:8b மற்றும் PARAMETER num_ctx 16384 உள்ள Modelfile-ஐ எழுதவும். பின்னர் ollama create llama3.1-16k -f ./Modelfile-ஐ இயக்கவும். llama3.1-16k-ஐக் கோரும் ஒவ்வொரு client-க்கும் எந்த options-ஐயும் அனுப்பாமல் அந்த context கிடைக்கும். தனக்கென num_ctx கொண்ட request அதற்கு முன்னுரிமை பெறும். எனவே இது ceiling அல்ல; இயல்புநிலை அமைப்பு மட்டுமே.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?