vLLM के साथ Llama 4: डेमो प्रोजेक्ट सहित मार्गदर्शिका

Meta के नवीनतम LLaMA 4 मॉडल्स, Scout और Maverick, लंबे संदर्भ में तर्क करने, मल्टी-मोडल समझ और बड़े पैमाने पर कुशल इन्फरेंस के लिए बनाए गए हैं। OpenAI-संगत API वाले उच्च थ्रूपुट इन्फरेंस इंजन vLLM के साथ मिलकर ये मॉडल वास्तविक-जीवन के अनुप्रयोगों के लिए व्यावहारिक बन जाते हैं।

इस ब्लॉग पोस्ट में, मैं आपको बताऊंगा कि कैसे vLLM का उपयोग करके मल्टी-GPU RunPod इंस्टेंस पर LLaMA 4 Scout को डिप्लॉय करें और उसे लोकल या रिमोट OpenAI-संगत API एंडपॉइंट के जरिए सर्व करें। हम मॉडल सेटअप, डिप्लॉयमेंट और API इंटरेक्शन को टेक्स्ट और इमेज—दोनों इनपुट्स के साथ कवर करेंगे।

इस ट्यूटोरियल के अंत तक, आपके पास दो पूर्ण डेमो भी होंगे:

1. टेक्स्ट कम्प्लीशन डेमो: OpenAI-संगत Python कोड का उपयोग करके LLaMA 4 से चैट करने और लंबे संदर्भ की क्षमताओं को खोजने के लिए एक सरल इंटरफ़ेस।
2. मल्टीमोडल विज़न डेमो: vLLM के मल्टी-मोडल सपोर्ट का उपयोग करते हुए टेक्स्ट और इमेज—दोनों इनपुट स्वीकार करने वाला इंटरफ़ेस, जो LLaMA 4 से ग्राउंडेड विज़ुअल रीजनिंग प्रतिक्रियाएँ देता है।

हम अपने पाठकों को एआई की ताज़ा खबरों से अपडेट रखते हैं The Median के माध्यम से—हमारा निःशुल्क शुक्रवार न्यूज़लेटर जो हफ्ते की प्रमुख कहानियों का संक्षेप प्रस्तुत करता है। सदस्यता लें और हर हफ्ते कुछ ही मिनटों में अपडेट रहें:

vLLM पर LLaMA 4 क्यों उपयोग करें?

vLLM (वर्चुअल लार्ज लैंग्वेज मॉडल) UC Berkeley की Sky Computing Lab में विकसित एक ऑप्टिमाइज़्ड LLM इन्फरेंस फ्रेमवर्क है, जो PagedAttention पेश करता है—एक नया मेमोरी मैनेजमेंट सिस्टम जो GPU मेमोरी फ्रैगमेंटेशन को कम करता है और बेहद लंबी सीक्वेंस के लिए कुशल की-वैल्यू कैशिंग की अनुमति देता है। अधिक जानने के लिए, vLLM पर यह ट्यूटोरियल देखें।

यहाँ बताया गया है कि LLaMA 4 को सर्व करने के लिए vLLM आदर्श इंजन क्यों है:

1. उच्च थ्रूपुट, कम लेटेंसी: vLLM का पेज्ड KV कैश लंबे संदर्भ के साथ भी कुशल इन्फरेंस सक्षम करता है।
2. मल्टी-मोडल और लॉन्ग-कॉन्टेक्स्ट के लिए तैयार: यह इमेज सपोर्ट करता है और Scout मॉडल के लिए 10M टोकन तक का कॉन्टेक्स्ट संभालता है।
3. OpenAI-संगत: आप OpenAI SDKs और टूल्स को बिना बदलाव के उपयोग कर सकते हैं।
4. स्केलेबल और GPU-कुशल: vLLM कई GPUs—जैसे H100, A100, और MI300X—का पूरा लाभ उठाते हुए टेन्सर और मेमोरी पैरेललिज़्म से उच्च थ्रूपुट इन्फरेंस देता है।

RunPod पर vLLM के साथ LLaMA 4 Scout होस्ट करना

इस सेक्शन में, हम RunPod पर एक शक्तिशाली मल्टी-GPU इंस्टेंस प्रोविजन करना, vLLM के जरिए Meta का LLaMA 4 Scout मॉडल डिप्लॉय करना, और लोकल व रिमोट—दोनों इन्फरेंस के लिए OpenAI-संगत API एक्सपोज़ करना सीखेंगे।

चरण 1: अपना RunPod वातावरण सेट करें 

मॉडल लॉन्च करने से पहले, सुनिश्चित करें कि आपका RunPod अकाउंट सेटअप है:

• लॉग इन करें RunPod.io पर और अपनी बिलिंग कॉन्फ़िगर करें।
• अपने बैलेंस में कम से कम $25 जोड़ें ताकि आप इस प्रोजेक्ट की अवधि के दौरान बड़े GPU इंस्टेंस चला सकें।

चरण 2: H100 NVL GPUs के साथ एक पॉड डिप्लॉय करें

अब, ऐसा पॉड प्रोविजन करें जो 17B LLaMA 4 Scout मॉडल होस्ट करने में सक्षम हो:

1. Pods सेक्शन में जाएँ और “Deploy a Pod” पर क्लिक करें।
2. VRAM के अनुसार GPUs को फ़िल्टर करें, न्यूनतम 80 GB सेट करें, और H100 NVL विकल्प चुनें। नोट: LLaMA 4 Scout को कम से कम 24 GB VRAM की आवश्यकता है। सर्वोत्तम प्रदर्शन के लिए, हम 4x H100 NVL का उपयोग करेंगे।

3. नीचे स्क्रॉल करें और अपने पॉड को “LLAMA4_DEMO” जैसा नाम दें।
4. Template के अंतर्गत “Change Template” पर क्लिक करें और PyTorch 2.4.0 चुनें।
5. “Edit Template” पर क्लिक करें, Container Disk और Volume Disk—दोनों को 1000 GB सेट करें, और overrides लागू करें।
6. (वैकल्पिक) मॉडल डाउनलोड के लिए अपने Hugging Face एक्सेस टोकन को environment variables में जोड़ें।

7. GPU Count को 4 पर सेट करें, फिर “Deploy On-Demand” पर क्लिक करें।

पॉड के प्रोविज़न होने के लिए कुछ मिनट प्रतीक्षा करें।

चरण 3: अपने पॉड से कनेक्ट करें

जब “Connect” बटन बैंगनी हो जाए, उस पर क्लिक करें। आपको कई कनेक्शन विकल्प दिखेंगे—आप या तो:

• JupyterLab टर्मिनल खोलकर शेल कमांड चला सकते हैं।
• या रिमोट कंट्रोल के लिए SSH या HTTP पोर्ट्स का उपयोग कर सकते हैं।

चरण 4: vLLM और आवश्यक लाइब्रेरीज़ इंस्टॉल करें

अपने पॉड के अंदर टर्मिनल में, vLLM और उसकी निर्भरताएँ इंस्टॉल करें। vLLM और अन्य लाइब्रेरीज़ को पॉड वातावरण के अंदर इंस्टॉल करें।

pip install -U vllm
pip install transformers accelerate pillow #optionalसंचालित द्वारा

चरण 5: vLLM पर LLaMA 4 Scout चलाएँ

अगले चरण में, हम निम्न कमांड का उपयोग करके LLaMA 4 Scout मॉडल सर्वर लॉन्च करेंगे:

VLLM_DISABLE_COMPILE_CACHE=1 vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
--tensor-parallel-size 4 \
--max-model-len 100000 --override-generation-config='{"attn_temperature_tuning": true}'संचालित द्वारा

यह कमांड निम्न कार्य करता है:

• तेज़ स्टार्टअप के लिए vLLM कम्पाइल कैश को अक्षम करता है।
• टेन्सर पैरेललिज़्म का उपयोग करते हुए मॉडल को 4 GPUs पर चलाता है।
• फिर, मेमोरी बाधाओं के कारण अधिकतम कॉन्टेक्स्ट लंबाई 100,000 टोकन सेट करता है। नोट - यदि आप मॉडल को 10M कॉन्टेक्स्ट लंबाई के साथ चलाना चाहते हैं, तो आपको कम से कम 8 x H100 GPUs की आवश्यकता होगी।
• लंबे संदर्भ वाले इन्फरेंस में सटीकता सुधारने के लिए attention temperature tuning कॉन्फ़िग सक्षम करता है।

अब जब आपकी API पोर्ट 8000 पर चल रही है, उसी पॉड वातावरण में एक नया Jupyter Notebook बनाएँ।

Llama 4 Scout के साथ टेक्स्ट कम्प्लीशन

इस डेमो में, हम vLLM के जरिए सर्व किए गए लोकली होस्टेड LLaMA 4 Scout मॉडल के साथ एक सरल Python स्क्रिप्ट से इंटरैक्ट करेंगे। मॉडल API के जरिए एक्सपोज़ है, जिससे हम मल्टी-टर्न संवाद समर्थित एक वार्तालाप सहायक बना सकते हैं।

चरण 1: पूर्वापेक्षाएँ

vLLM API से संचार के लिए हम आधिकारिक OpenAI Python SDK और रंगीन टर्मिनल आउटपुट के लिए Colorama लाइब्रेरी का उपयोग करेंगे। आप दोनों को इस प्रकार इंस्टॉल कर सकते हैं:

pip install openai coloramaसंचालित द्वारा

इंस्टॉल होने के बाद, आवश्यक मॉड्यूल इम्पोर्ट करें:

from openai import OpenAI
from colorama import Fore, Style, initसंचालित द्वारा

चरण 2: क्लाइंट प्रारंभ करें

हम OpenAI क्लाइंट को हमारे लोकली रनिंग vLLM सर्वर की ओर इंगित करते हैं। यदि आपके डिप्लॉयमेंट को API कुंजी की आवश्यकता नहीं है (लोकल रन के लिए डिफ़ॉल्ट व्यवहार), तो कुंजी के रूप में "EMPTY" पास करें:

# Initialize colorama
init(autoreset=True)
# Set up client
openai_api_key = "EMPTY"  
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)संचालित द्वारा

यह कोड Colorama लाइब्रेरी को रंगीन टर्मिनल आउटपुट के लिए ऑटो-रीसेट के साथ इनिशियलाइज़ करता है। फिर OpenAI क्लास का उपयोग कर OpenAI-संगत क्लाइंट सेट करता है, जो लोकली होस्टेड vLLM API की ओर इशारा करता है।

चरण 3: चैट लूप शुरू करें

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

# Initialize message history
messages = [
    {"role": "system", "content": "You are a helpful assistant."}
]
print("Start chatting with the assistant! Type 'exit' or 'quit' to end.\n")
while True:
    user_input = input(f"{Fore.BLUE}User: {Style.RESET_ALL}")
    if user_input.strip().lower() in ["exit", "quit"]:
        print("Exiting chat. Goodbye!")
        break
    messages.append({"role": "user", "content": user_input})
    chat_response = client.chat.completions.create(
        model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
        messages=messages,
    )
    assistant_message = chat_response.choices[0].message.content
    print(f"{Fore.GREEN}Assistant: {assistant_message}\n{Style.RESET_ALL}")
    messages.append({"role": "assistant", "content": assistant_message})संचालित द्वारा

एक साधारण टर्मिनल-आधारित चैट इंटरफ़ेस वार्तालाप इतिहास और सिस्टम प्रॉम्प्ट के साथ इनिशियलाइज़ होता है, जो लूप में लगातार यूज़र इनपुट स्वीकार करता है। प्रत्येक यूज़र संदेश को इतिहास में जोड़ा जाता है और Llama-4-Scout-17B-16E-Instruct मॉडल को client.chat.completions.create() API कॉल के माध्यम से भेजा जाता है।

मॉडल की प्रतिक्रिया Colorama का उपयोग करके हरे रंग में प्रिंट की जाती है और उसे संदेश इतिहास में जोड़ दिया जाता है, जिससे तब तक मल्टी-टर्न संवाद चलता रहता है जब तक यूज़र "exit" या "quit" टाइप नहीं करता।

अगले सेक्शन में, हम उसी API का उपयोग करते हुए इमेज + टेक्स्ट इनपुट्स के साथ मल्टीमोडल इन्फरेंस चलाना देखेंगे।

LLaMA 4 Scout के साथ मल्टीमोडल इमेज और टेक्स्ट इन्फरेंस

इस डेमो में, हम vLLM की नैटिव मल्टीमोडल क्षमताओं का उपयोग करते हुए LLaMA 4 Scout मॉडल को इमेज और टेक्स्ट—दोनों इनपुट्स भेजना सीखेंगे। इससे आप विज़ुअल रीजनिंग, इमेज कैप्शनिंग, या मल्टीमोडल प्रश्नोत्तर—सब कुछ एक ही OpenAI-संगत API के माध्यम से कर सकते हैं।

चरण 1: पूर्वापेक्षाएँ

यह उदाहरण vLLM सर्वर से इंटरफ़ेस करने के लिए OpenAI SDK का उपयोग करता है। यदि पहले से इंस्टॉल नहीं है, तो आप यह चला सकते हैं:

pip install openaiसंचालित द्वारा

फिर आवश्यक मॉड्यूल इम्पोर्ट करें: 

from openai import OpenAIसंचालित द्वारा

चरण 2: API क्लाइंट सेट करें

OpenAI-संगत इंटरफ़ेस का उपयोग कर अपने लोकल vLLM सर्वर से कनेक्ट करें। यदि आपका सर्वर ऑथेंटिकेशन नहीं माँगता, तो API कुंजी के रूप में "EMPTY" का उपयोग करें।

openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)संचालित द्वारा

ऊपर दिया गया कोड स्निपेट vLLM सर्वर का उपयोग करते हुए लोकल इन्फरेंस के लिए OpenAI-संगत क्लाइंट इनिशियलाइज़ करता है। api_key "EMPTY" (कोई ऑथ आवश्यक नहीं) पर सेट है, और base_url लोकल vLLM API एंडपॉइंट की ओर इशारा करता है।

चरण 3: एक मल्टीमोडल प्रॉम्प्ट भेजें

अब हम एक चैट प्रॉम्प्ट भेजेंगे जिसमें इमेज के साथ टेक्स्ट निर्देश भी होगा। LLaMA 4 Scout क्वेरी के साथ इमेज को प्रोसेस करेगा और एक विवरणात्मक प्रतिक्रिया लौटाएगा।

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": image_url1}},
            {"type": "text", "text": "Can you describe what's in this image?"}
        ]
    }
]
chat_response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",  
    messages=messages,
)
print("Response:", chat_response.choices[0].message.content)संचालित द्वारा

जब LLaMA 4 Scout मॉडल के साथ मल्टीमोडल इन्फरेंस सर्व हो जाता है, तो हम OpenAI चैट स्कीमा के अनुसार फॉर्मेटेड एक चैट-शैली इनपुट बनाते हैं जिसमें इमेज URL और टेक्स्ट प्रॉम्प्ट दोनों शामिल होते हैं। client.chat.completions.create() मेथड का उपयोग करके यह मल्टीमोडल अनुरोध मॉडल को भेजा जाता है, जो इमेज और साथ के टेक्स्ट को प्रोसेस कर संदर्भगत प्रतिक्रिया उत्पन्न करता है।

निष्कर्ष

इस ट्यूटोरियल में, हमने RunPod पर vLLM का उपयोग करके Meta के LLaMA 4 Scout मॉडल को होस्ट किया, जिससे वह टेक्स्ट और मल्टीमोडल—दोनों इन्फरेंस के लिए OpenAI-संगत एंडपॉइंट्स के माध्यम से सुलभ हो गया। vLLM के उच्च थ्रूपुट और RunPod के शक्तिशाली इंफ्रास्ट्रक्चर को मिलाकर, हमने लंबे संदर्भ और विज़न क्षमताओं वाले अत्याधुनिक LLMs को सर्व करने के लिए एक किफायती सेटअप बनाया।

LLaMA 4 और vLLM के बारे में अधिक जानने के लिए, ये देखें:

• Llama 4 ओवरव्यू
• Llama 4 आधिकारिक मॉडल कार्ड
• vLLM GitHub
• Unsloth क्वांटाइज़ेशन तकनीकें