เปรียบเทียบ GPU VPS กับ API Token จุดคุ้มทุนอยู่ที่ไหน

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

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

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

ผลการศึกษาเรื่องจุดคุ้มทุนที่เผยแพร่อยู่ทั่วไปไม่ได้ตอบคำถามนี้โดยตรง มีการศึกษา 2 ฉบับจากช่วงต้นปี 2026 ระบุว่าจุดตัดอยู่ที่การใช้งานต่อเนื่องประมาณ 72% บน H200 และอยู่ที่ duty cycle ระหว่าง 22% ถึง 48% บน MI300X ทั้งสองฉบับเปรียบเทียบกับผลิตภัณฑ์แบบ 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 ต่อเดือน ซึ่งเป็นปริมาณที่การ์ดจะผลิตได้หากทำงานตลอดเวลาโดยไม่หยุดพัก

[
  {
    "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)

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

[
  {
    "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 ดอลลาร์ ซึ่งถือว่าถูกมาก ที่รอบการทำงาน 10% ต้นทุนต่อล้าน tokens เดียวกันจะอยู่ที่ 3.47 ดอลลาร์ และที่รอบการทำงาน 2% ต้นทุนจะอยู่ที่ 17.36 ดอลลาร์ ซึ่งไม่ได้อยู่ในระดับเดียวกับราคา 0.20 ดอลลาร์ที่โมเดลแบบโฮสต์ทั่วไปเรียกเก็บสำหรับผลลัพธ์ที่เท่ากัน

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

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

[
  {
    "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 ที่ให้บริการผ่าน API ในราคา 0.20 ดอลลาร์ การ์ดระดับกลางหนึ่งใบไม่สามารถสร้างโทเค็นได้มากพอที่จะถึงจุดคุ้มทุนในหนึ่งเดือน

ทำไม API ของโมเดล open-weight ถึงมีราคาถูกกว่าการใช้ GPU ของตัวเอง?

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

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

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

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

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

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

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