SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-24

GPU VPS vs API tokens: லாபகரமான பயன்பாட்டு அளவு எது?

GPU VPS வாடகை மற்றும் API per-token கட்டணங்களுக்கு இடையிலான break-even புள்ளியைக் கணக்கிடுவது எப்படி? உங்கள் பயன்பாட்டு அளவை வைத்து எப்போது லாபம் கிடைக்கும் என்பதை அறியுங்கள்.

Break-even புள்ளி உண்மையில் எங்கே அமைகிறது

GPU VPS, per-token API கட்டணத்தை விட ஒரு குறிப்பிட்ட புள்ளியில் சிறந்தது: மாதந்திர வாடகைத் தொகையை, நீங்கள் அந்த மாதம் உருவாக்கும் output tokens எண்ணிக்கையால் வகுக்கும்போது, அது API வசூலிக்கும் கட்டணத்தை விடக் குறைவாக இருந்தால் மட்டுமே இது லாபகரமாக இருக்கும். வாடகை மாறாது. API கட்டணம் ஒவ்வொரு கோரிக்கையின் போதும் மாறும். எனவே, இதற்கான விடை எப்போதும் ஒரு மாத அளவீடாகவே இருக்கும், ஆம் அல்லது இல்லை என்று சொல்ல முடியாது.

ஒரு மணி நேரத்திற்கு $0.50 கட்டணம் கொண்ட mid-range GPU VPS-ஐ எடுத்துக்கொள்வோம். 730 மணிநேரம் கொண்ட ஒரு மாதத்திற்கு இது $365 ஆகும். ஒரு frontier model API-உடன் ஒப்பிடும்போது, நீங்கள் மாதத்திற்கு 24.3 மில்லியன் output tokens உருவாக்கும்போது break-even புள்ளியை அடைவீர்கள். ஒரு சிறிய commercial model-உடன் ஒப்பிடும்போது இது 73 மில்லியன் ஆகும். அதே அளவுள்ள hosted open-weight model-உடன் ஒப்பிடும்போது, நீங்கள் ஒருபோதும் break-even அடைய முடியாது, ஏனெனில் ஒரு card-ஆல் ஒரு மாதத்தில் அந்த crossing point-ஐ அடையத் தேவையான tokens-ஐ உருவாக்க முடியாது.

வெளியிடப்பட்ட break-even ஆய்வுகள் இந்தக் கேள்விக்கு விடையளிக்கவில்லை. ஜூலை 2026-ன் ஒரு vendor பகுப்பாய்வு, ஒரு dedicated H100-க்கு மணிக்கு $2.00 என்ற விலையில், serverless inference-க்கு எதிராக 50% பயன்பாட்டில் crossover புள்ளியை வைக்கிறது. இது போன்ற ஆய்வுகள் ஒரு dedicated data-centre card-ஐ serverless தயாரிப்புடன் ஒப்பிடுகின்றன, மேலும் அவை accelerators-க்கு இங்கு பயன்படுத்தப்பட்டதை விட பல மடங்கு அதிக hourly rate-ஐ நிர்ணயிக்கின்றன. கணக்கீடு ஒன்றுதான். கீழே கொடுக்கப்பட்டுள்ளவை ஒரு card, 7B முதல் 30B வரம்பில் உள்ள ஒரு open model மற்றும் சாதாரண metered API billing ஆகியவற்றிற்காக மீண்டும் கணக்கிடப்பட்டுள்ளன.

கீழே உள்ள ஒவ்வொரு எண்ணும் ஒரு உள்ளீடு (input), முடிவு அல்ல. அவை அனைத்தையும் உங்கள் சொந்த எண்களைக் கொண்டு மாற்றவும்.

உங்கள் சொந்த எண்களைப் பயன்படுத்திக்கொள்ள உதவும் சூத்திரம்

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 என்பது உங்கள் server-ன் உண்மையான concurrency நிலையில் அது வழங்கும் மொத்த output விகிதம். இது vendor-ன் அட்டவணையில் உள்ள single-stream எண் அல்ல.
  • duty_cycle என்பது ஒரு மாதத்தில் GPU tokens-களை உருவாக்கும் நேரத்தின் பங்கு. நீங்கள் மாதம் முழுவதும் வாடகைக்கு எடுத்து, ஒரு நாளைக்கு இரண்டு மணிநேரம் மட்டும் பயன்படுத்தினால், அது 8.3% ஆகும்.
  • api_price_per_million என்பது நீங்கள் ஒப்பிடும் output tokens-க்கான கட்டண விலை.

இந்த உதாரணம் இரு பக்கங்களிலும் உள்ள output tokens-க்கான விலையைக் கணக்கிடுகிறது, ஏனெனில் chat மற்றும் agent பணிகளில் output-தான் கட்டணத்தில் பெரும்பகுதியை ஆக்கிரமிக்கிறது. உங்கள் prompts நீளமாக இருந்தால், இரு பக்கங்களிலும் input-ஐச் சேர்க்கவும். API பக்கத்தில், இது invoice-ல் தனி வரியாக இருக்கும். உங்கள் சொந்த server-ல், prefill என்பது GPU நேரத்தைப் பயன்படுத்துவதால், அது ஏற்கனவே குறைவான tokens_per_second அளவீடாகத் தெரியும்.

கணக்கீடுகளை நம்புவதற்கு முன் tokens per second-ஐ அளவிடுவது எப்படி

மேலே உள்ள அனைத்தும் ஒரு குறிப்பிட்ட அளவீட்டை அடிப்படையாகக் கொண்டவை. அதில் மூன்று மடங்கு தவறு செய்தால், இறுதி விடையும் மூன்று மடங்கு தவறாகும். நீங்கள் வாடகைக்கு எடுக்கும் அதே card-ல், நீங்கள் பயன்படுத்தப்போகும் அதே model மற்றும் quantisation-ஐக் கொண்டு இதை அளவிடவும்.

Ollama ஒரு கட்டளையின் மூலம் single-stream அளவீட்டை வழங்குகிறது:

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

--verbose பதிலுக்குப் பிறகு ஒரு timing block-ஐ அச்சிடும். இதில் கவனிக்க வேண்டிய வரி eval rate ஆகும்; இது tokens per second-ல் generation-ஐ மட்டுமே கணக்கிடுகிறது. prompt eval rate என்பது prefill வேகம், இது பொதுவாக மிக அதிகமாக இருக்கும். உங்கள் அளவீடுகள் இவற்றிலிருந்து மாறுபடலாம்:

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

ஒரு cost model-க்கு single stream என்பது சரியான அளவீடு அல்ல, ஏனெனில் இது ஒரே நேரத்தில் பல கோரிக்கைகளை ஏற்கும் திறன் கொண்ட card-ல், ஒரு நேரத்தில் ஒரு கோரிக்கையை மட்டுமே அளவிடுகிறது. மொத்த அளவீட்டைப் பெற, vLLM மூலம் model-ஐ இயக்கி, server தன்னைத்தானே தெரிவிக்கும் throughput-ஐப் பார்க்கவும்:

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

கோரிக்கைகள் செயல்பாட்டில் இருக்கும்போது, ஒவ்வொரு reporting interval-லும் server ஒரு status வரியைப் பதிவு செய்யும். vLLM releases-க்கு ஏற்ப இதில் உள்ள fields மாறக்கூடும், எனவே என்னுடையதை விட உங்கள் server-ல் உள்ளதை வாசிக்கவும்:

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 என்பது சூத்திரத்திற்குத் தேவையான எண். நீங்கள் concurrent requests-ஐச் சேர்க்கச் சேர்க்க இது உயரும். KV cache (key-value cache, அதாவது vLLM VRAM-ல் வைத்திருக்கும் per-request attention state) நிரம்பும் வரை இது உயர்ந்து, பின் நின்றுவிடும். அதற்கு மேல் கோரிக்கைகளை அதிகரித்தால், வேகம் அதிகரிக்காமல் கோரிக்கைகள் வரிசையில் (queue) நிற்கும்; இதை நீங்கள் உயரும் Waiting எண்ணிக்கையாகக் காணலாம். vLLM-உடன் ஒரு load generator-ம் வருகிறது, அது vllm bench serve. இதன் flags பதிப்புகளுக்கு ஏற்ப மாறும், எனவே blog post-ல் உள்ள கட்டளையை நகலெடுப்பதற்குப் பதிலாக, நீங்கள் நிறுவிய பதிப்பில் vllm bench serve --help-ஐ இயக்கவும்.

சோதனை நடக்கும்போது card-ஐக் கவனிக்கவும்:

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

generation-ன் போது utilization.gpu 100%-க்கு அருகில் இருந்தால், நீங்கள் throughput-bound நிலையில் இருக்கிறீர்கள் என்று அர்த்தம்; நீங்கள் அளந்த எண்ணே உண்மையான உச்ச வரம்பு. அது குறைவாக இருந்தால், வேறு ஏதோ ஒன்று தடையாக இருக்கிறது: மிகக் குறைவான concurrent requests, மெதுவான client, அல்லது VRAM-ல் முழுமையாகப் பொருந்தாத model system RAM-க்கு மாற்றப்படுவது போன்றவை காரணமாக இருக்கலாம். Ollama மற்றும் vLLM ஆகியவை இதில் முற்றிலும் மாறுபட்ட அணுகுமுறைகளைக் கொண்டுள்ளன, ஒரே card-ல் இவை இரண்டிற்கும் இடையே உள்ள வித்தியாசம் உங்கள் break-even புள்ளியைப் பல மடங்கு மாற்றும் அளவுக்குப் பெரியது.

ஒரு மாதத்திற்கான கட்டண விவரம்

இந்த உதாரணத்தில், ஒரு 24 GB GPU VPS மணிக்கு $0.50 என்ற விலையில் கணக்கிடப்படுகிறது. vLLM மூலம் இயக்கப்படும் 8B open model, 16 concurrent requests-உடன் வினாடிக்கு 400 output tokens என்ற வேகத்தில் செயல்படுகிறது. நீங்கள் அந்த கார்டைப் பயன்படுத்தினாலும் இல்லாவிட்டாலும் வாடகை நிலையானது. இந்த வேகத்தில் ஒரு மாதத்திற்கு 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 மில்லியன் tokens-களுக்கு, சிறிய commercial model 250 டாலர்களைக் கட்டணமாக வசூலிக்கிறது, இதுவே மலிவான விருப்பமாகத் தொடர்கிறது. 1000 மில்லியன் output tokens-களுக்கு, கார்டு மாதத்தில் 95% நேரம் இயங்க வேண்டியிருக்கும்; அப்போது hosted open-weight API 200 டாலர்களைக் கட்டணமாக வசூலிக்கிறது. கார்டு அதிகபட்ச சுமையுடன் இயங்கும் அதே அளவில், அதன் செலவு கிட்டத்தட்ட இரண்டு மடங்கு அதிகமாகிறது.

இந்த இறுதி முடிவு பலரை ஆச்சரியப்படுத்துகிறது, ஆனால் இது தற்செயலானது அல்ல. ஒரு hosted open-weight endpoint என்பது அதிக பயன்பாட்டுத் திறனுடன் இயங்கும் GPU fleet ஆகும், எனவே அதன் விலை முழுமையாகப் பயன்படுத்தப்படும் கார்டின் செலவுக்கு நெருக்கமாக இருக்கும். ஒரு கார்டை வாடகைக்கு எடுத்து அதை முழுமையாகப் பயன்படுத்தாமல், ஒரு முழுமையான fleet-ன் விலையை உங்களால் முறியடிக்க முடியாது. நீங்கள் முறியடிக்கக்கூடியது frontier pricing மட்டுமே, ஏனெனில் அதன் விலை சிலிக்கான் பயன்பாட்டு நேரத்தை விட, அதன் திறனை அடிப்படையாகக் கொண்டே நிர்ணயிக்கப்படுகிறது.

ஒவ்வொரு duty cycle-லும் ஒரு மில்லியன் output tokens-க்கான செலவு

Volume மற்றும் duty cycle ஆகிய இரண்டும் ஒரே உண்மையை இரு வேறு கோணங்களில் காட்டுகின்றன. வாடகை என்பது நேரத்தை வாங்குவதாகும். பயன்பாடற்ற நேரங்கள் (idle hours) எதையும் உற்பத்தி செய்யாது, ஆனால் செலவை உருவாக்கும்.

விளக்கப்படம்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 நிலவரப்படி வெளியிடப்பட்ட பொதுவான பட்டியல் விலைகளைக் குறிக்கின்றன: ஒரு hosted 8B open-weight model-க்கு ஒரு மில்லியன் output tokens-க்கு 0.20 டாலர்கள், ஒரு சிறிய commercial model-க்கு 5.00 டாலர்கள், மற்றும் ஒரு frontier model-க்கு 15.00 டாலர்கள். இவை உதாரணத்திற்காக மட்டுமே. நீங்கள் எதையும் முடிவு செய்வதற்கு முன் இன்றைய விலைப்பட்டியலைச் சரிபார்க்கவும். உங்கள் ஒப்பீடு metered tokens-க்கு பதிலாக ஒரு நிலையான monthly plan-ஆக இருந்தால், subscription கணக்கீடு மாறுபடும் மற்றும் crossing point-ம் மாறும்.

GPU-வை முழுத் திறனில் இயக்கினால், ஒரு மில்லியன் output tokens-க்கான செலவு 0.35 டாலர்கள், இது உண்மையில் மலிவானது. 10% duty cycle-ல் அதே ஒரு மில்லியன் tokens-க்கான செலவு 3.47 டாலர்கள். 2% duty cycle-ல் இதன் செலவு 17.36 டாலர்கள். இது, அதே போன்ற output-க்கு ஒரு hosted open model வசூலிக்கும் 0.20 டாலர்களுடன் ஒப்பிடத்தக்க வரம்பில் இல்லை.

ஒரு hosted open-weight model-டன் ஒப்பிடும்போது, இந்த அட்டவணையில் உள்ள அனைத்து duty cycle-களிலும் GPU-வை வாடகைக்கு எடுப்பது அதிக செலவு பிடிக்கும் தேர்வாகும். 10% duty cycle-ல், 0.20 டாலர்களுக்கு விற்கப்படும் output-க்கு நீங்கள் 3.47 டாலர்களைச் செலவிடுகிறீர்கள். இந்த வித்தியாசத்திற்கு ஈடாக நீங்கள் பெறுவது தனியுரிமை (privacy) மற்றும் மாறாத கட்டண முறை மட்டுமே. இவை உண்மையான பண மதிப்புடையவை, ஆனால் இவை விலை குறைவான தேர்வுகள் அல்ல; எனவே இவற்றை அப்படி வகைப்படுத்த வேண்டாம். Commercial tiers-உடன் ஒப்பிடும்போது நிலைமை மாறுகிறது: 10% duty cycle-ல், இந்த GPU சிறிய commercial மற்றும் frontier விலைகளை விடக் குறைவாகவே செலவாகிறது. Duty cycle சுமார் 2.3% ஆகக் குறையும் வரை இது frontier tier-ஐ விட மலிவாகவே இருக்கும்.

ஒவ்வொரு API அடுக்குக்கும் தேவையான break-even அளவு

விளக்கப்படம்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 மில்லியன் output tokens தேவைப்படும். இது அந்த card-ன் மொத்தத் திறனில் 2.3% மட்டுமே. இது மிகக் குறைந்த அளவாகும். வேலை நேரத்தில் coding agents-ஐ இயக்கும் ஒரு சிறிய குழுவே இதை எளிதாக எட்டிவிடும்.

Small commercial அடுக்குடன் ஒப்பிடும்போது, உங்களுக்கு மாதத்திற்கு 73 மில்லியன் tokens அல்லது 6.9% duty cycle தேவைப்படும். Hosted open-weight அடுக்குக்குத் தேவையான duty cycle 174% ஆகும். 100%-க்கு மேல் உள்ள எந்த அளவும் அடைய முடியாதது; ஏனெனில் ஒரு மாதத்தில் உள்ள மொத்த நேரத்தை விட அதிக நேரம் அந்த card இயங்க வேண்டியிருக்கும். இந்த hourly rate-ல் ஒரு mid-range card-ஆல் இந்த ஒப்பீட்டில் வெற்றிபெற முடியாது. எனவே, முடிவை மாற்ற வேண்டுமெனில் மலிவான card, வேகமான card அல்லது விலையைத் தவிர்த்த வேறு காரணங்களை மட்டுமே பயன்படுத்த முடியும்.

இந்த சூத்திரம் மறைக்கும் உண்மைகள்

இந்த சூத்திரம் GPU மணிநேரங்கள் மற்றும் tokens-க்கான விலையை மட்டுமே கணக்கிடுகிறது. ஆனால், பல உண்மையான செலவுகள் இதற்கு வெளியே உள்ளன.

Cold starts. 16-bit எடைகள் கொண்ட ஒரு 8B model சுமார் 16 GB அளவு இருக்கும். அதை local disk-லிருந்து VRAM-க்கு ஏற்ற பல பத்து நொடிகள் ஆகும். வாடகையைச் சேமிக்கப் பயன்பாட்டிற்கு இடையில் அந்த box-ஐ நிறுத்தினால், ஒவ்வொரு முறையும் முதல் request-ன் போது அந்த காத்திருப்பு நேரத்தைச் செலுத்த வேண்டியிருக்கும். காத்திருப்பதைத் தவிர்க்க அதைத் தொடர்ந்து இயங்கவிட்டால், உங்கள் duty cycle குறையும், இது ஒரு token-க்கான செலவை அதிகரிக்கும். இந்த சமரசமே serverless inference இருப்பதற்கான முழுமையான காரணம்.

Storage மற்றும் download. Weights மிகப் பெரியவை. 16-bit-ல் ஒரு 8B model சுமார் 16 GB இருக்கும்; 4-bit-க்கு quantise செய்யப்பட்ட ஒரு 30B model சுமார் 18 GB இருக்கும்; 16-bit-ல் உள்ள ஒரு 30B model 24 GB card-ல் அறவே பொருந்தாது. உயர் நிலையில் இந்த வரம்பு மிக விரைவாக எட்டப்படும், அங்கு Kimi K3 போன்ற ஒரு டிரில்லியன்-parameter கொண்ட open model-ஐ இயக்குவது என்பது, நீங்கள் மணிநேர அடிப்படையில் வாடகைக்கு எடுக்கக்கூடிய எந்தவொரு தனிப்பட்ட card-ன் கொள்ளளவையும் விட weights-ன் அளவு அதிகமாக இருப்பதை உணர்த்தும். அந்த disk-க்காக நீங்கள் ஒவ்வொரு மாதமும் கட்டணம் செலுத்த வேண்டும், மேலும் ஒவ்வொரு முறை rebuild செய்யும்போதும் நேரத்தை இழக்கிறீர்கள். ஒரு வார கால சோதனைகளுக்குப் பிறகு du -sh ~/.cache/huggingface/hub-ஐ இயக்கவும். நீங்கள் ஒருமுறை முயன்ற ஒவ்வொரு quantisation-ம் அங்கேயே இருப்பதால், அது நீங்கள் எதிர்பார்ப்பதை விட வேகமாக வளரும்.

உங்கள் சொந்த நேரம். Driver மற்றும் CUDA பதிப்புகள், நேற்று வேலை செய்த context length-ல் இன்று ஏற்படும் out-of-memory பிழைகள், chat template-ஐ மாற்றும் ஒரு model update என இவை எதுவும் cost-per-token கணக்கில் தெரிவதில்லை, ஆனால் இவை அனைத்தும் உங்கள் மாலை நேரங்களைச் செலவழிக்கும். நீங்கள் இதுபோன்ற ஒரு box-ஐ இதற்கு முன் தேர்வு செய்ததில்லை என்றால், ஒரு GPU VPS உங்களுக்கு உண்மையில் என்ன தருகிறது என்பதை ஒரு மாத வாடகைக்கு ஒப்புக்கொள்ளும் முன் படிப்பது நல்லது.

தர இடைவெளி. இதுவே மிகப்பெரிய மறைமுகச் செலவு மற்றும் விலையை நிர்ணயிப்பதில் கடினமானது. ஒரு 8B open model என்பது ஒரு frontier model அல்ல. ஒரு frontier model-க்கு ஒரு முயற்சி தேவைப்படும் இடத்தில் இதற்கு மூன்று முயற்சிகள் தேவைப்பட்டால், பயனுள்ள ஒரு பதிலுக்கான இதன் உண்மையான விலை அட்டவணையில் உள்ள மதிப்பை விட மூன்று மடங்கு அதிகம், மேலும் இது அந்த வேலையைச் செய்யாமலும் போகலாம். விலையை ஒப்பிடுவதற்கு முன் உங்கள் சொந்த prompts-களை வைத்து ஒப்பிட்டுப் பாருங்கள். Agent workloads-க்கு, கடினத்தன்மையின் அடிப்படையில் routing செய்து, மொத்த வேலைகளுக்கு மலிவான local tokens-ஐப் பயன்படுத்துவதே வழக்கமான தீர்வாகும். VPS-ல் agent செலவைக் கட்டுப்படுத்துவது பெரும்பாலும் இதையே அடிப்படையாகக் கொண்டது.

நீங்கள் மறந்த கட்டணங்கள். நீங்கள் நிறுத்திய ஒரு hourly GPU instance, அதனுடன் இணைக்கப்பட்ட storage மற்றும் reserved IP address-க்காகத் தொடர்ந்து கட்டணம் வசூலிக்கக்கூடும். விலை பக்கத்தைப் பார்க்காமல், invoice-ஐப் படியுங்கள்.

விலையைத் தாண்டி self-hosting எப்போது சிறந்தது

கணக்கீடுகள் மட்டும் முடிவெடுக்கும் காரணியாக இல்லாத நான்கு சூழல்கள்.

  • உங்கள் கட்டுப்பாட்டை விட்டு வெளியேறக்கூடாத தரவு. ஒரு compliance விதி மூன்றாம் தரப்பினருக்குத் தரவை அனுப்பக் கூடாது என்று தடை விதித்தால், token-க்கான விலை இங்கு முக்கியமல்ல.
  • திட்டமிடப்பட்ட நிலையான அதிகப்படியான பயன்பாடு. ஒவ்வொரு இரவும் ஆறு மணிநேரம் இயங்கும் ஒரு batch classification பணி, வடிவமைப்பிலேயே 25% duty cycle-ல் இருக்கும்; இது எதிர்பாராத கட்டணங்களை உருவாக்காது.
  • Rate limits. உங்கள் சொந்த card-ல் ஒரே ஒரு queue மட்டுமே இருக்கும், அது உங்களுக்கே சொந்தமானது.
  • எந்த API-லும் இல்லாத ஒரு model. உங்களுக்கு ஒரு குறிப்பிட்ட fine-tune தேவைப்பட்டால், ஒப்பிடுவதற்கு வேறு எதுவும் இல்லை.

நீங்கள் முதலில் மலிவான பதிப்பைச் சோதிக்க விரும்பினால், Ollama மூலம் VPS-ல் சிறிய model-ஐ இயக்குவது ஒரு மதிய நேர வேலையே, மேலும் நீங்கள் வாடகைக்கு எடுக்கப்போகும் card-க்கு ஏற்ப open model-ஐ அளவிடுவது உங்களுக்கு உண்மையில் எந்த GPU தேவை என்பதைத் தெரிவிக்கும். ஒரு மாத கால GPU வாடகைக்கு ஒப்பந்தம் செய்வதற்கு முன்பே இதை அளவிடுங்கள்.

FAQ

GPU VPS-ன் மாதாந்திர token பயன்பாடு எந்த அளவில் API விலையை விட லாபகரமாக இருக்கும்?

GPU-ன் மாதாந்திர வாடகையை, ஒரு மில்லியன் output tokens-க்கான API விலையால் வகுக்கவும். ஒரு மாதத்திற்கு $365 வாடகை கொண்ட கார்டு, 15.00 டாலர் விலை கொண்ட frontier API-ஐ விட, மாதத்திற்கு 24.3 மில்லியன் output tokens பயன்பாட்டில் லாபகரமாகிறது. 5.00 டாலர் விலை கொண்ட சிறிய வணிக ரீதியான மாடலுடன் ஒப்பிடும்போது, இது 73 மில்லியன் ஆகும். 0.20 டாலர் விலை கொண்ட hosted open-weight மாடலுடன் ஒப்பிடும்போது, ஒரு நடுத்தர ரக கார்டால் ஒரு மாதத்தில் போதுமான tokens-ஐ உருவாக்க முடியாது, எனவே இதில் லாபம் கிடைக்காது.

hosted open-weight API ஏன் எனது சொந்த GPU-வை விடக் குறைந்த செலவில் கிடைக்கிறது?

ஏனெனில் அதன் விலை முழுமையாகப் பயன்படுத்தப்படும் GPU-ன் செலவுக்கு இணையாக நிர்ணயிக்கப்படுகிறது, ஆனால் உங்கள் கார்டு முழுமையாகப் பயன்படுத்தப்படுவதில்லை. ஆயிரக்கணக்கான கோரிக்கைகளை (concurrent requests) கையாளும் ஒரு நிறுவனம் தனது fleet-ஐ எப்போதும் முழு பயன்பாட்டில் வைத்திருக்கும், எனவே அவர்களால் tokens-ஐ உற்பத்தி செலவுக்கு அருகிலேயே விற்க முடிகிறது. உங்கள் கார்டு நாளின் பெரும்பகுதி சும்மா இருக்கும், அந்த idle நேரத்திற்கும் நீங்கள் பணம் செலுத்துகிறீர்கள். 10% duty cycle-ல், உங்கள் செலவு ஒரு மில்லியன் output tokens-க்கு 3.47 டாலர்கள், ஆனால் அவர்களின் விலை 0.20 டாலர்கள் மட்டுமே.

நான் input tokens மற்றும் output tokens இரண்டையும் கணக்கிட வேண்டுமா?

உங்கள் prompts நீளமாக இருந்தால் இரண்டையும் கணக்கிடுங்கள். இங்குள்ள ஒப்பீடு output tokens-ஐ மட்டுமே அடிப்படையாகக் கொண்டது, இது chat மற்றும் agent பணிகளுக்கு முக்கியமானது. input-ஐச் சேர்ப்பது இரு தரப்பிலும் மாற்றத்தை ஏற்படுத்தும். API தரப்பில், இது விலைப்பட்டியலில் தனித்தனி, குறைந்த விலை கொண்ட வரியாக இருக்கும். உங்கள் சொந்த கார்டில், prefill GPU நேரத்தை எடுத்துக்கொள்ளும், எனவே அந்தச் செலவு நீங்கள் கணக்கிட்ட aggregate tokens per second-ல் ஏற்கனவே அடங்கிவிடும். உங்கள் உண்மையான prompt நீளங்களை வைத்து அளவீடு செய்யுங்கள், அப்போதுதான் இரு தரப்பும் ஒப்பிடத்தக்கதாக இருக்கும்.

சூத்திரத்திற்குத் தேவையான tokens per second-ஐ நான் எவ்வாறு அளவிடுவது?

மாடலை நீங்கள் பயன்படுத்தப்போகும் முறையில் இயக்கி, உண்மையான concurrency-ன் கீழ் aggregate generation rate-ஐப் பார்க்கவும். Ollama-வில், ollama run <model> --verbose கட்டளை tokens per second-ல் eval rate-ஐக் காட்டும், ஆனால் அது ஒரு தனி stream மட்டுமே, batched server-ன் திறனை அது முழுமையாகக் காட்டாது. vLLM-ல், இயங்கும் server logs Avg generation throughput-ஐக் காட்டும், அந்த அளவீட்டையே பயன்படுத்த வேண்டும். அதே நேரத்தில் nvidia-smi-ஐயும் கவனிக்கவும். generation-ன் போது GPU பயன்பாடு 100%-க்கு அருகில் இல்லை என்றால், நீங்கள் இன்னும் அதன் உச்சகட்ட திறனை (ceiling) அடையவில்லை என்று அர்த்தம்.

10%-க்கும் குறைவான பயன்பாடு இருக்கும்போது GPU VPS-ஐ வாடகைக்கு எடுப்பது பயனுள்ளதா?

நீங்கள் எந்த API-க்கு பணம் செலுத்துவீர்கள் என்பதைப் பொறுத்தது. 10% duty cycle-ல் நீங்கள் ஒரு மில்லியன் output tokens-க்கு 3.47 டாலர்கள் செலுத்துகிறீர்கள், இது சிறிய வணிக ரீதியான மற்றும் frontier tier ஆகிய இரண்டையும் விடக் குறைவு, ஆனால் hosted open-weight tier-ஐ விட மிக அதிகம். 2% பயன்பாட்டில் நீங்கள் 17.36 டாலர்கள் செலுத்துகிறீர்கள், இது இந்த ஒப்பீட்டில் உள்ள அனைத்து metered API-களை விடவும் அதிகம். விலையை மட்டும் கணக்கில் கொண்டால், சிறிய வணிக ரீதியான tier-க்கு எதிராக 6.9% duty cycle-லும், frontier tier-க்கு எதிராக 2.3% duty cycle-லும் கார்டின் லாபம் முடிவுக்கு வருகிறது; hosted open-weight மாடல்களுக்கு எதிராக இது ஒருபோதும் லாபகரமாக இருப்பதில்லை. தனியுரிமை (privacy) அல்லது எந்த API-லும் கிடைக்காத ஒரு மாடல் தேவைப்படும்போது மட்டுமே இந்த வரம்புகளுக்குக் கீழ் வாடகைக்கு எடுக்கவும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?