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

เปรียบเทียบความคุ้มค่า GPU VPS กับ API Token

วิเคราะห์จุดคุ้มทุนระหว่างการเช่า GPU VPS รายชั่วโมงกับการจ่ายค่า API ตามจำนวน Token จริง พร้อมสูตรคำนวณและตัวเลขปริมาณการใช้งานที่ทำให้การเปลี่ยนไปใช้ VPS ประหยัดกว่าอย่างชัดเจน

จุดคุ้มทุนที่แท้จริงอยู่ที่ไหน

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

ลองคำนวณบน GPU VPS ระดับกลางที่ราคา $0.50 ต่อชั่วโมง ซึ่งคิดเป็น $365 ต่อเดือน (730 ชั่วโมง) หากเทียบกับ API ของโมเดลระดับแนวหน้า คุณจะถึงจุดคุ้มทุนที่ 24.3 ล้าน output token ต่อเดือน หากเทียบกับโมเดลเชิงพาณิชย์ขนาดเล็ก จุดคุ้มทุนจะอยู่ที่ 73 ล้าน token แต่หากเทียบกับโมเดลแบบ open-weight ที่โฮสต์เองในขนาดเดียวกัน คุณจะไม่มีวันถึงจุดคุ้มทุน เพราะการ์ดใบเดียวไม่สามารถผลิต token ได้มากพอในหนึ่งเดือนเพื่อไปถึงจุดตัดดังกล่าว

การศึกษาเรื่องจุดคุ้มทุนที่เผยแพร่อยู่ทั่วไปไม่ได้ให้คำตอบในประเด็นนี้ การวิเคราะห์จากผู้ให้บริการรายหนึ่งในเดือน July 2026 ระบุว่าจุดคุ้มทุนอยู่ที่การใช้งานประมาณ 50% สำหรับ H100 แบบ dedicated ที่ราคา $2.00 ต่อชั่วโมง เมื่อเทียบกับ serverless inference การศึกษาในลักษณะนี้เปรียบเทียบการ์ดระดับศูนย์ข้อมูลกับผลิตภัณฑ์แบบ serverless และตั้งราคาตัวเร่งความเร็วไว้สูงกว่าอัตราต่อชั่วโมงที่ใช้ในที่นี้หลายเท่า แต่หลักการคำนวณนั้นเหมือนกัน เนื้อหาถัดไปนี้เป็นการคำนวณใหม่สำหรับการ์ดหนึ่งใบ โมเดลแบบเปิดหนึ่งโมเดลในช่วง 7B ถึง 30B และการเรียกเก็บเงินผ่าน API แบบปกติ

ตัวเลขทุกตัวด้านล่างนี้คือค่าตั้งต้น ไม่ใช่ผลลัพธ์ คุณสามารถแทนที่ค่าเหล่านี้ด้วยข้อมูลของคุณเองได้ทั้งหมด

สูตรคำนวณเพื่อให้คุณแทนค่าด้วยตัวเลขของคุณเอง

cost_per_million = (hourly_rate * 1000000) / (tokens_per_second * 3600 * duty_cycle)

breakeven_millions_per_month = (hourly_rate * hours_per_month) / api_price_per_million

capacity_millions_per_month = (tokens_per_second * 3600 * hours_per_month) / 1000000

required_duty_cycle = breakeven_millions_per_month / capacity_millions_per_month

มีอินพุต 4 รายการที่คุณสามารถวัดหรือตรวจสอบได้ทั้งหมด

  • hourly_rate คือราคาต่อชั่วโมงของ GPU VPS โดยให้นับรวมชั่วโมงที่เครื่องไม่ได้ใช้งานด้วย หากคุณจ่ายเป็นรายเดือน ให้หารราคาต่อเดือนด้วย 730
  • tokens_per_second คืออัตราผลลัพธ์รวมที่เซิร์ฟเวอร์ของคุณทำได้จริงภายใต้ระดับการใช้งานพร้อมกัน (concurrency) ของคุณ ไม่ใช่ตัวเลขแบบ single-stream จากตารางของผู้ให้บริการ
  • duty_cycle คือสัดส่วนของเวลาในหนึ่งเดือนที่ GPU ใช้ในการสร้างโทเค็น หากคุณเช่าเครื่องไว้ตลอดทั้งเดือนแต่ใช้งานเพียงวันละ 2 ชั่วโมง ค่านี้จะอยู่ที่ 8.3%
  • api_price_per_million คือราคาตามการใช้งานจริง (metered price) ของโทเค็นขาออกที่คุณนำมาเปรียบเทียบ

ตัวอย่างนี้คำนวณราคาโทเค็นขาออกทั้งสองฝั่ง เนื่องจากโทเค็นขาออกเป็นส่วนหลักของค่าใช้จ่ายในการใช้งานแชทและงานประเภท agent หาก prompt ของคุณมีความยาวมาก ให้เพิ่มค่าอินพุตเข้าไปทั้งสองฝั่ง ในฝั่ง API รายการนี้จะปรากฏเป็นบรรทัดแยกต่างหากในใบแจ้งหนี้ ส่วนบนเครื่องของคุณเองนั้น การทำ prefill จะใช้เวลาของ GPU อยู่แล้ว จึงแสดงผลออกมาเป็นค่า tokens_per_second ที่วัดได้ต่ำลงโดยอัตโนมัติ

วิธีวัดจำนวนโทเค็นต่อวินาทีก่อนที่คุณจะเชื่อถือการคำนวณ

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

Ollama ช่วยให้คุณทราบค่า single-stream ได้ด้วยคำสั่งเดียว:

ollama run qwen3:8b --verbose "Write 400 words about disk latency."

--verbose จะพิมพ์บล็อกเวลาหลังจากแสดงคำตอบ บรรทัดที่สำคัญคือ eval rate ซึ่งแสดงเป็นจำนวนโทเค็นต่อวินาที โดยนับเฉพาะช่วงการสร้างข้อความเท่านั้น ส่วน prompt eval rate คือความเร็วในการ prefill ซึ่งโดยปกติจะสูงกว่ามาก ตัวเลขของคุณจะแตกต่างจากนี้:

eval count:       412 token(s)
eval duration:    9.612s
eval rate:        42.86 tokens/s

Single stream ไม่ใช่ตัวเลขที่เหมาะสมสำหรับโมเดลการคำนวณต้นทุน เพราะเป็นการวัดคำขอเพียงรายการเดียวบนการ์ดที่สามารถให้บริการพร้อมกันได้หลายรายการ สำหรับตัวเลขรวม ให้รันโมเดลด้วย vLLM แล้วอ่านค่า throughput ที่เซิร์ฟเวอร์รายงานออกมา:

pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 8192

ในขณะที่มีคำขอเข้ามา เซิร์ฟเวอร์จะบันทึกบรรทัดสถานะตามช่วงเวลาที่กำหนด ฟิลด์ข้อมูลอาจเปลี่ยนแปลงไปใน vLLM แต่ละรุ่น ดังนั้นให้อ่านค่าจากเวอร์ชันของคุณเองแทนที่จะอ้างอิงจากของผู้อื่น:

Avg prompt throughput: 812.4 tokens/s, Avg generation throughput: 396.1 tokens/s, Running: 16 reqs, Waiting: 0 reqs, GPU KV cache usage: 21.7%

Avg generation throughput คือตัวเลขที่สูตรต้องการ ค่านี้จะเพิ่มขึ้นเมื่อคุณเพิ่มจำนวนคำขอพร้อมกันจนกระทั่ง KV cache (key-value cache ซึ่งเป็นสถานะ attention ต่อคำขอที่ vLLM เก็บไว้ใน VRAM) เต็ม จากนั้นค่าจะหยุดเพิ่ม หากคุณเพิ่มภาระงานเกินกว่านั้น คำขอจะเข้าคิวแทนที่จะประมวลผลเร็วขึ้น ซึ่งคุณจะสังเกตได้จากจำนวน Waiting ที่เพิ่มขึ้น นอกจากนี้ vLLM ยังมีตัวสร้างโหลดมาให้ด้วยคือ vllm bench serve โดย flag ของคำสั่งจะเปลี่ยนไปตามเวอร์ชัน ดังนั้นให้รัน vllm bench serve --help บนเวอร์ชันที่คุณติดตั้งไว้แทนการคัดลอกคำสั่งจากบล็อกโพสต์

ให้เฝ้าดูการ์ดในขณะที่การทดสอบทำงาน:

nvidia-smi --query-gpu=utilization.gpu,memory.used,power.draw --format=csv -l 5

หาก utilization.gpu อยู่ใกล้ระดับ 100% ในระหว่างการสร้างข้อความ แสดงว่าคุณติดขัดที่ throughput และตัวเลขที่คุณวัดได้คือขีดจำกัดที่แท้จริง หากค่าดังกล่าวยังคงต่ำ แสดงว่ามีปัจจัยอื่นที่เป็นข้อจำกัด เช่น จำนวนคำขอพร้อมกันน้อยเกินไป, ไคลเอนต์ทำงานช้า หรือโมเดลมีขนาดใหญ่เกินกว่าจะเก็บใน VRAM ได้ทั้งหมดและถูกย้ายบางส่วนไปไว้ใน system RAM Ollama และ vLLM มีการแลกเปลี่ยนประสิทธิภาพที่แตกต่างกันมาก และช่องว่างระหว่างทั้งสองบนการ์ดใบเดียวกันนั้นกว้างพอที่จะทำให้จุดคุ้มทุนของคุณเปลี่ยนไปได้หลายเท่าตัว

ลักษณะของค่าใช้จ่ายตลอดทั้งเดือน

ตัวอย่างที่นำมาคำนวณคือ GPU VPS ขนาด 24 GB ในราคา 0.50 ดอลลาร์ต่อชั่วโมง โดยรันโมเดลแบบเปิดขนาด 8B ผ่าน vLLM ซึ่งวัดประสิทธิภาพได้ที่ 400 output tokens ต่อวินาทีโดยรวม และรองรับ 16 คำขอพร้อมกัน ค่าเช่าจะคงที่เสมอไม่ว่าคุณจะใช้งานการ์ดหรือไม่ก็ตาม กำลังการผลิตที่อัตรานี้คือ 1,051 ล้าน output tokens ต่อเดือน ซึ่งเป็นปริมาณที่การ์ดจะผลิตได้หากทำงานตลอดเวลาโดยไม่หยุดพัก

แผนภูมิMonthly cost by output volume: one GPU VPS at $0.50 per hour against metered APIs (USD)
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "output_tokens_millions": 5,
    "gpu_vps_usd": 365,
    "open_api_usd": 1,
    "small_api_usd": 25,
    "frontier_api_usd": 75
  },
  {
    "output_tokens_millions": 10,
    "gpu_vps_usd": 365,
    "open_api_usd": 2,
    "small_api_usd": 50,
    "frontier_api_usd": 150
  },
  {
    "output_tokens_millions": 25,
    "gpu_vps_usd": 365,
    "open_api_usd": 5,
    "small_api_usd": 125,
    "frontier_api_usd": 375
  },
  {
    "output_tokens_millions": 50,
    "gpu_vps_usd": 365,
    "open_api_usd": 10,
    "small_api_usd": 250,
    "frontier_api_usd": 750
  },
  {
    "output_tokens_millions": 100,
    "gpu_vps_usd": 365,
    "open_api_usd": 20,
    "small_api_usd": 500,
    "frontier_api_usd": 1500
  },
  {
    "output_tokens_millions": 250,
    "gpu_vps_usd": 365,
    "open_api_usd": 50,
    "small_api_usd": 1250,
    "frontier_api_usd": 3750
  },
  {
    "output_tokens_millions": 500,
    "gpu_vps_usd": 365,
    "open_api_usd": 100,
    "small_api_usd": 2500,
    "frontier_api_usd": 7500
  },
  {
    "output_tokens_millions": 1000,
    "gpu_vps_usd": 365,
    "open_api_usd": 200,
    "small_api_usd": 5000,
    "frontier_api_usd": 15000
  }
]

เส้นค่าใช้จ่ายของ GPU จะเป็นเส้นตรงที่ระดับ 365 ดอลลาร์ เนื่องจากค่าเช่าไม่ขึ้นอยู่กับปริมาณการใช้งานการ์ด ในขณะที่เส้นค่าใช้จ่ายของ API ทุกตัวจะเป็นเส้นตรงที่ลากผ่านจุดศูนย์ ทั้งสองเส้นจะตัดกันเพียงจุดเดียวเท่านั้น

ที่ปริมาณ 25 ล้าน output tokens ต่อเดือน Frontier API จะมีค่าใช้จ่ายอยู่ที่ 375 ดอลลาร์ ซึ่งทำให้ค่าใช้จ่ายทั้งสองฝั่งต่างกันไม่เกินสิบดอลลาร์ ที่ปริมาณ 50 ล้าน output tokens โมเดลเชิงพาณิชย์ขนาดเล็กจะมีค่าใช้จ่ายอยู่ที่ 250 ดอลลาร์ และยังคงเป็นตัวเลือกที่ถูกกว่า และที่ปริมาณ 1000 ล้าน output tokens ซึ่งต้องใช้การ์ดทำงานถึง 95% ของเดือน Hosted open-weight API จะมีค่าใช้จ่ายอยู่ที่ 200 ดอลลาร์ เมื่อเทียบกับค่าเช่าคงที่ การ์ดใบนี้จะมีค่าใช้จ่ายสูงกว่าเกือบสองเท่า ณ ปริมาณงานที่การ์ดทำงานหนักที่สุด

ผลลัพธ์สุดท้ายนี้สร้างความประหลาดใจให้กับหลายคน แต่มันไม่ใช่เรื่องบังเอิญ Hosted open-weight endpoint คือการรันกลุ่ม GPU ที่มีอัตราการใช้งานสูง ดังนั้นราคาจึงใกล้เคียงกับต้นทุนของการ์ดที่ทำงานเต็มประสิทธิภาพ คุณไม่สามารถเอาชนะราคาของกลุ่ม GPU ที่ทำงานเต็มประสิทธิภาพได้ด้วยการเช่าการ์ดเพียงใบเดียวแล้วใช้งานไม่เต็มที่ สิ่งที่คุณสามารถเอาชนะได้คือราคาของ Frontier API ซึ่งถูกกำหนดโดยความสามารถของโมเดลมากกว่าเวลาที่ใช้ในการประมวลผลจริง

ต้นทุนต่อล้าน output tokens ในแต่ละ duty cycle

ปริมาณงานและ duty cycle คือข้อเท็จจริงเดียวกันที่มองจากสองมุม การเช่าคือการซื้อเวลา ชั่วโมงที่ว่างงานไม่ได้สร้างผลผลิตแต่ยังคงมีค่าใช้จ่าย

แผนภูมิCost per million output tokens at each duty cycle (USD, list prices August 2026)
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "100% duty",
    "self_host_usd_per_million": "0.35",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "50% duty",
    "self_host_usd_per_million": "0.69",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "25% duty",
    "self_host_usd_per_million": "1.39",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "10% duty",
    "self_host_usd_per_million": "3.47",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "5% duty",
    "self_host_usd_per_million": "6.94",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  },
  {
    "label": "2% duty",
    "self_host_usd_per_million": "17.36",
    "open_api_usd_per_million": "0.20",
    "small_api_usd_per_million": "5.00",
    "frontier_api_usd_per_million": "15.00"
  }
]

คอลัมน์ API ทั้งสามคอลัมน์แสดงราคาตามรายการที่ประกาศไว้ ณ เดือนสิงหาคม 2026: 0.20 ดอลลาร์ต่อล้าน output tokens สำหรับโมเดล open-weight ขนาด 8B แบบโฮสต์, 5.00 ดอลลาร์สำหรับโมเดลเชิงพาณิชย์ขนาดเล็ก และ 15.00 ดอลลาร์สำหรับโมเดลระดับแนวหน้า ราคาเหล่านี้เป็นเพียงตัวอย่างประกอบ โปรดตรวจสอบหน้าแสดงราคาปัจจุบันก่อนตัดสินใจ และหากคุณกำลังเปรียบเทียบกับแผนรายเดือนแบบเหมาจ่ายแทนการคิดราคาตามจำนวน tokens การคำนวณค่าสมัครสมาชิกจะมีวิธีคิดที่ต่างออกไป และจุดคุ้มทุนก็จะเปลี่ยนไปเช่นกัน

หากใช้งานการ์ดเต็มประสิทธิภาพ ต้นทุนต่อล้าน output tokens จะอยู่ที่ 0.35 ดอลลาร์ ซึ่งถือว่าถูกมาก ที่ duty cycle ระดับ 10% ต้นทุนต่อล้าน tokens เดียวกันนี้จะอยู่ที่ 3.47 ดอลลาร์ และที่ duty cycle ระดับ 2% ต้นทุนจะอยู่ที่ 17.36 ดอลลาร์ ซึ่งไม่ใช่ระดับราคาเดียวกับ 0.20 ดอลลาร์ที่โมเดล open-weight แบบโฮสต์เรียกเก็บสำหรับผลลัพธ์ที่เท่ากัน

เมื่อเทียบกับโมเดล open-weight แบบโฮสต์ การเช่า GPU เป็นทางเลือกที่แพงกว่าในทุกระดับ duty cycle ที่แสดงในตาราง ที่ระดับ 10% คุณกำลังจ่ายเงิน 3.47 ดอลลาร์ต่อล้าน tokens เพื่อให้ได้ผลลัพธ์ที่ขายกันในราคา 0.20 ดอลลาร์ สิ่งที่คุณได้รับจากส่วนต่างราคาคือความเป็นส่วนตัวและค่าใช้จ่ายที่คงที่ ซึ่งสิ่งเหล่านี้มีมูลค่าจริง แต่ไม่ใช่การประหยัดต้นทุน ดังนั้นอย่าจัดประเภทว่าเป็นความคุ้มค่าด้านราคา เมื่อเทียบกับระดับเชิงพาณิชย์ ภาพจะกลับกัน: ที่ duty cycle ระดับ 10% การ์ดมีราคาถูกกว่าทั้งโมเดลเชิงพาณิชย์ขนาดเล็กและโมเดลระดับแนวหน้า และยังคงถูกกว่าระดับแนวหน้าจนกระทั่ง duty cycle ลดลงเหลือประมาณ 2.3%

ปริมาณจุดคุ้มทุนสำหรับ API แต่ละระดับ

แผนภูมิBreak-even output volume per month, and the duty cycle it requires
ข้อมูลเบื้องหลังแผนภูมินี้
[
  {
    "label": "Hosted open 8B API",
    "breakeven_tokens_millions": 1825,
    "required_duty_pct": 174
  },
  {
    "label": "Small commercial model",
    "breakeven_tokens_millions": 73,
    "required_duty_pct": 6.9
  },
  {
    "label": "Frontier model",
    "breakeven_tokens_millions": 24.3,
    "required_duty_pct": 2.3
  }
]

สำหรับระดับ frontier คุณจำเป็นต้องใช้ output tokens จำนวน 24.3 ล้าน tokens ต่อเดือน ซึ่งคิดเป็นเพียง 2.3% ของขีดความสามารถของกราฟิกการ์ดเท่านั้น นี่เป็นเกณฑ์ที่ต่ำมาก ทีมขนาดเล็กที่รัน coding agents ตลอดวันทำงานก็สามารถทำยอดถึงเกณฑ์นี้ได้

สำหรับระดับ small commercial คุณจำเป็นต้องใช้ tokens จำนวน 73 ล้าน tokens ต่อเดือน หรือคิดเป็น duty cycle ที่ 6.9% สำหรับระดับ hosted open-weight ค่า duty cycle ที่ต้องการคือ 174% โดยนิยามแล้ว ค่าใดก็ตามที่สูงกว่า 100% ถือเป็นไปไม่ได้ เพราะกราฟิกการ์ดจะต้องทำงานเกินจำนวนชั่วโมงที่มีในหนึ่งเดือน กราฟิกการ์ดระดับกลางหนึ่งใบที่อัตราค่าบริการรายชั่วโมงนี้ไม่สามารถชนะการเปรียบเทียบดังกล่าวได้ ดังนั้นวิธีเดียวที่จะเปลี่ยนผลลัพธ์นี้คือการใช้การ์ดที่ราคาถูกลง การ์ดที่เร็วขึ้น หรือเหตุผลอื่นที่ไม่ใช่เรื่องราคา

สิ่งที่สูตรคำนวณไม่ได้บอกไว้

สูตรคำนวณราคาจะคิดจากชั่วโมงการใช้งาน GPU และจำนวน token แต่ยังมีต้นทุนจริงอีกหลายอย่างที่อยู่นอกเหนือจากนั้น

Cold starts. โมเดลขนาด 8B ที่ความละเอียด 16-bit มีขนาดประมาณ 16 GB การโหลดข้อมูลจากดิสก์ภายในเข้าสู่ VRAM ต้องใช้เวลาหลายสิบวินาที หากคุณหยุดการทำงานของเครื่องระหว่างการใช้งานเพื่อประหยัดค่าเช่า คุณจะต้องเสียเวลารอโหลดใหม่ทุกครั้งที่มีการเรียกใช้งานครั้งแรก หากเปิดเครื่องทิ้งไว้เพื่อเลี่ยงเวลารอ อัตราการใช้งาน (duty cycle) ของคุณจะลดลง ซึ่งจะทำให้ต้นทุนต่อ token สูงขึ้น การแลกเปลี่ยนระหว่างสองทางเลือกนี้คือเหตุผลทั้งหมดที่ทำให้เกิดบริการ serverless inference

การจัดเก็บและการดาวน์โหลด. น้ำหนักของโมเดลมีขนาดใหญ่ โมเดล 8B ที่ 16-bit มีขนาดประมาณ 16 GB, โมเดล 30B ที่ทำ quantised เหลือ 4-bit มีขนาดประมาณ 18 GB และโมเดล 30B ที่ 16-bit ไม่สามารถรันบนการ์ดขนาด 24 GB ได้เลย ข้อจำกัดนี้จะชัดเจนขึ้นอย่างรวดเร็วในระดับบน ซึ่งการ รันโมเดลโอเพนซอร์สระดับล้านล้านพารามิเตอร์อย่าง Kimi K3 หมายความว่าแค่น้ำหนักของโมเดลเพียงอย่างเดียวก็เกินขีดความสามารถของการ์ดใบเดียวที่คุณเช่าเป็นรายชั่วโมงไปแล้ว คุณต้องจ่ายค่าดิสก์ทุกเดือน และเสียเวลาทุกครั้งที่ต้องสร้างสภาพแวดล้อมใหม่ ให้รัน du -sh ~/.cache/huggingface/hub หลังจากผ่านไปหนึ่งสัปดาห์ของการทดลอง คุณจะพบว่ามันโตเร็วกว่าที่คิด เพราะทุกการทำ quantisation ที่คุณเคยลองทำไว้ยังคงค้างอยู่ในนั้น

เวลาของคุณเอง. เวอร์ชันของไดรเวอร์และ CUDA, ข้อผิดพลาด out-of-memory ที่ความยาว context เท่าเดิมที่เคยรันได้เมื่อวาน, หรือการอัปเดตโมเดลที่เปลี่ยน chat template สิ่งเหล่านี้ไม่ปรากฏในตัวเลขต้นทุนต่อ token แต่ทั้งหมดนี้คือเวลาส่วนตัวของคุณที่ต้องเสียไป หากคุณยังไม่เคยประเมินขนาดของเครื่องเหล่านี้มาก่อน การอ่านเรื่อง สิ่งที่ GPU VPS มอบให้คุณจริงๆ เป็นสิ่งที่ควรทำก่อนตัดสินใจเช่ารายเดือน

ช่องว่างด้านคุณภาพ. นี่คือต้นทุนแฝงที่ใหญ่ที่สุดและประเมินราคาได้ยากที่สุด โมเดลโอเพนซอร์สขนาด 8B ไม่ใช่โมเดลระดับแนวหน้า หากมันต้องใช้ความพยายามสามครั้งในขณะที่โมเดลระดับแนวหน้าใช้เพียงครั้งเดียว ราคาที่แท้จริงต่อคำตอบที่ใช้งานได้จริงจะสูงเป็นสามเท่าของราคาในตาราง และมันอาจทำงานไม่สำเร็จเลยก็ได้ ให้เปรียบเทียบด้วย prompt ของคุณเองก่อนที่จะเปรียบเทียบด้วยราคา สำหรับภาระงานประเภท agent คำตอบทั่วไปคือการจัดเส้นทางตามความยาก และใช้ token ราคาถูกจากโมเดลในเครื่องสำหรับงานจำนวนมาก ซึ่งเป็นหัวใจสำคัญของ การควบคุมค่าใช้จ่ายของ agent บน VPS

ค่าใช้จ่ายที่คุณลืม. อินสแตนซ์ GPU แบบรายชั่วโมงที่คุณหยุดการทำงานไปแล้ว มักจะยังคงมีการเรียกเก็บค่าบริการสำหรับพื้นที่จัดเก็บข้อมูลที่ผูกไว้และ reserved IP address ของคุณ ให้ตรวจสอบจากใบแจ้งหนี้จริง ไม่ใช่จากหน้าแสดงราคา

เมื่อการโฮสต์ด้วยตนเองเหนือกว่าในแง่อื่นที่ไม่ใช่ราคา

สี่กรณีที่ตัวเลขค่าใช้จ่ายไม่ใช่ปัจจัยตัดสินใจ

  • ข้อมูลที่ไม่สามารถหลุดรอดจากการควบคุมของคุณได้ หากกฎระเบียบการปฏิบัติตามข้อกำหนดห้ามไม่ให้ส่งข้อความไปยังบุคคลที่สาม ราคาต่อ token จึงไม่ใช่ประเด็นที่ต้องนำมาพิจารณา
  • ปริมาณงานที่สม่ำเสมอตามตารางเวลา งานจำแนกข้อมูลแบบ batch ที่รันวันละหกชั่วโมงทุกคืนจะมีรอบการทำงานอยู่ที่ 25% โดยธรรมชาติ และจะไม่ทำให้คุณประหลาดใจกับใบแจ้งหนี้ที่เพิ่มขึ้น
  • ข้อจำกัดด้านอัตราการใช้งาน (Rate limits) การ์ดจอของคุณเองมีคิวการทำงานเพียงคิวเดียวและเป็นของคุณแต่เพียงผู้เดียว
  • โมเดลที่ไม่มี API ใดให้บริการ หากคุณต้องการการปรับแต่ง (fine-tune) เฉพาะทาง ก็ไม่มีบริการอื่นใดให้เปรียบเทียบได้

หากคุณต้องการทดสอบเวอร์ชันราคาประหยัดก่อน การรันโมเดลขนาดเล็กบน VPS ด้วย Ollama ใช้เวลาเพียงช่วงบ่าย และ การประเมินขนาดโมเดลแบบเปิดเทียบกับการ์ดจอที่คุณจะเช่า จะช่วยให้คุณทราบว่าต้องใช้ GPU รุ่นใดกันแน่ ให้วัดผลจากจุดนั้นก่อนที่คุณจะตัดสินใจเช่า GPU เป็นรายเดือน

FAQ

ปริมาณการใช้งานโทเค็นต่อเดือนเท่าใดที่ทำให้การเช่า GPU VPS คุ้มค่ากว่าการจ่ายผ่าน API?

ให้นำค่าเช่า GPU ต่อเดือนหารด้วยราคา API ต่อล้านโทเค็นขาออก หากการ์ดมีราคาเช่า 365 ดอลลาร์ต่อเดือน เมื่อเทียบกับ API ระดับแนวหน้าที่มีราคา 15.00 ดอลลาร์ต่อล้านโทเค็น จุดคุ้มทุนจะอยู่ที่ 24.3 ล้านโทเค็นขาออกต่อเดือน หากเทียบกับโมเดลเชิงพาณิชย์ขนาดเล็กที่ราคา 5.00 ดอลลาร์ จุดคุ้มทุนจะอยู่ที่ 73 ล้านโทเค็น และหากเทียบกับโมเดลแบบ open-weight ที่มีผู้ให้บริการโฮสต์ให้ในราคา 0.20 ดอลลาร์ การ์ดระดับกลางหนึ่งใบไม่สามารถสร้างโทเค็นได้มากพอในหนึ่งเดือนเพื่อให้ถึงจุดคุ้มทุน

เหตุใด API ของโมเดลแบบ open-weight ที่มีผู้ให้บริการโฮสต์ให้จึงมีราคาถูกกว่าการใช้ GPU ของตนเอง?

เพราะราคาของบริการเหล่านั้นถูกกำหนดให้ใกล้เคียงกับต้นทุนของ GPU ที่ทำงานเต็มประสิทธิภาพ ในขณะที่การ์ดของคุณไม่ได้ทำงานเต็มประสิทธิภาพตลอดเวลา ผู้ให้บริการที่รองรับคำขอพร้อมกันหลายพันรายการจะรักษาอัตราการใช้งานของกลุ่มเซิร์ฟเวอร์ให้ใกล้เคียงกับจุดอิ่มตัว จึงสามารถขายโทเค็นได้ในราคาใกล้เคียงกับต้นทุนส่วนเพิ่มในการผลิต แต่การ์ดของคุณมักจะว่างงานเป็นส่วนใหญ่ของวันและคุณต้องจ่ายค่าเช่าในช่วงเวลาที่ไม่ได้ใช้งานเหล่านั้น ที่อัตราการใช้งาน 10% ต้นทุนของคุณจะอยู่ที่ 3.47 ดอลลาร์ต่อล้านโทเค็นขาออก เมื่อเทียบกับราคา 0.20 ดอลลาร์ของผู้ให้บริการ

ฉันควรนับรวมโทเค็นขาเข้าด้วยหรือไม่?

ควรนับรวมหาก prompt ของคุณมีความยาว การเปรียบเทียบนี้ใช้เฉพาะโทเค็นขาออกซึ่งเป็นปัจจัยหลักสำหรับงานประเภทแชทและเอเจนต์ การเพิ่มโทเค็นขาเข้าจะส่งผลต่อทั้งสองฝั่ง ในฝั่ง API จะมีรายการเรียกเก็บเงินแยกต่างหากในราคาที่ต่ำกว่า ส่วนในการ์ดของคุณเอง ขั้นตอน prefill จะใช้เวลาของ GPU ดังนั้นต้นทุนจึงรวมอยู่ในอัตราโทเค็นต่อวินาทีที่คุณวัดไว้แล้ว ให้วัดผลด้วยความยาวของ prompt ที่คุณใช้งานจริงเพื่อให้ทั้งสองฝั่งเปรียบเทียบกันได้

ฉันจะวัดค่าโทเค็นต่อวินาทีที่สูตรต้องการได้อย่างไร?

ให้รันโมเดลในรูปแบบที่คุณจะใช้งานจริง จากนั้นอ่านอัตราการสร้างโทเค็นรวมภายใต้สภาวะการใช้งานจริง หากใช้ Ollama ตัว ollama run <model> --verbose จะแสดงค่า eval rate เป็นโทเค็นต่อวินาที แต่นั่นเป็นเพียงสตรีมเดียวและอาจต่ำกว่าความเป็นจริงสำหรับเซิร์ฟเวอร์ที่ประมวลผลแบบ batched หากใช้ vLLM เซิร์ฟเวอร์ที่กำลังทำงานจะบันทึกค่า Avg generation throughput ในขณะที่มีคำขอประมวลผลอยู่ ซึ่งนั่นคือตัวเลขที่ควรนำมาใช้ ให้ตรวจสอบ nvidia-smi ไปพร้อมกัน หากการใช้งาน GPU ไม่ใกล้เคียง 100% ในระหว่างการสร้าง แสดงว่าคุณยังไม่ถึงขีดจำกัดสูงสุด

การเช่า GPU VPS ยังคุ้มค่าหรือไม่หากมีอัตราการใช้งานต่ำกว่า 10%?

ขึ้นอยู่กับว่าคุณเลือกใช้ API ตัวใด หากอัตราการใช้งานอยู่ที่ 10% คุณจะมีต้นทุน 3.47 ดอลลาร์ต่อล้านโทเค็นขาออก ซึ่งต่ำกว่าทั้งระดับโมเดลเชิงพาณิชย์ขนาดเล็กและระดับแนวหน้า แต่สูงกว่าระดับโมเดลแบบ open-weight ที่มีผู้ให้บริการโฮสต์ให้มาก หากอัตราการใช้งานอยู่ที่ 2% ต้นทุนของคุณจะอยู่ที่ 17.36 ดอลลาร์ ซึ่งสูงกว่า API ทุกตัวในการเปรียบเทียบนี้รวมถึงระดับแนวหน้าด้วย หากพิจารณาจากราคาเพียงอย่างเดียว การ์ดจะหมดความคุ้มค่าที่อัตราการใช้งานประมาณ 6.9% เมื่อเทียบกับระดับเชิงพาณิชย์ขนาดเล็ก และประมาณ 2.3% เมื่อเทียบกับระดับแนวหน้า และจะไม่คุ้มค่าเลยเมื่อเทียบกับโมเดลแบบ open-weight ที่มีผู้ให้บริการโฮสต์ให้ การเช่าในอัตราที่ต่ำกว่าเกณฑ์เหล่านี้ควรทำก็ต่อเมื่อคุณจ่ายเพื่อความเป็นส่วนตัวหรือเพื่อเข้าถึงโมเดลที่ไม่มี API ใดให้บริการเท่านั้น

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