SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-30

Kailangan Mo Ba ng VPS na May GPU?

Alamin kung kailan sapat ang CPU VPS para sa quantized chat models, embeddings, at Whisper small, at kailan sulit ang GPU para sa batch throughput at malalaking model.

Kailangan mo ba ng VPS na may GPU, o sapat na ang CPU?

Dalawang bagay ang binabago ng VPS na may GPU kapag ikaw mismo ang nagpapatakbo ng isang model: ang bilis ng paglabas ng mga token, at kung gaano kalaking model ang kasya sa memory. Wala na itong ibang binabago. Kung ang workload mo ay isang quantized 7B hanggang 27B chat model na sumasagot sa isang tao bawat pagkakataon, embedding job na mababa ang volume, o speech transcription gamit ang Whisper small, sapat na para sa trabaho ang karaniwang CPU VPS na may sapat na RAM. Magsimula sa CPU, sukatin ang numerong nakakaabala sa iyo, saka mag-upgrade kung kinakailangan.

Memory bandwidth ang dahilan. Kapag bumubuo ng isang token ang isang language model, binabasa nito mula sa memory ang lahat ng weight na kailangan nito. Ang 8B model na na-quantize sa 4 bits ay humigit-kumulang 4.9 GB sa disk at halos ganoon din sa memory, kaya ang pagbuo ng isang token ay nangangahulugang paglilipat ng humigit-kumulang 4.9 GB. Hatiin ang memory bandwidth ng machine sa numerong iyon, at makukuha mo ang pinakamataas na posibleng tokens per second. Ipinapaliwanag ng simpleng dibisyong iyon ang halos lahat ng benchmark na mababasa mo.

Ano talaga ang naibibigay ng GPU

Bandwidth. Ang server DDR5 sa modernong host ay nakapaglilipat ng sampu-sampung gigabyte bawat segundo. Ang GPU memory (VRAM, video RAM) ay nakapaglilipat ng daan-daan hanggang mahigit isang libong gigabyte bawat segundo. Ang ratio na ito ang speedup, at malaki ito.

Capacity na may bilis. Maaaring mag-load ang isang CPU box na may 64 GB RAM ng 70B model sa 4 bits. Tatakbo ito, pero mas malapit ang bilis sa pagbabasa kaysa sa pakikipag-chat. Makakatulong lamang ang GPU dito kung kasya ang model sa VRAM, dahil kapag nailipat ang mga layer sa system RAM, mabagal na ulit ang path na gagamitin.

Batch throughput. Ito ang bahaging madalas minamaliit ng mga tao. Kapag para sa isang user lang ang generation ng GPU, malaking bahagi ng compute nito ang idle dahil naghihintay ito sa memory. Kapag sabay na nagseserbisyo ng 20 request, iisang pagbasa ng weights ang nagsisilbi sa lahat ng 20. Tumataas nang ilang ulit ang aggregate tokens per second, habang kaunti lamang ang ibinababa ng bilis para sa bawat user. Sinusuportahan din ng mga CPU inference engine gaya ng llama.cpp ang batching; nakadepende ang mga gain sa hardware at workload. Kung gumagawa ka ng API na tinatawag ng maraming client, batching ang pangunahing dahilan para gumamit ng GPU, higit pa sa raw single-stream speed.

Pagproseso ng prompt. Ang pagbasa ng mahabang prompt ay compute-bound, hindi memory-bound, at dito pinakamalaki ang lamang ng GPU. Ang 30,000-token context na inaabot ng isang minuto para iproseso ng CPU ay maaaring matapos sa ilang segundo sa GPU. Palagi itong ramdam sa mga retrieval setup na nagsasama ng mga dokumento sa bawat request.

Mga tantiya, at kung paano basahin ang mga ito

Ang aktuwal na throughput ay mas mababa rin kaysa sa bandwidth na hinati sa laki ng modelo, dahil nagdaragdag ng trabaho ang attention habang lumalaki ang context. Hindi ito isinasaalang-alang ng simpleng paghahati.

Para sa paghahambing, ang karaniwang bilis ng tahimik na pagbasa ng mga adulto sa English ay humigit-kumulang 4.0 hanggang 4.3 salita bawat segundo: 238 salita bawat minuto para sa non-fiction at 260 para sa fiction. Ang bilis na 15 tokens bawat segundo o higit pa ay parang normal na pagta-type na para sa isang mambabasa. Kaya maraming setup na CPU-only ang sapat na sa aktuwal na paggamit.

Tinatayang VRAM bago bumili

Ang laki ng model file ang minimum na batayan, hindi ang aktuwal na requirement. Isama sa budget ang weights, ang KV cache (key-value cache, ang memory na ginagamit ng attention para sa bawat token), at humigit-kumulang 1 GB na overhead.

Kalkulahin ang cache sa halip na magdagdag ng nakapirming porsiyento, dahil hindi nakukuwantisa ang cache kapag kinuwantisa ang weights. Para sa bawat token, nag-iimbak ang full-attention model ng isang key at isang value para sa bawat layer at bawat KV head, na may 2 bytes bawat number sa FP16, ang default na cache type ng Ollama. Batay sa model metadata ng Ollama na sinuri noong 2026-10-27, ang Llama 3.1 8B ay may 32 layer at 8 KV head na may 128 dimension. Katumbas ito ng 128 KiB bawat token: humigit-kumulang 1.07 GB sa 8k context at 2.15 GB sa 16k. Kaya ang 4.9 GB na 8B model ay nangangailangan ng humigit-kumulang 7 GB na VRAM sa 8k at humigit-kumulang 8 GB sa 16k. Ang 27B model sa 4 bits ay nasa humigit-kumulang 17 GB (Gemma 3 27B sa library ng Ollama). Nakalista sa metadata ng Gemma 3 ang sliding window na 1,024 token, kaya hindi gaanong lumalaki ang malaking bahagi ng cache nito. Maglaan ng 20 GB o higit pa. Ang 70B sa 4 bits ay nasa humigit-kumulang 43 GB (Llama 3.3 70B). Dahil mayroon itong 80 layer, nagdadagdag ang FP16 cache ng humigit-kumulang 2.7 GB sa 8k at 5.4 GB sa 16k. Kaya kailangan nito ng 48 GB na card na maliit ang matitirang kapasidad, o dalawang mas maliit na card. Gumagana pa rin ang parehong kalkulasyon sa mas malalaking model, at ipinapakita ng ang kalkulasyon ng VRAM para sa 2.8 trilyong parameter na model gaya ng Kimi K3 kung kailan hindi na pagpili ng card ang pangunahing tanong.

Pinakamahalaga ito sa mahahabang context. Sa mga full-attention model gaya ng Llama 3.1, lumalaki nang linear ang KV cache kasabay ng haba ng context. Sa 128k token, maaari itong lumampas sa laki mismo ng weights. Iba ang mga model na gumagamit ng sliding-window o chunked attention. Tinukoy ng dokumentasyon ng Hugging Face Transformers ang Mistral, Gemma 2, at Llama 4 bilang mga halimbawa kung saan tumitigil sa paglaki ang cache sa mga layer na iyon kapag naabot nito ang window o chunk size. Dahil dito, mas mabagal lumaki ang kabuuang memory requirement. Kung gagamit ka ng mahahabang context, unahin ang pagtantya sa cache at tingnan kung ano ang iniaalok ng engine mo para sa cache quantization. Sa Ollama, ang OLLAMA_KV_CACHE_TYPE=q8_0 ay gumagamit ng humigit-kumulang kalahati ng memory ng default na f16. Nalalapat lamang ang cache quantization kapag naka-enable ang Flash Attention. Itakda rin nang tahasan ang context length. Kinukuha ng Ollama ang default nito batay sa VRAM: 4k sa ibaba ng 24 GiB, 32k mula 24 hanggang 48 GiB, at 256k sa 48 GiB pataas. Sa 48 GB na card na nagpapatakbo ng 70B model, nangangailangan ang default na iyon ng mas malaking cache kaysa sa kayang hawakan ng card.

Suriin kung ano talaga ang nasa machine

Sa isang GPU instance, tiyaking nakikita ng driver ang card bago ang anumang iba pa.

nvidia-smi

Dapat may table na naglilista ng pangalan ng GPU, bersyon ng driver, at memory na ginagamit kumpara sa kabuuang memory. Ibig sabihin ng NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver na hindi maabot ng NVIDIA-SMI ang driver; tiyaking naka-install ang driver at naka-load ang kernel module nito. Sa stock Ubuntu image, karaniwang sudo apt install -y ubuntu-drivers-common && sudo ubuntu-drivers install ang solusyon, saka mag-reboot para ma-load ang bagong module. Para sa mga compute machine, inirerekomenda ng dokumentasyon ng Ubuntu para sa server ang sudo ubuntu-drivers install --gpgpu, na pumipili sa server driver branch.

Para sa mga container, hindi sapat ang driver lamang. Kailangan ng Docker ang NVIDIA Container Toolkit para maipasa ang device sa container.

sudo apt-get update && sudo apt-get install -y --no-install-recommends ca-certificates curl gnupg2
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Pagkatapos, patunayan na gumagana ang passthrough mula sa loob ng container:

sudo docker run --rm --gpus all ubuntu:24.04 nvidia-smi

Dapat lumitaw ang parehong table. Ang isang linyang docker: Error response from daemon: could not select device driver, na tumutukoy sa gpu capability na hindi nito matugunan, ay nangangahulugang hindi makahanap ang Docker ng device driver na tumutugma sa request; tiyaking naka-install ang toolkit, pagkatapos ay patakbuhin muli ang linyang nvidia-ctk at ang restart. Sa Compose, katumbas nito ang isang entry na deploy.resources.reservations.devices na ang driver ay nvidia at ang capabilities list nito ay naglalaman ng gpu. Maaari itong idagdag sa karaniwang service definitions na tinalakay sa Docker Compose sa isang VPS.

Sukatin muna bago mag-upgrade

Patakbuhin ang model na talagang gagamitin mo sa kasalukuyan mong CPU box, at itala ang mga resulta. Sa pagse-self-host ng LLM gamit ang Ollama sa isang VPS, isang flag lang ang kailangan:

ollama run llama3.1:8b --verbose "Summarise the causes of the 1929 crash in 200 words."

Nagtatapos ang output sa mga timing. Ang eval rate ang bilis ng generation mo sa tokens per second. Ang prompt eval rate ang bilis ng machine sa pagbasa ng input mo. Ipinapakita ng dalawang numerong ito kung aling upgrade ang makatutulong: ang mababang eval rate ay problema sa memory bandwidth, habang ang mababang prompt eval rate sa mahahabang input ay problema sa compute.

Sa machine na may GPU, tiyaking dito talaga nailagay ang model:

ollama ps

Ang column na PROCESSOR ay naglalaman ng 100% GPU kapag kasya ang lahat, o ng tulad ng 43%/57% CPU/GPU kapag hindi ito kasya. Karaniwang mas mabagal kaysa inaasahan ang partial split, dahil naghihintay pa rin ang bawat token sa mas mabagal na bahagi.

Ang usapin ng gastos

Sinisingil ang mga GPU instance batay sa nakalaan na compute time, hindi sa bilang ng token. Ang mga rate at singil para sa stopped instance ay itinatakda ng provider. Kung palaging naka-on ang isang GPU pero iilang request lang ang pinoproseso nito bawat araw, malaking bahagi ng binabayarang oras nito ay idle. Ang break-even ay nakabatay sa utilisation: mura ang busy na GPU kada token, pero purong aksaya ang idle na GPU.

May tatlong praktikal at tapat na pattern. Panatilihin sa CPU VPS ang tuloy-tuloy pero mababang volume ng trabaho. Ipadala ang paminsan-minsang mahirap na request sa hosted API at magbayad kada token. Mag-rent ng GPU kada oras para sa batch job, fine-tuning, o maramihang embedding run, pagkatapos ay i-destroy ito. Karaniwan ang pagsasama ng mga paraang ito. Nalalapat din dito ang budgeting discipline na inilalarawan sa Pagkontrol sa gastos ng AI agent sa isang palaging naka-on na VPS, ngunit idle time ang pinagmumulan ng pagtagas ng gastos, hindi ang bilang ng token.

Ano pa rin ang maayos na tumatakbo kahit walang GPU

Embeddings sa mababang volume. Kayang magproseso ng maliit na embedding model ng daan-daang maiikling dokumento bawat minuto gamit ang ilang CPU core, at hindi kailangang mabilis ang index na isang beses mo lang bubuuin.

Whisper small at base para sa transcription. Sa CPU, ang faster-whisper ay nakakapag-transcribe nang halos real time gamit ang small model. Sapat na ito para sa pipeline na tumatakbo magdamag.

Mga quantized chat model hanggang humigit-kumulang 27B, para sa isa o dalawang user. Mabagal, pero nababasa at nagagamit.

Anumang maituturing mong batch job. Kung walang tumitingin sa screen, detalye lang ng scheduling ang wall-clock speed at hindi ito requirement.

Ang talagang nangangailangan ng GPU ay training o fine-tuning na lampas sa maliit na adapter, pag-serve sa maraming concurrent user, image at video generation, at real-time speech kung latency ang pangunahing requirement.

FAQ

Gaano karaming VRAM ang kailangan ko para sa 7B o 8B na model?

Humigit-kumulang 7 GB para sa 4-bit quantized na 8B model sa 8k context, at humigit-kumulang 8 GB sa 16k, gamit ang default na FP16 cache ng Ollama. Tinatayang 4.9 GB ang weights, nagdaragdag ang KV cache ng humigit-kumulang 1.07 GB sa 8k o 2.15 GB sa 16k, at ang natitira ay humigit-kumulang 1 GB na overhead. Kasya ito sa 8 GB card sa 8k ngunit kapos sa 16k, samantalang nagbibigay ang 12 GB card ng sapat na espasyo para sa mas mahahabang context. Kapag pinalitan ang cache ng q8_0, humigit-kumulang kalahati ang nababawas sa bahagi ng cache. Kung plano mong gumamit ng 128k context, hiwalay na maglaan ng sapat na kapasidad para sa cache dahil maaari itong lumaki nang higit pa sa weights.

Maaari ko bang patakbuhin ang Ollama nang walang GPU?

Oo. Awtomatikong gumagamit ang Ollama ng CPU at kailangan lamang nito ng sapat na RAM para maglaman ng model. Asahan ang humigit-kumulang 5 hanggang 12 tokens bawat segundo para sa 4-bit na 8B model, depende sa memory speed. Malapit ito sa bilis ng pagbabasa para sa isang user. Ang mahahabang prompt ang pangunahing problema sa CPU dahil compute-bound ang pagbasa ng 30,000 tokens na context at mas matagal ito kaysa sa pagbuo ng reply.

Bakit halos hindi mas mabilis ang GPU ko kaysa sa CPU?

Karaniwang sanhi nito na hindi lubusang kasya ang model sa VRAM, kaya tumatakbo ang ilang layer sa CPU at naghihintay ang bawat token sa mas mabagal na bahagi. Patakbuhin ang ollama ps at tingnan kung ang column na PROCESSOR ay may halagang 100% GPU. Kung nagpapakita ito ng split, gumamit ng mas maliit na quantization o mas maliit na model. Ang isa pang karaniwang sanhi ay maikling benchmark kung saan nangingibabaw sa sukat ang oras ng pag-load ng model.

Sulit ba ang GPU VPS para sa isang user?

Karaniwan, hindi. Ang tahimik na pagbabasa ng nasa hustong gulang sa English ay may average na humigit-kumulang 4.0 hanggang 4.3 salita bawat segundo. Kailangang i-convert ang tokens bawat segundo sa salita bawat segundo bago ikumpara ang CPU box sa bilis na iyon. Ang mga sitwasyong maaaring magbigay-katwiran sa gastos para sa isang user ay mahahabang prompt, image generation, at fine-tuning. Ang sabay-sabay na pag-serve sa maraming user ang pinakamalakas na dahilan, dahil nagbibigay-daan ang batching na maibahagi ng isang GPU ang pagbasa ng weights sa maraming request.

Dapat ba akong umarkila ng GPU kada oras o panatilihin itong laging naka-on?

Umupa kada oras kapag pabugso-bugso ang workload: fine-tuning, maramihang embedding run, o batch transcription job. Panatilihin lamang itong laging naka-on kapag palaging ginagamit ang card, dahil naniningil ang provisioned GPU compute batay sa oras at hindi sa dami ng nalikhang tokens. Para sa assistant na kaunti ang traffic, mas mura ang CPU VPS o hosted API na binabayaran kada token kaysa sa GPU na idle.

Nakatulong ba ang artikulong ito?