Maaari bang tumakbo ang isang 125B na modelo sa isang 16 GB na GPU? Ang matematika ng memorya

Maikling sagot: hindi. Ang 125B-parameter na modelo ay nangangailangan ng humigit-kumulang 62.5 GB para sa mga timbang nito kahit pagkatapos ng 4-bit compression, at ang 16 GB na graphics card ay may hawak na mga isang-kapat nito. Maaari mo pa rin itong simulan sa pamamagitan ng pagtulak sa natitira sa system RAM o sa disk, ngunit hindi na ang card ang magpapasya kung paano tatakbo ang mga bagay.

Sa ibaba: kung paano mo makukuha ang numerong iyon sa ilang linya, ano ang tunay na sinasabi ng “122B-A10B” sa pangalan ng modelo, at kung kailan ang pagpapadala ng mga kahilingan sa isang API ang mas simpleng paraan upang gumamit ng malaking modelo.

Mga Timbang: parameter na beses bytes#

Isipin ang isang modelo bilang isang malaking tumpok ng mga numero, na tinatawag na mga timbang o parameter. Upang sagutin ka, kailangan ng computer ang lahat ng ito sa mabilis na memorya nang sabay-sabay. Kaya ang unang pagtatantya ay simpleng multiplikasyon: parameter sa bilyon × bytes bawat timbang = gigabytes. Ang isang timbang ay tumatagal ng 2 bytes sa 16-bit, 1 byte sa 8-bit at 0.5 byte sa 4-bit. Iyon lang ang ginagawa ng quantization: mas kaunting bits bawat numero.

Kunin ang isang modelo ng klase na ito, Qwen3.5-122B-A10B. Ang Hugging Face page nito (sinuri noong 30 Oktubre 2026) ay nagpangalan ng Apache-2.0 bilang lisensya, inilathala ang mga timbang bilang BF16 at F32, at inilista ang laki bilang 125B parameter. Para sa 125B:

• Sa 16 bits: 125 × 2 = 250 GB
• Sa 8 bits: 125 × 1 = 125 GB
• Sa 4 bits: 125 × 0.5 = 62.5 GB
• Sa 2 bits: 125 × 0.25 = 31.25 GB

Kahit ang 2-bit na linya ay halos dalawang beses ang card. At ang mga ito ay sahig, hindi kabuuan: hindi nila isinasama ang context cache (susunod na seksyon) at ang sariling overhead ng runtime, at ang mga tunay na quantized na format ay nagdaragdag ng kaunti sa itaas.

Baliktarin ang formula upang makita kung ano ang kayang hawakan ng 16 GB na card. Sa 4-bit iyon ay 16 / 0.5 = 32 bilyong parameter, at iyon ang kisame bago pa may iba pang kailangan ng espasyo. Subukan mo mismo ang sum:

“122B-A10B”: aling numero ang binibilang#

Ang pangalan ay may dalawang numero. Ayon sa model card, ang modelo ay may 122B parameter sa kabuuan at 10B aktibo para sa bawat token. Ito ay isang mixture-of-experts na modelo: sa loob ay maraming maliliit na espesyalistang sub-network, at para sa bawat token isang router ang gumising lamang ng ilan sa kanila.

Isipin ang isang aklatan na may 122 shelf kung saan ang anumang solong tanong ay magpapadala sa iyo sa 10 sa kanila. Maliit ang iyong pagsisikap sa pagbabasa, ngunit ang buong aklatan ay kailangan pa ring nasa loob ng gusali, dahil hindi mo malalaman kung aling mga shelf ang kakailanganin ng susunod na salita.

Kaya: ang memorya ay sumusunod sa kabuuan, ang compute ay sumusunod sa aktibo. Sampung bilyong aktibong parameter ang gumagawa ng isang token na mura sa compute, hindi mura sa storage. Kung gaano kabilis tumakbo ang isang setup na nagpapanatili ng bahagi ng mga expert sa RAM o sa disk ay depende sa iyong RAM, disk at software. Walang tapat na solong pigura, kaya mag-ingat sa anumang headline na nagbibigay nito.

Ang pangalawang bayarin: ang context cache#

Ang mga timbang ay ang fixed na bahagi. Ang iba pang bahagi ay lumalaki habang nag-uusap kayo. Upang maiwasan ang muling pagbasa ng buong usapan para sa bawat bagong token, ang modelo ay nagpapanatili ng mga tala sa bawat token na nakita na nito: ang KV cache (mga key at value). Mas mahaba ang context, mas malaki ang cache. Kung gusto mong ipaliwanag mula sa simula ang panig ng context, mayroong hiwalay na gabay sa context window.

Bawat token ang cache ay tumatagal ng: 2 × layers × KV heads × head size × bytes. Sabihin nating ang isang modelo ay may 48 layers, 8 KV heads, isang head size na 128 at isang 16-bit na cache (isang ipinapalagay na hugis, hindi ang mula sa anumang model card):

• isang token: 2 × 48 × 8 × 128 × 2 = 196608 bytes, mga 0.2 MB
• 32,768 token: 196608 × 32768 = 6442450944 bytes, mga 6.4 GB
• 131,072 token (128K): 196608 × 131072 = 25769803776 bytes, mga 25.8 GB

Sa 128K ang cache na iyon lamang ay mas malaki kaysa sa buong card. Ang iyong tunay na mga numero ay nasa config.json ng modelo (layers, KV heads, head size), at ang ilang arkitektura ay nagpapanatili ng cache na mas maliit, kaya ituring ito bilang ang paraan, hindi bilang hatol sa isang modelo.

Ang Qwen3.5-122B-A10B card ay nagpapakita kung ano ang hitsura ng malaking dulo: ang mga halimbawa ng serving nito ay gumagamit ng tensor parallelism sa 8 GPU sa buong 262,144-token na context. Kung maubos ang memorya, pinapayuhan nitong paikliin ang context habang pinapanatili ang hindi bababa sa 128K upang mapanatili ang pag-iisip, at ang vLLM flag na --language-model-only ay lumalaktaw sa vision encoder upang magbakante ng memorya para sa cache.

Ang iyong sariling pagtatantya sa isang dosenang linya#

Pagsamahin ang dalawang bahagi:

def weights_gb(params_b, bits):
    return params_b * bits / 8

def cache_gb(layers, kv_heads, head_dim, tokens, nbytes=2):
    return 2 * layers * kv_heads * head_dim * nbytes * tokens / 1e9

w = weights_gb(125, 4)                # 4-bit quantization
c = cache_gb(48, 8, 128, 32768)       # example shape, take yours from config.json
print(round(w, 1), round(c, 1), round(w + c, 1))
# 62.5 6.4 68.9

Ngayon ang reality check. Sabihin nating ang iyong PC ay may 32 GB na RAM katabi ng 16 GB na card: 16 + 32 = 48 GB, mas mababa pa rin sa 68.9 GB na inilimbag ng script. Ang offloading ay kailangang umabot din sa disk, at ikaw ay magpapatakbo ng isang malaking modelo na halos mula sa storage kaysa sa card.

Kailan ang API ang mas simpleng pagpipilian#

Hindi lahat ng gawain ay nangangailangan ng malaking modelo sa iyong mesa. Alin ang naglalarawan sa iyo?

Ano ang hitsura nito sa pagsasanay. Sabihin nating ang isang support bot ay nagbubuod ng 3,000 ticket sa isang buwan, bawat isa ay mga 2,000 token papasok at 400 token palabas. Sa buong buwan iyon ay 2000 × 3000 = 6000000 input token at 400 × 3000 = 1200000 output token. Sa DeepSeek-V4-Flash, ang input ay nagkakahalaga ng $0.015 at output $0.10 bawat 1M token, kaya ang buong buwan ay umabot sa $0.21. Ang talahanayan sa ibaba ay nagpapakita ng parehong load sa bawat modelo, kasama ang OpenRouter column sa tabi nito upang maihambing mo sa kabuuan, input at output nang magkasama:

Ang kahilingan mismo ay ang parehong OpenAI-style na tawag na gagawin mo sa anumang provider. Ang base URL ay https://api.cheaptokens.dev/v1, at ang model id ay ang buong deepseek-ai/DeepSeek-V4-Flash-0731:

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Flash-0731",
    "messages": [{"role": "user", "content": "Summarise this ticket in one sentence: ..."}],
    "max_tokens": 200
  }'

Ang tugon ay nagdadala ng usage block na may input at output token counts, upang masuri mo ang pagtatantya sa itaas laban sa iyong sariling mga ticket pagkatapos ng unang dosena. Ang DeepSeek-V4-Flash ay nagbibigay sa iyo ng hanggang 32,768 output token bawat sagot sa isang presyo sa buong araw, at ang GLM-5.3-Flash ay ang mas magaan na pang-araw-araw na opsyon na may hanggang 8,192. Ang mga detalye ng setup ay nasa docs, ang model page ay murang DeepSeek, at ang buong listahan ng presyo ay nasa pricing page.

Sa susunod na ang isang pangalan ng modelo ay may kasamang laki, mayroon ka nang tatlong hakbang: i-multiply, idagdag ang cache, ihambing sa card.