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

Kwa nini LLM yako hupunguza kasi kwa watumiaji 5?

Gundua sababu ya LLM yako kukwama wakati watumiaji wengi wanapojiunga. Jifunze jinsi ya kurekebisha mipangilio ya KV cache, batching, na queue depth ili kuboresha utendaji wa seva.

Kwa nini LLM inayojihudumia hupungua kasi watumiaji zaidi wanapojiunga?

LLM inayojihudumia inapokwama ikiwa na watumiaji 5 wanaotuma maombi kwa wakati mmoja, sababu ya kawaida ni kwamba seva imesanidiwa kuzalisha jibu moja kwa wakati mmoja, na watumiaji wengine 4 wanasubiri kwenye foleni. Nyaraka za Ollama zinaeleza wazi mpangilio wake wa msingi: OLLAMA_NUM_PARALLEL ni “idadi ya juu ya maombi sambamba ambayo kila modeli itashughulikia kwa wakati mmoja, chaguo-msingi ni 1.” Hakuna kitu kilichoharibika, na programu ya kuhudumia inaweza kushughulikia maombi kadhaa kwa wakati mmoja. Watu 4 kati ya 5 wanasubiri zamu yao kwa sababu mpangilio umeamuru hivyo.

Marekebisho si lazima yawe seva yenye uwezo mkubwa zaidi. Kinachohitajika ni engine ya kuhudumia inayopitisha maombi mengi kwenye modeli wakati wa forward pass moja, pamoja na memory ya ziada ya kutosha kuhifadhi mazungumzo ya kila mtu wakati wa mchakato huo. Sehemu zote mbili ni muhimu, lakini sehemu ya pili ndiyo huweka kikomo chako halisi.

Awamu mbili ambazo kila ombi hupitia

Prefill husoma prompt nzima kwa wakati mmoja na kujenga attention cache yake. Kila token ya prompt hupitia kwenye model kwa pamoja, kwa hivyo prefill ni matrix multiply moja kubwa, na kikomo chake ni arithmetic throughput. Decode kisha huandika jibu token moja kwa wakati. Kila token inahitaji uzito (weights) kamili wa model usomwe kutoka kwenye kumbukumbu tena, wakati hesabu inayofanyika kwenye token hiyo moja ni ndogo sana. Decode ina kikomo cha memory bandwidth.

Asymmetry hiyo ndiyo sababu kuu inayofanya batching kufanya kazi. Decoding kwa mtumiaji mmoja husoma, tuseme, 5 GB ya weights kwa kila token na kuacha sehemu kubwa ya vitengo vya hesabu (arithmetic units) bila kazi. Ukiongeza ombi la pili, injini husoma 5 GB ileile mara moja, kisha huhesabu token mbili kutoka hapo. Mtumiaji wa pili hatumii muda wowote wa ziada. Kuhudumia maombi moja baada ya jingine kwa ukali hupoteza faida hiyo.

Namba mbili hufafanua kile mtumiaji anachokiona. TTFT (time to first token) ni muda wa kusubiri kwenye foleni pamoja na prefill. ITL (inter-token latency) ni pengo kati ya token zinazotiririshwa, na huwekwa na decode. Seva ya polepole kwa kawaida huwa na tatizo katika mojawapo ya haya, na masuluhisho yake si sawa. Ni muhimu kubaini ni ipi unayopambana nayo kabla ya kubadilisha mpangilio wowote, na kupima prefill na decode kando ndiyo njia ya kujua.

Static batching huwafanya wote kusubiri jibu la polepole zaidi

Static batching ni mbinu ya msingi, na ndiyo unayopata unapojipangia maombi mwenyewe kwenye msimbo wa programu. Injini hukusanya maombi N, huyaendesha pamoja, na kushikilia kila nafasi hadi kizazi kirefu zaidi kwenye kundi hilo kikamilike.

Mtumiaji mmoja anayeomba muhtasari wa token 1,200 huweka majibu manne ya mstari mmoja yakiwa yamefungwa kwenye batch, kwa sababu batch haitoi nafasi yoyote hadi mwanachama wake wa polepole zaidi amalize.

Gharama mbili hujitokeza. Mfuatano uliokamilika huendelea kuchukua nafasi ambazo hazifanyi hesabu yoyote muhimu, kwa hivyo throughput halisi hupungua kadiri urefu wa matokeo unavyotofautiana, na urefu wa matokeo ya gumzo hutofautiana sana. Ombi linalowasili hatua moja baada ya batch kuundwa husubiri batch nzima imalizike kabla hata ya kuanza prefill, jambo linalomaanisha kuwa TTFT yake huamuliwa na insha ya mtu mwingine.

Continuous batching huingiza na kuondoa maombi katika kila tokeni

Continuous batching hupanga maombi kwa kiwango cha hatua moja ya decoding. Baada ya kila hatua, scheduler huondoa sequences zilizotoa stop token, kisha huingiza maombi yanayosubiri kwenye slots zilizo wazi. Jibu linalokamilika katika hatua ya 40 huachilia slot yake katika hatua ya 40, si mwisho wa batch.

Hili si jambo la kipekee. llama-server inaandika -cb, --cont-batching kama "iwapo continuous batching (pia huitwa dynamic batching) iwashwe (default: imewashwa)", inaorodhesha "Parallel decoding with multi-user support" miongoni mwa vipengele vyake, na tangu mabadiliko yaliyounganishwa mnamo November 2025 huanza kwa slots 4 kwa default (-np huwa na default ya -1, auto). vLLM imejengwa kuzunguka wazo hili. Ollama pia huhudumia maombi yanayotekelezwa kwa sambamba. Default huweka kikomo cha idadi kuwa moja tu. Ndiyo maana watu wengi huhitimisha kuwa hardware yao haiwezi kutumia concurrency, kumbe configuration yao ndiyo iliyokataa.

Matokeo yaliyochapishwa kuhusu continuous batching kwa kawaida hupimwa kwenye datacenter cards zenye compute ya ziada na makumi ya gigabytes kwa cache. Muundo wa matokeo hayo unatumika pia kwenye kompyuta yako. Ukubwa wake hautumiki moja kwa moja, na sehemu ya memory hapa chini inaeleza sababu.

Prefill inashindana na decode kwa ajili ya rasilimali za kompyuta

Ombi jipya linapowasili wakati majibu manne yanatiririka, prompt yake lazima ifanyiwe prefill kwanza, na prefill inahitaji nguvu kubwa ya kompyuta. Ikiwa scheduler itatoa hatua ya kipekee kwa prefill hiyo, watumiaji wanne wanaotiririsha data hawapokei token yoyote wakati huo. Kwenye prompt ndefu, hii ni kusita kunakoonekana katika kila dirisha lililofunguliwa. Hii ndiyo hali ya kukwama ambayo watu huirejelea wanaposema seva inasita kila wakati mtu mwingine anapobonyeza kitufe cha kutuma.

Chunked prefill huvunja prompt ndefu katika vipande na kuchanganya kila kipande kwenye hatua moja na decode zinazoendelea. Mwongozo wa tuning wa vLLM unaeleza bayana uwiano huo: bajeti ndogo za chunk "hufanikisha ITL bora zaidi kwa sababu kuna prefill chache zinazochelewesha decode", wakati thamani za juu "hufanikisha muda bora zaidi wa kupata token ya kwanza (TTFT) kwa kuwa unaweza kuchakata token nyingi zaidi za prefill katika batch moja". Unachagua ni uzoefu wa nani wa kulinda: mtu anayesubiri jibu lianze, au watu wanaotazama maandishi yakitiririka.

Urefu wa prompt huamua ukubwa wa athari hii. Prompt ya token 6,000 yenye jibu la token 200 ni kazi ya prefill ya token 6,000 dhidi ya hatua 200 za decode. Mazungumzo yanayotumia retrieval-augmented na system prompts ndefu vyote vinakuingiza katika hali hiyo, hivyo prefill huacha kuwa kiasi kidogo kisicho na maana na kuwa kitu ambacho watumiaji wanasubiri. Prefix caching husaidia wakati sehemu ndefu inajirudia: vLLM hutoa --enable-prefix-caching, ambayo hutumia tena cache kwa ajili ya prefix ya prompt inayoshirikiwa badala ya kuikokotoa upya kwa kila ombi.

Kumbukumbu inayojaa kwanza ni KV cache

Kila token katika kila mazungumzo yanayoendelea huacha key vector na value vector katika kila layer ya model. Hiyo ndiyo KV cache (key/value cache), na ndiyo inayowezesha decode kuepuka kuhesabu upya prompt nzima kwa kila token mpya. Idadi ya values zinazohifadhiwa kwa kila token huamuliwa na muundo wa model: 2 (key moja na value moja) ikizidishwa kwa idadi ya layers, idadi ya key/value heads, na head dimension. Soma nambari hizo kutoka kwenye config.json ya model. Zidisha kwa bytes kwa kila value ili kupata ukubwa. Kipengele hicho cha mwisho ni setting ya runtime, si sehemu ya model: llama-server huhifadhi cache katika f16 (bytes 2) kwa default na inakubali types ndogo kama q8_0 kupitia -ctk na -ctv.

Fanya hesabu hiyo mara moja, na kikomo hakitakuwa tena fumbo. Model ya kawaida ya 8B yenye layers 36, key/value heads 8 na head dimension ya 128, ikiwa cache imehifadhiwa katika 16-bit, hutumia 2 36 8 128 2 bytes kwa kila token. Hiyo ni bytes 147,456, takriban KiB 144. Mazungumzo moja yenye tokens 8,192 yanahitaji takriban GB 1.2 ya cache. Mazungumzo matano yanahitaji takriban GB 6, juu ya weights. Hilo ndilo jibu halisi la idadi ya users wanaoweza kutumika.

Concurrency huzidisha context, na tools hulionyesha wazi. FAQ ya Ollama inasema: "Usindikaji wa maombi sambamba kwa model fulani huongeza context size kwa idadi ya maombi sambamba. Kwa mfano, context ya 2K yenye maombi 4 sambamba itakuwa context ya 8K na allocation ya ziada ya memory." RAM inayohitajika huongezeka kulingana na OLLAMA_NUM_PARALLEL ikizidishwa kwa OLLAMA_CONTEXT_LENGTH. Katika llama-server, idadi ya default ya slots huendesha kila slot kwenye unified KV buffer moja. Kwa hiyo, context yote ya -c ni pool moja ambayo slots hutumia. Ukiweka -np mwenyewe, unified buffer huzimwa isipokuwa upitishe pia --kv-unified. Hivyo, context unayoomba kwa -c hugawanywa kati ya slots -np, na kuongeza idadi ya slots pekee hupunguza kiasi ambacho kila request inaweza kuhifadhi. Soma context ya kila slot kutoka kwenye startup log badala ya kuikadiria.

vLLM hutenga memory mapema badala yake. --gpu-memory-utilization (default 0.92) ni "sehemu ya GPU memory itakayotumiwa na model executor". Usipoweka --kv-cache-memory-bytes, vLLM hukadiria ukubwa wa KV cache kutokana na sehemu hiyo: bajeti inayobaki baada ya kuzingatia weights na working memory iliyopimwa ya engine huwa paged KV pool. Pool hiyo ikikosa nafasi, scheduler humtoa request badala ya kuifeli:

WARNING 05-09 00:49:33 scheduler.py:1057] Sequence group 0 is preempted by PreemptionMode.RECOMPUTE mode because there is not enough KV cache space.

Katika V1 engine ya vLLM, preemption mode ya default ni RECOMPUTE. Kwa hiyo, request iliyotolewa hupoteza cache yake na hufanya prefill tena inaporudishwa kwenye utekelezaji. Kazi hiyo hufanywa mara mbili. Documentation inaonya kwamba "preemption na recomputation zinaweza kuathiri vibaya latency ya mwisho hadi mwisho". Mstari huu wa log ndiyo maelezo bora zaidi ya kwa nini user mmoja asiye na bahati alisubiri muda mrefu zaidi kuliko wengine, ilhali wastani wako ulionekana mzuri. Weka disable_log_stats=False ili kurekodi jumla ya idadi hiyo, au soma preemption counter kutoka kwenye Prometheus metrics ambazo vLLM hutoa.

Mabadiliko yanayotokea kwa watumiaji 2, 5 na 20 kwa wakati mmoja

Watumiaji wawili. Karibu haionekani kwenye GPU yenye cache ya ziada, kwa sababu mtiririko wa pili wa decode huambatana na wa kwanza kwa muda mfupi sana wa ziada. Kwenye VPS inayotumia CPU pekee yenye 4 hadi 8 GB ya RAM, hii si bure: mitiririko yote miwili hushiriki vCPU chache zilezile na bandwidth ileile ya RAM, kwa hivyo kila mtumiaji huona takriban nusu ya token kwa sekunde, na mahitaji ya cache huongezeka maradufu dhidi ya bajeti ndogo zaidi.

Watumiaji watano. Hapa ndipo mipangilio chaguo-msingi inapokoma kutosheleza, na tatizo huanza kama foleni. Kwa OLLAMA_NUM_PARALLEL ikiwa 1, watu wanne husubiri yeyote aliyeomba jibu refu, na kila mmoja wao huona kasi ya kawaida wakati zamu yake inapofika. Ongeza idadi ya parallel na tatizo hubadilika umbo: nafasi tano zenye 8K context kila moja ni 40K ya token cache inayopaswa kupatikana. Ikiwa haitoshei kwenye VRAM, injini huhamisha layers kwenye RAM ya mfumo, na ikiwa haitoshei kwenye RAM, mashine huanza kufanya swapping na token kwa sekunde huporomoka.

Watumiaji ishirini. Watu ishirini kwenye UI ya chat kwa kawaida si maombi ishirini ya wakati mmoja, na hili ndilo jambo muhimu zaidi kulielewa kabla ya kununua vifaa. Mtu husoma jibu na kufikiri kwa sekunde 20 hadi 60 kati ya zamu, kwa hivyo sehemu kubwa ya session yao huwa imetulia. Mawakala ishirini, au kazi ishirini za kufupisha hati, ni mitiririko ishirini halisi bila muda wowote wa kutulia. Hiyo ni mashine ya aina nyingine. Msanidi programu mmoja ambaye ameelekeza wakala wa kuandika msimbo kwenye seva yake ya Ollama yuko karibu zaidi na hali ya pili kuliko ya kwanza, kwa sababu wakala huendelea kutuma maombi mradi kazi inaendelea na haachi mapumziko ya kusoma kama anavyofanya binadamu.

Je, watumiaji wako wanafanya maombi kwa wakati mmoja, au wameingia tu?

Kadiria maombi yanayoendelea kabla ya kupanga ukubwa wa mfumo. Hesabu ni rahisi: maombi yanayoendelea ni sawa na idadi ya watumiaji, ikizidishwa kwa sekunde zinazotumika kuzalisha kila mzunguko, kisha kugawanywa kwa sekunde kati ya mizunguko.

  1. Pima kwanza kasi yako ya mkondo mmoja, yaani prefill na decode. Usitumie nambari kutoka kwenye card ya mtu mwingine: pima tokens kwa sekunde kwenye mashine yako na utumie matokeo uliyopata.
  2. Kadiria duty cycle. Watumiaji 20 wa chat, sekunde 12 za uzalishaji kwa kila mzunguko, na mzunguko mmoja kila baada ya sekunde 90, hutoa 20 * 12 / 90, ambayo ni takriban maombi 2.7 yanayoendelea.
  3. Weka idadi ya slots juu kidogo ya thamani hiyo, kisha iangalie dhidi ya memory: idadi ya slots ikizidishwa kwa context ya kila ombi lazima itoshee ndani ya cache tokens ulizonazo.
  4. Weka queue fupi ili maombi yanayozidi uwezo yashindwe haraka na kwa uwazi.

Cache tokens zinazopatikana ni memory ya bure baada ya weights, ikigawanywa kwa gharama ya kila token kutoka kwenye sehemu iliyo hapo juu. Card ya 24 GB inayoendesha model ya 8B kwa 16-bit hutumia takriban 16 GB kwa weights na huwa na cache inayoweza kutumika ya takriban 6 GB kwa utilisation ya kawaida, ikiwa kidogo chini baada ya kutenga working memory. Hii ni sawa na takriban mazungumzo matano ya 8K. Ili kutosheleza zaidi, punguza context ya kila ombi, au hifadhi cache kwa 8-bit (llama-server huchukua --cache-type-k q8_0). Chaguo zote mbili huongeza concurrency kwa kutoa kitu fulani, na ni muhimu kusoma maelezo halisi ya trade-off hiyo kabla ya kuwekeza fedha kwenye hardware: mahali GPU VPS inalingana na gharama ya API tokens.

Wakati mipangilio chaguo-msingi ya Ollama haitoshi tena

Ongeza idadi ya maombi yanayochakatwa kwa wakati mmoja (parallel count) kupitia unit ya huduma, kwa sababu export ya shell haitafika kwenye daemon inayodhibitiwa na systemd.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_MAX_QUEUE=64"
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment
ollama ps

systemctl show inapaswa kuonyesha vigezo vitatu ulivyoweka sasa hivi. Ikiwa haionyeshi, basi drop-in haikuhifadhiwa, na hakuna kingine utakachofanya kitakachosaidia. ollama ps kisha huorodhesha modeli iliyopakiwa ikiwa na ukubwa mkubwa kuliko uzito (weights) pekee, kwa sababu nafasi nne za 8,192 tokens huhifadhi 32,768 tokens za cache kando yake. Safu ya PROCESSOR inayoonyesha sehemu ya modeli kwenye CPU wakati ulitarajia yote iwe kwenye GPU inamaanisha uliomba cache nyingi kuliko kile ambacho kadi ilikuwa nacho. Punguza mojawapo ya namba hizo mbili. Kupunguza context kwa kawaida ni njia salama zaidi, lakini dirisha dogo mno litakata prompts ndefu kimya kimya badala ya kutoa error, hivyo ni vyema kupanga num_ctx kwa makusudi badala ya kuipunguza hadi modeli itoshee.

Chaguo-msingi la foleni (queue) linastahili kuangaliwa upya. Ollama hupanga hadi maombi OLLAMA_MAX_QUEUE, na "chaguo-msingi ni 512". Baada ya hapo, hujibu "kwa error ya 503 inayoashiria kuwa seva imezidiwa". Foleni ya 512 kwenye seva inayohudumia wanne kwa wakati mmoja ni ahadi ambayo huwezi kuitekeleza, kwa sababu mteja aliye kwenye nafasi ya 300 atapata timeout muda mrefu kabla ya zamu yake kufika. Foleni fupi hurejesha error ambayo programu yako inaweza kujaribu tena au kutoa taarifa, jambo ambalo ni bora kuliko spinner isiyomalizika.

Ijaribu kikamilifu. Tuma maombi mawili kwa wakati mmoja kutoka kwenye terminal mbili na ufuatilie yote mawili. Ikiwa la pili halitoi matokeo yoyote hadi la kwanza limalize, basi mpangilio wa parallel haukufanya kazi.

Wakati injini halisi ya kuhudumia inaanza kujilipia

vLLM inastahili usanidi wake wa ziada unapokuwa na GPU yenye uwezo uliobaki na zaidi ya takriban maombi manne yanayoshughulikiwa kwa wakati mmoja. Scheduler yake hufanya kazi kwa kila tokeni, cache yake imegawanywa katika kurasa ili vipande vilivyo huru vitumike tena, na hubadilisha VRAM iliyobaki kuwa uwezo wa kushughulikia maombi mengi badala ya kuiacha bila kutumika. Kufikia October 2026, usanidi na uanzishaji wa GPU ulioandikwa unahitaji amri tatu. vllm download-kernels hupakua kernels zilizotengenezwa mapema ambazo vLLM ingelazimika kupakua na kuzikompile wakati wa kuanza:

uv pip install vllm --torch-backend=auto
vllm download-kernels
vllm serve Qwen/Qwen2.5-1.5B-Instruct
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-1.5B-Instruct",
        "messages": [{"role": "user", "content": "Say hello."}]
    }'

Jibu lenye array ya choices linamaanisha kuwa server imeanza na model imepakiwa. Wakati wa mzigo, vigezo viwili muhimu ni --max-num-seqs, "idadi ya juu zaidi ya sequences zinazoweza kuchakatwa katika iteration moja", na --max-num-batched-tokens, "idadi ya juu zaidi ya tokeni zinazoweza kuchakatwa katika iteration moja". Cha kwanza huweka kikomo cha concurrency. Cha pili ni bajeti ya chunked prefill iliyoelezwa hapo awali.

Chini ya maombi manne yanayoshughulikiwa kwa wakati mmoja, vLLM huongeza ugumu na hutoa faida ndogo. GPU haihitajiki tena: kufikia October 2026, mwongozo wa usakinishaji wa CPU unaeleza "basic model inferencing and serving" kwenye CPU za x86 na Arm, ukiwa na wheels za x86 zilizotengenezwa mapema tangu version 0.17.0 pamoja na CPU Docker image. Hata hivyo, tabia yake ya kutumia memory hubaki ileile. Kwenye CPU, hutumia sehemu ileile ya 0.92 ya system RAM na kuipa KV cache memory inayobaki baada ya weights, hivyo kwa chaguo-msingi huchukua sehemu kubwa ya memory ya mashine wakati wa kuanza isipokuwa uweke kikomo cha cache kwa --kv-cache-memory-bytes. Huo si mpangilio unaofaa kwenye VPS yenye 4 hadi 8 GB. Hapo, suluhisho ni model ndogo yenye context fupi na queue unayoidhibiti. jinsi Ollama na vLLM zinavyotofautiana kama injini za kuhudumia inaeleza chaguo hili kwa ukamilifu, na kuendesha Qwen 3 8B kwenye VPS inaonyesha mahitaji ya model ya ukubwa wa kati kabla hujaongeza mtumiaji hata mmoja wa ziada.

Mambo ya kuzingatia ambayo mara nyingi hayasemwi

Continuous batching huongeza jumla ya throughput, na kwa kawaida huboresha median latency pia, kwa sababu ombi lililopo kwenye foleni huanza kuchakatwa mapema. Hata hivyo, tail latency huathirika vibaya, na upande huu mara nyingi hauzungumziwi.

Kila sequence ya ziada katika hatua moja huongeza kiasi kidogo cha kazi, hivyo ITL huongezeka kwa kila mtu kadiri batch inavyojaa. Prefill ya ombi jipya huchukua sehemu ya muda wa hatua ambayo watumiaji wanaopokea data kwa mtiririko (streaming) wangeitumia. Chini ya shinikizo la cache, scheduler hufanya preemption, jambo ambalo hurudisha ombi lililozalishwa nusu kuanza upya mchakato wake wa prefill.

UI ya chat huonyesha tails, si wastani. Mtiririko wa data unaositisha kwa sekunde mbili katikati ya sentensi huonekana kama umeharibika, hata kama muda wa jumla wa kukamilisha kazi ni mzuri. Pima p95 TTFT na p95 ITL chini ya mzigo unaotarajia, na chukulia wastani wa tokens kwa sekunde kama namba ya uwezo wa mfumo badala ya maelezo ya uzoefu wa mtumiaji.

Usanidi wa kivitendo hutokana na hayo. Punguza concurrency kidogo chini ya kile ambacho kumbukumbu (memory) inaruhusu, ili engine isilazimike kufanya preemption. Foleni fupi inayotabirika ni bora kuliko batch kubwa inayosababisha thrashing, kwa sababu mtumiaji anayesubiri sekunde nne kisha akapokea data kwa mtiririko laini anaridhika zaidi kuliko mtumiaji anayeanza mara moja kisha akakwama mara mbili.

Mambo ya kukagua wakati mfumo ni mzito

Kila mtumiaji ni wa kawaida, lakini kusubiri ni kwingi. Hii ni foleni (queue), si tatizo la kasi. Kagua mpangilio wa parallel kwanza. Model inahudumia kwa usahihi, ombi moja kwa wakati mmoja.

HTTP 503 kutoka kwa Ollama. Foleni imejaa. Aidha seva imefika uwezo wake wa juu, au OLLAMA_MAX_QUEUE imewekwa chini kwa makusudi ili kupunguza mzigo, jambo ambalo ndilo unalotaka lifanyike.

Tokens kwa sekunde hupungua sana chini ya mzigo kwenye seva ya CPU. Endesha vmstat 1 wakati tatizo linatokea. Safu wima za si na so zisizo sifuri humaanisha mashine inafanya swapping, kwa hivyo weights zinasomwa kutoka kwenye diski kwa kila token. Hakuna mabadiliko ya configuration yatakayosaidia hili. Punguza ukubwa wa model au idadi ya slots.

Mtumiaji mmoja kati ya kumi anasubiri muda mrefu zaidi ya wengine. Tafuta preempted kwenye log ya vLLM. Preemption na uhesabuji wake upya ndiyo sababu ya kawaida, na hii humaanisha cache imezidiwa kwa urefu wa context unaoruhusu.

TTFT ni mbaya hata wakati seva haina kazi. Hii ni prefill, si concurrency. Prompt ndefu huchukua muda halisi kabla ya token ya kwanza kuonekana, kwa hivyo angalia ukubwa wa prompt na prefix caching kabla ya kuangalia hardware. Ikiwa kusubiri kwa muda mrefu kunampata mtu wa kwanza tu baada ya kipindi cha utulivu na kila mtu anayefuata yuko sawa, hiyo si prefill hata kidogo bali ni Ollama kuondoa model kwenye kumbukumbu na kusoma weights kutoka kwenye diski tena, jambo ambalo ni vyema kuliondoa kwa kuiweka model kwenye kumbukumbu kati ya maombi.

FAQ

Kwa nini LLM yangu ninayohost mwenyewe hupunguza kasi mtu wa pili anapoitumia?

Mara nyingi haipunguzi kasi kabisa. Huziweka ombi kwenye foleni. Ollama husafirisha OLLAMA_NUM_PARALLEL ikiwa na thamani ya 1, kwa hiyo ombi la pili husubiri la kwanza litoe token yake ya mwisho. Tofautisha hali hizi mbili kwa kupima muda wa stream ya mtumiaji mmoja huku mwingine akisubiri: ikiwa kasi ya token kwa sekunde ni ya kawaida mara tu mtumiaji wa pili anapoanza, kuna foleni, na kuongeza idadi ya parallel hutatua tatizo hilo. Ikiwa stream zote mbili zinafanya kazi kwa nusu ya kasi, mnashiriki bandwidth ya memory kwa kweli, na huo ni ukomo wa hardware.

GPU moja ndogo inaweza kuhudumia watumiaji wangapi kwa wakati mmoja?

Hesabu memory, si watumiaji. Anza na weights, kisha KV cache, ambayo hutumia 2 mara layers mara key/value heads mara head dimension mara bytes, kwa kila token na kwa kila mazungumzo yanayoendelea. Model ya kawaida ya 8B yenye layers 36, key/value heads 8 na head dimension 128 hutumia takribani 144 KiB kwa token katika 16-bit, kwa hiyo mazungumzo yenye token 8,192 yanahitaji takribani 1.2 GB. Card ya 24 GB iliyo na model hiyo katika 16-bit huwa na takribani 6 GB pekee kwa cache, ambayo ni sawa na mazungumzo matano yenye context kamili, au zaidi ukifupisha context.

Continuous batching hufanya jibu la kila mtumiaji liwe la polepole?

Latency ya wastani kwa kawaida huboreka, kwa sababu maombi hayaendelei kusubiri batch nzima ikamilike. Tail latency huwa mbaya zaidi. Kila sequence ya ziada huongeza kazi katika kila hatua ya decoding, ombi jipya linapochakatwa kwa prefill huchukua sehemu ya hatua kutoka kwa watumiaji wanaopokea stream, na ombi lililositishwa lazima lifanye prefill mara mbili. Pima p95 inter-token latency, si wastani, kwa sababu dirisha la chat huonyesha pause kwa urahisi kuliko wastani.

Niongeze OLLAMA_NUM_PARALLEL au nihamie vLLM?

Ongeza idadi ya parallel kwanza. Hii hailipishwi na inahitaji file moja ya drop-in, na hutatua hali ya kawaida ambapo watu wanne husubiri nyuma ya jibu moja refu. Memory ndiyo ukomo: maombi ya parallel huongeza mara nyingi context unayopaswa kuhifadhi, kwa hiyo fuatilia kama layers zinahamishwa kwenda CPU. Hamia vLLM unapokuwa na GPU yenye VRAM ya ziada na zaidi ya maombi manne yanayochakatwa kwa wakati mmoja, kwa sababu hapo paged cache na per-token scheduling huleta faida inayozidi gharama yake.

Cores nyingi zaidi za CPU zitatatua seva ya LLM yenye mwendo wa polepole?

Si kwa sehemu ambayo watumiaji huiona zaidi. Decode husoma model nzima kutoka kwenye memory kwa kila token, kwa hiyo huzuiwa na RAM bandwidth, na cores za ziada huacha kusaidia bandwidth inapojazwa. Prefill huongezeka kwa ufanisi kadiri cores zinavyoongezeka, kwa hiyo cores zaidi hupunguza muda hadi token ya kwanza kwenye prompts ndefu. Kwenye VPS ya 4 hadi 8 GB, kizuizi kikuu huwa ni uwezo wa memory, na suluhisho linalofaa kwa kawaida ni model ndogo au context fupi badala ya vCPUs zaidi.

Je, makala hii ilikusaidia?

#vllm#ollama#batching#throughput#self-hosted-ai