SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-24

GPU VPS vs API tokens: బ్రేక్-ఈవెన్ పాయింట్ ఎలా

GPU VPS అద్దె మరియు API టోకెన్ బిల్లింగ్ మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోండి. నెలకు ఎన్ని మిలియన్ల టోకెన్లు దాటితే GPU అద్దె లాభదాయకంగా మారుతుందో ఖచ్చితమైన ఫార్ములాతో ఇక్కడ చూడండి.

బ్రేక్-ఈవెన్ పాయింట్ ఎక్కడ ఉంటుంది

ఒక GPU VPS, పర్-టోకెన్ API బిల్లింగ్ కంటే ఒక విషయంలో మెరుగ్గా ఉంటుంది: నెలవారీ స్థిర అద్దెను, మీరు ఆ నెలలో ఉత్పత్తి చేసిన టోకెన్లతో భాగించినప్పుడు, అదే టోకెన్లకు API వసూలు చేసే ధర కంటే తక్కువగా ఉన్నప్పుడు. అద్దె మారదు, కానీ ప్రతి అభ్యర్థనతో API బిల్లు మారుతూ ఉంటుంది. కాబట్టి దీనికి సమాధానం ఎప్పుడూ నెలవారీ వినియోగంపై ఆధారపడి ఉంటుంది, అవును లేదా కాదు అని చెప్పలేము.

గంటకు $0.50 ధర కలిగిన మిడ్-రేంజ్ GPU VPSను పరిగణనలోకి తీసుకుంటే, 730 గంటల నెలకు అది $365 అవుతుంది. ఒక ఫ్రాంటియర్ మోడల్ APIతో పోలిస్తే, మీరు నెలకు 24.3 మిలియన్ అవుట్‌పుట్ టోకెన్ల వద్ద బ్రేక్-ఈవెన్ సాధిస్తారు. ఒక చిన్న కమర్షియల్ మోడల్‌తో పోలిస్తే ఇది 73 మిలియన్లు. అదే పరిమాణంలో ఉన్న హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్‌తో పోలిస్తే, మీరు ఎప్పటికీ బ్రేక్-ఈవెన్ సాధించలేరు, ఎందుకంటే ఒక కార్డ్ ఒక నెలలో ఆ స్థాయికి చేరుకోవడానికి అవసరమైన టోకెన్లను ఉత్పత్తి చేయలేదు.

ప్రచురించబడిన బ్రేక్-ఈవెన్ అధ్యయనాలు ఈ ప్రశ్నకు సమాధానం ఇవ్వవు. జూలై 2026 నాటి ఒక వెండర్ విశ్లేషణ, గంటకు $2.00 ధర కలిగిన డెడికేటెడ్ H100 కార్డ్, సర్వర్‌లెస్ ఇన్ఫరెన్స్‌తో పోలిస్తే 50% వినియోగం వద్ద క్రాస్‌ఓవర్ పాయింట్‌ను చేరుకుంటుందని పేర్కొంది. ఇటువంటి అధ్యయనాలు డెడికేటెడ్ డేటా-సెంటర్ కార్డును సర్వర్‌లెస్ ప్రొడక్ట్‌తో పోలుస్తాయి మరియు అవి యాక్సిలరేటర్లకు ఇక్కడ ఉపయోగించిన గంట ధర కంటే చాలా ఎక్కువ ధరను నిర్ణయిస్తాయి. గణితం మాత్రం ఒకటే. కింద ఉన్న విశ్లేషణ ఒక కార్డ్, 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

నాలుగు ఇన్‌పుట్‌లు ఉన్నాయి, మీరు ఈ నాలుగింటిని కొలవవచ్చు లేదా వెతికి తెలుసుకోవచ్చు.

  • hourly_rate అనేది GPU VPS గంటకు అయ్యే ఖర్చు, ఇది ఖాళీగా ఉన్న గంటలను కూడా పరిగణనలోకి తీసుకుంటుంది. మీరు నెలవారీ చెల్లిస్తుంటే, నెలవారీ ధరను 730తో భాగించండి.
  • tokens_per_second అనేది మీ వాస్తవ కాన్‌కరెన్సీ (concurrency) కింద మీ సర్వర్ నిర్వహించే మొత్తం అవుట్‌పుట్ రేటు. ఇది వెండర్ చార్ట్‌లోని సింగిల్-స్ట్రీమ్ సంఖ్య కాదు.
  • duty_cycle అనేది నెలలో GPU టోకెన్‌లను జనరేట్ చేయడానికి వెచ్చించే సమయం యొక్క భిన్నం. మీరు నెలంతా అద్దెకు తీసుకుని, రోజుకు రెండు గంటలు ఉపయోగించే బాక్స్ 8.3% వద్ద ఉంటుంది.
  • api_price_per_million అనేది మీరు పోల్చుకుంటున్న అవుట్‌పుట్ టోకెన్‌ల యొక్క మీటర్ ధర.

ఈ ఉదాహరణ ధరలు రెండు వైపులా అవుట్‌పుట్ టోకెన్‌లను లెక్కిస్తాయి, ఎందుకంటే చాట్ మరియు ఏజెంట్ పనిలో అవుట్‌పుట్ బిల్లును ప్రభావితం చేస్తుంది. మీ ప్రాంప్ట్‌లు పొడవుగా ఉంటే, రెండు వైపులా ఇన్‌పుట్‌ను జోడించండి. API వైపు, అది ఇన్‌వాయిస్‌లో ప్రత్యేక లైన్‌గా ఉంటుంది. మీ స్వంత కార్డ్‌పై, ప్రీఫిల్ (prefill) GPU సమయాన్ని వినియోగిస్తుంది, కాబట్టి ఇది ఇప్పటికే తక్కువ కొలవబడిన tokens_per_second గా కనిపిస్తుంది.

గణనను నమ్మే ముందు tokens per second ను ఎలా కొలవాలి

పైన పేర్కొన్నవన్నీ ఒక కొలమానంపై ఆధారపడి ఉంటాయి. ఆ సంఖ్యలో మూడు రెట్లు తేడా వస్తే, మీ సమాధానంలో కూడా మూడు రెట్లు తేడా వస్తుంది. మీరు అద్దెకు తీసుకున్న కార్డ్‌పై, మీరు నిజంగా రన్ చేయబోయే మోడల్ మరియు క్వాంటిజేషన్‌తోనే దీన్ని కొలవండి.

Ollama ఒకే కమాండ్‌తో single-stream గణాంకాలను ఇస్తుంది:

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

--verbose సమాధానం తర్వాత ఒక టైమింగ్ బ్లాక్‌ను ప్రింట్ చేస్తుంది. ఇందులో ముఖ్యమైన లైన్ eval rate, ఇది tokens per second లో ఉంటుంది మరియు కేవలం జనరేషన్‌ను మాత్రమే లెక్కిస్తుంది. prompt eval rate అనేది prefill వేగం, ఇది సాధారణంగా చాలా ఎక్కువగా ఉంటుంది. మీ సంఖ్యలు వీటి కంటే భిన్నంగా ఉండవచ్చు:

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

ఖర్చును అంచనా వేయడానికి single stream సరైన సంఖ్య కాదు, ఎందుకంటే ఇది ఒకేసారి అనేక అభ్యర్థనలను స్వీకరించగల కార్డ్‌పై ఒకే అభ్యర్థనను మాత్రమే కొలుస్తుంది. మొత్తం సామర్థ్యాన్ని (aggregate figure) తెలుసుకోవడానికి, 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, అంటే vLLM VRAM లో ఉంచే per-request attention state) నిండే వరకు మీరు అభ్యర్థనలను పెంచుతున్న కొద్దీ ఈ సంఖ్య పెరుగుతుంది, ఆ తర్వాత పెరగడం ఆగిపోతుంది. దానిని దాటి అభ్యర్థనలను పంపితే, వేగం పెరగడానికి బదులుగా అభ్యర్థనలు క్యూలో నిలుస్తాయి, ఇది Waiting కౌంట్ పెరగడం ద్వారా మీకు కనిపిస్తుంది. vLLM లో vllm bench serve అనే లోడ్ జనరేటర్ కూడా ఉంటుంది. దీని ఫ్లాగ్స్ వెర్షన్లను బట్టి మారుతుంటాయి, కాబట్టి ఏదైనా బ్లాగ్ పోస్ట్ నుండి కమాండ్‌ను కాపీ చేసే బదులు, మీరు ఇన్‌స్టాల్ చేసిన వెర్షన్‌పై vllm bench serve --help ను రన్ చేయండి.

టెస్ట్ రన్ అవుతున్నప్పుడు కార్డ్‌ను గమనించండి:

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

జనరేషన్ సమయంలో utilization.gpu 100% దగ్గర ఉంటే, మీరు throughput-bound లో ఉన్నారని మరియు మీరు కొలిచిన సంఖ్యే గరిష్ట పరిమితి అని అర్థం. అది తక్కువగా ఉంటే, వేరే ఏదో పరిమితిగా ఉంది: తక్కువ సంఖ్యలో అభ్యర్థనలు ఉండటం, నెమ్మదిగా ఉన్న క్లయింట్, లేదా VRAM లో సరిపోక కొంత భాగం system RAM కి offload అవుతున్న మోడల్ కావచ్చు. Ollama మరియు vLLM ఇక్కడ చాలా భిన్నమైన పద్ధతులను అనుసరిస్తాయి, ఒకే కార్డ్‌పై వీటి మధ్య ఉన్న వ్యత్యాసం మీ break-even పాయింట్‌ను గణనీయంగా మార్చేంత ఎక్కువగా ఉంటుంది.

ఒక నెలలో బిల్లు ఎలా ఉంటుందో పరిశీలన

ఈ ఉదాహరణలో 24 GB GPU VPS గంటకు $0.50 ధరతో ఉంది. vLLM ద్వారా అందించబడే 8B ఓపెన్ మోడల్, 16 ఏకకాల అభ్యర్థనలతో సెకనుకు 400 అవుట్‌పుట్ టోకెన్ల సామర్థ్యాన్ని కలిగి ఉంది. మీరు కార్డును ఉపయోగించినా, ఉపయోగించకపోయినా అద్దె స్థిరంగా ఉంటుంది. ఆ రేటు వద్ద నెలకు 1,051 మిలియన్ అవుట్‌పుట్ టోకెన్ల సామర్థ్యం ఉంటుంది, ఇది కార్డు నిరంతరం పనిచేస్తే ఉత్పత్తి చేసే పరిమాణం.

చార్ట్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 మిలియన్ అవుట్‌పుట్ టోకెన్ల వద్ద, ఫ్రాంటియర్ API బిల్లు 375 డాలర్లుగా ఉంటుంది, కాబట్టి రెండు వైపులా ధర పది డాలర్ల వ్యత్యాసంలోనే ఉంటుంది. 50 మిలియన్ల వద్ద, చిన్న కమర్షియల్ మోడల్ బిల్లు 250 డాలర్లుగా ఉండి, ఇప్పటికీ చౌకైన ఎంపికగా ఉంటుంది. 1000 మిలియన్ అవుట్‌పుట్ టోకెన్ల వద్ద, అంటే కార్డు నెలకు 95% సమయం బిజీగా ఉన్నప్పుడు, హోస్ట్ చేసిన ఓపెన్-వెయిట్ API బిల్లు అదే అద్దెతో పోలిస్తే 200 డాలర్లుగా ఉంటుంది. కార్డు అత్యంత కష్టపడి పనిచేసే పరిమాణం వద్ద కూడా, ఇది దాదాపు రెండు రెట్లు ఎక్కువ ఖర్చుతో నష్టపోతుంది.

ఆ చివరి ఫలితం ప్రజలను ఆశ్చర్యపరుస్తుంది, కానీ ఇది ప్రమాదవశాత్తు జరిగినది కాదు. హోస్ట్ చేసిన ఓపెన్-వెయిట్ ఎండ్‌పాయింట్ అనేది అధిక వినియోగంతో నడిచే GPU ఫ్లీట్, కాబట్టి దాని ధర పూర్తిగా వినియోగించబడిన కార్డు ఖర్చుకు దగ్గరగా ఉంటుంది. ఒక కార్డును అద్దెకు తీసుకుని, దానిని పూర్తి సామర్థ్యం కంటే తక్కువగా నడపడం ద్వారా, మీరు పూర్తి స్థాయిలో పనిచేసే ఫ్లీట్‌ను అధిగమించలేరు. మీరు అధిగమించగలిగేది ఫ్రాంటియర్ ధరలను మాత్రమే, ఎందుకంటే అవి సిలికాన్ సమయం ఆధారంగా కాకుండా సామర్థ్యం ఆధారంగా నిర్ణయించబడతాయి.

ప్రతి డ్యూటీ సైకిల్ వద్ద మిలియన్ అవుట్‌పుట్ టోకెన్లకు అయ్యే ఖర్చు

వాల్యూమ్ మరియు డ్యూటీ సైకిల్ అనేవి ఒకే విషయాన్ని రెండు కోణాల్లో చూపే అంశాలు. అద్దెకు తీసుకుంటే గంటల కొద్దీ సమయం లభిస్తుంది. ఖాళీగా ఉన్న గంటలు ఏ ఉత్పత్తిని ఇవ్వవు, కానీ ఖర్చు మాత్రం అవుతుంది.

చార్ట్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 నాటికి ప్రచురించబడిన సాధారణ జాబితా ధరలు: హోస్ట్ చేసిన 8B ఓపెన్-వెయిట్ మోడల్ కోసం మిలియన్ అవుట్‌పుట్ టోకెన్లకు 0.20 డాలర్లు, చిన్న కమర్షియల్ మోడల్ కోసం 5.00 డాలర్లు, మరియు ఫ్రాంటియర్ మోడల్ కోసం 15.00 డాలర్లు. ఇవి కేవలం ఉదాహరణలు మాత్రమే. మీరు ఏదైనా నిర్ణయం తీసుకునే ముందు నేటి ధరల పేజీని తనిఖీ చేయండి. ఒకవేళ మీరు మీ పోలికను మీటర్డ్ టోకెన్లకు బదులుగా ఫ్లాట్ మంత్లీ ప్లాన్‌తో చేస్తున్నట్లయితే, సబ్‌స్క్రిప్షన్ గణన భిన్నంగా ఉంటుంది మరియు బ్రేక్-ఈవెన్ పాయింట్ మారుతుంది.

కార్డ్‌ను పూర్తి సామర్థ్యంతో రన్ చేస్తే, మిలియన్ అవుట్‌పుట్ టోకెన్ల ఖర్చు 0.35 డాలర్లు అవుతుంది, ఇది నిజంగా చౌకైనది. 10% డ్యూటీ సైకిల్ వద్ద అదే మిలియన్ టోకెన్ల ఖర్చు 3.47 డాలర్లు. 2% డ్యూటీ సైకిల్ వద్ద దీని ఖర్చు 17.36 డాలర్లు, ఇది హోస్ట్ చేసిన ఓపెన్ మోడల్ వసూలు చేసే 0.20 డాలర్లతో పోలిస్తే చాలా ఎక్కువ.

హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్‌తో పోలిస్తే, ఈ చార్ట్‌లోని ప్రతి డ్యూటీ సైకిల్ వద్ద GPUని అద్దెకు తీసుకోవడం ఖరీదైన ఎంపిక. 10% వద్ద, మీరు 0.20 డాలర్లకు లభించే అవుట్‌పుట్ కోసం 3.47 డాలర్లు చెల్లిస్తున్నారు. ఈ వ్యత్యాసానికి మీరు పొందుతున్నది గోప్యత (privacy) మరియు మారనటువంటి బిల్లు. ఇవి నిజమైన విలువను కలిగి ఉండవచ్చు, కానీ వీటిని ధర పరమైన లాభంగా పరిగణించకూడదు. కమర్షియల్ టైర్లతో పోలిస్తే పరిస్థితి మారుతుంది: 10% డ్యూటీ సైకిల్ వద్ద ఈ కార్డ్ చిన్న కమర్షియల్ మరియు ఫ్రాంటియర్ ధరల కంటే తక్కువకే లభిస్తుంది. డ్యూటీ సైకిల్ సుమారు 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 టైర్‌తో పోలిస్తే, మీకు నెలకు 24.3 మిలియన్ల అవుట్‌పుట్ టోకెన్లు అవసరం. ఇది ఆ కార్డ్ సామర్థ్యంలో కేవలం 2.3% మాత్రమే. ఇది చాలా తక్కువ పరిమితి. పని దినాల్లో కోడింగ్ ఏజెంట్లను నడిపే ఒక చిన్న బృందం దీనిని సులభంగా చేరుకోగలదు.

small commercial టైర్‌తో పోలిస్తే, మీకు నెలకు 73 మిలియన్ల టోకెన్లు లేదా 6.9% డ్యూటీ సైకిల్ అవసరం. hosted open-weight టైర్ కోసం అవసరమైన డ్యూటీ సైకిల్ 174%. 100% కంటే ఎక్కువ ఏదీ సాధ్యం కాదు: ఎందుకంటే ఒక నెలలో ఉన్న గంటల కంటే ఎక్కువ సమయం కార్డ్ పనిచేయడం అసాధ్యం. ఈ గంటల ధర వద్ద ఒక మిడ్-రేంజ్ కార్డ్ ఈ పోలికలో గెలవలేదు. కాబట్టి ఫలితాన్ని మార్చడానికి తక్కువ ధర ఉన్న కార్డ్, వేగవంతమైన కార్డ్ లేదా ధర కాకుండా ఇతర కారణాలు మాత్రమే మార్గాలు.

ఫార్ములాలో దాగి ఉన్న అంశాలు

ఈ ఫార్ములా GPU గంటలను మరియు టోకెన్లను మాత్రమే లెక్కిస్తుంది. అయితే, అనేక వాస్తవ ఖర్చులు దీని పరిధిలోకి రావు.

కోల్డ్ స్టార్ట్స్ (Cold starts). 16-bit వెయిట్స్‌తో ఉన్న 8B మోడల్ సుమారు 16 GB ఉంటుంది. దీన్ని లోకల్ డిస్క్ నుండి VRAMలోకి లోడ్ చేయడానికి పదుల సెకన్ల సమయం పడుతుంది. అద్దె ఆదా చేయడానికి ప్రతి వినియోగం తర్వాత సర్వర్‌ను ఆపివేస్తే, ప్రతి మొదటి అభ్యర్థన కోసం మీరు ఆ నిరీక్షణ సమయాన్ని భరించాల్సి ఉంటుంది. ఆ నిరీక్షణను తప్పించుకోవడానికి సర్వర్‌ను రన్ చేస్తూ ఉంచితే, మీ డ్యూటీ సైకిల్ తగ్గి, ప్రతి టోకెన్‌కు అయ్యే ఖర్చు పెరుగుతుంది. సర్వర్‌లెస్ ఇన్ఫరెన్స్ (serverless inference) ఉనికికి ఈ సమతుల్యతే ప్రధాన కారణం.

స్టోరేజ్ మరియు డౌన్‌లోడ్. వెయిట్స్ చాలా పెద్దవిగా ఉంటాయి. 16-bit వద్ద 8B మోడల్ సుమారు 16 GB, 4-bit క్వాంటైజ్డ్ 30B మోడల్ సుమారు 18 GB ఉంటుంది. 16-bit వద్ద ఉన్న 30B మోడల్ 24 GB కార్డుపై అస్సలు పట్టదు. హై-ఎండ్ మోడల్స్ విషయంలో ఈ పరిమితి త్వరగా ఎదురవుతుంది. ఉదాహరణకు, Kimi K3 వంటి ట్రిలియన్-పారామీటర్ ఓపెన్ మోడల్‌ను రన్ చేయడం అంటే, మీరు గంటల ప్రాతిపదికన అద్దెకు తీసుకునే ఏ ఒక్క కార్డు సామర్థ్యం కంటే వెయిట్స్ పరిమాణం ఎక్కువగా ఉంటుంది. మీరు ప్రతి నెలా ఆ డిస్క్ కోసం చెల్లించాలి, అలాగే ప్రతి రీబిల్డ్ సమయంలో సమయాన్ని వెచ్చించాలి. ఒక వారం ప్రయోగాల తర్వాత du -sh ~/.cache/huggingface/hub రన్ చేయండి. మీరు ప్రయత్నించిన ప్రతి క్వాంటైజేషన్ ఫైల్ అక్కడే నిల్వ ఉండటం వల్ల, మీరు ఊహించిన దానికంటే వేగంగా స్టోరేజ్ నిండిపోతుంది.

మీ సమయం. డ్రైవర్ మరియు CUDA వెర్షన్లు, నిన్న పనిచేసిన కాంటెక్స్ట్ లెంగ్త్ వద్ద నేడు వచ్చే అవుట్-ఆఫ్-మెమరీ ఎర్రర్స్, చాట్ టెంప్లేట్‌ను మార్చే మోడల్ అప్‌డేట్ వంటివి. వీటిలో ఏవీ 'కాస్ట్-పర్-టోకెన్' లెక్కల్లో కనిపించవు, కానీ ఇవన్నీ మీ వ్యక్తిగత సమయాన్ని హరిస్తాయి. మీరు ఇంతకుముందు ఇలాంటి బాక్సులను సైజ్ చేయకపోతే, GPU VPS మీకు నిజంగా ఏమి ఇస్తుంది అనే దానిపై ఒక నెల అద్దెకు కట్టుబడే ముందు చదవడం మంచిది.

నాణ్యతలో వ్యత్యాసం. ఇది అతిపెద్ద దాగి ఉన్న ఖర్చు మరియు దీనికి ధర నిర్ణయించడం కష్టం. ఒక 8B ఓపెన్ మోడల్ అనేది ఫ్రాంటియర్ మోడల్ కాదు. ఒక ఫ్రాంటియర్ మోడల్ ఒక ప్రయత్నంలో చేసే పనికి, ఇది మూడు ప్రయత్నాలు చేయాల్సి వస్తే, ఆ పనికి అయ్యే అసలు ఖర్చు చార్టులో ఉన్న దానికంటే మూడు రెట్లు ఎక్కువ. అంతేకాకుండా, అది పనిని పూర్తి చేయడంలో విఫలం కూడా కావచ్చు. ధరను బట్టి నిర్ణయించుకునే ముందు మీ సొంత ప్రాంప్ట్‌లతో పోల్చి చూడండి. ఏజెంట్ వర్క్‌లోడ్స్ కోసం, కష్టాన్ని బట్టి రూటింగ్ చేయడం మరియు బల్క్ వర్క్ కోసం చౌకైన లోకల్ టోకెన్లను ఉపయోగించడం ఉత్తమం. VPSలో ఏజెంట్ ఖర్చును నియంత్రించడం అనే అంశం ప్రధానంగా దీనిపైనే ఆధారపడి ఉంటుంది.

మీరు మర్చిపోయిన బిల్లింగ్. మీరు ఆపివేసిన గంటల ప్రాతిపదికన పనిచేసే GPU ఇన్‌స్టాన్స్, దానికి అనుసంధానించబడిన స్టోరేజ్ మరియు రిజర్వ్డ్ IP అడ్రస్ కోసం బిల్లును వసూలు చేస్తూనే ఉండవచ్చు. ధరల పేజీని మాత్రమే కాకుండా, ఇన్‌వాయిస్‌ను కూడా జాగ్రత్తగా పరిశీలించండి.

ధర కంటే ఇతర అంశాలు ముఖ్యమైనప్పుడు self-hosting ఎంచుకోవడం

ఖర్చు మాత్రమే నిర్ణయాత్మక అంశం కాని నాలుగు సందర్భాలు ఇక్కడ ఉన్నాయి.

  • మీ నియంత్రణ దాటి వెళ్లకూడని డేటా. ఏదైనా compliance నిబంధన థర్డ్ పార్టీకి సమాచారాన్ని పంపకూడదని నిషేధిస్తే, అక్కడ token ధరతో పని ఉండదు.
  • షెడ్యూల్ ప్రకారం స్థిరంగా ఉండే అధిక పనిభారం. ప్రతి రాత్రి ఆరు గంటల పాటు నడిచే batch classification job, డిజైన్ ప్రకారం 25% duty cycle వద్ద ఉంటుంది. దీనివల్ల బిల్లు విషయంలో ఎటువంటి ఆశ్చర్యకరమైన మార్పులు ఉండవు.
  • Rate limits. మీ సొంత కార్డుకు ఒకే క్యూ ఉంటుంది మరియు అది పూర్తిగా మీ నియంత్రణలో ఉంటుంది.
  • ఏ API లోనూ అందుబాటులో లేని మోడల్. మీకు ప్రత్యేకమైన fine-tune అవసరమైతే, పోల్చడానికి వేరే ప్రత్యామ్నాయం ఉండదు.

మీరు ముందుగా తక్కువ ఖర్చుతో కూడిన వెర్షన్‌ను పరీక్షించాలనుకుంటే, Ollama తో VPS పై చిన్న మోడల్‌ను రన్ చేయడం ఒక మధ్యాహ్నం సమయంతో పూర్తవుతుంది. అలాగే మీరు అద్దెకు తీసుకునే కార్డుకు తగినట్లుగా open model ను సిద్ధం చేయడం ద్వారా మీకు ఏ GPU అవసరమో తెలుస్తుంది. నెల రోజుల పాటు GPU అద్దెకు తీసుకునే ఒప్పందం కుదుర్చుకునే ముందు ఈ పరీక్షలు నిర్వహించండి.

FAQ

ఏ నెలవారీ టోకెన్ పరిమాణం వద్ద GPU VPS, API ధరల కంటే తక్కువ ఖర్చుతో కూడుకున్నది?

GPU యొక్క నెలవారీ అద్దె ధరను, మిలియన్ అవుట్‌పుట్ టోకెన్లకు అయ్యే API ధరతో భాగించండి. నెలకు $365 అద్దె ఉన్న కార్డ్, 15.00 డాలర్ల ధర గల ఫ్రాంటియర్ API తో పోలిస్తే, నెలకు 24.3 మిలియన్ అవుట్‌పుట్ టోకెన్ల వద్ద లాభనష్టాలు లేని స్థితికి (break even) చేరుకుంటుంది. 5.00 డాలర్ల ధర గల చిన్న కమర్షియల్ మోడల్‌తో పోలిస్తే ఇది 73 మిలియన్లు. హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్ ధర 0.20 డాలర్లు అయితే, ఒక మిడ్-రేంజ్ కార్డ్ నెలకు సరిపడా టోకెన్లను ఉత్పత్తి చేయలేదు, కాబట్టి అక్కడ లాభం ఉండదు.

హోస్ట్ చేసిన ఓపెన్-వెయిట్ API ధర నా స్వంత GPU కంటే ఎందుకు తక్కువగా ఉంటుంది?

ఎందుకంటే దాని ధర పూర్తిగా వినియోగంలో ఉన్న GPU ఖర్చుకు దగ్గరగా నిర్ణయించబడుతుంది, కానీ మీ కార్డ్ పూర్తిగా వినియోగంలో ఉండదు. వేలకొద్దీ అభ్యర్థనలను స్వీకరించే ప్రొవైడర్ తన సర్వర్లను నిరంతరం పూర్తి సామర్థ్యంతో ఉంచుతాడు, కాబట్టి వారు టోకెన్లను ఉత్పత్తి చేసే నామమాత్రపు ఖర్చుకే విక్రయించగలరు. మీ కార్డ్ రోజులో ఎక్కువ సమయం ఖాళీగా ఉంటుంది, ఆ ఖాళీ సమయానికి కూడా మీరు చెల్లిస్తారు. 10% వినియోగం (duty cycle) వద్ద, మీ ఖర్చు మిలియన్ అవుట్‌పుట్ టోకెన్లకు 3.47 డాలర్లు, అదే వారి ధర 0.20 డాలర్లు.

నేను అవుట్‌పుట్ టోకెన్లతో పాటు ఇన్‌పుట్ టోకెన్లను కూడా లెక్కించాలా?

మీ ప్రాంప్ట్‌లు పెద్దవిగా ఉంటే వాటిని లెక్కించండి. ఇక్కడ చేసిన పోలిక కేవలం అవుట్‌పుట్ టోకెన్ల ఆధారంగా మాత్రమే ఉంది, ఎందుకంటే చాట్ మరియు ఏజెంట్ పనులకు అవే ప్రధానమైనవి. ఇన్‌పుట్ టోకెన్లను చేర్చడం వల్ల రెండు వైపులా లెక్కలు మారుతాయి. API వైపు, ఇన్‌పుట్ టోకెన్లు బిల్లులో విడిగా, తక్కువ ధరతో ఉంటాయి. మీ స్వంత కార్డ్ విషయంలో, ప్రీఫిల్ (prefill) GPU సమయాన్ని తీసుకుంటుంది, కాబట్టి ఆ ఖర్చు మీరు కొలిచిన టోకెన్లు పర్ సెకండ్ (tokens per second) లోనే కలిసి ఉంటుంది. మీ అసలైన ప్రాంప్ట్ పొడవులతో కొలవండి, అప్పుడు రెండు వైపులా పోల్చడానికి వీలుగా ఉంటుంది.

ఫార్ములాకు అవసరమైన టోకెన్లు పర్ సెకండ్ (tokens per second) ను ఎలా కొలవాలి?

మోడల్‌ను మీరు ఎలా ఉపయోగిస్తారో అలాగే సర్వ్ చేయండి, ఆపై వాస్తవ వినియోగం (concurrency) వద్ద మొత్తం జనరేషన్ రేటును చూడండి. Ollama తో, ollama run <model> --verbose కమాండ్ eval rate ను టోకెన్లు పర్ సెకండ్ లో చూపిస్తుంది, కానీ అది ఒకే స్ట్రీమ్ మాత్రమే, కాబట్టి అది బ్యాచ్డ్ సర్వర్ సామర్థ్యాన్ని తక్కువగా చూపుతుంది. vLLM తో, రన్ అవుతున్న సర్వర్ లాగ్స్ Avg generation throughput ను చూపిస్తాయి, అభ్యర్థనలు జరుగుతున్నప్పుడు ఆ విలువనే పరిగణనలోకి తీసుకోవాలి. అదే సమయంలో nvidia-smi ను గమనించండి. జనరేషన్ సమయంలో GPU వినియోగం 100% కి దగ్గరగా లేకపోతే, మీరు ఇంకా గరిష్ట సామర్థ్యాన్ని చేరుకోలేదని అర్థం.

10% కంటే తక్కువ వినియోగం (utilisation) ఉన్నప్పుడు GPU VPS అద్దెకు తీసుకోవడం లాభదాయకమా?

ఇది మీరు ఏ API కి చెల్లిస్తున్నారనే దానిపై ఆధారపడి ఉంటుంది. 10% వినియోగం వద్ద మీరు మిలియన్ అవుట్‌పుట్ టోకెన్లకు 3.47 డాలర్లు చెల్లిస్తారు, ఇది చిన్న కమర్షియల్ మరియు ఫ్రాంటియర్ టైర్ల కంటే తక్కువ, కానీ హోస్ట్ చేసిన ఓపెన్-వెయిట్ టైర్ కంటే చాలా ఎక్కువ. 2% వినియోగం వద్ద మీరు 17.36 డాలర్లు చెల్లిస్తారు, ఇది ఈ పోలికలోని అన్ని మీటర్డ్ API ల కంటే ఎక్కువ. కేవలం ధరను మాత్రమే చూస్తే, చిన్న కమర్షియల్ టైర్‌తో పోలిస్తే 6.9% వినియోగం వద్ద, మరియు ఫ్రాంటియర్ టైర్‌తో పోలిస్తే 2.3% వినియోగం వద్ద కార్డ్ వాడకం లాభదాయకం కాదు. హోస్ట్ చేసిన ఓపెన్-వెయిట్ మోడల్స్‌తో పోలిస్తే ఇది ఎప్పటికీ లాభదాయకం కాదు. గోప్యత (privacy) లేదా ఏ API లోనూ లభించని ప్రత్యేక మోడల్ అవసరమైనప్పుడు మాత్రమే ఈ పరిమితుల కంటే తక్కువ వినియోగం వద్ద అద్దెకు తీసుకోండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?