SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor · อัปเดตเมื่อ 2026-10-20

วิธีเลือก AI Model สำหรับ Self-host ตามขนาด RAM ที่มี

เรียนรู้วิธีคำนวณการเลือก AI Model ให้เหมาะกับ RAM ขนาด 4 GB, 16 GB และ 64 GB บน VPS พร้อมวิเคราะห์อัตรา Token ต่อวินาทีและผลกระทบของ Context Window ต่อหน่วยความจำที่คุณต้องทราบ

ปัจจัยที่กำหนดว่าคุณสามารถ self-host โมเดล AI รุ่นใดได้บ้าง

โมเดล AI ที่คุณสามารถ self-host ได้นั้นถูกกำหนดโดยตัวเลขเพียงค่าเดียว คือปริมาณ RAM บนเครื่องของคุณ ตระกูลของโมเดลและเฟรมเวิร์กมีความสำคัญน้อยกว่าการที่น้ำหนัก (weights) ของโมเดลนั้นสามารถโหลดลงในหน่วยความจำโดยเหลือพื้นที่ว่างเพียงพอหรือไม่ บทความนี้จะอธิบายการคำนวณเพื่อหาคำตอบดังกล่าว ส่วนการติดตั้ง runtime นั้นเป็นงานแยกต่างหาก ซึ่งได้อธิบายไว้ใน คู่มือการรัน Ollama บน VPS

ต้นทุนสองส่วนเป็นตัวกำหนดคำตอบ น้ำหนักของโมเดลคือต้นทุนคงที่ ซึ่งถูกกำหนดโดยจำนวนพารามิเตอร์และการทำ quantisation ส่วน context window คือต้นทุนผันแปร และเป็นสิ่งที่ผู้คนมักลืมจนกระทั่งโมเดลที่เคยโหลดได้เมื่อวานกลับโหลดไม่ได้ในวันนี้

การคำนวณขนาด: จำนวนบิตต่อพารามิเตอร์

ไฟล์โมเดลส่วนใหญ่ประกอบด้วยน้ำหนัก (weights) น้ำหนักแต่ละตัวจะถูกจัดเก็บด้วยจำนวนบิตที่กำหนด การทำ Quantisation คือการจัดเก็บน้ำหนักด้วยจำนวนบิตที่น้อยกว่าความละเอียดที่ใช้ในขณะฝึกสอน ซึ่งจะทำให้สูญเสียความแม่นยำไปเล็กน้อยแต่ประหยัดหน่วยความจำได้มหาศาล ขนาดของไฟล์จึงขึ้นอยู่กับปัจจัยนี้โดยตรง:

weights in GB = (parameters in billions x bits per weight) / 8

โมเดลส่วนใหญ่ถูกปล่อยออกมาที่ 16 บิต ซึ่งคิดเป็น 2 GB ต่อ 1 พันล้านพารามิเตอร์ โมเดลบางตัวมีการทำ Quantisation มาบ้างแล้ว เช่น gpt-oss ของ OpenAI ที่ผ่านการฝึกสอนเพิ่มเติมด้วยน้ำหนักแบบ mixture of experts ในรูปแบบ 4 bit MXFP4 อย่างไรก็ตาม แทบไม่มีใครรันน้ำหนักที่ 16 บิตบน VPS นี่คือระดับการทำ Quantisation ที่คุณจะได้พบจริง พร้อมค่าเฉลี่ยจำนวนบิตต่อหนึ่งน้ำหนัก:

  • Q8_0 จัดเก็บประมาณ 8.5 บิตต่อน้ำหนัก หรือประมาณ 1.1 GB ต่อ 1 พันล้านพารามิเตอร์
  • Q6_K จัดเก็บประมาณ 6.6 บิต หรือประมาณ 0.83 GB ต่อ 1 พันล้านพารามิเตอร์
  • Q5_K_M จัดเก็บประมาณ 5.7 บิต หรือประมาณ 0.71 GB ต่อ 1 พันล้านพารามิเตอร์
  • Q4_K_M จัดเก็บประมาณ 4.8 บิต หรือประมาณ 0.6 GB ต่อ 1 พันล้านพารามิเตอร์

ให้ใช้ตัวเลข 0.6 GB ต่อ 1 พันล้านพารามิเตอร์เป็นค่ามาตรฐานในการคำนวณ Q4_K_M เป็นค่าเริ่มต้นที่เหมาะสมสำหรับเครื่องที่มีหน่วยความจำจำกัด เพราะการสูญเสียคุณภาพเมื่อเทียบกับ 8 บิตนั้นมีน้อยมากในงานส่วนใหญ่ และขนาดไฟล์ลดลงเกือบครึ่งหนึ่ง หากต่ำกว่า 4 บิต การสูญเสียคุณภาพจะเพิ่มขึ้นอย่างรวดเร็ว ดังนั้นโมเดลขนาด 70B ที่ถูกบีบอัดเหลือ 2 บิต มักจะให้คำตอบที่แย่กว่าโมเดลขนาด 32B ที่ 4 บิตจากรุ่นเดียวกัน หากหน่วยความจำไม่เพียงพอ ให้ลดขนาดโมเดลลงหนึ่งระดับก่อนที่จะลดค่าบิตให้ต่ำกว่า 4 บิต

แผนภูมิRAM at 4-bit: weights and KV cache, calculated
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "3B",
    "weights_gb": 1.8,
    "kv_8k_gb": 0.9,
    "kv_128k_gb": 14
  },
  {
    "label": "8B",
    "weights_gb": 4.8,
    "kv_8k_gb": 1,
    "kv_128k_gb": 16
  },
  {
    "label": "14B",
    "weights_gb": 8.4,
    "kv_8k_gb": 1.5,
    "kv_128k_gb": 24
  },
  {
    "label": "32B",
    "weights_gb": 19.2,
    "kv_8k_gb": 2,
    "kv_128k_gb": 32
  },
  {
    "label": "70B",
    "weights_gb": 42,
    "kv_8k_gb": 2.5,
    "kv_128k_gb": 40
  }
]

คอลัมน์น้ำหนักด้านบนคือการนำกฎ 0.6 GB ต่อ 1 พันล้านพารามิเตอร์มาประยุกต์ใช้ ไฟล์ GGUF จริงจะมีขนาดใกล้เคียงกับค่านี้โดยคลาดเคลื่อนเพียงไม่กี่เปอร์เซ็นต์ เนื่องจากเลเยอร์ embedding และ output จะถูกเก็บไว้ที่ความละเอียดสูงกว่าส่วนอื่น โมเดลขนาด 3B ที่ 4 บิตจะมีขนาดประมาณ 1.8 GB, ขนาด 8B จะอยู่ที่ 4.8 GB, ขนาด 32B จะอยู่ที่ 19.2 GB และขนาด 70B จะอยู่ที่ 42 GB

เหตุใดความยาวของบริบท (context length) จึงใช้ RAM มากกว่าน้ำหนักของโมเดล

KV cache (key value cache ซึ่งเป็นสถานะ attention ที่โมเดลเก็บไว้สำหรับทุกโทเค็นในการสนทนา) คือต้นทุนส่วนที่สอง โดยจะถูกจัดสรรเมื่อโมเดลโหลดขึ้นมา โดยมีขนาดตามความยาวของบริบทที่คุณกำหนด และจะเพิ่มขึ้นเป็นเส้นตรงตามความยาวนั้น

สูตรคำนวณ KV cache และแหล่งข้อมูลตัวเลข
bytes per token = 2 x layers x kv_heads x head_dim x bytes per element

เลข 2 คือการนับทั้ง key และ value ค่าสำหรับ layers, kv_heads (ระบุไว้เป็น num_key_value_heads) และ head_dim ทั้งหมดอยู่ใน config.json บนหน้าข้อมูลของโมเดล (model card) จำนวนไบต์ต่อหนึ่ง element คือ 2 สำหรับ cache ขนาด 16 bit โมเดลขนาด 8B ทั่วไปจะมี 32 เลเยอร์, มี key value heads 8 ชุด และ head dimension ขนาด 128 ดังนั้น 2 x 32 x 8 x 128 x 2 = 131072 ไบต์ ซึ่งเท่ากับ 128 KiB ต่อหนึ่งโทเค็น

ที่ค่า context เริ่มต้นของ Ollama โมเดลขนาด 8B จะใช้ RAM ไปครึ่งกิกะไบต์สำหรับ cache ที่ 8192 โทเค็นจะใช้ไป 1 GB และที่บริบท 128k ตามที่ระบุใน model card จะใช้ไป 16 GB ซึ่งมากกว่าน้ำหนักของโมเดลถึงสามเท่า ส่วนโมเดลขนาด 70B จะเป็นกรณีตรงกันข้าม คือ cache ที่ 128k จะใช้เพียง 40 GB ซึ่งน้อยกว่าน้ำหนักของตัวโมเดลเอง เนื่องจาก grouped query attention ช่วยป้องกันไม่ให้ต้นทุนต่อโทเค็นเพิ่มขึ้นเร็วเท่ากับจำนวนพารามิเตอร์

ความยาวบริบทเริ่มต้นของ Ollama คือ 4096 โทเค็นบนเซิร์ฟเวอร์ที่ใช้เฉพาะ CPU แต่หากมี GPU ระบบจะเลือกค่าเริ่มต้นจาก VRAM แทน คือ 32k สำหรับ VRAM ระหว่าง 24 ถึง 48 GiB และ 256k สำหรับ 48 GiB ขึ้นไป คุณสามารถเพิ่มค่านี้ได้ด้วยตัวแปร OLLAMA_CONTEXT_LENGTH บนเซิร์ฟเวอร์ จากนั้นตรวจสอบว่าโมเดลที่กำลังทำงานอยู่ได้รับค่าเท่าใดจริงในคอลัมน์ CONTEXT ของ ollama ps การคำนวณหน่วยความจำเบื้องหลังการตั้งค่านี้ได้อธิบายไว้ใน บทความเรื่อง num_ctx และความยาวของบริบท

มีสองวิธีในการลดการใช้หน่วยความจำของ cache วิธีแรกคือการกำหนดความยาวบริบทเท่าที่จำเป็นแทนที่จะใช้ค่าตามที่ model card ระบุ เนื่องจากงานแชทและการเขียนโปรแกรมส่วนใหญ่ใช้พื้นที่เพียง 8k ถึง 32k เท่านั้น หรือวิธีที่สองคือการทำ quantise ตัว cache เองให้เหลือ 8 bits ซึ่งจะช่วยลดขนาดลงครึ่งหนึ่ง แต่อาจส่งผลต่อความแม่นยำในการเรียกคืนข้อมูลจากบริบทที่ยาวมากได้

โมเดลที่ทำงานค้างไว้จะยึดพื้นที่ RAM จนกว่าจะมีคำสั่งให้ยกเลิกการโหลด

Ollama จะเก็บโมเดลไว้ในหน่วยความจำเป็นเวลา 5 นาทีหลังจากคำขอสุดท้าย จากนั้นจึงจะยกเลิกการโหลด ค่าเริ่มต้นนี้เหมาะสมกับแล็ปท็อปแต่ไม่เหมาะกับเซิร์ฟเวอร์ เนื่องจากทุกครั้งที่มีการเว้นช่วงการใช้งาน คำขอแรกหลังจากนั้นจะต้องเสียเวลาโหลดโมเดลใหม่อีกครั้ง

ollama ps
ollama stop qwen3:4b

ollama ps จะแสดงรายการสิ่งที่ค้างอยู่ในหน่วยความจำ โดยมีคอลัมน์ SIZE แสดงปริมาณหน่วยความจำที่ใช้ และคอลัมน์ UNTIL แสดงเวลาที่จะหมดอายุ หากต้องการตรึงโมเดลไว้ถาวร ให้ตั้งค่า OLLAMA_KEEP_ALIVE=-1 ใน service หากกำหนดค่าเป็น 0 ระบบจะยกเลิกการโหลดโมเดลทันทีที่การตอบกลับแต่ละครั้งเสร็จสิ้น

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
sudo systemctl daemon-reload
sudo systemctl restart ollama

ให้ส่ง prompt หนึ่งรายการ จากนั้นรันคำสั่ง ollama ps อีกครั้งในอีกสิบนาทีถัดมา โมเดลจะยังคงอยู่ในรายการ ซึ่งนั่นคือจุดประสงค์หลัก: โมเดลจะยึดพื้นที่ RAM นั้นไว้ไม่ว่าจะมีใครใช้งานอยู่หรือไม่ก็ตาม โมเดลที่ถูกตรึงไว้ไม่ใช่ความจุส่วนเกิน บน VPS ขนาด 16 GB โมเดลขนาด 8B ที่ context 8k จะใช้พื้นที่ประมาณ 6 GB ตลอดระยะเวลาที่ service ทำงาน ดังนั้นควรคำนวณขนาดของเซิร์ฟเวอร์โดยรวมทั้งโมเดลและแอปพลิเคชันของคุณ ไม่ใช่คำนวณแค่ขนาดของโมเดลเพียงอย่างเดียว การตรึงโมเดลไว้ในหน่วยความจำ ครอบคลุมถึงการแลกเปลี่ยนระหว่างการตรึงโมเดลกับความหน่วงในการเริ่มทำงานแบบ cold start

สิ่งที่รันบน VPS ขนาด 4 GB

ให้สำรองหน่วยความจำประมาณ 1 GB สำหรับระบบปฏิบัติการและเซิร์ฟเวอร์โมเดล ซึ่งจะเหลือพื้นที่ใช้งานจริงประมาณ 3 GB ขนาดนี้เพียงพอสำหรับโมเดลขนาด 1B ถึง 4B ที่ระดับ 4-bit และ context 4096 token ตามค่าเริ่มต้น ณ เดือนสิงหาคม 2026 โมเดลในกลุ่มนี้ได้แก่ Llama 3.2 ขนาด 3B, Qwen 3 ขนาด 1.7B และ 4B รวมถึงโมเดลขนาดเล็กอย่าง Gemma และ Phi ให้ถือว่าชื่อเหล่านี้เป็นเพียงตัวอย่างขนาด ไม่ใช่คำแนะนำในการเลือกใช้ เนื่องจากชื่อโมเดลมีการเปลี่ยนแปลงทุกสองสามเดือน แต่หลักการคำนวณยังคงเดิม

คาดการณ์ความเร็วในการประมวลผลได้ประมาณ 6 ถึง 14 token ต่อวินาที โมเดลขนาดเล็กเหล่านี้ทำงานเฉพาะทางได้ดี เช่น การจำแนกประเภท, การดึงข้อมูลแท็ก, การสรุปความสั้นๆ และการปรับแก้ข้อความให้เป็นไปตามรูปแบบที่กำหนด แต่โมเดลเหล่านี้มีข้อจำกัดในการใช้เหตุผลหลายขั้นตอนและการเขียนโค้ดที่ครอบคลุมหลายไฟล์ ซึ่งการปรับแต่ง prompt ไม่สามารถช่วยแก้ปัญหานี้ได้

รูปแบบความล้มเหลวที่ระดับนี้คือการเกิด swap หากโมเดลมีขนาดใหญ่เกินกว่าหน่วยความจำ Linux จะไม่ปฏิเสธการโหลด แต่จะย้ายข้อมูลหน่วยความจำไปไว้บนดิสก์แทน และเนื่องจากการสร้าง token หนึ่งตัวต้องอ่านค่าน้ำหนัก (weight) ของโมเดลทั้งหมดหนึ่งรอบ ความเร็วในการสร้างข้อความจึงลดลงเหลือระดับวินาทีต่อหนึ่ง token ให้เฝ้าสังเกต free -h รวมถึงคอลัมน์ si และ so ของ vmstat 1 ในขณะที่โมเดลกำลังตอบคำถาม ให้ละเว้นบรรทัดแรกของผลลัพธ์ vmstat ซึ่งเป็นการเฉลี่ยค่าทั้งหมดตั้งแต่เริ่มบูตระบบ และพึงระลึกว่าตัวนับเหล่านี้ครอบคลุมทั้งระบบ ไม่ใช่แค่ตัวโมเดลเท่านั้น หากค่า swap in และ swap out เป็นศูนย์ในขณะที่เครื่องไม่ได้ใช้งาน แต่เพิ่มขึ้นทันทีที่เริ่มการสร้างข้อความ แสดงว่าโมเดลมีขนาดใหญ่เกินกว่าที่แผนการใช้งานจะรองรับได้

สิ่งที่รันบน VPS ขนาด 8 ถึง 16 GB

นี่คือจุดที่โมเดลแบบ self-hosted เริ่มมีประโยชน์อย่างแท้จริง บนหน่วยความจำ 8 GB คุณสามารถรันโมเดลขนาด 7B หรือ 8B ที่ระดับ 4 bits ซึ่งใช้ขนาด weight ประมาณ 4.8 GB พร้อม context ขนาด 8k ส่วนบนขนาด 16 GB คุณสามารถรันโมเดลขนาด 13B หรือ 14B ที่ระดับ 4 bits ซึ่งใช้ขนาดประมาณ 8.4 GB หรือจะเลือกใช้โมเดลขนาด 8B ที่ระดับ 8 bits หากคุณต้องการใช้หน่วยความจำไปกับความละเอียดของโมเดลมากกว่าจำนวนพารามิเตอร์

ความเร็วคือข้อจำกัดสำคัญ โมเดลขนาด 8B ที่รันบน CPU จะสร้างข้อความได้ประมาณ 3 ถึง 7 tokens ต่อวินาที และโมเดลขนาด 14B จะอยู่ที่ประมาณ 1.5 ถึง 3.5 tokens ต่อวินาที โดยปกติมนุษย์อ่านหนังสือด้วยความเร็วประมาณ 5 ถึง 10 tokens ต่อวินาที ดังนั้นการรันโมเดล 8B บน VPS ที่ใช้ CPU จะให้ความรู้สึกเหมือนกำลังดูคนพิมพ์งานช้าๆ ซึ่งถือว่าเพียงพอสำหรับงานเบื้องหลัง (background job) แต่จะน่าเหนื่อยหน่ายสำหรับการแชทโต้ตอบ ผลการทดสอบรัน Qwen 3 ขนาด 8B และขนาดที่ใหญ่กว่าบน VPS แสดงให้เห็นถึงประสิทธิภาพในทางปฏิบัติ

สิ่งที่รันบน VPS ขนาด 32 ถึง 64 GB

โมเดลขนาด 32B ที่ระดับ 4 บิต ใช้หน่วยความจำประมาณ 19.2 GB ดังนั้นจึงสามารถรันบนแผน 32 GB ได้หากใช้ context สั้นๆ และจะทำงานได้อย่างราบรื่นบนแผน 48 GB หรือ 64 GB ส่วนโมเดล 70B ที่ระดับ 4 บิต ใช้หน่วยความจำประมาณ 42 GB ซึ่งสอดคล้องกับที่ Ollama ระบุไว้ว่า Llama 3.3 70B ที่ระดับ Q4_K_M ต้องการหน่วยความจำ 43 GB ทำให้สามารถรันบนแผน 48 GB ได้แบบพอดีหากใช้ context สั้นๆ แต่จำเป็นต้องใช้ 64 GB หากต้องการใช้ context ที่ยาวขึ้น

จากนั้นให้พิจารณาความเร็วตามความเป็นจริง โมเดล 32B บน CPU จะทำงานที่ความเร็วประมาณ 0.6 ถึง 1.5 tokens ต่อวินาที และโมเดล 70B จะอยู่ที่ 0.2 ถึง 0.5 การตอบกลับความยาว 500 tokens จากโมเดล 70B จะใช้เวลาประมาณยี่สิบนาที ด้วยความเร็วระดับนี้ คำขอมักจะถูกตัดการเชื่อมต่อก่อนที่โมเดลจะทำงานเสร็จ เนื่องจาก client หรือ proxy ที่อยู่หน้า Ollama จะหมดเวลา (timeout) ไปก่อน ซึ่งเป็นที่มาของ ข้อผิดพลาด context deadline exceeded โมเดลเหล่านี้เป็นเครื่องมือสำหรับประมวลผลแบบ batch คุณควรส่งคิวเอกสารให้มันประมวลผลข้ามคืน ซึ่งในกรณีนี้ความเร็วจะไม่ใช่ประเด็นสำคัญ แต่หากนำไปใช้หลังหน้าต่างแชท ความเร็วจะมีความสำคัญอย่างยิ่ง

การจัดเส้นทางแบบ Mixture of Experts (MoE) เปลี่ยนแปลงการคำนวณเหล่านี้ และเป็นรายละเอียดทางสถาปัตยกรรมเพียงอย่างเดียวที่ควรศึกษา โมเดลแบบ MoE จะส่งแต่ละ token ผ่านส่วนของน้ำหนัก (weights) เพียงบางส่วนเท่านั้น โมเดลที่มีพารามิเตอร์รวม 30B แต่มีพารามิเตอร์ที่ทำงานจริง (active) 3B ต่อ token จะต้องการหน่วยความจำเท่ากับโมเดล 30B แต่สร้างผลลัพธ์ได้ใกล้เคียงกับความเร็วของโมเดล dense 3B เพราะแต่ละ token จะอ่านเฉพาะส่วนของ expert ที่ทำงานอยู่เท่านั้น บนเครื่องขนาด 32 GB โมเดล MoE ในลักษณะนี้จะใช้งานได้จริงมากกว่าโมเดล dense 30B กฎที่ควรจำคือ: พารามิเตอร์รวมเป็นตัวกำหนดหน่วยความจำที่ใช้ ส่วนพารามิเตอร์ที่ทำงานจริงเป็นตัวกำหนดความเร็ว

การประมวลผล inference บน CPU มีความเร็วเท่าใดในความเป็นจริง?

การสร้าง 1 token จำเป็นต้องอ่าน weight ที่ใช้งานอยู่ทั้งหมดออกจากหน่วยความจำ 1 ครั้ง ไม่มีวิธีใดหลีกเลี่ยงขั้นตอนนี้ได้ ดังนั้นความเร็วในการสร้างบน CPU จึงถูกกำหนดโดยแบนด์วิดท์ของหน่วยความจำ (memory bandwidth) ไม่ใช่จำนวนคอร์ ขีดจำกัดสูงสุดคำนวณได้จากการหาร: แบนด์วิดท์หน่วยความจำที่ใช้งานได้ หารด้วยขนาดของ weight ทั้งหมดในหน่วยไบต์ VPS ขนาดเล็กทั่วไปมักทำความเร็วได้ที่ 10 ถึง 25 GB ต่อวินาทีผ่าน vCPU ดังนั้นโมเดลขนาด 4.8 GB จะทำความเร็วได้สูงสุดประมาณ 2 ถึง 5 tokens ต่อวินาที

แผนภูมิTypical reported CPU generation speed at 4-bit on a small VPS
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "3B",
    "tokens_per_second_low": 6,
    "tokens_per_second_high": 14
  },
  {
    "label": "8B",
    "tokens_per_second_low": 3,
    "tokens_per_second_high": 7
  },
  {
    "label": "14B",
    "tokens_per_second_low": 1.5,
    "tokens_per_second_high": 3.5
  },
  {
    "label": "32B",
    "tokens_per_second_low": 0.6,
    "tokens_per_second_high": 1.5
  },
  {
    "label": "70B",
    "tokens_per_second_low": 0.2,
    "tokens_per_second_high": 0.5
  }
]

ตัวเลขเหล่านี้เป็นช่วงความเร็วที่พบได้ทั่วไปบนฮาร์ดแวร์ VPS ปกติ ไม่ใช่ผลการทดสอบจากเครื่องใดเครื่องหนึ่งโดยเฉพาะ ตัวเลขของคุณจะขึ้นอยู่กับรุ่นของหน่วยความจำ, จำนวนช่องสัญญาณ (channel count) บนโฮสต์ และจำนวนเพื่อนบ้านที่แย่งทรัพยากรกันอยู่ คุณสามารถวัดค่าด้วยตนเองโดยใช้ tag ของโมเดลที่คุณมีอยู่แล้ว:

ollama run qwen3:4b --verbose "Write three sentences about disk latency."

สรุปผลที่แสดงหลังจากคำตอบเสร็จสิ้นจะลงท้ายด้วยบรรทัดที่ระบุว่า eval rate: ... tokens/s นั่นคือความเร็วในการสร้างคำตอบของคุณ ให้ละเว้นการรันครั้งแรกของเซสชันนั้นไป เพราะค่า load duration ในสรุปผลเดียวกันจะรวมเวลาที่ใช้ในการอ่าน weight จากดิสก์ด้วย เนื้อหาใน การวัดจำนวน tokens ต่อวินาทีอย่างถูกต้อง จะอธิบายวิธีเพื่อให้ได้ตัวเลขที่นำไปเปรียบเทียบกันได้จริง

มีผลลัพธ์ 2 อย่างที่มักทำให้ผู้ใช้ประหลาดใจ อย่างแรกคือการเพิ่ม vCPU จะหยุดช่วยเพิ่มประสิทธิภาพอย่างรวดเร็ว เพราะเมื่อเกิน 8 คอร์โดยประมาณ คอร์ที่เพิ่มเข้ามาจะรอหน่วยความจำมากกว่าที่จะได้คำนวณจริง และอย่างที่สองคือบนแผนบริการแบบ shared คำสั่งเดียวกันอาจให้ตัวเลขที่ต่างกันในแต่ละช่วงเวลา ซึ่งเป็นผลมาจาก CPU steal time จากเพื่อนบ้านที่ใช้งานหนัก ไม่ใช่เพราะคุณตั้งค่าอะไรผิดพลาด

การอ่าน prompt ของคุณเป็นงานที่ต่างจากการสร้างคำตอบ การประมวลผล prompt เป็นงานที่เน้นการคำนวณ (compute bound) ดังนั้นจึงเพิ่มประสิทธิภาพตามจำนวนคอร์ได้จริง และเป็นจุดที่ GPU ทิ้งห่าง CPU มากที่สุด เอกสารขนาดยาวอาจใช้เวลา CPU อ่านนานหลายนาที แต่ GPU ใช้เวลาเพียงไม่กี่วินาที นี่คืออุปสรรคแรกที่คุณจะพบเมื่อ ใช้งาน coding agent กับโมเดลที่คุณโฮสต์เอง เพราะทุกครั้งที่มีการโต้ตอบ ระบบจะต้องส่ง context ของไฟล์และคำจำกัดความของเครื่องมือใหม่ทั้งหมด ก่อนที่จะได้รับ token แรกของคำตอบกลับมา

สิ่งที่เปลี่ยนไปเมื่อเพิ่ม GPU

การคำนวณไม่ได้เปลี่ยนไป แต่เปลี่ยนเฉพาะกลุ่มทรัพยากรที่นำมาใช้ VRAM เป็นข้อจำกัดที่ตายตัว ดังนั้นควรคำนวณสิ่งที่ใส่ได้ก่อนทำการเช่า:

  • VRAM ขนาด 8 GB รองรับโมเดล 7B หรือ 8B ที่ 4 bits พร้อม context สั้นๆ
  • VRAM ขนาด 16 GB รองรับโมเดล 14B ที่ 4 bits พร้อม context ที่ใช้งานได้จริง หรือ 8B ที่ 8 bits
  • VRAM ขนาด 24 GB รองรับโมเดล 32B ที่ 4 bits โดยต้องจำกัดความยาว context
  • VRAM ขนาด 48 GB รองรับโมเดล 70B ที่ 4 bits พร้อม context ระดับปานกลาง ส่วนการรองรับ context ที่ยาวขึ้นและการทำงานพร้อมกันหลายงานจะเริ่มที่ประมาณ 80 GB

เมื่อโมเดลมีขนาดใหญ่เกินกว่าจะใส่ได้ทั้งหมด Ollama จะทำการแบ่งส่วน: บางเลเยอร์จะอยู่บน GPU และส่วนที่เหลือจะอยู่บน CPU โดย ollama ps จะรายงานการแบ่งส่วนนี้ในคอลัมน์ PROCESSOR ในรูปแบบเช่น 78%/22% CPU/GPU ให้มองว่านี่คือคำเตือนมากกว่าจะเป็นฟีเจอร์ เพราะส่วนที่ทำงานบน CPU จะเป็นตัวกำหนดความเร็ว เนื่องจากทุก token ยังคงต้องรอการประมวลผลจากเลเยอร์เหล่านั้น ดังนั้นโมเดลที่มีเลเยอร์หนึ่งในสี่ทำงานบน CPU จะมีความเร็วใกล้เคียงกับความเร็ว CPU มากกว่าความเร็ว GPU หากคุณพบการแบ่งส่วนโดยไม่ได้ตั้งใจ ให้ลดความยาว context ลงก่อน เพราะโดยปกติแล้ว cache คือสิ่งที่ทำให้หน่วยความจำเต็ม

การทำงานพร้อมกัน (Concurrency) เป็นอีกเหตุผลที่ต้องขยายขนาดทรัพยากร แม้ว่าน้ำหนัก (weights) ของโมเดลจะถูกใช้ร่วมกันระหว่างคำขอที่เข้ามาพร้อมกัน แต่ทุกคำขอที่ทำงานอยู่จำเป็นต้องมี KV cache ของตัวเอง ดังนั้นผู้ใช้ 10 คนที่ใช้งานโมเดล 8B พร้อม context 8k จะต้องใช้ cache เพิ่มขึ้นอีก 10 เท่าของ 1 GB นอกเหนือจากน้ำหนักของโมเดล การให้บริการผู้ใช้พร้อมกันจากโมเดลที่โฮสต์เอง จะอธิบายถึงวิธีการคำนวณขีดจำกัดดังกล่าว

ความคุ้มค่าในการเช่า GPU ก็เป็นเรื่องของการคำนวณเช่นกัน ซึ่งขึ้นอยู่กับจำนวน token ต่อเดือนที่คุณสร้างจริง จุดคุ้มทุนระหว่าง GPU VPS และ API tokens มีตัวเลขเหล่านั้นให้คุณพิจารณา

สิ่งที่คุณไม่สามารถ self-host ได้

มีกำแพงสองประเภทที่แตกต่างกันในเรื่องนี้ และการทราบว่าคุณกำลังเผชิญกับกำแพงแบบใดจะช่วยได้มาก

ประเภทแรกคือโมเดลแบบ closed weights โมเดลเชิงพาณิชย์ระดับแนวหน้าไม่ได้ถูกแจกจ่ายออกมา ดังนั้นจึงไม่มีไฟล์ให้ดาวน์โหลด และไม่ว่าคุณจะปรับเปลี่ยน RAM อย่างไรก็ไม่สามารถช่วยได้ คุณสามารถ self-host ทุกอย่างที่อยู่รอบตัวโมเดลเหล่านั้นได้ ไม่ว่าจะเป็นอินเทอร์เฟซ, เลเยอร์การดึงข้อมูล, ลูปของเอเจนต์ หรือ log แต่ตัวโมเดลเองยังคงเป็น API ระยะไกล ว่าด้วยเรื่องที่คุณสามารถ self-host Claude ได้หรือไม่ ได้อธิบายเรื่องนี้ไว้อย่างละเอียด

ประเภทที่สองคือโมเดลแบบ open weights ที่มีขนาดใหญ่เกินไป โมเดลแบบ open releases ที่ใหญ่ที่สุดใช้การออกแบบแบบ mixture of experts ซึ่งมีพารามิเตอร์รวมกันหลายแสนล้านตัว กฎเดียวกันนี้ยังคงใช้กับโมเดลเหล่านี้: โมเดลที่มีพารามิเตอร์รวม 400B ที่ความละเอียด 4 bits ต้องการพื้นที่ประมาณ 240 GB สำหรับตัว weights เพียงอย่างเดียว ก่อนจะรวม cache นี่คือฮาร์ดแวร์เฉพาะทาง และการเช่าใช้งานรายเดือนมีค่าใช้จ่ายสูงกว่าค่า API tokens ที่คนส่วนใหญ่จ่ายในหนึ่งปีมาก สิ่งที่ต้องใช้ในการ self-host โมเดลระดับ Kimi จะอธิบายถึงความต้องการที่แท้จริง การแบ่งแยกแบบเดียวกันนี้ปรากฏให้เห็นในไลบรารีของ Ollama เอง โดยที่ GLM 5.2 ถูกระบุว่าเป็นโมเดลแบบ cloud เท่านั้น และมีโมเดลรุ่นน้องที่เล็กกว่ามากซึ่งสามารถดาวน์โหลดลงบน VPS ได้จริง

เส้นแบ่งที่ชัดเจนระหว่างสองทางเลือกนี้คือ: ให้เลือก self-host เมื่อปริมาณงานมีความสม่ำเสมอและข้อมูลไม่ควรออกจากเซิร์ฟเวอร์ของคุณ และให้เลือกซื้อ tokens เมื่อปริมาณงานมีความผันผวน หรือเมื่อคุณภาพคำตอบระดับแนวหน้าคือสิ่งที่คุณต้องการจริงๆ

ตรวจสอบทรัพยากรที่คุณมีก่อนตัดสินใจ

free -h
nproc
lscpu | grep 'Model name'

ให้วางแผนโดยอ้างอิงจากคอลัมน์ available ของ free -h ไม่ใช่คอลัมน์ total เนื่องจาก total ได้รวมหน่วยความจำที่ระบบกำลังใช้งานอยู่ไว้แล้ว ให้หักลบหน่วยความจำประมาณ 1 GB สำหรับระบบปฏิบัติการและเซิร์ฟเวอร์โมเดล จากนั้นนำค่าที่เหลือหารด้วย 0.6 เพื่อหาจำนวนพารามิเตอร์สูงสุดในหน่วยพันล้านที่คุณสามารถรองรับได้ที่ระดับ 4 bits ต่อจากนั้นให้หักลบหน่วยความจำสำหรับ KV cache ตามบริบท (context) ที่คุณต้องการใช้งานจริง ผลลัพธ์ที่ได้คือคำตอบของคุณ ซึ่งต่างจากรายการชื่อโมเดลตรงที่ค่านี้จะไม่ล้าสมัย

FAQ

ฉันต้องใช้ RAM เท่าไรในการรันโมเดลขนาด 8B?

ต้องใช้ RAM ประมาณ 4.8 GB สำหรับน้ำหนักโมเดลที่การทำ quantisation ระดับ 4 bit บวกกับ KV cache ตามความยาว context ของคุณ และอีกประมาณ 1 GB สำหรับระบบปฏิบัติการและตัว model server หากใช้ context ที่ 8192 token ตัว cache จะเพิ่มขึ้นอีกประมาณ 1 GB ดังนั้นแผนการใช้งานขนาด 8 GB จึงเพียงพอ แต่แผนขนาด 4 GB จะไม่เพียงพอ หากคุณต้องการใช้ context เต็มที่ 128k ตามที่ระบุไว้ใน model card ตัว cache เพียงอย่างเดียวจะใช้พื้นที่ถึง 16 GB ซึ่งคุณจะต้องพิจารณาแผนการใช้งานขนาด 32 GB

ทำไมโมเดลของฉันถึงทำงานช้าทั้งที่ VPS มี vCPU จำนวนมาก?

เพราะการสร้างข้อความ (generation) ถูกจำกัดด้วย memory bandwidth ไม่ใช่จำนวน core ทุก token จำเป็นต้องดึงชุดน้ำหนักที่ใช้งานอยู่ทั้งหมดออกมาจาก RAM ดังนั้นเมื่อ core จำนวนหนึ่งใช้งาน memory channels จนเต็มแล้ว core ที่เหลือก็จะทำได้เพียงรอ อีกสาเหตุที่พบบ่อยคือ swap หาก vmstat 1 แสดงค่า si และ so เป็นศูนย์ก่อนที่คุณจะส่ง prompt และค่าเริ่มสูงขึ้นในขณะที่โมเดลกำลังตอบ เป็นไปได้สูงว่าน้ำหนักโมเดลไม่พอดีกับ RAM และบางส่วนของทุก token กำลังถูกดึงมาจากดิสก์ ซึ่งทำให้เสียเวลามากกว่าที่ควรจะเป็นมาก

context window ที่ยาวขึ้นต้องการหน่วยความจำมากขึ้นจริงหรือไม่?

จริง และการเพิ่มขึ้นจะเป็นแบบเส้นตรงตามจำนวน token โมเดลขนาด 8B ทั่วไปใช้ KV cache ประมาณ 128 KiB ต่อหนึ่ง token ดังนั้น 8192 token จะใช้พื้นที่ 1 GB และ 131072 token จะใช้พื้นที่ 16 GB ตัว cache จะถูกจองไว้ตั้งแต่ตอนโหลดโมเดล ไม่ใช่เมื่อบทสนทนายาวขึ้น ดังนั้นการกำหนด context ไว้ที่ 128k จะเป็นการจองหน่วยความจำจำนวนนั้นทันที แม้ว่าทุก prompt ที่คุณส่งจะมีความยาวเพียง 200 token ก็ตาม

ฉันควรเลือกรันโมเดลขนาดใหญ่ที่ 2 bits หรือโมเดลขนาดเล็กที่ 4 bits?

ให้เลือกโมเดลขนาดเล็กที่ 4 bits คุณภาพของโมเดลจะลดลงอย่างช้าๆ จาก 8 bits ลงมาที่ 4 bits แต่จะลดลงอย่างรวดเร็วหากต่ำกว่า 4 bits ดังนั้นโมเดลขนาด 70B ที่ถูกบีบอัดเหลือ 2 bits มักจะให้คำตอบที่แย่กว่าโมเดลขนาด 32B ที่ 4 bits จากตระกูลเดียวกัน การทำ quantisation ที่หนักเกินไปจะแสดงผลออกมาในรูปแบบของการพูดซ้ำหรือการข้ามคำสั่ง แทนที่จะเป็นข้อความแจ้งเตือนข้อผิดพลาด ซึ่งทำให้ง่ายต่อการโทษว่าเป็นเพราะ prompt ของคุณ ให้ถือว่า 4 bits เป็นเกณฑ์ขั้นต่ำและใช้วิธีปรับเปลี่ยนจำนวน parameter แทน

ฉันสามารถ self-host โมเดลที่มีความสามารถเทียบเท่าโมเดลเชิงพาณิชย์ขนาดใหญ่ได้หรือไม่?

ไม่ได้บน VPS ทั่วไป โมเดลแบบ open weight ที่แข็งแกร่งที่สุดมีขนาดพารามิเตอร์หลายแสนล้านตัว ซึ่งที่ระดับ 4 bits จะต้องใช้ RAM มากกว่า 200 GB ก่อนจะรวม KV cache และโมเดลเชิงพาณิชย์ที่แข็งแกร่งที่สุดนั้นไม่ได้เปิดเผยให้ใช้งานทั่วไป สิ่งที่ฮาร์ดแวร์ทั่วไปทำได้ดีคือการรันโมเดลขนาด 8B ถึง 32B เพื่อทำงานเฉพาะอย่าง ซึ่งโมเดลขนาดเล็กที่จำกัดขอบเขตและได้รับ prompt ที่ดีมักจะให้ผลลัพธ์เทียบเท่ากับโมเดลทั่วไป หากคุณต้องการคุณภาพระดับแนวหน้า ให้เปรียบเทียบราคาค่า API กับราคาฮาร์ดแวร์ก่อนตัดสินใจเลือกอย่างใดอย่างหนึ่ง

บทความนี้มีประโยชน์หรือไม่