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

วิธีรัน Qwen 3.8 27B บน VPS ด้วย Ollama ให้ใช้งานได้จริง

เรียนรู้วิธีรันโมเดล qwen3.8:27b ผ่าน Ollama บน VPS ที่ไม่มี GPU พร้อมคำนวณ RAM ที่ต้องใช้จริงสำหรับรุ่น Q4_K_M เพื่อให้คุณเลือกสเปกเซิร์ฟเวอร์ขนาด 8GB ถึง 64GB ได้อย่างแม่นยำ

คุณสามารถรัน Qwen 3.8 27B บน VPS ที่ไม่มี GPU ได้หรือไม่

ในการรัน Qwen 3.8 27B บน VPS คุณจำเป็นต้องใช้แท็ก qwen3.8:27b และ ณ วันที่ 21 ตุลาคม 2026 ไลบรารีของ Ollama ได้บรรจุแท็กนี้ไว้ให้ดึงข้อมูลมาใช้งานในเครื่องได้ โดยมีพารามิเตอร์ 27.3 พันล้านตัว, การทำ quantization แบบ Q4_K_M, สิทธิ์การใช้งานแบบ Apache 2.0, context window ขนาด 256K และไฟล์ดาวน์โหลดขนาด 18 GB ซึ่งรวม vision projector ขนาดประมาณ 0.9 GB ไว้ด้วย Ollama ได้เพิ่มการรองรับ Qwen 3.8 27B ในเวอร์ชัน v0.32.12 ซึ่งปล่อยออกมาเมื่อวันที่ 14 สิงหาคม 2026 ดังนั้นการติดตั้งเวอร์ชันเก่าจำเป็นต้องอัปเกรดก่อน ณ วันที่ 29 ตุลาคม 2026 เวอร์ชันเสถียรล่าสุดคือ v0.40.13 ซึ่งเผยแพร่เมื่อวันที่ 28 ตุลาคม 2026

คำตอบสั้นๆ คือทำได้บน VPS ขนาด 32 GB ขึ้นไป แต่จะทำงานได้ช้า โมเดลแบบ dense ขนาด 27B ที่ระดับ Q4 ต้องการ RAM ประมาณ 17 GB สำหรับเก็บค่าน้ำหนักเพียงอย่างเดียว ก่อนที่จะมีการจัดเก็บ token ของ context แม้แต่ตัวเดียว ซึ่งทำให้แผนบริการขนาด 8 GB และ 16 GB ไม่สามารถใช้งานได้โดยสิ้นเชิง บน VPS ที่ใช้ DDR4 แบบสองช่องสัญญาณทั่วไป ขีดจำกัดความเร็วจะอยู่ที่ประมาณ 3 token ต่อวินาที ซึ่งช้ากว่าความเร็วในการอ่านของคนส่วนใหญ่

แท็ก 27B รุ่นก่อนหน้ายังคงอยู่ในไลบรารี: qwen3.6:27b และ qwen3.5:27b ต่างก็เป็นรุ่น Q4_K_M ที่มีขนาดใกล้เคียงกัน Qwen3.8-27B ยังคงสถาปัตยกรรมเดิมของ Qwen3.6-27B และไฟล์ config อย่างเป็นทางการของทั้งสองรุ่นแสดงโครงสร้างเลเยอร์ที่เหมือนกัน ดังนั้นการคำนวณหน่วยความจำด้านล่างนี้จึงใช้ได้กับทั้งสองรุ่น โปรดตรวจสอบรายการล่าสุดก่อนคัดลอกคำสั่งใดๆ ได้ที่ หน้าแท็ก qwen3.8 ของ Ollama การคำนวณในที่นี้ขึ้นอยู่กับจำนวนพารามิเตอร์, จำนวนบิตต่อน้ำหนัก และโครงสร้างของ attention มากกว่าเลขเวอร์ชัน

ควรดึง Ollama tag ใด และตรวจสอบอย่างไร

การดึง tag ที่ไม่มีอยู่จริงจะแสดงข้อผิดพลาดที่ชัดเจน ทำให้ตรวจสอบบนเครื่องได้รวดเร็ว ส่วน tag ที่มีอยู่จริงอาจไม่สามารถรันบนเครื่องได้ ซึ่งเป็นจุดที่ทำให้ผู้ใช้สับสนกับ GLM 5.2 ที่ระบุไว้ใน library แต่ให้บริการผ่าน cloud ของ Ollama เท่านั้น

ollama --version
ollama pull qwen3.8:27b
ollama show qwen3.8:27b

ollama show จะแสดงสถาปัตยกรรม, จำนวนพารามิเตอร์, ความยาว context และการทำ quantisation ของ tag ที่คุณมีอยู่จริง หากบรรทัดพารามิเตอร์แสดง 27.3B และบรรทัด quantisation แสดง Q4_K_M แสดงว่าคุณมี build ที่ตรงกับคู่มือนี้ นอกจากนี้ใน library ยังมี qwen3.8:27b-q8_0 และ qwen3.8:27b-bf16 สำหรับน้ำหนักเดียวกันที่ความละเอียดสูงกว่า, รุ่น 27b-mtp และ tag 27b-nvfp4, 27b-mxfp8, 27b-mlx และ 27b-mlx-bf16 ซึ่งหน้า tag ระบุว่าเป็น MLX ซึ่งเป็นรูปแบบที่เน้นสำหรับ Apple Silicon ไม่ใช่ Linux VPS ต่างจาก qwen3.6 ตรงที่รายการ qwen3.8 ไม่มี tag 35b-a3b โมเดล MoE (mixture of experts) เหล่านั้นยังคงอยู่ภายใต้ qwen3.6 และมีพฤติกรรมบน CPU ที่แตกต่างออกไปอย่างมาก รายละเอียดเพิ่มเติมเกี่ยวกับเรื่องนี้มีอยู่ด้านล่าง

การคำนวณจำนวนพารามิเตอร์คูณด้วยไบต์ต่อค่าน้ำหนัก

แผนภูมิQwen3.8 27B weights in RAM, by quantisation
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "Q4_K_M",
    "size_gb": 17,
    "bits_per_weight": 4.98,
    "notes": "published tag qwen3.8:27b, language model file"
  },
  {
    "label": "Q5_K_M",
    "size_gb": 19.5,
    "bits_per_weight": 5.7,
    "notes": "computed, no official library tag exists"
  },
  {
    "label": "NVFP4",
    "size_gb": 18,
    "bits_per_weight": 5.27,
    "notes": "published tag 27b-nvfp4, MLX build, one file including the vision encoder"
  },
  {
    "label": "Q8_0",
    "size_gb": 29,
    "bits_per_weight": 8.5,
    "notes": "published tag 27b-q8_0, language model file"
  },
  {
    "label": "BF16",
    "size_gb": 55,
    "bits_per_weight": 16.1,
    "notes": "published tag 27b-bf16, language model file"
  }
]

สูตรคำนวณมีเพียงบรรทัดเดียว คือ จำนวนไบต์ของค่าน้ำหนัก = จำนวนพารามิเตอร์ * จำนวนบิตต่อค่าน้ำหนัก / 8 หากใช้ความละเอียดที่ 4 บิตอย่างสมบูรณ์ พารามิเตอร์จำนวน 27.3 พันล้านตัวจะมีขนาด 13.7 GB ไฟล์โมเดลภาษาในแท็ก Q4_K_M ที่ปล่อยออกมามีขนาด 17 GB ซึ่งเมื่อคำนวณจริงจะได้ค่า 4.98 บิตต่อค่าน้ำหนัก

ช่องว่างดังกล่าวไม่ใช่ข้อผิดพลาด รูปแบบการทำ quantization แบบ K-quant ไม่ได้จัดเก็บทุก tensor ด้วยความกว้างที่ระบุไว้ตามชื่อเรียก โดย tensor ที่สูญเสียคุณภาพมากที่สุดจากการบีบอัดจะได้รับจำนวนบิตที่มากกว่า รายการ tensor ของ Ollama สำหรับไฟล์ qwen3.8:27b ที่ปล่อยออกมาแสดงให้เห็นว่า tensor เหล่านี้ใช้ระดับ Q6_K ได้แก่ เลเยอร์เอาต์พุต, ประมาณครึ่งหนึ่งของ feed-forward down projections, attention V projections ในประมาณครึ่งหนึ่งของเลเยอร์ full-attention และประมาณครึ่งหนึ่งของ fused QKV projections ในเลเยอร์ linear-attention ส่วน tensor สำหรับการทำ normalization ขนาดเล็กจะยังคงความละเอียดเต็มที่ 32 บิต สำหรับ token embedding, attention Q และ K projections รวมถึง feed-forward gate และ up projections จะใช้ระดับ Q4_K เช่นเดียวกับส่วนใหญ่ของโมเดล ชื่อของรูปแบบจึงเป็นค่าเฉลี่ย ซึ่งค่าเฉลี่ยนี้จะอยู่ที่ประมาณ 5 บิต ผลลัพธ์ในลักษณะเดียวกันยังปรากฏที่ปลายอีกด้านของสเกล คือขนาด 55 GB สำหรับ BF16 ซึ่งคิดเป็น 16.1 บิตต่อค่าน้ำหนัก แทนที่จะเป็น 16 บิตแบบคงที่ ในกรณีนี้ token embedding จะเป็น BF16 เหมือนส่วนอื่นๆ และส่วนเกินเล็กน้อยมาจาก metadata ของไฟล์, tensor normalization ที่เก็บไว้ที่ 32 บิต และการที่ขนาดที่ระบุถูกปัดเศษให้เป็นกิกะไบต์ที่ใกล้ที่สุด

ควรเผื่อพื้นที่สำหรับแท็กทั้งหมด ไม่ใช่แค่ไฟล์โมเดลภาษาเท่านั้น ทุกแท็ก GGUF ของ qwen3.8:27b จะมาพร้อมกับ vision projector ขนาดประมาณ 0.9 GB ซึ่งเป็นเหตุผลว่าทำไมแท็ก Q4_K_M จึงระบุขนาดไว้ที่ 18 GB

Q5_K_M ไม่มีแท็กที่เผยแพร่อยู่ในรายการไลบรารีอย่างเป็นทางการของ qwen3.8 ดังนั้นแถวขนาด 19.5 GB จึงเป็นการคำนวณที่ระดับ 5.7 บิตต่อค่าน้ำหนักตามปกติสำหรับรูปแบบนั้น แทนที่จะเป็นการวัดจริง ส่วน Q8_0 มีขนาดเกือบสองเท่าของ Q4 คือ 29 GB บนเครื่องที่ใช้ CPU เพียงอย่างเดียว การเพิ่มขนาดเป็นสองเท่านี้จะทำให้เกิดภาระการรับส่งข้อมูลหน่วยความจำต่อ token เพิ่มขึ้นสองเท่า ซึ่งส่งผลให้ความเร็วในการประมวลผล token ต่อวินาทีลดลงประมาณครึ่งหนึ่งด้วย ด้วยเหตุนี้ Q4_K_M จึงเป็นค่าเริ่มต้นที่เหมาะสมที่สุด หากคุณต้องการพิจารณาในแง่ของคุณภาพมากกว่าหน่วยความจำ การเปรียบเทียบอย่างละเอียดระหว่าง Q4, Q8 และ fp16 จะแสดงให้เห็นว่าคุณภาพของผลลัพธ์เริ่มลดลงที่จุดใด

ต้นทุนของ KV cache เมื่อ context เพิ่มขึ้น

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

แผนภูมิKV cache size by context length, Qwen3.8 27B
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "4k tokens",
    "kv_f16_gb": 0.25,
    "kv_q8_gb": 0.13
  },
  {
    "label": "8k tokens",
    "kv_f16_gb": 0.5,
    "kv_q8_gb": 0.25
  },
  {
    "label": "16k tokens",
    "kv_f16_gb": 1,
    "kv_q8_gb": 0.5
  },
  {
    "label": "32k tokens",
    "kv_f16_gb": 2,
    "kv_q8_gb": 1
  },
  {
    "label": "64k tokens",
    "kv_f16_gb": 4,
    "kv_q8_gb": 2
  },
  {
    "label": "128k tokens",
    "kv_f16_gb": 8,
    "kv_q8_gb": 4
  }
]

ตัวเลขเหล่านี้มาจากไฟล์ config ของโมเดลโดยตรง Qwen3.8-27B เช่นเดียวกับ Qwen3.6-27B เป็นโมเดลแบบ hybrid-attention โดยมีเพียง 16 จาก 64 เลเยอร์ที่ใช้ full attention และเก็บ cache ที่เพิ่มขึ้นตามจำนวน token ซึ่งเลเยอร์เหล่านี้มี 4 key/value heads ภายใต้ GQA (grouped-query attention) และมี head dimension ขนาด 256 ส่วนอีก 48 เลเยอร์ที่เหลือใช้ linear attention (Gated DeltaNet) และเก็บสถานะขนาดคงที่ไว้แทน ซึ่งจากการคำนวณของผมจะอยู่ที่ประมาณ 150 MB ต่อหนึ่งช่องสนทนาไม่ว่า context จะยาวเท่าใดก็ตาม ซึ่งคิดเป็น 64 KiB ต่อ token ที่ f16 ดังนั้นจึงเท่ากับ 2 GB ที่ 32k tokens และ 8 GB ที่ 128k อย่าเชื่อการคำนวณของผมมากกว่าเครื่องของคุณเอง ให้โหลดโมเดลขึ้นมาแล้วอ่านค่าในคอลัมน์ SIZE ของ ollama ps ซึ่งจะรายงานผลรวมของน้ำหนัก บวก cache และ overhead เป็นตัวเลขเดียว

context ขนาด 256K ที่ระบุไว้ใน model card นั้นสามารถทำได้บนสถาปัตยกรรมนี้ แต่มีต้นทุนที่ต้องจ่าย การเติมข้อมูลจนเต็มที่ f16 จะต้องใช้ cache เพิ่มอีกประมาณ 16 GB นอกเหนือจากน้ำหนักโมเดล บนเครื่องที่ใช้ RAM ไปแล้ว 17 GB สำหรับน้ำหนัก Ollama ไม่ได้ให้ window ขนาดเต็มมาเป็นค่าเริ่มต้น โดยเอกสารประกอบเรื่อง context-length จะกำหนดค่าเริ่มต้นตาม VRAM: 4k tokens สำหรับ VRAM ต่ำกว่า 24 GiB, 32k สำหรับ 24 ถึง 48 GiB และ 256k สำหรับ 48 GiB ขึ้นไป VPS ที่ใช้เฉพาะ CPU จะไม่มี VRAM จึงถูกจัดอยู่ในระดับ 4k คุณสามารถเพิ่มค่านี้ได้ด้วยตนเองผ่าน OLLAMA_CONTEXT_LENGTH ตัวแปรระดับเซิร์ฟเวอร์นี้ไม่ใช่ทางเลือกเดียว แต่ การตั้งค่า num_ctx ในแต่ละคำขอ ช่วยให้คุณคงค่าเริ่มต้นที่ประหยัดทรัพยากรไว้สำหรับงานทั่วไป ในขณะที่งานที่ต้องใช้ context ยาวสามารถใช้ window ที่ใหญ่ขึ้นได้ ให้ค่อยๆ เพิ่มค่าและตรวจสอบ ollama ps หลังการเปลี่ยนแปลงแต่ละครั้ง

การตั้งค่าสองอย่างช่วยลดขนาด cache ได้ OLLAMA_KV_CACHE_TYPE=q8_0 จะจัดเก็บ cache ที่ 8 bits แทนที่จะเป็น 16 bits ซึ่งช่วยลดขนาดสำหรับ 32k tokens จาก 2 GB ลงเหลือ 1 GB การตั้งค่านี้ต้องใช้ flash attention ดังนั้นควรตั้งค่า OLLAMA_FLASH_ATTENTION=1 ด้วย และตรวจสอบการลดลงของขนาดใน ollama ps แทนการคาดเดาว่าการตั้งค่ามีผลแล้ว หากคุณยังไม่เคยปรับแต่งประเภทของ cache มาก่อน คำแนะนำการใช้งาน q8_0 เทียบกับ f16 สำหรับ KV cache ของ Ollama จะครอบคลุมวิธีการตั้งค่าตัวแปรทั้งสองและการอ่านค่าก่อนและหลังการปรับแต่ง OLLAMA_NUM_PARALLEL=1 ก็มีความสำคัญไม่แพ้กัน Ollama สามารถให้บริการหลายคำขอพร้อมกันได้ และแต่ละช่อง (slot) จะได้รับส่วนแบ่งของ context ดังนั้นการเพิ่ม parallelism จะเป็นการคูณจำนวน cache ที่คุณจัดสรรไว้โดยไม่รู้ตัว ค่าเริ่มต้นปัจจุบันคือ 1 และการ override ด้านล่างจะล็อกค่าไว้ที่ระดับนั้น หากมีผู้ใช้งานมากกว่าหนึ่งคนบนเซิร์ฟเวอร์นี้ การคูณจำนวน cache จะเป็นจุดที่ทำให้เกิดปัญหา และ จำนวนผู้ใช้งานพร้อมกันที่โมเดลแบบ self-hosted รองรับได้ จะถูกกำหนดโดยจำนวนช่อง cache และความลึกของคิว ก่อนที่จะถูกกำหนดโดยจำนวน core ของ CPU เสียอีก

สิ่งที่สามารถใช้งานได้กับ RAM ขนาด 8, 16, 32 และ 64 GB

แผนภูมิUsable context by VPS RAM tier, f16 cache, headless Linux
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "8 GB",
    "q4_max_ctx_ktok": 0,
    "q8_max_ctx_ktok": 0,
    "notes": "Weights alone exceed the box. Use a 4b or 8b model."
  },
  {
    "label": "16 GB",
    "q4_max_ctx_ktok": 0,
    "q8_max_ctx_ktok": 0,
    "notes": "17 GB of weights does not fit in 16 GB of RAM."
  },
  {
    "label": "32 GB",
    "q4_max_ctx_ktok": 128,
    "q8_max_ctx_ktok": null,
    "notes": "Q4 fits with room for long context. Q8 weights fit, but usable context needs a measured total memory budget."
  },
  {
    "label": "64 GB",
    "q4_max_ctx_ktok": 256,
    "q8_max_ctx_ktok": 256,
    "notes": "Both fit with the full 256K window."
  }
]

ให้อ่านตัวเลขทั้งสองค่าเป็นจำนวนโทเค็นของบริบท (context) ในหน่วยพันโทเค็น ซึ่งสามารถรองรับได้ควบคู่ไปกับน้ำหนัก (weights) และ vision projector โดยใช้ cache แบบ f16 บน Linux VPS แบบ headless ที่เหลือ RAM สำหรับระบบปฏิบัติการประมาณ 1.5 GB และมีส่วนเผื่อเหลือเล็กน้อย ค่าศูนย์หมายความว่าตัวน้ำหนักเองไม่สามารถโหลดลง RAM ได้ ดังนั้นจึงไม่สามารถใช้งานได้ ส่วนค่า null หมายความว่าน้ำหนักสามารถโหลดได้ แต่ยังไม่มีการยืนยันตัวเลขบริบทที่ใช้งานได้จริงสำหรับระดับนั้น

ขนาด 8 GB และ 16 GB ไม่ใช่ตัวเลือกที่เหมาะสม น้ำหนักขนาด 17 GB ไม่สามารถโหลดลงใน RAM ขนาด 16 GB ได้ และไม่มีการตั้งค่าบริบทใดที่จะเปลี่ยนผลลัพธ์นี้ได้ การเพิ่ม swap ก็ไม่สามารถช่วยได้เช่นกัน Ollama ใช้การ memory-map ไฟล์ GGUF ดังนั้นเมื่อหน้าหน่วยความจำที่ถูกเรียกใช้งาน (resident pages) เกินกว่า RAM ที่มี เคอร์เนลจะเริ่มทำการย้ายข้อมูลออกและอ่านข้อมูลใหม่จากดิสก์ ส่งผลให้ทุกโทเค็นต้องดึงข้อมูลขนาดหลายกิกะไบต์จากดิสก์ เครื่องจะติดสถานะ iowait สูงและสร้างข้อความได้ต่ำกว่าหนึ่งโทเค็นต่อวินาที

ขนาด 32 GB คือจุดเริ่มต้นที่ใช้งานได้ น้ำหนักใช้พื้นที่ 17 GB, vision projector ใช้พื้นที่ประมาณ 0.9 GB และคุณจะเหลือ RAM ประมาณ 12.5 GB ซึ่งเพียงพอสำหรับบริบทแบบ f16 ประมาณ 128k โทเค็นพร้อมส่วนเผื่อ น้ำหนักแบบ Q8_0 ที่ขนาด 29 GB สามารถโหลดลงใน 32 GB ได้ แต่บริบทที่ใช้งานได้จริงยังขึ้นอยู่กับ vision projector, cache, ระบบปฏิบัติการ และหน่วยความจำขณะรันไทม์ ให้ตรวจสอบการใช้ทรัพยากรรวมบนเครื่องของคุณก่อนที่จะตัดสินใจว่า Q8 สามารถใช้งานได้ในระดับนี้

ขนาด 64 GB เป็นระดับที่สะดวกสบาย Q4 มีพื้นที่เหลือสำหรับหน้าต่างบริบทเต็มรูปแบบที่ 256k โทเค็น และน้ำหนักแบบ Q8_0 ก็สามารถโหลดได้พร้อมกับบริบทเต็มรูปแบบที่ 256k โทเค็นเช่นกัน ก่อนที่จะจ่ายเงินเพิ่มเพื่ออัปเกรดเป็น 64 GB เพื่อใช้ Q8 ให้พิจารณาให้ชัดเจนว่าคุณกำลังซื้ออะไร: ผลลัพธ์ที่ดีขึ้นเล็กน้อยในความเร็วที่ลดลงครึ่งหนึ่ง บนเครื่องที่ทำงานช้าอยู่แล้ว Q4 สามารถรองรับได้ถึง 128k โทเค็นบนแผน 32 GB ซึ่งเป็นการแลกเปลี่ยนที่คุ้มค่ากว่าสำหรับคนส่วนใหญ่

ความเร็วในการทำ CPU inference บน VPS เป็นอย่างไร

การสร้างหนึ่ง token จาก dense model หมายถึงการอ่าน weight ทุกตัวจากหน่วยความจำหนึ่งครั้ง ไม่ใช่แค่อ่านบางส่วน แต่ต้องอ่านทั้งหมด ดังนั้นขีดจำกัดความเร็วไม่ได้อยู่ที่จำนวน core ของคุณ แต่อยู่ที่ memory bandwidth หารด้วยขนาดของ weight สำหรับการทำ Q4 จะมีการรับส่งข้อมูลในหน่วยความจำอยู่ที่ 17 GB ต่อหนึ่ง token

แผนภูมิTheoretical token ceiling from memory bandwidth, 17 GB of weights
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "DDR4-2666, 2 channel",
    "mem_bandwidth_gb_s": 42.6,
    "ceiling_tok_s": 2.5
  },
  {
    "label": "DDR4-3200, 2 channel",
    "mem_bandwidth_gb_s": 51.2,
    "ceiling_tok_s": 3
  },
  {
    "label": "DDR5-4800, 2 channel",
    "mem_bandwidth_gb_s": 76.8,
    "ceiling_tok_s": 4.5
  },
  {
    "label": "DDR4-3200, 8 channel",
    "mem_bandwidth_gb_s": 204.8,
    "ceiling_tok_s": 12
  },
  {
    "label": "DDR5-4800, 12 channel",
    "mem_bandwidth_gb_s": 460.8,
    "ceiling_tok_s": 27.1
  }
]

ตัวเลขเหล่านี้เป็นเพียงเพดานสูงสุด ไม่ใช่ค่าที่วัดได้จริง ผลลัพธ์ที่ได้จริงจะอยู่ที่ประมาณ 50 ถึง 70 เปอร์เซ็นต์ของตัวเลขที่แสดง เนื่องจาก latency ของหน่วยความจำและการทำ prefetching ที่ไม่สมบูรณ์ทำให้คุณไม่มีทางไปถึงจุดสูงสุดตามทฤษฎี VPS ที่ใช้ DDR4-3200 แบบสองช่องสัญญาณมีเพดานอยู่ที่ 3 tokens ต่อวินาที ดังนั้นคาดหวังได้ประมาณ 2 tokens ต่อวินาที ส่วนเครื่องที่ใช้ DDR5-4800 แบบสองช่องสัญญาณมีเพดานอยู่ที่ 4.5 ดังนั้นคาดหวังได้ประมาณ 3 tokens ต่อวินาที

เซิร์ฟเวอร์ขนาดใหญ่มีข้อควรระวัง แพลตฟอร์ม EPYC แบบ 12 ช่องสัญญาณมี bandwidth อยู่ที่ 460.8 GB/s และมีเพดานอยู่ที่ 27.1 tokens ต่อวินาที แต่คุณไม่ได้เช่าเครื่อง EPYC ทั้งเครื่อง memory bandwidth เป็นทรัพยากรที่ใช้ร่วมกันทั้งโฮสต์โดยผู้เช่าทุกรายบนเครื่องนั้น ดังนั้น slice ขนาด 8 vCPU จึงไม่ได้มาพร้อมกับ bandwidth แบบพิเศษ 12 ช่องสัญญาณ คู่มือที่เน้น GPU มักข้ามประเด็นนี้ไปทั้งหมด ซึ่งเป็นเหตุผลว่าทำไม VPS สองแผนที่มีจำนวน vCPU เท่ากันเป๊ะ อาจมีความเร็วต่างกันถึง 3 เท่าเมื่อรันโมเดลเดียวกัน

การเพิ่ม vCPU จะเลิกช่วยเพิ่มประสิทธิภาพอย่างรวดเร็วด้วยเหตุผลเดียวกัน เมื่อ core ร้องขอข้อมูลเร็วกว่าที่ memory controller จะส่งให้ได้ thread ที่เพิ่มเข้ามาจะสร้างเพียงภาระงานในการจัดการ (scheduling overhead) เท่านั้น Ollama ไม่มี environment variable ระดับเซิร์ฟเวอร์สำหรับกำหนดจำนวน thread ดังนั้นให้ตั้งค่า num_thread ในคำขอ options ให้เท่ากับจำนวน physical core ของคุณ จากนั้นให้วัดผล แล้วลองลดจำนวนลงครึ่งหนึ่ง ในหลายแผนแบบ shared การตั้งค่าที่ต่ำกว่ามักจะเร็วกว่า

การประมวลผล prompt มีพฤติกรรมที่ต่างออกไป ช่วง prefill หรือการประมวลผล input ก่อนที่ token แรกจะปรากฏนั้น เป็นงานที่เน้นการคำนวณ (compute bound) มากกว่าการใช้ bandwidth จึงสามารถขยายประสิทธิภาพตามจำนวน core ได้ ผลที่เห็นได้ชัดคือการหยุดรอที่ยาวนานก่อนที่ผลลัพธ์จะเริ่มแสดงเมื่อใช้ prompt ขนาดใหญ่ ตามด้วยอัตราความเร็วที่คงที่และช้าดังที่กล่าวไปข้างต้น ให้จับเวลาทั้งสองส่วนแยกกันด้วย --verbose ซึ่งจะแสดงค่า prompt eval rate และ eval rate สำหรับทุกคำขอ

หากโมเดล dense 27B ช้าเกินไป ให้พิจารณาแท็ก qwen3.6:35b-a3b ก่อนที่จะล้มเลิกการใช้ CPU แท็กเหล่านั้นจะเปิดใช้งานพารามิเตอร์ประมาณ 3 พันล้านตัวต่อหนึ่ง token แทนที่จะใช้ทั้งหมด 27.3 พันล้านตัว ดังนั้นปริมาณการรับส่งข้อมูลในหน่วยความจำต่อหนึ่ง token จะลดลงเกือบหนึ่งลำดับความสำคัญ แม้ว่าไฟล์บนดิสก์จะมีขนาดใหญ่กว่าก็ตาม คุณกำลังแลกพื้นที่ RAM กับความเร็ว การเลือก runtime ก็มีความสำคัญในจุดนี้เช่นกัน และ Ollama และ llama.cpp มีการควบคุมการปรับแต่ง CPU ที่แตกต่างกัน บนโค้ด inference พื้นฐานชุดเดียวกัน

เมื่อใดที่ควรเช่า GPU เป็นรายชั่วโมงแทน

แผนภูมิGPU memory bandwidth and token ceiling on the same 17 GB of weights
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "L40S, 48 GB",
    "mem_bandwidth_gb_s": 864,
    "ceiling_tok_s": 51
  },
  {
    "label": "RTX 4090, 24 GB",
    "mem_bandwidth_gb_s": 1008,
    "ceiling_tok_s": 59
  },
  {
    "label": "A100, 80 GB",
    "mem_bandwidth_gb_s": 2039,
    "ceiling_tok_s": 120
  },
  {
    "label": "H100 SXM, 80 GB",
    "mem_bandwidth_gb_s": 3350,
    "ceiling_tok_s": 197
  }
]

สูตรเดียวกันนี้เมื่อนำไปใช้กับค่า memory bandwidth ของ GPU ที่ระบุไว้ จะให้คำตอบในอีกระดับหนึ่ง การ์ดจอสำหรับผู้บริโภคขนาด 24 GB มีขีดจำกัดอยู่ที่ 59 token ต่อวินาทีสำหรับน้ำหนักโมเดลเหล่านี้ ในขณะที่การ์ดจอสำหรับศูนย์ข้อมูลรุ่นปัจจุบันทำได้ถึง 197 ซึ่งไม่ใช่ช่องว่างที่คุณจะปิดได้ด้วยการปรับแต่งจำนวน thread การ์ดจอทำงานด้วย memory bandwidth ที่ 1008 GB/s ในขณะที่ VPS ของคุณทำงานได้เพียงหลักสิบเท่านั้น

ดังนั้น ให้ตัดสินใจโดยดูจากภาระงานแทนที่จะดูจากความชอบ การทำ inference บน CPU เป็นคำตอบที่ถูกต้องเมื่อเป็นงานแบบ asynchronous และไม่มีใครรอผลลัพธ์อยู่ เช่น การสรุปเอกสารจำนวนมากในตอนกลางคืน หรือการจัดหมวดหมู่ข้อมูลที่ทำงานในขณะที่คุณนอนหลับ ให้เช่า GPU ทันทีที่มีคนรอผลลัพธ์ หรือเมื่อมีคำขอเข้ามาเร็วกว่าที่เครื่องของคุณจะประมวลผลเสร็จ runtime ของ CPU ไม่ได้จำกัดอยู่แค่การประมวลผลทีละคำขอ: เอกสารของ llama.cpp server ระบุว่ารองรับการทำ parallel decoding และ continuous batching บน CPU ได้เช่นเดียวกับบน GPU และ Ollama ก็สามารถให้บริการคำขอแบบขนานได้เช่นกัน โดยแลกกับการใช้ cache ที่มากขึ้น สิ่งที่ใช้ตัดสินใจคืออัตราการให้บริการที่คุณวัดได้เทียบกับอัตราการเข้ามาของคำขอ ดังนั้นควรทดสอบ batch ที่สมจริงบนเครื่องของคุณเอง เมื่อใดที่คำขอเข้ามาเร็วกว่าอัตรานั้น คิวงานก็จะยาวขึ้น

การเปรียบเทียบต้นทุนไม่ได้ชัดเจนอย่างที่เห็น VPS ขนาด 64 GB จะคิดค่าบริการทุกชั่วโมงตลอดทั้งเดือนไม่ว่าโมเดลจะถูกโหลดไว้หรือไม่ ในขณะที่การเช่า GPU รายชั่วโมงจะแยกค่าประมวลผลออกจากค่าจัดเก็บข้อมูลซึ่งสามารถคงอยู่ได้แม้จะหยุดใช้งานไปแล้ว หากการใช้งานจริงของคุณคือวันละสองชั่วโมง การเช่า GPU อาจทั้งเร็วกว่าและถูกกว่า ให้คำนวณ duty cycle ของคุณก่อนแล้วจึงประเมินราคา การเลือก VPS ที่มี GPU จะครอบคลุมสิ่งที่ต้องตรวจสอบบนตัว instance เอง และ vLLM เหนือกว่า Ollama เมื่อคุณให้บริการคำขอพร้อมกันบน GPU เพราะมันจัดการ batch ได้อย่างเหมาะสมกว่า

ยังมีตัวเลือกที่สามที่คนมักลืมไป คือการเก็บโมเดลขนาด 27B ไว้บน CPU สำหรับงาน batch และใช้ hosted API model สำหรับงานที่ต้องการการโต้ตอบ ไม่มีกฎข้อไหนบังคับว่าต้องใช้โมเดลเดียวสำหรับทั้งสองงาน

การติดตั้ง Ollama และการวัดประสิทธิภาพเครื่องของคุณ

สคริปต์ติดตั้งที่ใช้เป็นสคริปต์อย่างเป็นทางการ ซึ่งจะตั้งค่า systemd service ให้ทำงานภายใต้ผู้ใช้เฉพาะที่ชื่อ ollama

curl -fsSL https://ollama.com/install.sh | sh
ollama --version
free -g

ollama --version ควรแสดงผลเป็น 0.32.12 หรือใหม่กว่า ซึ่งเป็นรุ่นแรกที่รองรับ Qwen 3.8 27B ตรวจสอบ free -g ก่อนที่คุณจะดึงข้อมูลใดๆ ระบบจะรายงานหน่วยเป็น GiB ดังนั้นแผนที่ระบุว่ามี RAM 32 GB อาจแสดงค่าประมาณ 29 ในคอลัมน์ total ให้เปรียบเทียบหน่วยความจำที่ใช้งานได้กับน้ำหนักของโมเดลและงบประมาณแคชที่ระบุไว้ข้างต้น

ให้ตั้งค่ารันไทม์ผ่าน systemd override แทนการตั้งค่าในเชลล์ของคุณ เนื่องจากโมเดลทำงานภายใน service จึงไม่สามารถมองเห็นสภาพแวดล้อมแบบอินเทอร์แอคทีฟของคุณได้

sudo systemctl edit ollama
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
Environment="OLLAMA_KEEP_ALIVE=60m"
sudo systemctl restart ollama
ollama pull qwen3.8:27b
ollama run qwen3.8:27b --verbose "Name two Linux distributions."

ผลลัพธ์จาก --verbose คือค่าการวัดที่คุณต้องการ eval rate คือจำนวนโทเค็นต่อวินาทีระหว่างการสร้างข้อความ prompt eval rate คือความเร็วในการ prefill load duration คือระยะเวลาที่ใช้ในการอ่านน้ำหนักโมเดลจากดิสก์ ซึ่งเป็นเหตุผลว่าทำไมจึงต้องตั้งค่า OLLAMA_KEEP_ALIVE=60m ไว้ เพราะบน CPU การโหลด 17 GB จากดิสก์ในทุกคำขอมีต้นทุนสูงกว่าตัวคำขอเอง ค่าเริ่มต้นของ idle timeout คือห้านาที ซึ่งสั้นเกินไปจนทำให้คิวงานที่มีช่องว่างระหว่างรายการต้องเสียค่าโหลดซ้ำแล้วซ้ำเล่า และ ตัวเลือกสำหรับการคงโมเดลไว้ในหน่วยความจำ ครอบคลุมทั้งฟิลด์ keep_alive ต่อคำขอ และการตั้งค่าให้คงอยู่ถาวรหลังรีบูต

ในขณะที่โมเดลถูกโหลดอยู่ ให้ตรวจสอบการใช้ทรัพยากรจากเทอร์มินัลที่สอง

ollama ps

คอลัมน์ SIZE คือการใช้หน่วยความจำจริงรวมถึง KV cache ซึ่งควรมีค่าใกล้เคียงกับน้ำหนักโมเดลรวมกับ vision projector และค่าสำหรับความยาวบริบท (context length) ของคุณในตาราง KV ที่ 8192 โทเค็นด้วยแคชแบบ 8-bit ส่วนที่เพิ่มขึ้นของแคชจะมีขนาดเพียงประมาณหนึ่งในสี่ของกิกะไบต์ เมื่อเทียบกับ 0.5 GB หากใช้ f16 ร่วมกับสถานะ linear-attention แบบคงที่ คอลัมน์ PROCESSOR ควรแสดงเป็น 100% CPU หากแสดงเป็นค่าอื่น แสดงว่ามีบางอย่างแย่งใช้งาน GPU อยู่ และตัวเลขความเร็วในคู่มือนี้จะไม่ตรงกับประสิทธิภาพเครื่องของคุณ

รูปแบบความล้มเหลวและข้อความที่คุณจะพบ

โมเดลไม่ยอมโหลด Ollama จะแสดงบรรทัดที่ระบุตัวเลขทั้งสองค่าในรูปแบบ model requires more system memory (18.6 GiB) than is available (15.2 GiB) นี่เป็นความล้มเหลวในลักษณะที่ดี เพราะ Ollama ตรวจสอบก่อนที่จะจัดสรรหน่วยความจำ แทนที่จะปล่อยให้ kernel เป็นผู้จัดการ ให้ลดความยาวของ context ลง เปลี่ยนไปใช้ tag ที่เล็กลง หรือย้ายไปใช้แผนการใช้งานที่ใหญ่ขึ้น

กระบวนการหายไปในระหว่างการตอบคำถาม ฝ่ายไคลเอนต์ไม่แสดงข้อมูลที่เป็นประโยชน์ และ journalctl -u ollama -n 50 แสดงให้เห็นว่าบริการกำลังเริ่มทำงานใหม่ ให้รันคำสั่ง dmesg -T | tail หากพบข้อความ Out of memory: Killed process ... (ollama) หมายความว่า kernel OOM killer ได้ยุติการทำงานของกระบวนการนี้ เหตุการณ์นี้เกิดขึ้นเมื่อการตรวจสอบก่อนโหลดผ่าน แต่แคชมีขนาดใหญ่เกินกว่าที่ประเมินไว้ระหว่างการสนทนาที่ยาวนาน ให้ลดความยาวของ context ลง

การดึงข้อมูลล้มเหลวในทันที Error: pull model manifest: file does not exist หมายความว่า tag นั้นไม่มีอยู่ในคลัง หมายเลขเวอร์ชันที่ยังไม่ได้ปล่อยออกมาจะทำให้เกิดข้อความนี้ รวมถึงการพิมพ์ผิดในชื่อ tag ด้วย qwen3.8:27b เป็นชื่อที่มีอยู่จริง ดังนั้นหาก tag นั้นล้มเหลว ให้ตรวจสอบการพิมพ์ผิดก่อนเป็นอันดับแรก ยืนยัน tag บนหน้าเว็บคลังข้อมูลก่อนที่จะโทษระบบเครือข่ายของคุณ และหาก tag ที่มีอยู่จริงสามารถดึงข้อมูลได้แต่ไม่สามารถรันได้ ให้ตรวจสอบ ollama --version เทียบกับเวอร์ชัน 0.32.12

ทุกอย่างทำงานได้แต่ช้าจนรับไม่ได้ หากความเร็วต่ำกว่าหนึ่ง token ต่อวินาทีบนเครื่องที่มี RAM เพียงพอ แสดงว่าเป็นปัญหาเรื่อง paging ไม่ใช่เรื่องการประมวลผล ให้รัน vmstat 1 ในขณะที่กำลังสร้างข้อความ หากคอลัมน์ si หรือ so มีค่าที่ไม่ใช่ศูนย์ หมายความว่า kernel กำลังทำ swapping วิธีแก้ไขคือลด context หรือลดจำนวนโมเดลที่โหลดไว้ หากค่า wa สูงอย่างต่อเนื่องโดยไม่มีกิจกรรม swap แสดงว่า memory-mapped weights กำลังถูกอ่านซ้ำจากดิสก์ ซึ่งหมายความว่าโมเดลเหล่านั้นไม่ได้อยู่ในหน่วยความจำจริง

token แรกใช้เวลา 30 วินาทีก่อนที่ความเร็วในการแสดงผลจะเพิ่มขึ้น นี่คือขั้นตอน prefill ซึ่งเป็นเรื่องปกติ ระบบ prompt ที่ยาวจะถูกประมวลผลในทุกคำขอที่ไม่ได้อยู่ในแคช ดังนั้นควรทำให้ system prompt สั้นลงก่อนที่จะปรับแต่งส่วนอื่นใด

สิ่งที่ CPU-only 27B เหมาะสมสำหรับการใช้งานจริง

จงตั้งความคาดหวังจากตัวเลขแทนที่จะใช้ความหวัง ด้วยความเร็วสองถึงสี่โทเค็นต่อวินาที คำตอบที่มีความยาว 500 โทเค็นจะใช้เวลาประมวลผลระหว่างสองถึงสี่นาที ซึ่งถือว่าใช้งานไม่ได้สำหรับการแชท แต่ใช้งานได้ดีเยี่ยมสำหรับงานแบบคิว (queue) โมเดลที่คิดก่อนตอบจะทำให้ตัวเลขนี้แย่ลงไปอีก เนื่องจากโทเค็นการใช้เหตุผลที่ซ่อนอยู่จะถูกสร้างขึ้นด้วยความเร็วที่ช้าเท่ากับคำตอบ ดังนั้น การปรับระดับความพยายามในการใช้เหตุผลให้เหมาะสมกับงาน จึงเป็นหนึ่งในไม่กี่วิธีที่จะช่วยให้การตอบกลับสั้นลงโดยไม่ต้องเปลี่ยนโมเดล งานสรุปเอกสาร, การติดแท็กจำนวนมาก, การดึงข้อมูลจากไฟล์ที่ค้างอยู่ และการตรวจสอบโค้ดแบบไม่ต้องเฝ้าหน้าจอล้วนรองรับความเร็วระดับนี้ได้ เพราะไม่มีใครรอคำตอบอยู่ งานช่วยเหลือด้านการเขียนโค้ดนั้นก้ำกึ่ง ดังนั้น การชี้เป้า coding agent ไปยังโมเดลที่คุณโฮสต์เอง จึงคุ้มค่าสำหรับงานเบื้องหลัง เช่น การเขียน commit message และการสร้างโครงสร้างทดสอบ (test scaffolding) แต่ไม่เหมาะสำหรับคำแนะนำแบบ inline ที่คุณต้องนั่งรอ

ประเด็นเรื่องความเป็นส่วนตัวคือเหตุผลที่แท้จริง โมเดลทำงานบนฮาร์ดแวร์ที่คุณเช่าและควบคุมเอง ไม่มีคำขอใดหลุดออกไปนอกเครื่อง และไม่มีค่าใช้จ่ายต่อโทเค็น ซึ่งมีค่ามากสำหรับข้อมูลที่ถูกควบคุมดูแลแม้จะมีความเร็วเพียงสามโทเค็นต่อวินาทีก็ตาม จงชั่งน้ำหนักอย่างตรงไปตรงมากับทางเลือกอื่น: การ self-host โมเดลระดับ frontier ต้องใช้ฮาร์ดแวร์มากกว่านี้อีกหลายเท่า และโมเดลขนาด 27B บน CPU คือจุดที่ถูกที่สุดบนเส้นกราฟนั้นที่ผลลัพธ์ยังคงคุ้มค่าที่จะอ่าน

ในการวัดประสิทธิภาพ คุณต้องใช้ข้อมูลนำเข้าที่มีโครงสร้างจริง และ API ข้อมูลสาธารณะส่วนใหญ่ต้องการบัญชีผู้ใช้ก่อนที่คุณจะวัด throughput ได้ สคีมาตัวอย่างของ Strasmore (ที่เราดูแลอยู่) จัดทำเอกสาร SQL แบบอ่านอย่างเดียวสำหรับข้อมูลหุ้นและออปชันของสหรัฐฯ โดยไม่ต้องใช้คีย์และไม่ต้องลงทะเบียน โดยใช้ชื่อตารางที่ระบุฐานข้อมูล: https://ai.strasmore.com/api/demo/sql?sql=SELECT ticker, close FROM global_markets.delayed_stocks_minute_aggs LIMIT 5 ข้อจำกัดของตัวอย่างคือ 500 แถวและ 20 วินาทีต่อการเรียกใช้งาน โดยมีประวัติข้อมูลตั้งแต่วันที่ 1 มกราคม 2025 เป็นต้นไป ซึ่งเพียงพอเกินกว่าที่เครื่องระดับสองโทเค็นต่อวินาทีจะประมวลผลได้ รายการคอลัมน์ทั้งหมดอยู่ที่ https://ai.strasmore.com/api/demo/schema

หากนี่เป็นการติดตั้ง Ollama ครั้งแรกของคุณ คำแนะนำฉบับสมบูรณ์สำหรับการรัน Ollama บน VPS จะครอบคลุมการตั้งค่า service, HTTP API และกฎ firewall ที่คู่มือนี้ถือว่าคุณมีอยู่แล้ว ห้ามเปิดพอร์ต 11434 สู่สาธารณะ API ภายในของ Ollama ไม่ต้องการการตรวจสอบสิทธิ์ ดังนั้นใครก็ตามที่เข้าถึงพอร์ตนี้ได้จะสามารถใช้งานโมเดลของคุณได้ทันที

FAQ

มีโมเดล Qwen 3.8 27B บน Ollama หรือไม่?

มีครับ ณ วันที่ 21 ตุลาคม 2026 คลังของ Ollama มีรายการ qwen3.8 อยู่ และ qwen3.8:27b (ซึ่งแท็กด้วย latest) เป็นรุ่น Q4_K_M ขนาด 18 GB ของโมเดลแบบ dense ที่มีพารามิเตอร์ 27.3 พันล้านตัว พร้อม vision projector และ context window ขนาด 256K โมเดลนี้รันในเครื่องและต้องการ Ollama v0.32.12 ขึ้นไป ส่วนแท็กเก่าอย่าง qwen3.6:27b และ qwen3.5:27b ยังคงมีแสดงอยู่ในรายการ ตรวจสอบ https://ollama.com/library/qwen3.8/tags เพื่อดูรายการปัจจุบัน หากระบุแท็กที่ไม่มีอยู่จริงจะเกิดข้อผิดพลาด Error: pull model manifest: file does not exist

ต้องใช้ RAM เท่าไรในการรันโมเดล Qwen 27B บน VPS?

32 GB คือขั้นต่ำที่ใช้งานได้จริงสำหรับ Q4_K_M โดยน้ำหนักโมเดลมีขนาด 17 GB, vision projector เพิ่มอีกประมาณ 0.9 GB, ระบบปฏิบัติการใช้ประมาณ 1.5 GB และ KV cache ใช้เพิ่มอีกประมาณ 1 GB ต่อทุกๆ 16,000 tokens ของ context ที่ระดับ f16 เนื่องจากมีเพียง 16 จาก 64 เลเยอร์ของโมเดลเท่านั้นที่เก็บ cache ที่ขยายตัว แผน 16 GB ไม่สามารถโหลดน้ำหนักโมเดลได้เลย และการใช้ swap ก็ไม่ช่วยเนื่องจากไฟล์ถูกทำ memory-mapped และ kernel จะอ่านไฟล์จากดิสก์ใหม่ทุกครั้งที่ประมวลผล token แผน 64 GB จะช่วยให้คุณมีพื้นที่เพียงพอสำหรับ context window เต็มขนาด 256K แม้จะใช้น้ำหนักแบบ Q8_0 ที่ขนาด 29 GB ก็ตาม

โมเดล 27B จะให้ความเร็วได้กี่ tokens ต่อวินาทีบน CPU?

ให้นำ memory bandwidth ของคุณหารด้วยขนาดของน้ำหนักโมเดล แล้วคิดเป็น 50 ถึง 70 เปอร์เซ็นต์ของค่าที่ได้ VPS ที่ใช้ DDR4-3200 แบบสองช่องสัญญาณ (two-channel) มีเพดานความเร็วใกล้เคียงกับ 3 tokens ต่อวินาที และทำความเร็วได้จริงประมาณ 2 tokens ต่อวินาที ส่วนเครื่องที่ใช้ DDR5-4800 แบบสองช่องสัญญาณมีเพดานใกล้เคียงกับ 4.5 และทำความเร็วได้จริงประมาณ 3 tokens ต่อวินาที แพลตฟอร์มเซิร์ฟเวอร์ที่มีช่องสัญญาณมากกว่าดูดีกว่ามากในทางทฤษฎี แต่ memory bandwidth จะถูกแชร์ร่วมกับผู้เช่ารายอื่นบนโฮสต์ ดังนั้นควรวัดค่าด้วยตัวเองโดยใช้ ollama run qwen3.8:27b --verbose และอ่านค่าที่บรรทัด eval rate

ควรใช้ Q4 หรือ Q8 บน VPS ที่รันเฉพาะ CPU?

ในเกือบทุกกรณีควรใช้ Q4_K_M ครับ Q8_0 มีขนาด 29 GB เทียบกับ 17 GB ของ Q4_K_M แม้น้ำหนักจะพอดีกับ RAM 32 GB แต่เมื่อรวม projector, cache, ระบบปฏิบัติการ และ runtime แล้ว จะเหลือพื้นที่ว่างน้อยมาก ส่วน 64 GB จะช่วยให้มีพื้นที่สำหรับ context ที่ยาวขึ้นได้ การใช้ Q8_0 จะมีการย้ายข้อมูลในหน่วยความจำต่อหนึ่ง token มากขึ้นเกือบสองเท่า ซึ่งจะทำให้ความเร็ว tokens ต่อวินาทีของคุณลดลงประมาณครึ่งหนึ่ง ความแตกต่างของคุณภาพระหว่าง Q4_K_M และ Q8_0 ในโมเดลขนาด 27B นั้นมีน้อยมากสำหรับงานส่วนใหญ่ ดังนั้นควรนำ RAM ไปใช้กับ context ที่ยาวขึ้นจะดีกว่า เพราะนั่นจะช่วยเปลี่ยนความสามารถของโมเดลได้มากกว่าการเปลี่ยนวิธีการเรียบเรียงประโยค

การเช่า GPU คุ้มค่ากว่า VPS ที่มี RAM เยอะๆ เมื่อใด?

เมื่อรอบการทำงาน (duty cycle) ของคุณต่ำ หรือมีผู้ใช้งานรอผลลัพธ์อยู่ GPU ที่มีหน่วยความจำ 24 GB มีเพดานความเร็วทางทฤษฎีอยู่ที่ประมาณ 59 tokens ต่อวินาที เมื่อเทียบกับ 2 หรือ 3 tokens ต่อวินาทีบน VPS ทั่วไป ค่าใช้จ่ายในการประมวลผล GPU รายชั่วโมงจะหยุดลงเมื่อหยุดอินสแตนซ์ แต่ค่าพื้นที่จัดเก็บข้อมูลแบบถาวรอาจยังคงมีอยู่ ในขณะที่ VPS ขนาด 64 GB จะคิดค่าบริการตลอดทั้งเดือนไม่ว่าโมเดลจะถูกโหลดอยู่หรือไม่ก็ตาม ให้คำนวณว่าในแต่ละวันคุณสร้าง tokens จริงๆ กี่ชั่วโมง จุดคุ้มทุนขึ้นอยู่กับอัตราค่าเช่า, ระยะเวลาการใช้งาน และค่าใช้จ่ายของพื้นที่จัดเก็บข้อมูลถาวร สำหรับงานประมวลผลแบบ batch ที่มีความสำคัญต่ำและรันต่อเนื่อง VPS แบบเปิดตลอดเวลาจะเป็นตัวเลือกที่คุ้มค่ากว่า

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