SSD Nodes Learn Hosting plans →
Mwongozo Matt ConnorNa Matt Connor · Imeboreshwa 2026-10-25

Mifano ya AI unayoweza kujiendeshea kwenye seva yako

Chagua mfano wa AI kulingana na RAM yako. Pata maelekezo ya hesabu kwa 4GB, 16GB na 64GB, viwango halisi vya token za CPU, na gharama za siri za kumbukumbu ya muktadha.

Ni nini huamua ni mifano ipi ya AI unayoweza kujiendeshea (self-host)

Ni nini unachoweza kujiendeshea kama mfano wa AI huamuliwa na namba moja: RAM iliyopo kwenye seva yako. Familia ya mfano na mfumo wa uendeshaji (framework) havina umuhimu mkubwa kuliko uwezo wa uzito (weights) wa mfano huo kutoshea kwenye kumbukumbu huku kukiwa na nafasi iliyobaki. Chapisho hili linaelezea hesabu za kufanya hivyo. Kusakinisha runtime ni kazi tofauti, ambayo imeelezewa katika mwongozo wa kuendesha Ollama kwenye VPS.

Gharama mbili huamua jibu. Uzito wa mfano ni gharama isiyobadilika, inayowekwa na idadi ya vigezo (parameter count) na quantisation. Dirisha la muktadha (context window) ni gharama inayobadilika, na ndiyo watu husahau hadi pale mfano uliopakia jana unapokataa kupakia leo.

Hesabu ya ukubwa: biti kwa kila parameter

Faili la model karibu lote linaundwa na weights. Kila weight huhifadhiwa kwa idadi fulani ya biti. Quantisation inamaanisha kuzihifadhi kwa biti chache kuliko usahihi uliotumika wakati wa kuzifunza, jambo linalopunguza usahihi kidogo na kuokoa kumbukumbu nyingi. Ukubwa hutokana moja kwa moja na hilo:

weights in GB = (parameters in billions x bits per weight) / 8

Model nyingi hutolewa kwa biti 16, ambazo ni 2 GB kwa kila bilioni moja ya parameters. Chache tayari husafirishwa zikiwa zimefanyiwa quantisation kwa sehemu: kwa mfano, gpt-oss ya OpenAI ilifanyiwa post-training na weights zake za mixture of experts katika 4 bit MXFP4. Vyovyote vile, karibu hakuna anayeendesha weights za biti 16 kwenye VPS. Hizi ndizo quantisation utakazokutana nazo kihalisi, pamoja na wastani wake halisi wa biti kwa kila weight:

  • Q8_0 huhifadhi takriban biti 8.5 kwa kila weight, hivyo ni takriban 1.1 GB kwa kila bilioni ya parameters.
  • Q6_K huhifadhi takriban biti 6.6, hivyo ni takriban 0.83 GB kwa kila bilioni.
  • Q5_K_M huhifadhi takriban biti 5.7, hivyo ni takriban 0.71 GB kwa kila bilioni.
  • Q4_K_M huhifadhi takriban biti 4.8, hivyo ni takriban 0.6 GB kwa kila bilioni.

Tumia 0.6 GB kwa kila bilioni ya parameters kama namba yako ya kufanyia kazi. Q4_K_M ndiyo chaguo msingi la busara kwenye seva yenye kumbukumbu finyu: upotevu wa ubora ukilinganisha na biti 8 ni mdogo katika kazi nyingi, na faili huwa karibu nusu ya ukubwa wake. Chini ya biti 4, upotevu huongezeka kwa kasi, kwa hivyo model ya 70B iliyoshinikizwa hadi biti 2 kwa kawaida hujibu vibaya zaidi kuliko model ya 32B ya biti 4 kutoka kizazi kimoja. Kumbukumbu ikiwa finyu, punguza ukubwa wa model kabla ya kushuka chini ya biti 4.

ChatiRAM at 4-bit: weights and KV cache, calculated
Data iliyo nyuma ya chati hii
[
  {
    "label": "3B",
    "weights_gb": 1.8,
    "kv_8k_gb": 0.9,
    "kv_128k_gb": 14
  },
  {
    "label": "8B",
    "weights_gb": 4.8,
    "kv_8k_gb": 1,
    "kv_128k_gb": 16
  },
  {
    "label": "14B",
    "weights_gb": 8.4,
    "kv_8k_gb": 1.5,
    "kv_128k_gb": 24
  },
  {
    "label": "32B",
    "weights_gb": 19.2,
    "kv_8k_gb": 2,
    "kv_128k_gb": 32
  },
  {
    "label": "70B",
    "weights_gb": 42,
    "kv_8k_gb": 2.5,
    "kv_128k_gb": 40
  }
]

Safu ya weight hapo juu ni ile kanuni ya 0.6 GB kwa kila bilioni iliyotumika. Faili halisi za GGUF huwa ndani ya asilimia chache ya namba hiyo, kwa sababu embedding na output layers huwekwa katika usahihi wa juu zaidi kuliko sehemu nyingine. Model ya 3B katika biti 4 ni takriban 1.8 GB. Model ya 8B ni 4.8 GB. Model ya 32B ni 19.2 GB, na model ya 70B ni 42 GB.

Kwa nini urefu wa muktadha (context length) unagharimu RAM zaidi kuliko uzito (weights)

KV cache (key value cache, hali ya umakini ambayo modeli huihifadhi kwa kila token iliyopo kwenye mazungumzo) ndiyo gharama ya pili. Hutengwa wakati modeli inapopakiwa, ikikadiriwa kulingana na urefu wa muktadha uliouomba, na hukua kwa mstari mnyoofu kulingana na urefu huo.

Mfumo wa KV cache, na mahali pa kusoma namba hizo
bytes per token = 2 x layers x kv_heads x head_dim x bytes per element

Namba 2 inawakilisha key na value. Thamani za layers, kv_heads (zilizoorodheshwa kama num_key_value_heads) na head_dim zote zipo kwenye config.json katika ukurasa wa kadi ya modeli. Bytes kwa kila element ni 2 kwa cache ya 16 bit. Modeli ya kawaida ya 8B ina layers 32, 8 key value heads na head dimension ya 128, kwa hivyo 2 x 32 x 8 x 128 x 2 = 131072 bytes, ambayo ni 128 KiB kwa kila token.

Katika muktadha chaguo-msingi wa Ollama, modeli hiyo ya 8B hutumia nusu gigabyte kwa cache. Katika token 8192 hutumia 1 GB. Katika muktadha wa 128k ambao kadi ya modeli inatangaza, hutumia 16 GB, ambayo ni zaidi ya mara tatu ya uzito wake. Modeli ya 70B ni kinyume chake: cache yake katika 128k ni 40 GB, chini ya uzito wake yenyewe, kwa sababu grouped query attention huzuia gharama kwa kila token isikue kwa kasi inayokaribia idadi ya vigezo (parameters).

Urefu wa muktadha chaguo-msingi wa Ollama ni token 4096 kwenye seva ya CPU pekee. GPU inapokuwepo, huchagua chaguo-msingi kutoka VRAM badala yake: 32k kati ya 24 na 48 GiB, na 256k katika 48 GiB na zaidi. Iongeze kwa kutumia variable ya OLLAMA_CONTEXT_LENGTH kwenye seva, kisha angalia kile ambacho modeli inayofanya kazi imepata katika safu ya CONTEXT ya ollama ps. Hesabu za kumbukumbu nyuma ya mpangilio huo zimefafanuliwa katika makala kuhusu num_ctx na urefu wa muktadha.

Kuna njia mbili za kupunguza gharama ya cache. Omba muktadha unaohitaji badala ya muktadha unaotangazwa na kadi ya modeli, kwa kuwa kazi nyingi za gumzo na uandishi wa programu hutoshea ndani ya 8k hadi 32k. Au fanya quantise ya cache yenyewe hadi 8 bits, jambo linaloipunguza kwa nusu, kwa gharama ya uwezo wa kukumbuka muktadha mrefu.

Mfumo wa resident model unashikilia RAM hiyo hadi kitu kingine kiondoe

Ollama huweka model kwenye kumbukumbu kwa dakika 5 baada ya ombi la mwisho, kisha huiondoa. Mpangilio huo wa awali unafaa kwa kompyuta ya mkononi lakini si sahihi kwa seva, ambapo kila ombi la kwanza baada ya muda wa kutofanya kazi hulazimika kusubiri muda wa kupakia tena.

ollama ps
ollama stop qwen3:4b

ollama ps huorodhesha kilichopo kwenye kumbukumbu, huku safu ya SIZE ikionyesha kiasi cha kumbukumbu kinachotumiwa na safu ya UNTIL ikionyesha muda wa kuisha kwa muda huo. Ili kubandika (pin) model moja kwa moja, weka OLLAMA_KEEP_ALIVE=-1 kwenye huduma hiyo. Thamani ya 0 huiondoa mara tu kila jibu linapokamilika.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
sudo systemctl daemon-reload
sudo systemctl restart ollama

Tuma ombi moja, kisha endesha ollama ps tena baada ya dakika kumi. Model hiyo bado imeorodheshwa, na ndilo lengo hasa: inashikilia RAM hiyo bila kujali kama kuna mtu anaitumia au la. Model iliyobandikwa si uwezo wa ziada. Kwenye VPS ya 16 GB, model ya 8B yenye context ya 8k inashikilia takriban 6 GB kwa muda wote ambao huduma hiyo inaendelea kufanya kazi, kwa hivyo pima ukubwa wa seva kulingana na model pamoja na programu yako, si kulingana na model pekee. Kubandika model kwenye kumbukumbu kunashughulikia uwiano dhidi ya muda wa kusubiri wa kuanza kwa baridi (cold start latency).

Nini kinaweza kuendeshwa kwenye VPS ya 4 GB

Tenga takriban 1 GB kwa ajili ya mfumo wa uendeshaji na seva ya modeli, jambo linaloacha takriban 3 GB. Hii inatosha kwa modeli ya 1B hadi 4B katika 4 bits, kwa context ya kawaida ya 4096 token. Kufikia Agosti 2026, darasa hilo linajumuisha Llama 3.2 ya 3B, Qwen 3 ya 1.7B na 4B, pamoja na matoleo madogo ya Gemma na Phi. Chukulia hayo kama mifano ya ukubwa, si mapendekezo. Majina hubadilika kila baada ya miezi michache lakini hesabu za msingi hazibadiliki.

Tarajia takriban 6 hadi 14 token kwa sekunde. Modeli ndogo kama hizi hufanya kazi mahususi vizuri: uainishaji, uchimbaji wa tag, muhtasari mfupi, na kuandika upya aya kulingana na mtindo maalum. Ni dhaifu katika hoja za hatua nyingi na katika msimbo unaohusisha faili kadhaa, na hakuna kiasi chochote cha prompting kinachoweza kurekebisha hilo.

Hali ya kushindwa katika ngazi hii ni swap. Ikiwa modeli haitoshi kwenye kumbukumbu, Linux haikatai kuipakia. Badala yake, inahamisha kumbukumbu kwenye diski, na kwa sababu utengenezaji wa token moja husoma kila uzito (weight) mara moja, kasi ya utengenezaji hushuka hadi sekunde kadhaa kwa kila token. Fuatilia free -h na safu za si na so za vmstat 1 wakati modeli inajibu. Puuza mstari wa kwanza wa matokeo ya vmstat, ambao hupiga wastani wa kila kitu tangu boot, na kumbuka kuwa viashiria hivi hufunika mfumo mzima, si modeli pekee. Swap in na swap out zinazobaki kwenye sifuri wakati seva haifanyi kazi na kupanda mara tu utengenezaji unapoanza inamaanisha kuwa modeli ni kubwa mno kwa mpango huo.

Nini kinachoweza kuendeshwa kwenye VPS ya 8 hadi 16 GB

Hapa ndipo mtindo wa self-hosted unapokuwa na manufaa kwa ujumla. Kwenye 8 GB unaweza kuendesha modeli ya 7B au 8B kwa 4 bits, takriban 4.8 GB ya weights, ikiwa na 8k context. Kwenye 16 GB unaweza kuendesha modeli ya 13B au 14B kwa 4 bits, takriban 8.4 GB, au kubaki na 8B kwa 8 bits ikiwa unapendelea kutumia kumbukumbu kwa ajili ya usahihi badala ya idadi ya vigezo (parameter count).

Kasi ndiyo changamoto. Modeli ya 8B kwenye CPU huzalisha takriban 3 hadi 7 tokens kwa sekunde, na 14B takriban 1.5 hadi 3.5. Binadamu husoma kwa kasi ya takriban 5 hadi 10 tokens kwa sekunde, kwa hiyo 8B kwenye VPS ya CPU huonekana kama kumtazama mtu anayechapa kwa polepole. Hii inafaa kwa kazi za nyuma (background jobs) lakini inachosha kwa mazungumzo ya moja kwa moja (interactive chat). Majaribio ya Qwen 3 ya 8B na makubwa zaidi kwenye VPS yanaonyesha hali halisi ya utendaji wake.

Nini kinachoweza kuendeshwa kwenye VPS ya 32 hadi 64 GB

Model ya 32B yenye bits 4 inachukua takriban 19.2 GB, kwa hivyo inatoshea kwenye mpango wa 32 GB ikiwa na context fupi, na inakaa vizuri kwenye 48 GB au 64 GB. Model ya 70B yenye bits 4 inachukua takriban 42 GB, kulingana na 43 GB ambayo Ollama inataja kwa ajili ya Llama 3.3 70B katika Q4_K_M, kwa hivyo inabana kwenye mpango wa 48 GB ikiwa na context fupi na inahitaji 64 GB kwa kazi ndefu zaidi.

Kisha, tathmini kasi kwa uaminifu. Model ya 32B kwenye CPU inaendesha kwa takriban 0.6 hadi 1.5 tokens kwa sekunde, na 70B kwa 0.2 hadi 0.5. Jibu la tokens 500 kutoka kwa model ya 70B huchukua takriban dakika ishirini. Kwa kasi hiyo, ombi mara nyingi hufeli kabla model haijamaliza, kwa sababu muda wa kusubiri (timeout) wa client au proxy iliyo mbele ya Ollama huisha kwanza, ambapo ndipo kosa la context deadline exceeded hutokea. Hizi ni zana za batch. Zipe foleni ya nyaraka usiku kucha na kasi haitakuwa na umuhimu. Ziweke nyuma ya dirisha la chat na kasi itakuwa na umuhimu mkubwa.

Uelekezaji wa Mixture of Experts (MoE) hubadilisha hesabu hii, na ni maelezo ya usanifu ambayo yanafaa kujifunza. Model ya MoE hutuma kila token kupitia sehemu ndogo tu ya uzito wake (weights). Model yenye jumla ya parameters 30B na 3B zinazofanya kazi kwa kila token inahitaji kumbukumbu ya 30B na inazalisha kwa kasi inayokaribia ile ya model ya 3B, kwa sababu kila token inasoma tu experts wanaofanya kazi. Kwenye mashine ya 32 GB, MoE ya aina hiyo inatumika zaidi kuliko model ya 30B ya kawaida (dense). Kanuni ya kuzingatia: jumla ya parameters huamua kumbukumbu, parameters zinazofanya kazi huamua kasi.

Kasi ya CPU inference ni ipi, kwa kweli?

Kuzalisha token moja kunahitaji kusoma kila uzito (weight) amilifu kutoka kwenye kumbukumbu mara moja. Hakuna kinachoweza kuepuka hili, kwa hivyo kasi ya uzalishaji kwenye CPU huamuliwa na bandwidth ya kumbukumbu na si idadi ya cores. Kikomo ni mgawanyo: bandwidth ya kumbukumbu inayoweza kutumika ikigawanywa na ukubwa wa uzito katika bytes. VPS ndogo ya pamoja kwa uhalisia hutoa 10 hadi 25 GB kwa sekunde kupitia vCPUs zake, kwa hivyo model ya 4.8 GB hufikia ukomo wa karibu token 2 hadi 5 kwa sekunde.

ChatiTypical reported CPU generation speed at 4-bit on a small VPS
Data iliyo nyuma ya chati hii
[
  {
    "label": "3B",
    "tokens_per_second_low": 6,
    "tokens_per_second_high": 14
  },
  {
    "label": "8B",
    "tokens_per_second_low": 3,
    "tokens_per_second_high": 7
  },
  {
    "label": "14B",
    "tokens_per_second_low": 1.5,
    "tokens_per_second_high": 3.5
  },
  {
    "label": "32B",
    "tokens_per_second_low": 0.6,
    "tokens_per_second_high": 1.5
  },
  {
    "label": "70B",
    "tokens_per_second_low": 0.2,
    "tokens_per_second_high": 0.5
  }
]

Hizo ni safu zinazoripotiwa mara kwa mara kwenye vifaa vya kawaida vya VPS, si benchmark ya mashine moja. Takwimu yako inategemea kizazi cha kumbukumbu, idadi ya njia (channels) kwenye host, na ni majirani wangapi wanaoshindania rasilimali hiyo. Pima yako mwenyewe, kwa kutumia tag yoyote ya model uliyo nayo tayari:

ollama run qwen3:4b --verbose "Write three sentences about disk latency."

Muhtasari unaochapishwa baada ya jibu kuisha huishia na mstari unaosomeka eval rate: ... tokens/s. Hiyo ndiyo kasi yako ya uzalishaji. Puuza jaribio la kwanza la kikao, kwa sababu load duration kwenye muhtasari huo huo inajumuisha kusoma uzito kutoka kwenye diski. Kupima tokens kwa sekunde kwa usahihi inaelezea jinsi ya kupata namba inayostahili kulinganishwa.

Matokeo mawili huwashangaza watu hapa. Kuongeza vCPUs huacha kusaidia haraka, kwa sababu baada ya takriban cores 8, cores za ziada husubiri kumbukumbu badala ya kufanya hesabu. Na kwenye mpango wa pamoja, amri hiyo hiyo hurejesha namba tofauti saa kwa saa, jambo ambalo ni CPU steal time kutoka kwa jirani mwenye kelele badala ya kitu chochote ulichokisanidi vibaya.

Kusoma prompt yako ni kazi tofauti na kuzalisha jibu. Uchakataji wa prompt unategemea uwezo wa kompyuta (compute bound), kwa hivyo huongezeka kulingana na cores, na hapo ndipo GPU inapopiga hatua kubwa zaidi. Hati ndefu huchukua CPU dakika kusoma na GPU sekunde. Hilo ndilo kizuizi cha kwanza unachokutana nacho unapokuwa unaelekeza coding agent kwenye model unayohost, kwa sababu kila hatua hutuma tena muktadha wa faili na ufafanuzi wa zana kabla ya token moja ya jibu kurudi.

Nini hubadilika unapoongeza GPU

Hesabu haibadiliki, inabadilika tu kundi inalotumika. VRAM ni kikomo thabiti, kwa hivyo hesabu kile kinachotoshea kabla ya kukodisha:

  • 8 GB ya VRAM inatosheleza modeli ya 7B au 8B kwa bits 4 na context fupi.
  • 16 GB inatosheleza modeli ya 14B kwa bits 4 na context ya kweli, au 8B kwa bits 8.
  • 24 GB inatosheleza modeli ya 32B kwa bits 4 huku context ikiwa fupi.
  • 48 GB inatosheleza modeli ya 70B kwa bits 4 na context ya wastani, na nafasi ya context ndefu na concurrency huanzia juu zaidi, takriban 80 GB.

Wakati modeli haitoshei, Ollama huigawa: tabaka zingine kwenye GPU, zingine kwenye CPU. ollama ps huripoti mgawanyo huo kwenye safu yake ya PROCESSOR, kama kitu kinachofanana na 78%/22% CPU/GPU. Isome hiyo kama onyo badala ya kipengele. Nusu ya CPU ndiyo huweka kasi, kwa sababu kila token bado husubiri tabaka hizo, kwa hivyo modeli yenye robo ya tabaka zake kwenye CPU huenda kwa kasi inayokaribia kasi ya CPU kuliko kasi ya GPU. Ukiona mgawanyo usiotarajiwa, punguza urefu wa context kwanza. Cache ndiyo mara nyingi husababisha kuzidi kwa nafasi.

Concurrency ndiyo sababu nyingine ya kuongeza ukubwa. Weights hushirikiwa kati ya maombi ya wakati mmoja, lakini kila ombi linaloendelea linahitaji KV cache yake yenyewe, kwa hivyo watumiaji kumi wa wakati mmoja wa modeli ya 8B yenye 8k context wanahitaji mara kumi ya 1 GB ya cache juu ya weights. Kuhudumia watumiaji wengi kwa wakati mmoja kutoka kwa modeli moja iliyojiendesha hufafanua mahali ambapo kikomo hicho hufikia.

Ikiwa GPU inafaa kukodishwa ni swali la hesabu pia, na inategemea ni token ngapi kwa mwezi unazozalisha kweli. Kiwango cha usawa kati ya GPU VPS na token za API kina namba hizo.

Mambo ambayo huwezi kuyahifadhi mwenyewe (self-host)

Kuna vikwazo viwili tofauti hapa, na inasaidia kujua ni kipi unachokabiliana nacho.

Cha kwanza ni uzito uliofungwa (closed weights). Modeli za kibiashara za kiwango cha juu hazisambazwi, kwa hivyo hakuna faili ya kupakua na hakuna kiasi cha RAM kinachoweza kubadilisha hilo. Unaweza kuhifadhi mwenyewe kila kitu kinachozunguka modeli hizo: kiolesura, safu ya urejeshaji (retrieval layer), kitanzi cha wakala (agent loop), na logi. Modeli yenyewe inabaki kuwa API ya mbali. Kama unaweza kuhifadhi Claude mwenyewe inaelezea hilo kikamilifu.

Cha pili ni uzito ulio wazi (open weights) ambao ni mkubwa mno. Matoleo makubwa zaidi yaliyo wazi ni miundo ya aina ya mixture of experts yenye mamia ya mabilioni ya vigezo (parameters) kwa jumla. Kanuni hiyo hiyo inatumika kwao: modeli yenye jumla ya vigezo 400B katika 4 bits inahitaji takriban 240 GB kwa ajili ya uzito pekee, kabla ya cache yoyote. Hiyo ni hardware maalum, na kuikodisha kwa mwezi kunagharimu zaidi ya kile ambacho watu wengi hutumia kwa token za API kwa mwaka. Kinachohitajika ili kuhifadhi mwenyewe modeli ya daraja la Kimi kinaelezea mahitaji halisi. Mgawanyo huo huo unaonekana ndani ya maktaba ya Ollama, ambapo GLM 5.2 imeorodheshwa kama modeli ya wingu pekee na ndugu yake mdogo zaidi ndiye anayepakua kwenye VPS.

Mstari wa kweli kati ya hayo mawili: hifadhi mwenyewe wakati mzigo ni thabiti na data haipaswi kuondoka kwenye seva yako. Nunua token wakati mzigo unabadilika-badilika, au wakati ubora wa majibu ya kiwango cha juu ndicho kitu unachohitaji hasa.

Angalia ulichonacho kabla ya kuchagua

free -h
nproc
lscpu | grep 'Model name'

Panga kulingana na safu ya available ya free -h, si safu ya total, kwa sababu total inajumuisha kumbukumbu ambayo mfumo unaitumia tayari. Ondoa takriban 1 GB kwa ajili ya mfumo wa uendeshaji na seva ya modeli. Gawanya kilichobaki kwa 0.6 ili kupata idadi kubwa zaidi ya vigezo (parameters) kwa mabilioni unayoweza kuhifadhi kwa bits 4. Kisha ondoa KV cache kwa ajili ya muktadha (context) unaotaka kutumia. Kilichobaki ndicho jibu lako, na tofauti na orodha ya majina ya modeli, hili halipitwi na wakati.

FAQ

Ninahitaji RAM kiasi gani ili kuendesha modeli ya 8B?

Takriban 4.8 GB kwa ajili ya uzito katika 4 bit quantisation, pamoja na KV cache kwa urefu wa muktadha wako, pamoja na takriban 1 GB kwa ajili ya mfumo wa uendeshaji na seva ya modeli. Katika muktadha wa token 8192, cache huongeza takriban 1 GB, kwa hivyo mpango wa 8 GB hufanya kazi na mpango wa 4 GB haufanyi kazi. Ikiwa unataka muktadha kamili wa 128k ambao kadi ya modeli inatangaza, cache pekee ni 16 GB na unatazama mpango wa 32 GB.

Kwa nini modeli yangu ni ya polepole ingawa VPS ina vCPU nyingi?

Kwa sababu uzalishaji (generation) unadhibitiwa na bandwidth ya kumbukumbu, si kwa cores. Kila token inahitaji kuvuta seti nzima ya uzito inayotumika kutoka RAM, kwa hivyo mara tu cores chache zinapojaza njia za kumbukumbu, nyingine zote husubiri tu. Sababu nyingine ya kawaida ni swap. Ikiwa vmstat 1 inaonyesha si na so katika sifuri kabla ya kutuma prompt na kupanda wakati modeli inajibu, uzito una uwezekano mkubwa wa kutotoshea kwenye RAM na sehemu ya kila token inahudumiwa kutoka kwenye diski, jambo ambalo linagharimu zaidi kuliko inavyoonekana.

Je, dirisha refu zaidi la muktadha linahitaji kumbukumbu zaidi?

Ndiyo, na ukuaji wake ni wa mstari kulingana na token. Modeli ya kawaida ya 8B hutumia takriban 128 KiB ya KV cache kwa kila token, kwa hivyo token 8192 zinagharimu 1 GB na token 131072 zinagharimu 16 GB. Cache hutengwa wakati modeli inapopakiwa badala ya wakati mazungumzo yanapokua, kwa hivyo kuomba muktadha wa 128k kunahifadhi kumbukumbu hiyo mara moja, hata kama kila prompt unayotuma ina urefu wa token 200.

Je, niendeshe modeli kubwa kwa 2 bits au ndogo kwa 4 bits?

Chukua modeli ndogo kwa 4 bits. Ubora hushuka polepole kutoka 8 bits hadi 4 na kwa haraka chini ya 4, kwa hivyo 70B iliyopunguzwa hadi 2 bits kwa kawaida hutoa majibu mabaya kuliko 32B kwa 4 bits kutoka kizazi kimoja cha modeli. Quantisation nzito huonekana kama kurudia maneno na maagizo yaliyopotea badala ya ujumbe wa hitilafu, jambo ambalo hufanya iwe rahisi kulaumu prompt yako. Ichukulie 4 bits kama kiwango cha chini na ubadilishe idadi ya vigezo badala yake.

Je, ninaweza kuhifadhi mwenyewe modeli yenye uwezo kama zile kubwa za kibiashara?

Si kwenye VPS ya kawaida. Modeli zenye nguvu zaidi za uzito ulio wazi zina mamia ya mabilioni ya vigezo, ambayo kwa 4 bits inamaanisha zaidi ya 200 GB ya RAM kabla ya KV cache yoyote, na modeli zenye nguvu zaidi za kibiashara hazisambazwi kabisa. Kile ambacho hardware ya kawaida hufanya vizuri ni kuendesha modeli nzuri ya 8B hadi 32B kwa kazi moja maalum, ambapo modeli ndogo iliyoelekezwa vizuri mara nyingi hulingana na ile ya jumla. Ikiwa unahitaji ubora wa kiwango cha juu, linganisha bei ya API na hardware kabla ya kununua yoyote.

Je, makala hii ilikusaidia?