वीलैम क्विकस्टार्ट: उच्च प्रदर्शन एलएलएम सर्विंग

त्वरित एलएलएम इन्फरेंस ओपनएआई एपीआई के साथ

Page content

vLLM एक उच्च-थ्रूपुट, मेमोरी-क्षमता वाले इन्फरेंस और सर्विंग इंजन है जो बड़े भाषा मॉडल (LLMs) के लिए विकसित किया गया है, जो UC Berkeley के Sky Computing Lab द्वारा विकसित किया गया है।

अपनी क्रांतिकारी PagedAttention एल्गोरिदम के साथ, vLLM पारंपरिक सर्विंग विधियों की तुलना में 14-24 गुना अधिक थ्रूपुट प्राप्त करता है, जिससे यह उत्पादन LLM तैनाती के लिए सबसे अच्छा विकल्प बन जाता है।

vllm logo

vLLM क्या है?

vLLM (वर्चुअल LLM) एक ओपन-सोर्स लाइब्रेरी है जो तेज़ LLM इन्फरेंस और सर्विंग के लिए है, जो उत्पादन तैनाती के लिए उद्योग मानक बन गया है। 2023 में जारी किया गया, यह PagedAttention पेश करता है, एक क्रांतिकारी मेमोरी प्रबंधन तकनीक जो सर्विंग की कुशलता को महत्वपूर्ण रूप से बढ़ाती है।

मुख्य विशेषताएं

उच्च थ्रूपुट प्रदर्शन: vLLM HuggingFace Transformers की तुलना में उसी हार्डवेयर के साथ 14-24 गुना अधिक थ्रूपुट प्रदान करता है। यह विशाल प्रदर्शन लाभ निरंतर बैचिंग, ऑप्टिमाइज़्ड CUDA कर्नल्स, और PagedAttention एल्गोरिदम से आता है जो मेमोरी फ्रैगमेंटेशन को समाप्त करता है।

OpenAI API संगतता: vLLM में एक बिल्ट-इन API सर्वर शामिल है जो OpenAI के फॉर्मेट के साथ पूर्ण रूप से संगत है। यह OpenAI से स्व-होस्टेड इन्फ्रास्ट्रक्चर में आसान प्रवास की अनुमति देता है बिना एप्लिकेशन कोड में बदलाव किए। बस अपने API क्लाइंट को vLLM के एंडपॉइंट पर निर्देशित करें और यह पारदर्शी रूप से काम करता है।

PagedAttention एल्गोरिदम: vLLM के प्रदर्शन के पीछे का मुख्य नवाचार PagedAttention है, जो ध्यान तंत्रों के लिए वर्चुअल मेमोरी पेजिंग की अवधारणा लागू करता है। KV कैशों के लिए निरंतर मेमोरी ब्लॉक्स आवंटित करने (जो फ्रैगमेंटेशन का कारण बनता है) के बजाय, PagedAttention मेमोरी को फिक्स्ड-साइज ब्लॉक्स में विभाजित करता है जो आवश्यकता के अनुसार आवंटित किए जा सकते हैं। यह मेमोरी की बर्बादी को 4 गुना तक कम करता है और बहुत बड़े बैच साइज की अनुमति देता है।

निरंतर बैचिंग: स्टैटिक बैचिंग जहां आप सभी अनुक्रमों के पूरा होने की प्रतीक्षा करते हैं, के विपरीत, vLLM निरंतर (रोलिंग) बैचिंग का उपयोग करता है। जैसे ही एक अनुक्रम पूरा होता है, एक नया बैच में जोड़ा जा सकता है। यह GPU उपयोग को अधिकतम करता है और आने वाली रिक्वेस्ट्स के लिए लेटेंसी को कम करता है।

मल्टी-GPU समर्थन: vLLM टेंसर पैरालेलिज्म और पाइपलाइन पैरालेलिज्म का समर्थन करता है ताकि बड़े मॉडल को कई GPUs पर वितरित किया जा सके। यह उन मॉडल्स को कुशलतापूर्वक सर्व कर सकता है जो एक एकल GPU के मेमोरी में फिट नहीं होते हैं, 2 से 8+ GPUs तक के कॉन्फ़िगरेशन का समर्थन करता है।

वाइड मॉडल समर्थन: LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma, और अन्य कई लोकप्रिय मॉडल आर्किटेक्चर के साथ संगत है। HuggingFace Hub से दोनों निर्देश-ट्यून और बेस मॉडल्स का समर्थन करता है।

vLLM का उपयोग कब करें

vLLM उन विशिष्ट स्थितियों में उत्कृष्ट प्रदर्शन करता है जहां इसकी ताकतें उभर कर सामने आती हैं:

उत्पादन API सेवाएं: जब आपको API के माध्यम से कई समानांतर उपयोगकर्ताओं को LLM सर्व करना हो, तो vLLM के उच्च थ्रूपुट और कुशल बैचिंग इसे सबसे अच्छा विकल्प बनाते हैं। चैटबॉट्स, कोड असिस्टेंट्स, या कंटेंट जनरेशन सेवाएं प्रदान करने वाले कंपनियों को इसके हजारों रिक्वेस्ट्स प्रति सेकंड हैंडल करने की क्षमता से लाभ होता है।

उच्च-संवेदनशीलता कार्यभार: अगर आपका एप्लिकेशन कई समानांतर उपयोगकर्ताओं के साथ है जो रिक्वेस्ट्स भेज रहे हैं, तो vLLM की निरंतर बैचिंग और PagedAttention अधिक उपयोगकर्ताओं को उसी हार्डवेयर के साथ सर्व करने की अनुमति देती है।

लागत अनुकूलन: जब GPU लागत एक चिंता हो, तो vLLM का उत्कृष्ट थ्रूपुट यह सुनिश्चित करता है कि आप उसी ट्रैफिक को कम GPUs के साथ सर्व कर सकते हैं, जिससे सीधे इन्फ्रास्ट्रक्चर लागत कम होती है। PagedAttention से 4 गुना मेमोरी कुशलता भी छोटे, सस्ते GPU इंस्टेंस का उपयोग करने की अनुमति देती है।

क्यूबर्नेट्स तैनाती: vLLM की स्टेटलेस डिजाइन और कंटेनर-मित्रवत आर्किटेक्चर इसे क्यूबर्नेट्स क्लस्टर्स के लिए आदर्श बनाता है। इसकी लोड के तहत स्थिर प्रदर्शन और सरल संसाधन प्रबंधन क्लाउड-नेटिव इन्फ्रास्ट्रक्चर के साथ अच्छी तरह से एकीकृत होता है।

vLLM का उपयोग कब न करें: स्थानीय विकास, प्रयोग, या एकल-उपयोगकर्ता स्थितियों के लिए, Ollama जैसे टूल्स बेहतर उपयोगकर्ता अनुभव प्रदान करते हैं जिसमें सरल सेटअप होता है। vLLM की जटिलता तब उचित होती है जब आपको उत्पादन कार्यभार के लिए इसके प्रदर्शन लाभों की आवश्यकता हो।

vLLM का इंस्टॉलेशन कैसे करें

पूर्वापेक्षाएँ

vLLM इंस्टॉल करने से पहले, सुनिश्चित करें कि आपका सिस्टम इन आवश्यकताओं को पूरा करता है:

  • GPU: NVIDIA GPU के साथ कम्प्यूट क्षमता 7.0+ (V100, T4, A10, A100, H100, RTX 20/30/40 सीरीज)
  • CUDA: संस्करण 11.8 या उच्चतर
  • Python: 3.8 से 3.11
  • VRAM: 7B मॉडल्स के लिए न्यूनतम 16GB, 13B के लिए 24GB+, बड़े मॉडल्स के लिए 40GB+
  • ड्राइवर: NVIDIA ड्राइवर 450.80.02 या नई

pip के माध्यम से इंस्टॉलेशन

सबसे सरल इंस्टॉलेशन विधि pip का उपयोग करना है। यह CUDA 11.8 या नई के साथ सिस्टम्स पर काम करता है:

# एक वर्चुअल एन्वायरनमेंट बनाएं (सिफारिश की जाती है)
python3 -m venv vllm-env
source vllm-env/bin/activate

# vLLM इंस्टॉल करें
pip install vllm

# इंस्टॉलेशन की पुष्टि करें
python -c "import vllm; print(vllm.__version__)"

अलग CUDA संस्करणों वाले सिस्टम्स के लिए, उपयुक्त व्हील इंस्टॉल करें:

# CUDA 12.1 के लिए
pip install vllm==0.4.2+cu121 -f https://github.com/vllm-project/vllm/releases

# CUDA 11.8 के लिए
pip install vllm==0.4.2+cu118 -f https://github.com/vllm-project/vllm/releases

Docker के साथ इंस्टॉलेशन

Docker उत्पादन के लिए सबसे विश्वसनीय तैनाती विधि प्रदान करता है:

# आधिकारिक vLLM इमेज डाउनलोड करें
docker pull vllm/vllm-openai:latest

# GPU समर्थन के साथ vLLM चलाएं
docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-7B-Instruct-v0.2

--ipc=host फ्लैग मल्टी-GPU सेटअप्स के लिए महत्वपूर्ण है क्योंकि यह उचित इंटर-प्रोसेस संचार को सक्षम करता है।

स्रोत से बिल्ड करना

नवीनतम विशेषताओं या कस्टम संशोधनों के लिए, स्रोत से बिल्ड करें:

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

vLLM क्विकस्टार्ट गाइड

अपने पहले मॉडल को चलाना

कमांड-लाइन इंटरफेस का उपयोग करके एक मॉडल के साथ vLLM शुरू करें:

# HuggingFace Hub से Mistral-7B डाउनलोड और OpenAI-संगत API के साथ सर्व करें
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000

vLLM स्वचालित रूप से मॉडल को HuggingFace Hub से डाउनलोड करेगा (अगर कैश नहीं है) और सर्वर शुरू करेगा। आप सर्वर तैयार होने का संकेत देने वाली आउटपुट देखेंगे:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000

API रिक्वेस्ट्स भेजना

एक बार सर्वर चलने के बाद, आप OpenAI Python क्लाइंट या curl का उपयोग करके रिक्वेस्ट्स भेज सकते हैं:

curl का उपयोग करना:

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.2",
        "prompt": "Explain what vLLM is in one sentence:",
        "max_tokens": 100,
        "temperature": 0.7
    }'

OpenAI Python क्लाइंट का उपयोग करना:

from openai import OpenAI

# अपने vLLM सर्वर पर निर्देशित करें
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM डिफ़ॉल्ट रूप से प्रमाणिकरण की आवश्यकता नहीं है
)

response = client.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    prompt="Explain what vLLM is in one sentence:",
    max_tokens=100,
    temperature=0.7
)

print(response.choices[0].text)

चैट कम्प्लीशन्स API:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is PagedAttention?"}
    ],
    max_tokens=200
)

print(response.choices[0].message.content)

उन्नत कॉन्फ़िगरेशन

vLLM प्रदर्शन को अनुकूलित करने के लिए कई पैरामीटर्स प्रदान करता है:

python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000 \
    --gpu-memory-utilization 0.95 \  # GPU मेमोरी का 95% उपयोग करें
    --max-model-len 8192 \            # अधिकतम अनुक्रम लंबाई
    --tensor-parallel-size 2 \        # टेंसर पैरालेलिज्म के साथ 2 GPUs का उपयोग करें
    --dtype float16 \                 # FP16 प्रिसिजन का उपयोग करें
    --max-num-seqs 256                # अधिकतम बैच साइज

मुख्य पैरामीटर्स की व्याख्या:

  • --gpu-memory-utilization: GPU मेमोरी का कितना उपयोग करना है (0.90 = 90%)। उच्च मान बड़े बैच की अनुमति देते हैं लेकिन मेमोरी स्पाइक्स के लिए कम मार्जिन छोड़ते हैं।
  • --max-model-len: अधिकतम संदर्भ लंबाई। इसे कम करने से बड़े बैच के लिए मेमोरी बचती है।
  • --tensor-parallel-size: मॉडल को कितने GPUs पर विभाजित करना है।
  • --dtype: वेट्स के लिए डेटा टाइप (float16, bfloat16, या float32)। FP16 आमतौर पर आदर्श होता है।
  • --max-num-seqs: एक बैच में प्रोसेस करने के लिए अधिकतम अनुक्रमों की संख्या।

vLLM vs Ollama तुलना

vLLM और Ollama दोनों लोकल LLM होस्टिंग के लिए लोकप्रिय विकल्प हैं, लेकिन वे अलग-अलग उपयोग के मामलों को टारगेट करते हैं। प्रत्येक टूल का उपयोग कब करना है, इसका समझना आपकी परियोजना की सफलता को महत्वपूर्ण रूप से प्रभावित कर सकता है।

प्रदर्शन और थ्रूपुट

vLLM को बहु-उपयोगकर्ता परिदृश्यों में अधिकतम थ्रूपुट के लिए डिज़ाइन किया गया है। इसके PagedAttention और निरंतर बैचिंग के माध्यम से सैकड़ों समकालिक अनुरोधों को कुशलतापूर्वक सेवा प्रदान की जा सकती है। बेंचमार्क्स दिखाते हैं कि vLLM 14-24x अधिक थ्रूपुट प्राप्त करता है जो मानक कार्यान्वयनों से और 2-4x अधिक Ollama से उच्च समकालिकता के तहत।

Ollama एकल-उपयोगकर्ता इंटरैक्टिव उपयोग के लिए अनुकूलित है, जिसमें व्यक्तिगत अनुरोधों के लिए कम लेटेंसी पर ध्यान केंद्रित किया गया है। जबकि यह vLLM के बहु-उपयोगकर्ता थ्रूपुट को नहीं मिला सकता, यह विकास और व्यक्तिगत उपयोग के लिए उत्कृष्ट प्रदर्शन प्रदान करता है, जिसमें तेज़ कोल्ड-स्टार्ट समय और कम निष्क्रिय संसाधन उपभोग होता है।

उपयोग की आसानी

Ollama सरलता में निर्णायक रूप से जीत जाता है। स्थापना एक ही कमांड (curl | sh) है, और मॉडल चलाना इतना ही सरल है जैसे ollama run llama2। इसमें विभिन्न हार्डवेयर प्रोफाइल के लिए अनुकूलित क्वांटाइज्ड संस्करणों के साथ एक मॉडल लाइब्रेरी शामिल है। उपयोगकर्ता अनुभव डॉकर के समान है – पुल, चलाएं, और चलें।

vLLM अधिक सेटअप की आवश्यकता होती है: Python वातावरण प्रबंधन, CUDA स्थापना, सेवा पैरामीटर की समझ, और मैन्युअल मॉडल स्पेसिफिकेशन। सीखने का पथ कठिन है, लेकिन आपको प्रदर्शन अनुकूलन पर फाइन-ग्रेन्ड कंट्रोल मिलता है। यह जटिलता उत्पादन तैनाती के लिए उचित है जहां आपको अपने हार्डवेयर से अधिकतम प्रदर्शन प्राप्त करना होता है।

API और एकीकरण

vLLM बॉक्स में OpenAI-संगत REST APIs प्रदान करता है, जिससे यह मौजूदा अनुप्रयोगों में OpenAI के API के लिए एक ड्रॉप-इन रिप्लेसमेंट बन जाता है। यह उत्पादन सेवाओं को क्लाउड प्रदाताओं से स्व-होस्टेड इन्फ्रास्ट्रक्चर में कोड बदलाव के बिना माइग्रेट करने के लिए महत्वपूर्ण है।

Ollama एक सरल REST API और एक समर्पित Python/JavaScript लाइब्रेरी प्रदान करता है। जबकि कार्यात्मक, यह OpenAI-संगत नहीं है, जिससे OpenAI के फॉर्मेट की अपेक्षा करने वाले अनुप्रयोगों के साथ एकीकरण करने के लिए कोड बदलाव की आवश्यकता होती है। हालांकि, समुदाय परियोजनाएं जैसे Ollama-OpenAI एडाप्टर इस अंतर को पाटती हैं।

मेमोरी प्रबंधन

vLLM का PagedAttention एल्गोरिदम समकालिक अनुरोधों के लिए उत्कृष्ट मेमोरी दक्षता प्रदान करता है। यह नैवाइव कार्यान्वयनों की तुलना में 2-4x अधिक समकालिक उपयोगकर्ताओं को उसी VRAM के साथ सेवा दे सकता है। यह उत्पादन तैनाती में प्रति अनुरोध लागत में सीधे बचत में बदल जाता है।

Ollama सरल मेमोरी प्रबंधन का उपयोग करता है जो एकल-उपयोगकर्ता परिदृश्यों के लिए उपयुक्त है। यह गतिविधि के आधार पर मॉडल लोडिंग/अनलोडिंग को स्वचालित रूप से प्रबंधित करता है, जो विकास के लिए सुविधाजनक है लेकिन उच्च-समकालिकता उत्पादन उपयोग के लिए अनुकूल नहीं है।

मल्टी-GPU समर्थन

vLLM नेटिव टेंसर पैरलेलिज्म और पाइपलाइन पैरलेलिज्म के साथ उत्कृष्ट प्रदर्शन करता है, मॉडल को 2-8+ GPUs के बीच कुशलतापूर्वक वितरित करता है। यह एकल GPU में फिट नहीं होने वाले बड़े मॉडल जैसे 70B पैरामीटर LLMs को सेवा देने के लिए आवश्यक है।

Ollama वर्तमान में सीमित मल्टी-GPU समर्थन है, मुख्य रूप से एकल GPU के साथ सबसे अच्छा काम करता है। यह वितरित इन्फरेंस की आवश्यकता वाले बहुत बड़े मॉडल के लिए कम उपयुक्त बनाता है।

उपयोग के मामले की सिफारिशें

vLLM का चयन करें जब:

  • उत्पादन APIs को कई समकालिक उपयोगकर्ताओं के लिए सेवा देने के लिए
  • क्लाउड तैनाती में प्रति अनुरोध लागत को अनुकूलित करने के लिए
  • Kubernetes या कंटेनर ऑर्केस्ट्रेशन प्लेटफॉर्म में चलाने के लिए
  • मौजूदा अनुप्रयोगों के लिए OpenAI API संगतता की आवश्यकता हो
  • मल्टी-GPU समर्थन की आवश्यकता वाले बड़े मॉडल सेवा करने के लिए
  • प्रदर्शन और थ्रूपुट महत्वपूर्ण आवश्यकताएं हों

Ollama का चयन करें जब:

  • स्थानीय विकास और प्रयोग
  • एकल-उपयोगकर्ता इंटरैक्टिव उपयोग (व्यक्तिगत सहायक, चैटबॉट)
  • तेज़ प्रोटोटाइपिंग और मॉडल मूल्यांकन
  • LLM के बारे में सीखने के लिए इन्फ्रास्ट्रक्चर जटिलता के बिना
  • व्यक्तिगत वर्कस्टेशन या लैपटॉप पर चलाने के लिए
  • सरलता और उपयोग की आसानी प्राथमिकताएं हों

कई टीमों का उपयोग दोनों का होता है: विकास और प्रयोग के लिए Ollama, फिर उत्पादन तैनाती के लिए vLLM। यह संयोजन डेवलपर उत्पादकता को बनाए रखते हुए उत्पादन प्रदर्शन को बनाए रखता है।

vLLM vs Docker Model Runner

डॉकर ने हाल ही में मॉडल रनर (पहले GenAI स्टैक) को स्थानीय AI मॉडल तैनाती के लिए अपना आधिकारिक समाधान पेश किया है। यह vLLM के साथ कैसे तुलना करता है?

आर्किटेक्चर दर्शन

डॉकर मॉडल रनर का उद्देश्य “AI के लिए Docker” बनना है – AI मॉडल को स्थानीय रूप से चलाने का एक सरल, मानकीकृत तरीका, जिसकी आसानी कंटेनर चलाने की तरह ही है। यह जटिलता को छिपाता है और विभिन्न मॉडल और फ्रेमवर्क के बीच एक सुसंगत इंटरफेस प्रदान करता है।

vLLM एक विशेषीकृत इन्फरेंस इंजन है जो केवल LLM सेवा के लिए अधिकतम प्रदर्शन के साथ केंद्रित है। यह एक निम्न-स्तरीय टूल है जिसे आप Docker के साथ कंटेनराइज़ करते हैं, बजाय एक पूर्ण प्लेटफॉर्म के।

सेटअप और शुरूआत

डॉकर मॉडल रनर स्थापना डॉकर उपयोगकर्ताओं के लिए सरल है:

docker model pull llama3:8b
docker model run llama3:8b

यह Docker के इमेज वर्कफ्लो के समानता इसे कंटेनर का उपयोग करने वाले डेवलपर्स के लिए तुरंत परिचित बनाता है।

vLLM अधिक प्रारंभिक सेटअप की आवश्यकता होती है (Python, CUDA, डिपेंडेंसी) या प्री-बिल्ट Docker इमेज का उपयोग करना:

docker pull vllm/vllm-openai:latest
docker run --runtime nvidia --gpus all vllm/vllm-openai:latest --model <model-name>

प्रदर्शन विशेषताएं

vLLM PagedAttention और निरंतर बैचिंग के कारण बहु-उपयोगकर्ता परिदृश्यों के लिए उत्कृष्ट थ्रूपुट प्रदान करता है। उत्पादन API सेवाओं के लिए जो सेकंड में सैकड़ों अनुरोधों को हैंडल करते हैं, vLLM के अनुकूलन 2-5x बेहतर थ्रूपुट प्रदान करते हैं जो सामान्य सेवा दृष्टिकोणों की तुलना में।

डॉकर मॉडल रनर अधिकतम प्रदर्शन के बजाय उपयोग की आसानी पर ध्यान केंद्रित करता है। यह स्थानीय विकास, परीक्षण, और मध्यम कार्यभार के लिए उपयुक्त है, लेकिन vLLM को स्केल पर उत्कृष्ट बनाने वाले उन्नत अनुकूलन को लागू नहीं करता है।

मॉडल समर्थन

डॉकर मॉडल रनर एक क्यूरेटेड मॉडल लाइब्रेरी प्रदान करता है जिसमें एकल कमांड के साथ लोकप्रिय मॉडल तक पहुंच है। यह कई फ्रेमवर्क (केवल LLMs नहीं) का समर्थन करता है जिसमें Stable Diffusion, Whisper, और अन्य AI मॉडल शामिल हैं, जिससे यह विभिन्न AI कार्यभार के लिए अधिक बहुमुखी बन जाता है।

vLLM LLM इन्फरेंस में विशेषज्ञता रखता है जिसमें ट्रांसफॉर्मर-आधारित भाषा मॉडल के लिए गहरा समर्थन है। यह किसी भी HuggingFace-संगत LLM का समर्थन करता है लेकिन छवि उत्पादन या भाषण पहचान जैसे अन्य AI मॉडल प्रकारों तक नहीं फैला है।

उत्पादन तैनाती

vLLM Anthropic, Replicate, और अन्य कंपनियों में उत्पादन में परीक्षण किया गया है जो दैनिक रूप से अरबों टोकन सेवा करते हैं। इसके प्रदर्शन विशेषताएं और भारी लोड के तहत स्थिरता इसे उत्पादन LLM सेवा के लिए डिफ़ॉल्ट मानक बनाती हैं।

डॉकर मॉडल रनर नया है और स्वयं को विकास और स्थानीय परीक्षण परिदृश्यों के लिए अधिक पोजीशन करता है। जबकि यह उत्पादन ट्रैफिक को सेवा दे सकता है, लेकिन उत्पादन तैनाती की आवश्यकताओं के लिए आवश्यक सिद्धांत और प्रदर्शन अनुकूलन का अभाव है।

एकीकरण पारिस्थितिकी

vLLM उत्पादन इन्फ्रास्ट्रक्चर टूल्स के साथ एकीकरण करता है: Kubernetes ऑपरेटर्स, Prometheus मेट्रिक्स, Ray के लिए वितरित सेवा, और मौजूदा अनुप्रयोगों के लिए व्यापक OpenAI API संगतता।

डॉकर मॉडल रनर स्वाभाविक रूप से Docker के पारिस्थितिकी और Docker Desktop के साथ एकीकरण करता है। Docker पारिस्थितिकी में मानकीकृत टीमों के लिए यह एक समग्र अनुभव प्रदान करता है लेकिन कम विशेषीकृत LLM सेवा विशेषताएं।

प्रत्येक का उपयोग कब करें

vLLM का उपयोग करें:

  • उत्पादन LLM API सेवाओं के लिए
  • उच्च-थ्रूपुट, बहु-उपयोगकर्ता तैनाती के लिए
  • अधिकतम दक्षता की आवश्यकता वाले लागत-संवेदनशील क्लाउड तैनाती के लिए
  • Kubernetes और क्लाउड-नेटिव वातावरण के लिए
  • जब आपको सिद्ध स्केलेबिलिटी और प्रदर्शन की आवश्यकता हो

डॉकर मॉडल रनर का उपयोग करें:

  • स्थानीय विकास और परीक्षण के लिए
  • विभिन्न AI मॉडल प्रकारों (केवल LLMs नहीं) चलाने के लिए
  • Docker पारिस्थितिकी में गहरे निवेश वाली टीमों के लिए
  • इन्फ्रास्ट्रक्चर सेटअप के बिना तेज़ प्रयोग के लिए
  • सीखने और शैक्षिक उद्देश्यों के लिए

हाइब्रिड दृष्टिकोण: कई टीमें स्थानीय सुविधा के लिए Docker Model Runner से विकास करती हैं, फिर प्रदर्शन के लिए vLLM से उत्पादन में तैनाती करती हैं। Docker Model Runner इमेज का उपयोग vLLM कंटेनर चलाने के लिए भी किया जा सकता है, दोनों दृष्टिकोणों को मिलाकर।

उत्पादन तैनाती सर्वोत्तम प्रथाएँ

डॉकर तैनाती

एक उत्पादन-तैयार डॉकर कॉम्पोज़ कॉन्फ़िगरेशन बनाएं:

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    environment:
      - CUDA_VISIBLE_DEVICES=0,1
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --tensor-parallel-size 2
      --gpu-memory-utilization 0.90
      --max-num-seqs 256
      --max-model-len 8192      
    restart: unless-stopped
    shm_size: '16gb'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

कubernates तैनाती

उत्पादन पैमाने पर vLLM को कubernates पर तैनात करें:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.2
          - --tensor-parallel-size
          - "2"
          - --gpu-memory-utilization
          - "0.90"
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: cache
        hostPath:
          path: /mnt/huggingface-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

निगरानी और अवलोकन

vLLM प्रोमेथियस मेट्रिक्स को निगरानी के लिए एक्सपोज़ करता है:

import requests

# मेट्रिक्स प्राप्त करें
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

निगरानी के लिए मुख्य मेट्रिक्स:

  • vllm:num_requests_running - सक्रिय अनुरोध
  • vllm:gpu_cache_usage_perc - KV कैश उपयोग
  • vllm:time_to_first_token - लैटेंसी मेट्रिक्स
  • vllm:time_per_output_token - जनरेशन स्पीड

प्रदर्शन ट्यूनिंग

GPU मेमोरी उपयोग को अनुकूलित करें: --gpu-memory-utilization 0.90 से शुरू करें और पर्यवेक्षण के आधार पर समायोजित करें। उच्च मान बड़े बैच की अनुमति देते हैं लेकिन ट्रैफिक स्पाइक्स के दौरान OOM त्रुटियों का खतरा होता है।

मैक्स सीक्वेंस लेंथ को समायोजित करें: अगर आपकी उपयोग स्थिति पूर्ण संदर्भ लेंथ की आवश्यकता नहीं है, तो --max-model-len को कम करें। यह बड़े बैच के लिए मेमोरी मुक्त करता है। उदाहरण के लिए, अगर आपको केवल 4K संदर्भ की आवश्यकता है, तो --max-model-len 4096 सेट करें बजाय मॉडल के अधिकतम (आमतौर पर 8K-32K) का उपयोग करने के।

उपयुक्त क्वांटाइजेशन का चयन करें: उन मॉडल के लिए जो इसे समर्थन करते हैं, क्वांटाइज्ड संस्करण (8-बिट, 4-बिट) का उपयोग करें ताकि मेमोरी कम हो और थ्रूपुट बढ़े:

--quantization awq  # AWQ क्वांटाइज्ड मॉडल के लिए
--quantization gptq # GPTQ क्वांटाइज्ड मॉडल के लिए

प्रीफिक्स कैशिंग को सक्षम करें: उन अनुप्रयोगों के लिए जो दोहराए गए प्रॉम्प्ट्स (जैसे चैटबॉट्स के साथ सिस्टम संदेश) होते हैं, प्रीफिक्स कैशिंग को सक्षम करें:

--enable-prefix-caching

यह सामान्य प्रीफिक्स के लिए KV मानों को कैश करता है, जिससे उन अनुरोधों के लिए कंप्यूटेशन कम होता है जो समान प्रॉम्प्ट प्रीफिक्स साझा करते हैं।

सामान्य समस्याओं का समाधान

मेमोरी समाप्ति त्रुटियाँ

लक्षण: सर्वर CUDA मेमोरी समाप्ति त्रुटियों के साथ क्रैश होता है।

समाधान:

  • --gpu-memory-utilization को 0.85 या 0.80 तक कम करें
  • अगर आपकी उपयोग स्थिति अनुमति देती है तो --max-model-len को कम करें
  • --max-num-seqs को कम करें ताकि बैच साइज कम हो
  • एक क्वांटाइज्ड मॉडल संस्करण का उपयोग करें
  • टेंसर पैरालेलिज्म को सक्षम करें ताकि अधिक GPU पर वितरित किया जा सके

कम थ्रूपुट

लक्षण: सर्वर अपेक्षित से कम अनुरोधों को संभालता है।

समाधान:

  • --max-num-seqs को बढ़ाएं ताकि बड़े बैच की अनुमति हो
  • अगर आपका हेडरूम है तो --gpu-memory-utilization को बढ़ाएं
  • htop के साथ CPU बॉटलनेक की जांच करें - तेज़ CPUs पर विचार करें
  • nvidia-smi के साथ GPU उपयोग की जांच करें - यह 95%+ होना चाहिए
  • अगर FP32 का उपयोग कर रहे हैं तो FP16 को सक्षम करें: --dtype float16

धीमी पहली टोकन समय

लक्षण: जनरेशन शुरू होने से पहले उच्च लैटेंसी।

समाधान:

  • लैटेंसी-संवेदनशील अनुप्रयोगों के लिए छोटे मॉडल का उपयोग करें
  • दोहराए गए प्रॉम्प्ट्स के लिए प्रीफिक्स कैशिंग को सक्षम करें
  • लैटेंसी को थ्रूपुट पर प्राथमिकता देने के लिए --max-num-seqs को कम करें
  • समर्थित मॉडल के लिए स्पेकुलेटिव डिकोडिंग पर विचार करें
  • टेंसर पैरालेलिज्म कॉन्फ़िगरेशन को अनुकूलित करें

मॉडल लोडिंग विफलताएँ

लक्षण: सर्वर शुरू नहीं हो पाता है, मॉडल लोड नहीं हो पाता है।

समाधान:

  • मॉडल नाम को HuggingFace फॉर्मेट के साथ सटीक रूप से मिलाएं
  • HuggingFace Hub के साथ नेटवर्क कनेक्टिविटी की जांच करें
  • ~/.cache/huggingface में पर्याप्त डिस्क स्पेस की पुष्टि करें
  • गेटेड मॉडल के लिए HF_TOKEN पर्यावरण चर सेट करें
  • huggingface-cli download <model> के साथ मैन्युअल रूप से डाउनलोड करने का प्रयास करें

उन्नत विशेषताएँ

स्पेकुलेटिव डिकोडिंग

vLLM स्पेकुलेटिव डिकोडिंग का समर्थन करता है, जहां एक छोटा ड्राफ्ट मॉडल टोकन्स का प्रस्ताव करता है जिसे एक बड़ा टारगेट मॉडल द्वारा सत्यापित किया जाता है। यह जनरेशन को 1.5-2x तक तेज़ कर सकता है:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-70b-chat-hf \
    --speculative-model meta-llama/Llama-2-7b-chat-hf \
    --num-speculative-tokens 5

LoRA एडाप्टर्स

एक बेस मॉडल पर कई LoRA एडाप्टर्स को सर्व करने के लिए बिना कई पूर्ण मॉडल लोड किए:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-hf \
    --enable-lora \
    --lora-modules sql-lora=./path/to/sql-adapter \
                   code-lora=./path/to/code-adapter

फिर प्रत्येक अनुरोध के लिए किस एडाप्टर का उपयोग करना है, यह निर्दिष्ट करें:

response = client.completions.create(
    model="sql-lora",  # SQL एडाप्टर का उपयोग करें
    prompt="इसको SQL में बदलें: इस महीने बनाए गए सभी उपयोगकर्ताओं को दिखाएं"
)

मल्टी-LoRA सर्विंग

vLLM का मल्टी-LoRA सर्विंग न्यूनतम मेमोरी ओवरहेड के साथ दर्जनों फाइन-ट्यून किए गए एडाप्टर्स होस्ट करने की अनुमति देता है। यह ग्राहक-विशिष्ट या कार्य-विशिष्ट मॉडल वैरिएंट्स को सर्व करने के लिए आदर्श है:

# विशिष्ट LoRA एडाप्टर के साथ अनुरोध
response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[{"role": "user", "content": "SQL क्वेरी लिखें"}],
    extra_body={"lora_name": "sql-lora"}
)

प्रीफिक्स कैशिंग

दोहराए गए प्रॉम्प्ट प्रीफिक्स के लिए KV कैश को पुनः कंप्यूट करने से बचने के लिए स्वचालित प्रीफिक्स कैशिंग को सक्षम करें:

--enable-prefix-caching

यह विशेष रूप से प्रभावी है:

  • स्थिर सिस्टम प्रॉम्प्ट्स वाले चैटबॉट्स के लिए
  • स्थिर संदर्भ टेम्पलेट्स वाले RAG अनुप्रयोगों के लिए
  • अनुरोधों के बीच दोहराए गए फ्यू-शॉट लर्निंग प्रॉम्प्ट्स के लिए

प्रीफिक्स कैशिंग प्रॉम्प्ट प्रीफिक्स साझा करने वाले अनुरोधों के लिए समय-से-प्रथम-टोकन को 50-80% तक कम कर सकता है।

एकीकरण उदाहरण

LangChain एकीकरण

from langchain.llms import VLLMOpenAI

llm = VLLMOpenAI(
    openai_api_key="EMPTY",
    openai_api_base="http://localhost:8000/v1",
    model_name="mistralai/Mistral-7B-Instruct-v0.2",
    max_tokens=512,
    temperature=0.7,
)

response = llm("PagedAttention को सरल शब्दों में समझाएं")
print(response)

LlamaIndex एकीकरण

from llama_index.llms import VLLMServer

llm = VLLMServer(
    api_url="http://localhost:8000/v1",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    temperature=0.7,
    max_tokens=512
)

response = llm.complete("vLLM क्या है?")
print(response)

FastAPI अनुप्रयोग

from fastapi import FastAPI
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

@app.post("/generate")
async def generate(prompt: str):
    response = await client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.2",
        prompt=prompt,
        max_tokens=200
    )
    return {"result": response.choices[0].text}

प्रदर्शन बेंचमार्क्स

वास्तविक दुनिया के प्रदर्शन डेटा vLLM के फायदों को दर्शाने में मदद करते हैं:

थ्रूपुट तुलना (Mistral-7B पर A100 GPU):

  • vLLM: ~3,500 टोकन्स/सेकंड 64 समकालिक उपयोगकर्ताओं के साथ
  • HuggingFace Transformers: ~250 टोकन्स/सेकंड उसी समकालिकता के साथ
  • Ollama: ~1,200 टोकन्स/सेकंड उसी समकालिकता के साथ
  • परिणाम: vLLM बुनियादी कार्यान्वयनों के मुकाबले 14x सुधार प्रदान करता है

मेमोरी दक्षता (LLaMA-2-13B):

  • मानक कार्यान्वयन: 24GB VRAM, 32 समकालिक सीक्वेंस
  • vLLM के साथ PagedAttention: 24GB VRAM, 128 समकालिक सीक्वेंस
  • परिणाम: उसी मेमोरी के साथ 4x अधिक समकालिक अनुरोध

लोड के तहत लैटेंसी (Mixtral-8x7B पर 2xA100):

  • vLLM: P50 लैटेंसी 180ms, P99 लैटेंसी 420ms 100 req/s पर
  • मानक सर्विंग: P50 लैटेंसी 650ms, P99 लैटेंसी 3,200ms 100 req/s पर
  • परिणाम: vLLM उच्च लोड के तहत स्थिर लैटेंसी बनाए रखता है

इन बेंचमार्क्स से पता चलता है कि vLLM प्रदर्शन पर ध्यान देने वाले उत्पादन LLM सर्विंग के लिए de facto मानक बन गया है।

लागत विश्लेषण

vLLM का चयन करने के लागत निहितार्थों को समझना:

स्थिति: 1M अनुरोध/दिन सर्व करना

मानक सर्विंग के साथ:

  • आवश्यक: 8x A100 GPU (80GB)
  • AWS लागत: ~$32/घंटा × 24 × 30 = $23,040/महीना
  • 1M टोकन्स के लिए लागत: ~$0.75

vLLM के साथ:

  • आवश्यक: 2x A100 GPU (80GB)
  • AWS लागत: ~$8/घंटा × 24 × 30 = $5,760/महीना
  • 1M टोकन्स के लिए लागत: ~$0.19
  • बचत: $17,280/महीना (75% कमी)

यह लागत लाभ पैमाने के साथ बढ़ता है। हर महीने अरबों टोकन्स सर्व करने वाले संगठन vLLM के अनुकूलित सर्विंग का उपयोग करके नैविव कार्यान्वयनों के मुकाबले लाखों डॉलर बचाते हैं।

सुरक्षा विचार

प्रमाणन

vLLM डिफ़ॉल्ट में प्रमाणन शामिल नहीं करता है। उत्पादन के लिए, रिवर्स प्रॉक्सी स्तर पर प्रमाणन लागू करें:

# Nginx कॉन्फ़िगरेशन
location /v1/ {
    auth_request /auth;
    proxy_pass http://vllm-backend:8000;
}

location /auth {
    proxy_pass http://auth-service:8080/verify;
    proxy_pass_request_body off;
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

या एंटरप्राइज़-ग्रेड प्रमाणन और रेट लिमिटिंग के लिए API गेटवे जैसे Kong, Traefik, या AWS API Gateway का उपयोग करें।

नेटवर्क अलगाव

vLLM को निजी नेटवर्क में चलाएं, सीधे इंटरनेट पर एक्सपोज नहीं:

# Kubernetes NetworkPolicy उदाहरण
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: vllm-access
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: api-gateway
    ports:
    - protocol: TCP
      port: 8000

रेट लिमिटिंग

दुरुपयोग को रोकने के लिए रेट लिमिटिंग लागू करें:

# Redis का उपयोग करके रेट लिमिटिंग का उदाहरण
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import redis
from datetime import datetime, timedelta

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.middleware("http")
async def rate_limit_middleware(request, call_next):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"

    requests = redis_client.incr(key)
    if requests == 1:
        redis_client.expire(key, 60)  # 60 सेकंड का विंडो

    if requests > 60:  # प्रति मिनट 60 अनुरोध
        raise HTTPException(status_code=429, detail="Rate limit exceeded")

    return await call_next(request)

मॉडल एक्सेस कंट्रोल

मल्टी-टेनेंट डिप्लॉयमेंट के लिए, नियंत्रित करें कि किस उपयोगकर्ता को किस मॉडल तक पहुंच है:

ALLOWED_MODELS = {
    "user_tier_1": ["mistralai/Mistral-7B-Instruct-v0.2"],
    "user_tier_2": ["mistralai/Mistral-7B-Instruct-v0.2", "meta-llama/Llama-2-13b-chat-hf"],
    "admin": ["*"]  # सभी मॉडल
}

def verify_model_access(user_tier: str, model: str) -> bool:
    allowed = ALLOWED_MODELS.get(user_tier, [])
    return "*" in allowed or model in allowed

माइग्रेशन गाइड

OpenAI से vLLM

API संगतता के कारण OpenAI से स्व-होस्टेड vLLM में माइग्रेट करना सरल है:

पहले (OpenAI):

from openai import OpenAI

client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello"}]
)

बाद में (vLLM):

from openai import OpenAI

client = OpenAI(
    base_url="https://your-vllm-server.com/v1",
    api_key="your-internal-key"  # अगर आपने प्रमाणन जोड़ा है
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Hello"}]
)

केवल दो बदलाव की आवश्यकता है: base_url और model नाम अपडेट करें। अन्य सभी कोड वही रहता है।

Ollama से vLLM

Ollama एक अलग API फॉर्मेट का उपयोग करता है। यहाँ परिवर्तन है:

Ollama API:

import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'llama2',
        'prompt': 'Why is the sky blue?'
    })

vLLM समकक्ष:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.completions.create(
    model="meta-llama/Llama-2-7b-chat-hf",
    prompt="Why is the sky blue?"
)

आपको अपने कोडबेस में API कॉल अपडेट करने होंगे, लेकिन OpenAI क्लाइंट लाइब्रेरी बेहतर त्रुटि हैंडलिंग और फीचर्स प्रदान करती हैं।

HuggingFace Transformers से vLLM

डायरेक्ट पाइथन उपयोग माइग्रेशन:

HuggingFace:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

inputs = tokenizer("Hello", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])

vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.2")
sampling_params = SamplingParams(max_tokens=100)

outputs = llm.generate("Hello", sampling_params)
result = outputs[0].outputs[0].text

vLLM का पाइथन API सरल और बैच इन्फरेंस के लिए बहुत तेज़ है।

vLLM का भविष्य

vLLM तेज़ी से विकास जारी रखता है जिसमें रोमांचक फीचर्स रोडमैप पर हैं:

डिसएग्रीगेटेड सर्विंग: प्रीफिल (प्रॉम्प्ट प्रोसेसिंग) और डिकोड (टोकन जनरेशन) को अलग-अलग GPU पर चलाने के लिए, संसाधन उपयोग को अनुकूलित करने के लिए। प्रीफिल कंप्यूट-बाउंड है जबकि डिकोड मेमोरी-बाउंड है, इसलिए उन्हें विशेष हार्डवेयर पर चलाने से कुशलता बढ़ती है।

मल्टी-नोड इन्फरेंस: बहुत बड़े मॉडल (100B+ पैरामीटर्स) को कई मशीनों पर वितरित करना, एकल-नोड सेटअप के लिए बहुत बड़े मॉडल सर्विंग की अनुमति देना।

एन्हांस्ड क्वांटाइजेशन: GGUF (llama.cpp द्वारा उपयोग किया जाता है) जैसे नए क्वांटाइजेशन फॉर्मेट का समर्थन और बेहतर AWQ/GPTQ इंटीग्रेशन के लिए क्वांटाइज्ड मॉडल के साथ बेहतर प्रदर्शन।

स्पेकुलेटिव डिकोडिंग सुधार: अधिक कुशल ड्राफ्ट मॉडल और एडैप्टिव स्पेकुलेशन रणनीतियाँ ताकि गति बढ़े बिना सटीकता में कोई नुकसान न हो।

अटेंशन ऑप्टिमाइजेशन: FlashAttention 3, रिंग अटेंशन बहुत लंबे कंटेक्स्ट (100K+ टोकन) के लिए, और अन्य कटिंग-एज अटेंशन मेकेनिज्म।

बेहतर मॉडल कवरेज: मल्टीमोडल मॉडल (विज़न-लैंग्वेज मॉडल), ऑडियो मॉडल, और विशेष आर्किटेक्चर के लिए समर्थन बढ़ाना जैसे-जैसे वे उभरते हैं।

vLLM प्रोजेक्ट UC Berkeley, Anyscale, और व्यापक ओपन-सोर्स समुदाय से योगदान के साथ सक्रिय विकास बनाए रखता है। जैसे-जैसे LLM डिप्लॉयमेंट उत्पादन प्रणालियों के लिए अधिक महत्वपूर्ण होता जाता है, vLLM के प्रदर्शन मानक के रूप में अपना भूमिका बढ़ती जाती है।

उपयोगी लिंक्स

इस साइट पर संबंधित लेख

  • लोकल LLM होस्टिंग: पूर्ण 2025 गाइड - Ollama, vLLM, LocalAI, Jan, LM Studio & अधिक - 12+ लोकल LLM होस्टिंग टूल्स का व्यापक तुलना जिसमें विस्तृत vLLM विश्लेषण शामिल है, साथ ही Ollama, LocalAI, Jan, LM Studio और अन्य। API परिपक्वता, टूल कॉलिंग समर्थन, GGUF संगतता और प्रदर्शन बेंचमार्क्स को कवर करता है ताकि सही समाधान चुनने में मदद मिल सके।

  • Ollama चीटशीट - पूर्ण Ollama कमांड रेफरेंस और चीटशीट जिसमें इंस्टॉलेशन, मॉडल प्रबंधन, API उपयोग और लोकल LLM डिप्लॉयमेंट के लिए सर्वोत्तम प्रैक्टिस शामिल हैं। vLLM के साथ या इसके बजाय Ollama का उपयोग करने वाले डेवलपर्स के लिए आवश्यक।

  • Docker Model Runner vs Ollama: किसे चुनना है? - Docker के Model Runner और Ollama के लिए लोकल LLM डिप्लॉयमेंट का गहन तुलना, प्रदर्शन, GPU समर्थन, API संगतता और उपयोग मामलों का विश्लेषण करता है। vLLM के प्रतिस्पर्धी लैंडस्केप को समझने में मदद करता है।

  • Docker Model Runner चीटशीट: कमांड और उदाहरण - AI मॉडल डिप्लॉयमेंट के लिए प्रैक्टिकल Docker Model Runner चीटशीट जिसमें कमांड और उदाहरण शामिल हैं। vLLM के विशेष LLM सर्विंग क्षमताओं के साथ Docker के दृष्टिकोण का तुलना करने वाले टीमों के लिए उपयोगी है।

बाहरी संसाधन और दस्तावेज़ीकरण

  • vLLM GitHub रिपॉजिटरी - विल्लम का आधिकारिक रिपॉजिटरी जिसमें स्रोत कोड, व्यापक दस्तावेज़ीकरण, इंस्टॉलेशन गाइड और सक्रिय समुदाय चर्चाएँ शामिल हैं। नवीनतम फीचर्स के साथ अपडेट रहने और समस्याओं को सुलझाने के लिए आवश्यक संसाधन।

  • vLLM दस्तावेज़ीकरण - बुनियादी सेटअप से लेकर उन्नत कॉन्फ़िगरेशन तक विल्लम के सभी पहलुओं को कवर करने वाला आधिकारिक दस्तावेज़ीकरण। API रेफरेंस, प्रदर्शन ट्यूनिंग गाइड और डिप्लॉयमेंट सर्वोत्तम प्रैक्टिस शामिल हैं।

  • PagedAttention पेपर - विल्लम की कुशलता को सक्षम करने वाले PagedAttention एल्गोरिदम का परिचय देने वाला अकादमिक पेपर। विल्लम के प्रदर्शन लाभों के पीछे तकनीकी नवाचारों को समझने के लिए आवश्यक पठन सामग्री।

  • vLLM ब्लॉग - आधिकारिक विल्लम ब्लॉग जिसमें रिलीज़ घोषणाएँ, प्रदर्शन बेंचमार्क, तकनीकी गहन विश्लेषण और उत्पादन डिप्लॉयमेंट से समुदाय के केस स्टडीज शामिल हैं।

  • HuggingFace मॉडल हब - ओपन-सोर्स LLMs का व्यापक रिपॉजिटरी जो विल्लम के साथ काम करते हैं। अपने उपयोग मामले के लिए सही मॉडल ढूँढने के लिए आकार, कार्य, लाइसेंस और प्रदर्शन विशेषताओं के आधार पर मॉडल खोजें।

  • Ray Serve दस्तावेज़ीकरण - उत्पादन प्रणालियों के लिए स्केलेबल, वितरित विल्लम डिप्लॉयमेंट बनाने के लिए Ray Serve फ्रेमवर्क दस्तावेज़ीकरण। Ray ऑटोस्केलिंग, मल्टी-मॉडल सर्विंग और संसाधन प्रबंधन जैसे उन्नत फीचर्स प्रदान करता है।

  • NVIDIA TensorRT-LLM - NVIDIA के TensorRT-LLM के लिए अत्यधिक ऑप्टिमाइज्ड इन्फरेंस NVIDIA GPUs पर। विल्लम का विकल्प अलग-अलग ऑप्टिमाइजेशन रणनीतियों के साथ, इन्फरेंस ऑप्टिमाइजेशन लैंडस्केप को समझने के लिए उपयोगी है।

  • OpenAI API रेफरेंस - आधिकारिक OpenAI API दस्तावेज़ीकरण जिसका विल्लम का API संगत है। जब भी एप्लिकेशन बनाना हो जो OpenAI और स्व-होस्टेड विल्लम एंडपॉइंट्स को आपस में बदलने योग्य रूप से काम कर सकें, तो इस रेफरेंस का उपयोग करें।