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

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-உடன் ஒப்பிடும்போது இது {{q:breakeven_tokens_millions@1}} மில்லியன் ஆகும். அதே அளவுள்ள ஒரு hosted open-weight model-உடன் ஒப்பிடும்போது, நீங்கள் ஒருபோதும் break-even புள்ளியை அடைய முடியாது. ஏனெனில், ஒரு கார்டால் ஒரு மாதத்தில் அந்த இலக்கை எட்டுவதற்குத் தேவையான tokens-ஐ உருவாக்க முடியாது.

வெளியிடப்பட்ட break-even ஆய்வுகள் இந்தக் கேள்விக்கு விடையளிக்கவில்லை. 2026-ன் தொடக்கத்தில் வெளியான இரண்டு ஆய்வுகள், H200-ல் 72% sustained utilisation மற்றும் MI300X-ல் 22% முதல் 48% duty cycle ஆகியவற்றில் crossover புள்ளி இருப்பதாகக் கூறுகின்றன. இவை இரண்டுமே அதே vendor-ன் serverless தயாரிப்புடன் ஒப்பிடப்பட்டுள்ளன. மேலும், இங்குள்ள வாசகர்கள் ஒரு மாதத்தில் செலவழிக்கும் தொகையை விட, அந்த ஆய்வுகளில் பயன்படுத்தப்பட்ட accelerators-ன் ஒரு மணிநேரக் கட்டணம் அதிகம். கணக்கீடு ஒன்றுதான். கீழே கொடுக்கப்பட்டுள்ளவை ஒரு கார்டு, 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-களை உருவாக்க முடியும்; கார்டு இடைவிடாமல் இயங்கினால் மட்டுமே இது சாத்தியம்.

[
  {
    "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) எதையும் உற்பத்தி செய்வதில்லை, ஆனால் செலவை ஏற்படுத்துகின்றன.

[
  {
    "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-க்கு பதிலாக ஒரு நிலையான மாதத் திட்டத்துடன் (flat monthly plan) ஒப்பிடுகிறீர்கள் என்றால், சந்தா கணக்கீடு மாறுபடும் மற்றும் லாபகரமான புள்ளி (crossing point) இடமாறும்.

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

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

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

[
  {
    "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-ஐ நிறுத்தினால், ஒவ்வொரு முறையும் முதல் கோரிக்கையின் போது அந்தத் தாமதத்தைச் சந்திக்க நேரிடும். அந்தத் தாமதத்தைத் தவிர்க்க அதைத் தொடர்ந்து இயங்கவிட்டால், உங்கள் 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 கார்டில் பொருந்தாது. உயர்தர மாடல்களில் இந்த வரம்பு மிக விரைவாக எட்டப்படும். Kimi K3 போன்ற டிரில்லியன்-பாராமீட்டர் கொண்ட open model-ஐ இயக்குவது என்பது, நீங்கள் மணிநேர அடிப்படையில் வாடகைக்கு எடுக்கக்கூடிய எந்தவொரு தனி கார்டின் கொள்ளளவையும் விட எடைகள் அதிகமாக இருப்பதைக் குறிக்கும். அந்த 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 வேலைகளுக்கு, கடினத்தன்மையின் அடிப்படையில் 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 வாடகை கொண்ட ஒரு கார்டு, ஒரு முன்னணி API-ன் 15.00 டாலர் விலையுடன் ஒப்பிடும்போது, மாதம் 24.3 மில்லியன் output tokens-ல் சமநிலையை (break even) அடைகிறது. ஒரு சிறிய வணிக ரீதியான மாடலின் 5.00 டாலர் விலையுடன் ஒப்பிடும்போது, இது 73 மில்லியன் ஆகும். Hosted open-weight மாடலின் 0.20 டாலர் விலையுடன் ஒப்பிடும்போது, ஒரு mid-range கார்டால் ஒரு மாதத்தில் போதுமான tokens-ஐ உருவாக்கி சமநிலையை அடைய முடியாது.

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

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

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

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

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

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

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

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