วิธีตั้งค่า num_ctx ใน Ollama เพื่อขยาย Context Length
Ollama มักตัดทอน Prompt ที่ยาวเกินค่าเริ่มต้นโดยไม่แจ้งเตือน เรียนรู้วิธีตั้งค่า num_ctx ทั้งรายคำขอและระดับเซิร์ฟเวอร์ พร้อมคำนวณการใช้ RAM สำหรับ KV Cache ให้เหมาะสม
หน้าที่ของ num_ctx และสาเหตุที่ prompt ขนาดยาวของคุณถูกตัดทอน
ความยาวบริบท (context length) ของ Ollama คือจำนวนโทเค็นที่โมเดลซึ่งถูกโหลดไว้สามารถเก็บไว้ในหน่วยความจำได้พร้อมกัน โดยมี num_ctx เป็นตัวเลือกสำหรับกำหนดค่านี้ Ollama จะเลือกค่าเริ่มต้นที่ต่ำกว่าค่าสูงสุดที่โมเดลรองรับได้จริงมาก ส่งผลให้ prompt ที่ยาวเกินไปถูกตัดทอนก่อนที่โมเดลจะอ่านถึง และไม่มีการแจ้งเตือนใดๆ ในคำตอบว่าเหตุการณ์นี้เกิดขึ้น
Llama 3.1 8B ถูกระบุว่ามีหน้าต่างบริบทขนาด 128k ในคลังโมเดลของ Ollama แต่เซิร์ฟเวอร์ที่ติดตั้งตามค่ามาตรฐานจะไม่ให้ค่าดังกล่าวแก่คุณ เอกสารของ Ollama เองยังระบุค่าเริ่มต้นที่แตกต่างกันในแต่ละหน้า โดย FAQ ระบุว่า 4096 โทเค็น ส่วนอ้างอิง Modelfile ระบุว่า num_ctx มีค่าเริ่มต้นที่ 2048 และใน หน้าความยาวบริบท ระบุว่าค่าเริ่มต้นจะถูกเลือกจาก VRAM (video RAM) ที่มีอยู่ คือ 4k สำหรับ VRAM ต่ำกว่า 24 GiB, 32k สำหรับ 24 GiB ถึง 48 GiB และ 256k สำหรับ 48 GiB ขึ้นไป แต่ละค่าเคยเป็นค่าจริงในบางเวอร์ชันที่สร้างขึ้น บทเรียนสำคัญจากความไม่สอดคล้องนี้คือ ให้ตรวจสอบค่าจากเซิร์ฟเวอร์ที่คุณใช้งานอยู่จริง แทนที่จะเชื่อข้อมูลจากหน้าเว็บใดๆ รวมถึงหน้านี้ด้วย
การตัดทอนข้อมูลเกิดขึ้นอย่างเงียบเชียบเนื่องจากโมเดลยังคงตอบคำถามและคำตอบที่ได้ยังอ่านรู้เรื่อง โดยคำตอบนั้นถูกเขียนขึ้นจากส่วนท้ายของข้อมูลที่คุณป้อนเข้าไป การสรุปความที่ขาดเนื้อหาครึ่งแรกของเอกสารอาจทำให้ดูเหมือนเป็นโมเดลที่ไม่มีประสิทธิภาพ แต่โดยปกติแล้วสาเหตุมาจากหน้าต่างบริบทที่มีขนาดเล็กเกินไป
ตรวจสอบความยาว context ที่ Ollama ใช้งานจริงบนเซิร์ฟเวอร์ของคุณ
วิธีตรวจสอบที่ใช้ได้กับทุก build คือการดู prompt_eval_count ซึ่งเป็นจำนวน token ของ prompt ที่เซิร์ฟเวอร์รายงานว่าประมวลผลไปแล้ว หากส่งข้อมูลที่มีขนาดเกินกว่าที่ 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 token ไปมาก ค่า prompt_eval_count ที่ได้กลับมาจะใกล้เคียงกับ 4096 แทนที่จะเป็นจำนวน token จริง เนื่องจากเซิร์ฟเวอร์ตัดส่วนที่เกินออกไป ให้ลองรันคำสั่งอีกครั้งด้วย "num_ctx":16384 แล้วจำนวนจะเพิ่มขึ้น หาก build ของคุณแสดงข้อผิดพลาดแทนที่จะตัดทอนข้อมูล นั่นถือเป็นผลลัพธ์ที่ยืนยันได้ชัดเจนเช่นเดียวกัน
ollama psคอลัมน์ CONTEXT ใน build ที่แสดงผลข้อมูลนี้ จะระบุความยาวของ context ที่โมเดลที่โหลดอยู่กำลังใช้งานในขณะนั้น ส่วนคอลัมน์ PROCESSOR ที่อยู่ถัดไปจะแสดงตำแหน่งที่โมเดลถูกโหลดไว้ ค่า 100% CPU เป็นค่าปกติบน VPS ที่ไม่มี GPU ส่วนการแบ่งข้อมูลแบบ 30%/70% CPU/GPU บนเครื่องที่มี GPU หมายความว่าน้ำหนักของโมเดลรวมกับ cache ไม่สามารถเก็บใน VRAM ได้ทั้งหมด ซึ่งสาเหตุส่วนใหญ่มักเกิดจากการตั้งค่า num_ctx ที่สูงเกินไป
journalctl -u ollama --no-pager | grep -i n_ctx | tail -n 5ตัวประมวลผล inference จะแสดงขนาด context ในบรรทัดที่มีข้อความ n_ctx รูปแบบข้อความที่แน่นอนอาจเปลี่ยนแปลงไปตามแต่ละ releases ดังนั้นหากไม่พบข้อความดังกล่าว ให้สันนิษฐานว่ามีการเปลี่ยนชื่อเรียกแทนที่จะสรุปว่าระบบมีปัญหา
สี่ตำแหน่งสำหรับการตั้งค่า num_ctx
ในคำขอ (Request): ส่ง "options": {"num_ctx": 16384} ไปยัง /api/generate หรือ /api/chat วิธีนี้มีลำดับความสำคัญสูงสุดเหนือการตั้งค่าอื่นทั้งหมด และมีผลเฉพาะกับคำขอนั้นๆ หากค่าที่ส่งไปแตกต่างจากค่าที่โมเดลที่โหลดอยู่ใช้งานอยู่ เซิร์ฟเวอร์จะทำการโหลดโมเดลใหม่ก่อน ซึ่งคุณสามารถสังเกตได้จาก load_duration ในส่วนของ response โดยค่าจะกระโดดจากใกล้ศูนย์ไปเป็นหลักวินาที การรอคอยในลักษณะเดียวกันจะเกิดขึ้นเมื่อโมเดลไม่ได้ใช้งานนานจนถูก unload ดังนั้นเมื่อคุณตัดสินใจเลือกขนาด context ที่เหมาะสมได้แล้ว ควร คงโมเดลไว้ในหน่วยความจำด้วย keep_alive
ในเซสชันแบบโต้ตอบ (Interactive session): ภายใน ollama run ให้พิมพ์ /set parameter num_ctx 16384 ค่านี้จะมีผลเฉพาะในเซสชันนั้น
ใน Modelfile: วิธีนี้เป็นการฝังค่าลงในโมเดลที่ตั้งชื่อไว้ ทำให้ทุกไคลเอนต์ได้รับค่านี้โดยไม่ต้องแก้ไขที่ฝั่งไคลเอนต์
FROM llama3.1:8b
PARAMETER num_ctx 16384ollama create llama3.1-16k -f ./Modelfile
ollama run llama3.1-16kบนเซิร์ฟเวอร์: OLLAMA_CONTEXT_LENGTH เป็นการกำหนดค่าเริ่มต้นสำหรับทุกคำขอที่ไม่ได้ระบุ num_ctx ของตนเอง หากใช้งานภายใต้ systemd ให้เพิ่มไฟล์ drop-in แทนการแก้ไขไฟล์ unit โดยตรง
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama psลำดับความสำคัญมีความสำคัญอย่างยิ่งเมื่อคุณกำลังดีบั๊กไคลเอนต์ของผู้อื่น คำขอที่ระบุ num_ctx จะมีความสำคัญเหนือกว่าค่าเริ่มต้นของเซิร์ฟเวอร์ ดังนั้น chat front end หรือ agent ที่ส่งค่าขนาดเล็กของตนเองมาด้วย จะทำให้การตั้งค่าผ่าน systemd ของคุณถูกยกเลิกไปโดยไม่รู้ตัว เมื่อคุณ เชื่อมต่อ coding agent เข้ากับเซิร์ฟเวอร์ Ollama ของคุณ ให้ตรวจสอบสิ่งที่ไคลเอนต์ส่งมาก่อนที่จะสรุปว่าปัญหาเกิดจากเซิร์ฟเวอร์
เหตุผลที่คุณไม่สามารถตั้งค่า num_ctx ให้เท่ากับค่าสูงสุดของโมเดลได้
กลไก Attention ทำให้ทุก token ต้องตรวจสอบ token ก่อนหน้าทั้งหมด คีย์และค่า (keys and values) ที่คำนวณสำหรับ token ก่อนหน้าจะถูกเก็บไว้เพื่อไม่ให้ต้องคำนวณใหม่สำหรับ token ใหม่แต่ละตัว พื้นที่จัดเก็บนี้เรียกว่า KV cache (key/value cache) ซึ่งจะถูกจองไว้สำหรับ num_ctx ทั้งหมดตั้งแต่ตอนที่โมเดลโหลด ไม่ใช่ค่อยๆ เพิ่มขึ้นตามการสนทนา ดังนั้น context ขนาดใหญ่จึงใช้หน่วยความจำเต็มจำนวนแม้จะเป็นเพียง prompt บรรทัดเดียวก็ตาม
แต่ละ layer จะเก็บเวกเตอร์คีย์หนึ่งชุดและเวกเตอร์ค่าหนึ่งชุดต่อหนึ่ง key/value head สำหรับแต่ละ token ดังนั้นการคำนวณจึงสรุปได้ในบรรทัดเดียว:
kv_bytes_per_token = 2 * layers * kv_heads * head_dim * bytes_per_valueเลข 2 มาจากการนับคีย์และค่าแยกกัน คุณสามารถอ่านตัวเลขอื่นๆ ได้จากโมเดลของคุณเอง
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 คือ embed หารด้วย heads ดังนั้นในกรณีนี้คือ 4096 / 32 = 128 และโมเดลบางรุ่นจะระบุค่านี้โดยตรงเป็น llama.attention.key_length แคชเริ่มต้นจะเก็บค่าแบบ f16 ดังนั้น bytes_per_value จึงเท่ากับ 2 และผลลัพธ์ของ 2 32 8 128 2 คือ 131,072 bytes นั่นหมายถึง 128 KiB ของแคชสำหรับ context ทุกๆ หนึ่ง token เมื่อคูณด้วยความยาวของ context ค่าใช้จ่ายที่เกิดขึ้นจะไม่ใช่เรื่องนามธรรมอีกต่อไป
ข้อมูลเบื้องหลังแผนภูมินี้
[
{
"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 เหล่านั้นมาจากการคำนวณตามสูตรข้างต้น ไม่ใช่การวัดจริง คอลัมน์รวมได้รวมขนาดไฟล์ดาวน์โหลด 4.9 GB ที่ไลบรารี Ollama ระบุไว้สำหรับ llama3.1:8b ในเดือนตุลาคม 2026 ซึ่งเท่ากับ 4.6 GiB โดยยังไม่รวม compute buffers และตัว process ของเซิร์ฟเวอร์เอง ให้ถือว่าตัวเลขนี้เป็นค่าต่ำสุดที่ต้องใช้
ประเด็นสำคัญคือรูปแบบการใช้หน่วยความจำ ที่ 8k แคชจะมีค่าใช้จ่าย 1 GiB ซึ่งถือว่าน้อยมากเมื่อเทียบกับน้ำหนักของโมเดล แต่ที่ความยาวเต็ม 128k ของโมเดล มันจะมีค่าใช้จ่ายถึง 16 GiB ซึ่งมากกว่าน้ำหนักของโมเดลถึงสามเท่า ทำให้ยอดรวมใกล้เคียงกับ 20.6 GiB ดังนั้น VPS ขนาด 4 GB จึงไม่สามารถโหลดโมเดลนี้ด้วย context ที่ใช้งานได้จริง VPS ขนาด 8 GB สามารถใช้งานที่ 8k ได้อย่างสบาย ส่วน VPS ขนาด 16 GB สามารถไปถึง 32k โดยยังมีพื้นที่เหลือสำหรับส่วนอื่นๆ ของระบบ เกณฑ์เหล่านี้จะขยับขึ้นตามน้ำหนักของโมเดล ดังนั้นหากคุณกำลังเปรียบเทียบโมเดลที่ใหญ่กว่ากับรุ่น 8B นี้ การคำนวณแบบเดียวกันที่แสดงไว้ใน แท็ก Qwen 27B บน VPS ที่ใช้เฉพาะ CPU จะแสดงให้เห็นว่าน้ำหนักของโมเดลเหลือพื้นที่สำหรับ context น้อยเพียงใดเมื่อมี RAM ระหว่าง 8 ถึง 64 GB
เกิดอะไรขึ้นเมื่อ KV cache มีขนาดไม่พอ
บน VPS ที่ใช้เฉพาะ CPU กระบวนการทำงานจะขยายขนาดขึ้นเรื่อยๆ ให้เฝ้าสังเกตขณะที่โมเดลกำลังโหลดและขณะที่คำขอที่มีความยาวกำลังประมวลผล
free -m
ps -eo rss,comm --sort=-rss | head -n 5RSS (resident set size) จะแสดงเป็นหน่วยกิโลไบต์ หากค่า swap ที่ใช้ใน free -m เริ่มเพิ่มสูงขึ้น ให้ลดขนาด context ลง KV cache ที่ไปอยู่ใน swap จะทำให้การสร้างข้อความหยุดชะงักเป็นเวลาหลายวินาทีต่อหนึ่ง token เนื่องจากทุก token ใหม่จะต้องอ่าน cache ทั้งหมด
หากเครื่องหน่วยความจำเต็ม kernel จะเลือกกระบวนการหนึ่งเพื่อสั่งยุติการทำงาน (kill) ซึ่งมักจะเป็นกระบวนการที่ใช้หน่วยความจำมากที่สุด
sudo dmesg | grep -i "killed process"บรรทัดที่ระบุว่า Out of memory: Killed process 1234 (ollama) หมายความว่า Ollama คือกระบวนการที่ kernel เลือก ไม่ได้หมายความว่า Ollama เป็นกระบวนการที่ใช้หน่วยความจำจนหมดเสมอไป ในเครื่องที่มี Ollama เป็นกระบวนการขนาดใหญ่เพียงตัวเดียว สาเหตุที่พบบ่อยคือขนาด context ใหญ่เกินกว่าจะรองรับได้ ให้ตรวจสอบว่ามีโปรแกรมอื่นใดทำงานอยู่ก่อนที่คุณจะลด num_ctx โดยปกติ Ollama มักจะปฏิเสธคำขอก่อนที่จะถึงขั้นนั้น และคำขอจะล้มเหลวพร้อมข้อความระบุจำนวนหน่วยความจำที่ต้องการเทียบกับหน่วยความจำที่เหลืออยู่
บนเครื่องที่มี GPU ความล้มเหลวจะเกิดขึ้นอย่างเงียบๆ เลเยอร์ต่างๆ จะถูกย้ายไปที่ system RAM โดย ollama ps จะแสดงการแบ่งการทำงานระหว่าง CPU และ GPU และอัตรา throughput จะลดลงอย่างรวดเร็ว ความเร็วที่ลดลงจะขึ้นอยู่กับฮาร์ดแวร์ของคุณ ดังนั้นให้ วัดจำนวน tokens ต่อวินาทีบนเครื่องของคุณเอง ในแต่ละการตั้งค่า context แทนที่จะเชื่อตัวเลขจากเครื่องของผู้อื่น
เวลาในการทำ Prefill เพิ่มขึ้นเร็วกว่าความยาวของ prompt
Prefill คือกระบวนการทำงานกับข้อมูลนำเข้าของคุณก่อนที่ token แรกจะถูกสร้างออกมา โดย token แต่ละตัวใน prompt จะต้องประมวลผลร่วมกับ token ทั้งหมดที่อยู่ก่อนหน้า ส่งผลให้ปริมาณงานรวมเพิ่มขึ้นในอัตราส่วนยกกำลังสองของความยาวข้อมูลนำเข้า การเพิ่มความยาว 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 ยาว แล้วหารจำนวน token ด้วยจำนวนวินาทีของแต่ละกรณี บน VPS ที่ใช้ CPU เท่านั้น prefill มักเป็นส่วนที่ช้าที่สุดของคำขอที่มี context ยาว และค่า tokens per second ที่วัดจาก prompt สั้นจะไม่สามารถใช้คาดการณ์กรณีดังกล่าวได้ หาก prefill ใช้เวลานานเกิน timeout ที่อยู่ด้านหน้า คำขอด้วย prompt ยาวมักส่งกลับเป็น context deadline exceeded แทนคำตอบ ดังนั้นให้ตรวจสอบก่อนว่า layer ใดเป็นผู้ยกเลิกการทำงาน ก่อนลดขนาด contextลง
ปัญหาจะเห็นได้ชัดเจนที่สุดเมื่อมีการทำงานพร้อมกัน (concurrency) คำขอแต่ละรายการที่กำลังประมวลผลต้องใช้ cache ของตนเอง ดังนั้นหน่วยความจำในแผนภูมิด้านบนจึงเป็นค่าต่อคำขอ ไม่ใช่ต่อเซิร์ฟเวอร์ และคำขอที่ยาวเพียงรายการเดียวอาจยึดทรัพยากรของระบบไว้ในขณะที่คำขอสั้นๆ ต้องรอคิวอยู่ด้านหลัง ควรตั้งค่า OLLAMA_NUM_PARALLEL อย่างรอบคอบ และอ่านข้อมูลเรื่อง จำนวนผู้ใช้งานพร้อมกันที่ LLM แบบ self-hosted รองรับได้ ก่อนที่คุณจะเพิ่มค่าทั้งสองตัวพร้อมกัน
กู้คืนบริบทด้วยแคชที่มีขนาดเล็กลง
bytes_per_value ในสูตรคือการตั้งค่าที่คุณสามารถควบคุมได้ FAQ ของ Ollama ได้ระบุถึง OLLAMA_KV_CACHE_TYPE โดยมี f16 เป็นค่าเริ่มต้น, q8_0 จะใช้หน่วยความจำประมาณครึ่งหนึ่งของ f16 และ q4_0 จะใช้ประมาณหนึ่งในสี่ ตัวเลขที่แน่นอนสำหรับ q8_0 นั้นมากกว่าครึ่งหนึ่งเล็กน้อย เนื่องจาก llama.cpp จัดเก็บข้อมูลแต่ละบล็อกขนาด 32 ค่าไว้เป็นค่าขนาด 1 ไบต์จำนวน 32 ค่า บวกกับสเกลขนาด 2 ไบต์ รวมเป็น 34 ไบต์ ในขณะที่ f16 ต้องการ 64 ไบต์ ดังนั้นการเปลี่ยนไปใช้ q8_0 จึงทำให้แถวขนาด 32k มีขนาดประมาณ 2.1 GiB แทนที่จะเป็น 4 GiB การทำ Quantisation ให้กับน้ำหนัก (weights) จะช่วยเพิ่มหน่วยความจำจากอีกด้านหนึ่งของงบประมาณเดียวกัน และ แท็ก GLM ที่เหมาะกับ VPS จะถูกประมวลผลผ่านการทำ Quantisation ทีละระดับหากนั่นคือการแลกเปลี่ยนที่คุณต้องการ FAQ เดียวกันยังระบุว่าแคชจะถูกทำ Quantisation ก็ต่อเมื่อเปิดใช้งาน Flash Attention เท่านั้น และได้ระบุถึง OLLAMA_FLASH_ATTENTION=1 เพื่อบังคับให้เปิดใช้งาน
[Service]
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"ตรวจสอบให้แน่ใจแทนการคาดเดา: ให้รีสตาร์ทเซอร์วิส โหลดโมเดลที่ num_ctx เดิม แล้วเปรียบเทียบค่า RSS การรองรับขึ้นอยู่กับโมเดลและแบ็กเอนด์ ดังนั้นหากการตั้งค่าใดไม่มีผลใดๆ แสดงว่าชุดค่าผสมของคุณไม่รองรับการตั้งค่าดังกล่าว ประเภทของแคชเป็นตัวเลือกแบบ Global ดังนั้นทุกโมเดลบนเซิร์ฟเวอร์จะทำงานด้วยการตั้งค่านี้ ในด้านคุณภาพ FAQ ระบุว่า q8_0 มักไม่มีผลกระทบที่สังเกตได้ ในขณะที่ q4_0 จะสูญเสียความแม่นยำมากกว่า ซึ่งสังเกตได้ชัดเจนที่สุดเมื่อใช้ขนาดบริบทที่ใหญ่ขึ้น ดังนั้นควรทดสอบ q4_0 กับพรอมต์ของคุณเองก่อนที่จะนำไปใช้งานจริง หากปุ่มปรับเหล่านี้คือเหตุผลที่คุณมาที่นี่ Ollama และ llama.cpp มีวิธีการเปิดเผยการตั้งค่าเหล่านี้ที่แตกต่างกัน
สูตรสำหรับการเลือก num_ctx
- อ่านค่า context สูงสุด, จำนวน layer และจำนวน head ของ key/value ของโมเดลจาก
/api/show - คำนวณจำนวนไบต์ต่อ token ด้วยสูตรที่กำหนด จากนั้นคูณด้วยค่า context ที่คุณต้องการ
- รวมขนาดของ weight เข้าไป แล้วเปรียบเทียบกับ RAM ที่ว่างอยู่ โดยต้องเหลือ RAM ไว้ที่ 1 GiB เป็นอย่างน้อยสำหรับกระบวนการอื่นในระบบ
- กำหนดค่าดังกล่าว โหลดโมเดล แล้วตรวจสอบค่าที่ถูกนำไปใช้จริงด้วย
ollama psและprompt_eval_count - รัน workload จริงของคุณพร้อมกับเฝ้าดู
free -mหากเริ่มมีการใช้งาน swap ให้ลดค่า context ลงครึ่งหนึ่ง
งานส่วนใหญ่ต้องการ context น้อยกว่าที่ผู้ใช้มักจะกำหนดให้ การสรุปรายงานขนาดยาวใช้พื้นที่เพียง 16k ส่วนระบบ retrieval front end ที่ดึงข้อมูลเอกสารมา 5 ส่วน มักใช้ไม่เกิน 8k กรณีที่จำเป็นต้องใช้ 64k หรือมากกว่านั้นจริงๆ คือ coding agent ที่ต้องอ่านไฟล์ทั้งไฟล์ ซึ่งในกรณีนี้คุณควรเลือกขนาดเครื่องให้เหมาะสมกับ context แทนที่จะทำในทางกลับกัน หากเซิร์ฟเวอร์ยังเป็นเครื่องใหม่ ให้เริ่มจาก การติดตั้ง Ollama บน VPS ให้ใช้งานได้ แล้วจึงปรับจูน context หลังจากที่โหลดโมเดลได้สำเร็จแล้ว
FAQ
ค่าความยาวบริบท (context length) เริ่มต้นของ Ollama คือเท่าใด
ค่านี้ขึ้นอยู่กับรุ่นที่ติดตั้งและฮาร์ดแวร์ ดังนั้นควรตรวจสอบแทนการคาดเดา FAQ ของ Ollama ระบุไว้ที่ 4096 tokens, เอกสารอ้างอิง Modelfile ระบุค่าเริ่มต้น num_ctx ไว้ที่ 2048 และหน้าเอกสารเกี่ยวกับความยาวบริบทยังระบุว่าค่าเริ่มต้นจะถูกเลือกตาม VRAM ที่มีอยู่: 4k สำหรับ VRAM ต่ำกว่า 24 GiB, 32k สำหรับ VRAM ตั้งแต่ 24 GiB ถึง 48 GiB และ 256k สำหรับ VRAM ตั้งแต่ 48 GiB ขึ้นไป ทั้งนี้ VPS ที่ใช้เฉพาะ CPU จะได้ค่าที่อยู่ใกล้เคียงกับช่วงต่ำสุด ollama ps จะแสดงค่าบริบทที่ถูกนำมาใช้ในรุ่นที่มีคอลัมน์นี้ และ prompt_eval_count ในการตอบกลับของ API จะเป็นตัวยืนยันค่านี้ได้ในทุกรุ่น
ทำไม Ollama ถึงละเลยส่วนต้นของ prompt ที่ยาวของฉัน
เพราะ prompt มีความยาวเกินกว่าหน้าต่างบริบท (context window) เซิร์ฟเวอร์จึงตัดส่วนเกินออกก่อนที่โมเดลจะได้รับข้อมูล และไม่มีข้อความแจ้งเตือนความผิดพลาดส่งกลับมา ให้ส่ง prompt เดิมอีกครั้งโดยกำหนด num_ctx ที่ใหญ่ขึ้น และสังเกตค่า prompt_eval_count ในการตอบกลับว่าเพิ่มขึ้นหรือไม่ หากตัวเลขดังกล่าวไม่เปลี่ยนแปลง แสดงว่ามีบางอย่างระหว่างคุณกับเซิร์ฟเวอร์กำลังกำหนดค่า num_ctx เอง ซึ่งเป็นเรื่องปกติที่พบได้ในส่วนติดต่อผู้ใช้งานแบบแชทและเฟรมเวิร์กสำหรับเอเจนต์
การใช้ num_ctx ที่ใหญ่ขึ้นต้องใช้ RAM เพิ่มขึ้นเท่าใด
ให้นำความยาวบริบทคูณกับค่าใช้จ่ายของแคชต่อหนึ่ง token ซึ่งคือ 2 * layers * kv_heads * head_dim * bytes_per_value สำหรับ Llama 3.1 8B ที่ระดับ f16 ค่าใช้จ่ายจะอยู่ที่ 128 KiB ต่อ token ดังนั้น 32k tokens จะใช้พื้นที่ 4 GiB และที่ 128k เต็มจะใช้พื้นที่ 16 GiB เพิ่มเติมจากน้ำหนักของโมเดล (weights) แคชจะถูกจัดสรรเมื่อโมเดลโหลดขึ้นมา ดังนั้นการกำหนด num_ctx ขนาดใหญ่จะทำให้เสียหน่วยความจำส่วนนั้นไปแม้ว่า prompt ของคุณจะยังสั้นอยู่ก็ตาม
หน้าต่างบริบทที่ใหญ่ขึ้นทำให้ Ollama ทำงานช้าลงหรือไม่
ใช่ โดยช้าลงในสองกรณี งานส่วน prefill จะเพิ่มขึ้นตามกำลังสองของความยาว prompt ดังนั้น input ที่ยาวจะทำให้ token แรกล่าช้ามากกว่าที่ความยาวของมันบ่งบอก นอกจากนี้แคชที่ใหญ่ขึ้นยังแย่งพื้นที่หน่วยความจำ: บนเครื่องที่ใช้ GPU มันจะผลักดันเลเยอร์ต่างๆ ไปยัง RAM ของระบบ และบนเครื่องที่ใช้ CPU มันจะผลักดันให้เครื่องต้องใช้ swap การกำหนด num_ctx ขนาดใหญ่ที่คุณไม่เคยใช้งานจนเต็มก็ยังคงเสียหน่วยความจำส่วนนั้นไป แม้ว่าจะไม่เสียเวลาในส่วน prefill ก็ตาม
ฉันสามารถตั้งค่า num_ctx แบบถาวรสำหรับโมเดลหนึ่งๆ ได้หรือไม่
ได้ ให้เขียน Modelfile ที่มีคำสั่ง FROM llama3.1:8b และ PARAMETER num_ctx 16384 จากนั้นรันคำสั่ง ollama create llama3.1-16k -f ./Modelfile ไคลเอนต์ทุกตัวที่เรียกใช้ llama3.1-16k จะได้รับค่าบริบทนั้นโดยไม่ต้องส่งตัวเลือกใดๆ เพิ่มเติม อย่างไรก็ตาม คำขอที่ระบุค่า num_ctx ของตัวเองจะยังคงมีผลเหนือกว่า ดังนั้นวิธีนี้จึงเป็นการตั้งค่าเริ่มต้นไม่ใช่การจำกัดเพดานสูงสุด