SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-26

Self-hosted LLM 5 वापरकर्त्यांवर धीमा का होतो?

एक वापरकर्ता सुरळीत, पण पाच जणांवर वेग का घटतो? batching, KV cache, prefill आणि queue depth तुमचा LLM server एकावेळी किती वापरकर्ते हाताळेल ते ठरवतात.

जास्त वापरकर्ते आल्यावर self-hosted LLM चा वेग का कमी होतो?

जेव्हा 5 समवर्ती (concurrent) वापरकर्ते असताना self-hosted LLM चा वेग मंदावतो, तेव्हा त्याचे सामान्य कारण म्हणजे सर्व्हर एका वेळी फक्त एकच उत्तर तयार करण्यासाठी सेट केलेला असतो आणि इतर चार वापरकर्ते रांगेत थांबलेले असतात. Ollama चे डॉक्युमेंटेशन त्याच्या डीफॉल्ट सेटिंगबद्दल स्पष्ट आहे: OLLAMA_NUM_PARALLEL म्हणजे "प्रत्येक मॉडेल एकाच वेळी प्रक्रिया करेल अशा समांतर विनंत्यांची कमाल संख्या, डीफॉल्ट 1 आहे." यात काहीही बिघडलेले नसते आणि सर्व्हिंग सॉफ्टवेअर एकाच वेळी अनेक विनंत्यांवर काम करू शकते. तुमच्या पाचपैकी चार लोक आपली पाळी येण्याची वाट पाहत आहेत कारण सेटिंगमध्ये तसे नमूद केले आहे.

यावर उपाय म्हणून सहसा अधिक शक्तिशाली हार्डवेअरची गरज नसते. त्याऐवजी, एक असे सर्व्हिंग इंजिन आवश्यक असते जे अनेक विनंत्यांना एकाच 'forward pass' मध्ये मॉडेलद्वारे प्रोसेस करते, तसेच हे करत असताना प्रत्येकाचे संभाषण साठवून ठेवण्यासाठी पुरेशी अतिरिक्त मेमरी लागते. या दोन्ही गोष्टी महत्त्वाच्या आहेत आणि दुसरी गोष्टच प्रत्यक्षात तुमच्या क्षमतेची मर्यादा (ceiling) ठरवते.

प्रत्येक विनंती ज्या दोन टप्प्यांतून जाते

Prefill संपूर्ण prompt एकाच वेळी वाचतो आणि त्यासाठी attention cache तयार करतो. प्रत्येक prompt token model मधून एकत्रितपणे जातो. त्यामुळे prefill हा एक मोठा matrix multiply असतो आणि त्याची मर्यादा arithmetic throughput मुळे येते. त्यानंतर decode उत्तर एकावेळी एक token लिहितो. प्रत्येक token साठी model चे संपूर्ण weights पुन्हा memory मधून वाचावे लागतात, परंतु त्या एका token वर होणारी arithmetic अत्यल्प असते. त्यामुळे decode ची मर्यादा memory bandwidth मुळे येते.

Batching कार्यक्षम ठरण्याचे संपूर्ण कारण हीच असममिती आहे. एका user साठी decoding करताना प्रत्येक token साठी, उदाहरणार्थ, 5 GB weights वाचले जातात आणि बहुतेक arithmetic units निष्क्रिय राहतात. दुसरी विनंती जोडल्यावर engine तेच 5 GB एकदाच वाचतो आणि त्यावरून दोन tokens ची गणना करतो. दुसऱ्या user मुळे लागणारा अतिरिक्त वेळ जवळजवळ शून्य असतो. विनंत्या काटेकोरपणे एकामागोमाग एक पूर्ण केल्यास हा लाभ मिळत नाही.

User ला जाणवणाऱ्या अनुभवाचे वर्णन दोन संख्यांनी करता येते. TTFT (time to first token) म्हणजे queue wait अधिक prefill. ITL (inter-token latency) म्हणजे stream केलेल्या tokens मधील अंतर, आणि ते decode द्वारे निर्धारित होते. Server मंद असल्यास, यांपैकी एका घटकात सामान्यतः मंदपणा असतो; आणि दोन्हींसाठीचे उपाय सारखे नसतात. तुम्ही नेमक्या कोणत्या घटकाशी झुंज देत आहात हे कोणतीही setting बदलण्यापूर्वी निश्चित करणे उपयुक्त ठरते. हे शोधण्याचा मार्ग म्हणजे prefill आणि decode यांचा कालावधी स्वतंत्रपणे मोजणे.

Static batching मुळे सर्वांना सर्वात उशिरा येणाऱ्या प्रतिसादाची वाट पाहावी लागते

Static batching ही त्याची साधी आवृत्ती आहे. अॅप्लिकेशन कोडमध्ये विनंत्या स्वतः गटबद्ध केल्यास हेच मिळते. Engine N विनंत्या जमा करतो, त्या एकत्र चालवतो आणि गटातील सर्वात दीर्घ generation पूर्ण होईपर्यंत प्रत्येक slot रोखून ठेवतो.

एखादा user 1,200 token चा सारांश मागत असेल, तर batch मधील चार एक-ओळींची उत्तरेही त्याच batch मध्ये अडकून राहतात. कारण batch मधील सर्वात धीम्या सदस्याचे काम पूर्ण होईपर्यंत batch कोणताही slot मोकळा करत नाही.

यातून दोन खर्च निर्माण होतात. पूर्ण झालेल्या sequences कोणतेही उपयुक्त compute न करताही slots व्यापून ठेवतात. त्यामुळे output length बदलत असल्यास effective throughput कमी होते; chat मध्ये output lengths मध्ये मोठा फरक असतो. Batch तयार झाल्यानंतर एका step ने आलेली विनंती सुरू होण्यापूर्वी संपूर्ण batch रिकामा होईपर्यंत थांबते. त्यामुळे तिचा TTFT दुसऱ्या user च्या मोठ्या मजकुरामुळे ठरतो.

Continuous batching प्रत्येक टोकननंतर विनंत्या स्वीकारते आणि पूर्ण करते

Continuous batching हे प्रत्येक decoding स्टेपच्या स्तरावर शेड्युलिंग करते. प्रत्येक स्टेप पूर्ण झाल्यावर, ज्या सीक्वेन्सनी त्यांचा stop token उत्सर्जित केला आहे, त्यांना शेड्युलर काढून टाकतो आणि त्यानंतर रिक्त स्लॉट्समध्ये नवीन विनंत्या स्वीकारतो. जर एखादा रिप्लाय 40 व्या स्टेपला संपला, तर तो 40 व्या स्टेपलाच आपला स्लॉट रिकामा करतो, बॅचच्या शेवटी नाही.

हे काही वेगळे किंवा दुर्मिळ तंत्र नाही. llama-server हे -cb, --cont-batching ला "continuous batching (ज्याला dynamic batching असेही म्हणतात) सक्षम करायचे का (डिफॉल्ट: enabled)" असे दस्तऐवजीकरण करते. तसेच, ते आपल्या वैशिष्ट्यांमध्ये "multi-user support सह parallel decoding" चा उल्लेख करते. नोव्हेंबर 2025 मध्ये मर्ज झालेल्या बदलामुळे, आता डिफॉल्टनुसार 4 स्लॉट्सपासून सुरुवात होते (-np डिफॉल्ट -1, म्हणजेच auto असते). vLLM हे याच संकल्पनेवर आधारित आहे. Ollama देखील समांतर विनंत्या हाताळते. डिफॉल्ट सेटिंगमध्ये ही संख्या फक्त एकवर मर्यादित असते, म्हणूनच अनेक लोकांना असे वाटते की त्यांचे हार्डवेअर concurrency हाताळू शकत नाही, तर प्रत्यक्षात त्यांच्या कॉन्फिगरेशननेच त्याला नकार दिलेला असतो.

Continuous batching चे प्रकाशित निकाल सहसा अशा डेटासेंटर कार्ड्सवर मोजले जातात, ज्यांच्याकडे अतिरिक्त compute पॉवर आणि कॅशेसाठी दहापट gigabytes मेमरी उपलब्ध असते. त्या निकालांचे स्वरूप तुमच्या सिस्टमसाठीही लागू होते, परंतु त्यांची व्याप्ती (size) लागू होत नाही. याचे कारण खालील मेमरी विभागात दिले आहे.

Prefill त्याच compute साठी decode शी स्पर्धा करते

चार replies stream होत असताना नवीन request आल्यास, तिचा prompt आधी prefill करावा लागतो आणि prefill साठी मोठ्या प्रमाणात compute लागतो. Scheduler ने त्या prefill साठी स्वतंत्र step दिल्यास, त्या काळात चारही streaming users ना एकही token मिळत नाही. मोठ्या prompt मुळे प्रत्येक उघड्या window मध्ये हा स्पष्ट pause दिसतो. इतर कोणी send दाबल्यावर server hiccup होतो असे म्हणताना लोक याच stutter बद्दल बोलतात.

Chunked prefill मोठ्या prompt चे तुकडे करते आणि प्रत्येक तुकडा चालू decode च्या त्याच step मध्ये मिसळते. vLLM च्या tuning guide मध्ये हा tradeoff थेट सांगितला आहे: लहान chunk budgets मुळे “decode धीमे करणारे prefill कमी असल्याने चांगले ITL मिळते”, तर मोठ्या values मुळे “batch मध्ये अधिक prefill tokens process करता येत असल्याने चांगला time to first token (TTFT) मिळतो”. तुम्ही कोणाचा अनुभव जपायचा हे निवडत आहात: reply सुरू होण्याची वाट पाहणारी व्यक्ती की text stream होताना पाहणारे users.

या समस्येची तीव्रता prompt च्या लांबीवर अवलंबून असते. 200 token च्या उत्तरासाठी 6,000 token चा prompt असल्यास, 200 decode steps च्या तुलनेत 6,000 tokens चे prefill काम करावे लागते. Retrieval-augmented chat आणि मोठे system prompts दोन्ही तुम्हाला या परिस्थितीत नेतात. त्यामुळे prefill हा किरकोळ अतिरिक्त वेळ राहत नाही; users ज्याची वाट पाहतात तेच मुख्य काम बनते. मोठा भाग वारंवार समान असल्यास prefix caching मदत करते: vLLM मध्ये --enable-prefix-caching उपलब्ध आहे. प्रत्येक request साठी shared prompt prefix पुन्हा compute करण्याऐवजी ते त्याचा cache पुन्हा वापरते.

सर्वात आधी संपणारी मेमरी म्हणजे KV cache

प्रत्येक सक्रिय संभाषणातील प्रत्येक टोकन मॉडेलच्या प्रत्येक लेयरमध्ये एक key vector आणि value vector सोडून जाते. यालाच KV cache (key/value cache) म्हणतात. यामुळेच प्रत्येक नवीन टोकनसाठी पूर्ण प्रॉम्प्ट पुन्हा मोजण्याची (recompute) गरज पडत नाही. प्रति टोकन कॅश केलेल्या व्हॅल्यूजची संख्या मॉडेलच्या रचनेनुसार निश्चित असते: 2 (एक key, एक value) गुणिले लेयरची संख्या, गुणिले key/value heads ची संख्या, गुणिले head dimension. हे आकडे मॉडेलच्या config.json मधून वाचा. साईज काढण्यासाठी याला प्रति व्हॅल्यू बाइट्सने गुणा. हा शेवटचा घटक रनटाइम सेटिंग आहे, मॉडेलचा भाग नाही: llama-server डीफॉल्टनुसार कॅश f16 (2 बाइट्स) मध्ये साठवते आणि q8_0 ते -ctk आणि -ctv सारखे लहान प्रकार स्वीकारते.

एकदा हे गणित सोडवले की मेमरीची मर्यादा समजणे सोपे होते. 36 लेयर्स, 8 key/value heads आणि 128 head dimension असलेले एक सामान्य 8B मॉडेल, जे 16-बिटमध्ये कॅश साठवते, त्यासाठी प्रति टोकन 2 36 8 128 2 बाइट्स खर्च होतात. हे 147,456 बाइट्स म्हणजेच सुमारे 144 KiB आहेत. त्यामुळे 8,192 टोकनच्या एका संभाषणासाठी सुमारे 1.2 GB कॅश लागते. मॉडेलच्या वजनांव्यतिरिक्त (weights), अशा पाच संभाषणांसाठी सुमारे 6 GB मेमरी लागते आणि किती वापरकर्ते एका वेळी काम करू शकतील याचे हेच खरे उत्तर आहे.

कॉन्करन्सीमुळे (concurrency) कॉन्टेक्स्ट वाढतो आणि टूल्स हे स्पष्टपणे सांगतात. Ollama चे FAQ: "एका विशिष्ट मॉडेलसाठी समांतर विनंत्यांवर प्रक्रिया केल्यास, समांतर विनंत्यांच्या संख्येनुसार कॉन्टेक्स्ट साईज वाढते. उदाहरणार्थ, 4 समांतर विनंत्यांसह 2K कॉन्टेक्स्ट असल्यास, 8K कॉन्टेक्स्ट आणि अतिरिक्त मेमरी अलोकेशन होईल." आवश्यक RAM हे OLLAMA_NUM_PARALLEL गुणिले OLLAMA_CONTEXT_LENGTH नुसार वाढते. llama-server मध्ये, डीफॉल्ट ऑटो स्लॉट काउंट प्रत्येक स्लॉटला एका युनिफाइड KV बफरवर चालवते, त्यामुळे संपूर्ण -c कॉन्टेक्स्ट हा एकच पूल असतो ज्यातून सर्व स्लॉट्स मेमरी घेतात. जर तुम्ही स्वतः -np सेट केले, तर युनिफाइड बफर बंद होतो, जोपर्यंत तुम्ही --kv-unified पास करत नाही. त्यामुळे -c द्वारे तुम्ही मागितलेला कॉन्टेक्स्ट -np स्लॉट्समध्ये विभागला जातो आणि स्लॉट काउंट वाढवल्यास प्रत्येक विनंतीसाठी उपलब्ध मेमरी कमी होते. गृहीत धरण्याऐवजी स्टार्टअप लॉगवरून प्रति-स्लॉट कॉन्टेक्स्ट तपासा.

vLLM त्याऐवजी प्री-अलोकेशन (preallocation) करते. --gpu-memory-utilization (डीफॉल्ट 0.92) म्हणजे "मॉडेल एक्झिक्युटरसाठी वापरल्या जाणाऱ्या GPU मेमरीचा हिस्सा". जोपर्यंत तुम्ही --kv-cache-memory-bytes सेट करत नाही, तोपर्यंत vLLM त्या हिश्श्यातून KV cache ची साईज ठरवते: वजने (weights) आणि इंजिनची वर्किंग मेमरी वजा जाता जेवढी मेमरी शिल्लक राहते, ती paged KV पूल बनते. जेव्हा हा पूल कमी पडतो, तेव्हा शेड्युलर विनंती अयशस्वी करण्याऐवजी तिला काढून टाकतो (evict):

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.

vLLM च्या V1 इंजिनमध्ये डीफॉल्ट प्रीएम्प्शन मोड RECOMPUTE असतो, त्यामुळे काढून टाकलेली विनंती आपली कॅश सोडून देते आणि पुन्हा प्रवेश मिळाल्यावर ती पुन्हा प्रीफिल (prefill) होते. हे काम दोनदा केले जाते. डॉक्युमेंटेशन इशारा देते की "प्रीएम्प्शन आणि रिकम्प्युटेशनचा एंड-टू-एंड लॅटन्सीवर विपरीत परिणाम होऊ शकतो". ही लॉग लाईन एका दुर्दैवी वापरकर्त्याला इतरांपेक्षा जास्त वेळ का वाट पाहावी लागली, याचे सर्वोत्तम स्पष्टीकरण आहे, जरी तुमचा सरासरी वेग चांगला दिसत असला तरीही. एकत्रित संख्या लॉग करण्यासाठी disable_log_stats=False सेट करा किंवा vLLM द्वारे एक्सपोज केलेल्या Prometheus मेट्रिक्समधून प्रीएम्प्शन काउंटर वाचा.

2, 5 आणि 20 एकाचवेळी वापरकर्ते असताना काय बदलते

दोन वापरकर्ते. अतिरिक्त cache असलेल्या GPU वर याचा परिणाम जवळजवळ जाणवत नाही, कारण दुसरा decode stream पहिल्या stream सोबत चालतो आणि त्यासाठी फारच कमी अतिरिक्त वेळ लागतो. केवळ CPU असलेल्या 4 ते 8 GB RAM च्या VPS वर ते विनामूल्य नसते: दोन्ही stream समान काही vCPU आणि समान RAM bandwidth वापरतात. त्यामुळे प्रत्येक वापरकर्त्याला साधारणपणे निम्मे tokens per second मिळतात आणि तुलनेने खूपच कमी असलेल्या budget च्या तुलनेत cache ची मागणी दुप्पट होते.

पाच वापरकर्ते. या टप्प्यावर default settings पुरेशा राहत नाहीत आणि सुरुवात queue च्या समस्येपासून होते. OLLAMA_NUM_PARALLEL 1 वर असल्यास, चार जणांना दीर्घ उत्तराची विनंती करणाऱ्या व्यक्तीची प्रतीक्षा करावी लागते. मात्र प्रत्येकाची पाळी आल्यावर त्यांना नेहमीचा वेग मिळतो. parallel count वाढवल्यावर समस्येचे स्वरूप बदलते: प्रत्येकी 8K context असलेले पाच slots मिळून 40K tokens च्या cache साठी जागा आवश्यक असते. ते VRAM मध्ये मावत नसेल, तर engine काही layers system RAM मध्ये offload करते. ते RAM मध्येही मावत नसेल, तर मशीन swap वापरते आणि tokens per second झपाट्याने कमी होतात.

वीस वापरकर्ते. chat UI मधील वीस माणसे म्हणजे सामान्यतः वीस एकाचवेळी सुरू असलेल्या requests नसतात. Hardware खरेदी करण्यापूर्वी समजून घेण्याची ही सर्वात महत्त्वाची बाब आहे. एखादी व्यक्ती reply वाचते आणि पुढील turn साठी 20 ते 60 seconds विचार करते. त्यामुळे तिचे session बहुतांश वेळ idle असते. वीस agents किंवा वीस document summarisation jobs म्हणजे मात्र idle time नसलेले वीस वास्तविक streams असतात. त्यासाठी वेगळ्या क्षमतेचे machine आवश्यक असते. coding agent ला स्वतःच्या Ollama server कडे निर्देशित करणारा एक developer पहिल्या परिस्थितीपेक्षा दुसऱ्या परिस्थितीच्या अधिक जवळ असतो, कारण task सुरू असेपर्यंत agent requests पाठवत राहतो आणि एखादी व्यक्ती घेते तसे reading pauses ठेवत नाही.

तुमचे वापरकर्ते एकाच वेळी सक्रिय आहेत की फक्त लॉग-इन केलेले आहेत?

कोणत्याही गोष्टीचा आकार निश्चित करण्यापूर्वी, किती विनंत्या (requests) प्रक्रियेत आहेत हे मोजा. याचे गणित साधे आहे: प्रक्रियेतील विनंत्या म्हणजे वापरकर्त्यांची संख्या, गुणिले प्रति टर्न जनरेशनसाठी लागणारे सेकंद, भागिले दोन टर्नमधील सेकंद.

  1. प्रथम तुमच्या स्वतःचा सिंगल-स्ट्रीम वेग मोजा, प्रीफिल आणि डिकोड दोन्ही तपासा. दुसऱ्या कोणाच्या कार्डवरील आकडा वापरू नका: तुमच्या स्वतःच्या बॉक्सवर टोकन्स प्रति सेकंद मोजा आणि तुम्हाला जे मिळेल तेच वापरा.
  2. ड्युटी सायकलचा अंदाज घ्या. वीस चॅट वापरकर्ते, प्रति टर्न 12 सेकंद जनरेशन, दर 90 सेकंदांनी एक टर्न, असे केल्यास 20 * 12 / 90, म्हणजेच सुमारे 2.7 विनंत्या प्रक्रियेत असतात.
  3. स्लॉटची संख्या त्यापेक्षा थोडी जास्त ठेवा, त्यानंतर मेमरीच्या तुलनेत ती तपासा: स्लॉटची संख्या गुणिले प्रति-विनंती संदर्भ (context) हे तुमच्याकडे असलेल्या प्रत्यक्ष कॅशे टोकन्समध्ये बसले पाहिजे.
  4. रांग (queue) लहान ठेवा जेणेकरून ओव्हरफ्लो झाल्यास ते त्वरित आणि स्पष्टपणे समजेल.

उपलब्ध कॅशे टोकन्स म्हणजे वेट्स (weights) नंतर उरलेली मोकळी मेमरी, जिला वरील विभागातील प्रति-टोकन खर्चाने भागले जाते. 16-बिटमध्ये 8B मॉडेल चालवणारे 24 GB कार्ड वेट्सवर सुमारे 16 GB खर्च करते आणि डीफॉल्ट वापरामध्ये जास्तीत जास्त 6 GB कॅशे उपलब्ध असते. वर्किंग मेमरी बाजूला काढल्यानंतर हे प्रमाण थोडे कमी होते, जे सुमारे पाच 8K संभाषणांइतके असते. अधिक क्षमता हवी असल्यास, प्रति-विनंती संदर्भ कमी करा किंवा कॅशे 8-बिटमध्ये साठवा (llama-server साठी --cache-type-k q8_0 लागते). दोन्ही पर्याय काहीतरी गमावून कॉन्करन्सी (concurrency) मिळवून देतात. हार्डवेअरवर पैसे खर्च करण्यापूर्वी या तडजोडीचे प्रामाणिक विश्लेषण वाचणे फायदेशीर ठरेल: GPU VPS कधी API टोकन्सच्या तुलनेत फायदेशीर ठरते.

Ollama चे डीफॉल्ट पुरेसे ठरत नाहीत तेव्हा

parallel count service unit मधून वाढवा, कारण shell export systemd-managed daemon पर्यंत पोहोचणार नाही.

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 ने तुम्ही नुकतेच सेट केलेले तीन variables दाखवले पाहिजेत. तसे झाले नाही, तर drop-in save झालेले नाही आणि तुम्ही केलेली इतर कोणतीही कृती उपयोगी ठरणार नाही. ollama ps नंतर loaded model ची size दाखवते. ही size फक्त weights पेक्षा मोठी असते, कारण 8,192 tokens चे चार slots त्यांच्यासोबत 32,768 tokens cache साठी राखून ठेवतात. सर्व model GPU वर अपेक्षित असताना PROCESSOR column मध्ये model चा काही भाग CPU वर दिसत असल्यास, card वर उपलब्ध असलेल्या cache पेक्षा तुम्ही अधिक cache मागितला आहे. दोनपैकी एक संख्या कमी करा. दोन्हीपैकी context कमी करणे सहसा अधिक सुरक्षित असते. मात्र window खूप लहान असल्यास error न देता long prompts शांतपणे truncate होतात. त्यामुळे model बसेपर्यंत संख्या कमी करत जाण्याऐवजी num_ctx जाणीवपूर्वक योग्य आकारात ठरवा.

queue default कडे पुन्हा पाहणे आवश्यक आहे. Ollama कमाल OLLAMA_MAX_QUEUE requests queue करते आणि "the default is 512". ही मर्यादा ओलांडल्यावर ते "with a 503 error indicating the server is overloaded" असा प्रतिसाद देते. एकावेळी चार requests serve करणाऱ्या box वर 512-deep queue ठेवणे म्हणजे पाळता न येणारे आश्वासन आहे, कारण 300 व्या क्रमांकावरील client ची पाळी येण्यापूर्वीच timeout होतो. लहान queue मुळे application retry किंवा report करू शकेल असा error मिळतो. कधीही पूर्ण न होणाऱ्या spinner पेक्षा हे अधिक उपयुक्त आहे.

प्रत्यक्ष चाचणी करा. दोन terminals मधून एकाच वेळी दोन requests पाठवा आणि दोन्हींचे निरीक्षण करा. पहिली request पूर्ण होईपर्यंत दुसरीकडून काहीही output मिळत नसेल, तर parallel setting लागू झालेली नाही.

जेव्हा प्रत्यक्ष serving engine खर्च भरून काढू लागतो

GPU मध्ये पुरेशी क्षमता शिल्लक असेल आणि साधारणपणे चारपेक्षा अधिक विनंत्या प्रत्यक्षात एकाच वेळी प्रक्रियेत असतील, तेव्हा vLLM ची अतिरिक्त setup योग्य ठरते. त्याचे scheduler token नुसार काम करते. त्याचा cache paged असल्यामुळे मोकळे fragments पुन्हा वापरले जातात. तसेच निष्क्रिय ठेवण्याऐवजी उरलेली VRAM अधिक concurrent विनंत्यांसाठी वापरली जाते. October 2026 पर्यंत दस्तऐवजीकृत GPU install आणि launch साठी तीन commands आहेत. vllm download-kernels हे precompiled kernels fetch करते. अन्यथा vLLM ते startup वेळी download आणि compile करते:

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."}]
    }'

choices array असलेले reply म्हणजे server सुरू आहे आणि model loaded आहे. Load असताना महत्त्वाच्या दोन knobs म्हणजे --max-num-seqs, म्हणजे “एका iteration मध्ये process करता येणाऱ्या sequences ची maximum संख्या”, आणि --max-num-batched-tokens, म्हणजे “एका iteration मध्ये process करता येणाऱ्या tokens ची maximum संख्या”. पहिला knob concurrency मर्यादित करतो. दुसरा आधी वर्णन केलेल्या chunked prefill budget ची मर्यादा ठरवतो.

एकाच वेळी प्रक्रियेत असलेल्या विनंत्यांची संख्या चारपेक्षा कमी असेल, तर vLLM मुळे complexity वाढते आणि लाभ कमी मिळतो. GPU आता आवश्यक नाही. October 2026 पर्यंतच्या CPU install guide मध्ये x86 आणि Arm CPUs वर “basic model inferencing and serving” documented आहे. Version 0.17.0 पासून prebuilt x86 wheels आणि CPU Docker image उपलब्ध आहेत. मात्र memory वापरण्याची पद्धत तशीच राहते. CPU वर system RAM साठी ते 0.92 utilisation fraction वापरते आणि weights नंतर उरलेली memory KV cache ला देते. त्यामुळे default नुसार startup वेळी ते मशीनची बहुतांश memory वापरण्याचा प्रयत्न करते, जोपर्यंत तुम्ही --kv-cache-memory-bytes वापरून cache मर्यादित करत नाही. 4 ते 8 GB VPS वर हा योग्य trade नाही. अशा ठिकाणी shorter context असलेले छोटे model आणि तुम्ही नियंत्रित करत असलेली queue हा योग्य पर्याय आहे. Ollama आणि vLLM serving engines म्हणून कसे वेगळे आहेत या निवडीचे संपूर्ण स्पष्टीकरण देते, तर VPS वर Qwen 3 8B चालवणे एकही अतिरिक्त user जोडण्यापूर्वी mid-sized model साठी आवश्यक असलेल्या संसाधनांची माहिती देते.

लोककथेत लपलेला तडजोडीचा मुद्दा

Continuous batching मुळे एकूण throughput वाढतो आणि median latency देखील सहसा सुधारते, कारण queue मध्ये असलेली request लवकर सुरू होते. Tail latency मात्र उलट दिशेने बदलते आणि या बाजूचा उल्लेख क्वचितच केला जातो.

एखाद्या step मध्ये प्रत्येक अतिरिक्त sequence मुळे थोडे अधिक काम वाढते. त्यामुळे batch भरत जाताना सर्वांसाठी ITL वाढतो. नवीन आलेल्या request च्या prefill साठी streaming वापरकर्त्यांना मिळू शकणाऱ्या step मधील काही वेळ वापरला जातो. Cache वर दबाव आल्यास scheduler preempt करतो. त्यामुळे अर्धवट तयार झालेली request तिच्या prefill च्या सुरुवातीला पुन्हा पाठवली जाते.

Chat UI मध्ये averages नव्हे, तर tails दिसतात. वाक्याच्या मध्यात stream दोन सेकंद थांबला, तर completion साठी लागणारा एकूण वेळ चांगला असला तरी अनुभव बिघडलेला वाटतो. अपेक्षित load अंतर्गत p95 TTFT आणि p95 ITL मोजा. Mean tokens per second कडे अनुभवाचे वर्णन म्हणून नव्हे, तर capacity number म्हणून पाहा.

यावरून practical setting ठरते. Memory जितकी परवानगी देते त्यापेक्षा concurrency किंचित कमी मर्यादित करा, जेणेकरून engine ला preempt करण्याची गरज पडणार नाही. खोल batch वारंवार thrash होण्यापेक्षा लहान आणि अंदाज करता येणारी queue चांगली असते. कारण चार सेकंद प्रतीक्षा करून नंतर सुरळीत stream मिळणारा वापरकर्ता, लगेच सुरू होऊन दोनदा अडखळणाऱ्या stream पेक्षा अधिक समाधानी असतो.

मंद गती असताना काय तपासावे

प्रत्येक वापरकर्त्यासाठी गती सामान्य आहे, पण प्रतीक्षा वेळ जास्त आहे. ही रांग आहे; गतीची समस्या नाही. सर्वप्रथम parallel setting तपासा. मॉडेल योग्यरीत्या सेवा देत आहे, मात्र एका वेळी एकच विनंती हाताळत आहे.

Ollama कडून HTTP 503 मिळतो. रांग पूर्ण भरली आहे. सर्व्हरची क्षमता खरोखरच संपली असू शकते किंवा OLLAMA_MAX_QUEUE जाणूनबुजून कमी ठेवलेले असू शकते, जेणेकरून load कमी करता येईल. या परिस्थितीत तेच अपेक्षित वर्तन आहे.

CPU सर्व्हरवर load असताना tokens per second मोठ्या प्रमाणात कमी होतो. हे घडत असताना vmstat 1 चालवा. si आणि so स्तंभांमध्ये शून्यापेक्षा मोठी मूल्ये दिसत असल्यास मशीन swapping करत आहे. त्यामुळे प्रत्येक token साठी weights disk वरून पुन्हा वाचले जात आहेत. कोणताही configuration बदल ही समस्या दूर करू शकत नाही. मॉडेलचा आकार किंवा slot count कमी करा.

दहा वापरकर्त्यांपैकी एकाची प्रतीक्षा इतरांपेक्षा खूप जास्त असते. vLLM log मध्ये preempted शोधा. Preemption आणि त्यानंतर होणारे recompute हे याचे नेहमीचे कारण आहे. तुम्ही अनुमत केलेल्या context length साठी cache ची मागणी उपलब्ध क्षमतेपेक्षा जास्त आहे, असा याचा अर्थ होतो.

सर्व्हर idle असतानाही TTFT खराब आहे. ही prefill ची समस्या आहे, concurrency ची नाही. पहिला token दिसण्यापूर्वी मोठ्या prompt साठी प्रत्यक्ष वेळ लागतो. त्यामुळे hardware तपासण्यापूर्वी prompt size आणि prefix caching तपासा. शांत कालावधीनंतर परत आलेल्या पहिल्या वापरकर्त्यालाच दीर्घ प्रतीक्षा करावी लागत असेल आणि त्यानंतरचे सर्व वापरकर्ते ठीक असतील, तर ही prefill ची समस्या नाही. Ollama ने मॉडेल unload करून weights पुन्हा disk वरून वाचलेली असू शकतात. ही शक्यता विनंत्यांदरम्यान मॉडेल resident ठेवणे याची खात्री करून नाकारता येते.

FAQ

माझे self-hosted LLM दुसऱ्या व्यक्तीने वापरल्यावर का मंदावते?

बहुतेक वेळा ते मंदावत नाही, तर ते रांगेत (queue) उभे राहते. Ollama मध्ये OLLAMA_NUM_PARALLEL हे 1 वर सेट केलेले असते, त्यामुळे दुसरी विनंती पहिल्या विनंतीचा शेवटचा टोकन (token) येईपर्यंत थांबते. एका वापरकर्त्याचा स्ट्रीम सुरू असताना दुसऱ्याची वाट पाहण्याची वेळ मोजून या दोन परिस्थितींमधील फरक ओळखा: जर एकदा सुरू झाल्यावर त्यांचा tokens per second वेग सामान्य असेल, तर याचा अर्थ रांग लागली आहे आणि parallel count वाढवल्यास ही समस्या सुटेल. जर दोन्ही स्ट्रीम अर्ध्या वेगाने चालत असतील, तर तुम्ही खरोखरच मेमरी बँडविड्थ शेअर करत आहात आणि ही एक हार्डवेअर मर्यादा आहे.

एक लहान GPU किती समवर्ती (concurrent) वापरकर्त्यांना सेवा देऊ शकतो?

वापरकर्त्यांची संख्या नाही, तर मेमरी मोजा. आधी weights, त्यानंतर KV cache, ज्याचा खर्च प्रति टोकन, प्रति सक्रिय संभाषण: 2 गुणिले layers गुणिले key/value heads गुणिले head dimension गुणिले bytes इतका असतो. 36 layers, 8 key/value heads आणि 128 head dimension असलेले एक सामान्य 8B मॉडेल 16-bit मध्ये प्रति टोकन सुमारे 144 KiB घेते, त्यामुळे 8,192 टोकनच्या संभाषणासाठी सुमारे 1.2 GB मेमरी लागते. 24 GB च्या कार्डवर ते मॉडेल 16-bit मध्ये ठेवल्यास cache साठी जास्तीत जास्त 6 GB उरतात, ज्याचा अर्थ पूर्ण context मध्ये सुमारे पाच संभाषणे किंवा context लहान केल्यास अधिक संभाषणे होऊ शकतात.

continuous batching मुळे प्रत्येक वापरकर्त्याचे उत्तर मंद होते का?

Median latency सहसा सुधारते, कारण विनंत्यांना संपूर्ण बॅच पूर्ण होण्याची वाट पाहावी लागत नाही. Tail latency मात्र खराब होते. प्रत्येक अतिरिक्त sequence मुळे प्रत्येक decoding step मध्ये काम वाढते, नवीन येणाऱ्या विनंतीचे prefill हे streaming वापरकर्त्यांच्या कामातील काही भाग हिरावून घेते आणि preempted विनंतीला दोनदा prefill करावे लागते. सरासरी (average) मोजण्याऐवजी p95 inter-token latency मोजा, कारण चॅट विंडोमध्ये सरासरीमुळे लपून राहणारे पॉजेस (pauses) स्पष्टपणे जाणवतात.

मी OLLAMA_NUM_PARALLEL वाढवावे की vLLM वर स्थलांतर करावे?

आधी parallel count वाढवा. हे विनामूल्य आहे आणि यासाठी फक्त एक drop-in फाईल लागते. चार लोक एका लांब उत्तराच्या मागे रांगेत उभे राहतात, अशा सामान्य परिस्थितीवर हा उपाय काम करतो. मेमरी ही मर्यादा आहे: parallel विनंत्या तुम्हाला राखून ठेवाव्या लागणाऱ्या context मध्ये वाढ करतात, त्यामुळे layers CPU वर spill होत नाहीत ना, याकडे लक्ष द्या. जेव्हा तुमच्याकडे VRAM शिल्लक असेल आणि चारपेक्षा जास्त विनंत्या खरोखरच प्रक्रियेत असतील, तेव्हा vLLM वर स्थलांतर करा, कारण त्या टप्प्यावर paged cache आणि per-token scheduling हे त्यांच्या खर्चापेक्षा जास्त फायदा देतात.

अधिक CPU cores मुळे LLM सर्व्हरचा वेग वाढेल का?

वापरकर्त्यांना ज्या भागाचा सर्वाधिक अनुभव येतो, त्यासाठी नाही. Decode करताना प्रत्येक टोकनसाठी संपूर्ण मॉडेल मेमरीमधून वाचावे लागते, त्यामुळे ते RAM बँडविड्थवर अवलंबून असते आणि बँडविड्थ संपल्यावर अतिरिक्त cores काहीही मदत करत नाहीत. Prefill हे cores नुसार वाढते, त्यामुळे अधिक cores असल्यास लांब prompts साठी पहिल्या टोकनचा वेळ कमी होतो. 4 ते 8 GB च्या VPS वर मेमरी क्षमता ही मुख्य मर्यादा असते आणि अधिक vCPUs ऐवजी लहान मॉडेल किंवा लहान context वापरणे हाच प्रभावी उपाय असतो.

हा लेख उपयुक्त होता का?