vLLM: CPU के लिए लोकली और Google Cloud पर vLLM सेटअप करना

vLLM (Virtual Large Language Model) बड़े भाषा मॉडल्स (LLMs) को होस्ट करने के लिए बनाई गई एक लाइब्रेरी है। यह बड़े पैमाने के भाषा प्रसंस्करण कार्यों को संभालने के लिए एक अनुकूलित वातावरण प्रदान करती है।

ऐसी कई वजहें हैं जिनकी वजह से हम अपना स्वयं का LLM होस्ट करना चाह सकते हैं। किसी मॉडल को लोकली या क्लाउड प्लेटफ़ॉर्म पर होस्ट करने से हमें डेटा गोपनीयता पर नियंत्रण मिलता है, मॉडल को अपनी विशिष्ट आवश्यकताओं के अनुसार अनुकूलित करने की संभावना मिलती है, और एप्लिकेशन के आधार पर यह सस्ता भी हो सकता है।

इसके अलावा, vLLM OpenAI API के साथ संगत है। इसका अर्थ है कि यदि हमारे पास पहले से ऐसा कोड है जो OpenAI के इन्फ्रास्ट्रक्चर के साथ इंटरफ़ेस करता है, तो हम मौजूदा कोडबेस को बिना बदले vLLM के जरिए अपने स्वयं के होस्ट किए हुए LLM से उसे प्रतिस्थापित कर सकते हैं।

इस लेख में, मैं आपको vLLM सेटअप करने के चरणों के बारे में बताऊंगा। हम अपने कंप्यूटर पर Docker का उपयोग करके इसे कैसे चलाएं, यह दिखाने से शुरू करेंगे—यह कंटेनरीकरण का एक लोकप्रिय टूल है जो अलग-अलग वातावरणों में एप्लिकेशन को एकसमान रूप से चलाना आसान बनाता है। फिर, हम सीखेंगे कि Google Cloud पर vLLM कैसे डिप्लॉय करें, ताकि इन मॉडलों की होस्टिंग के लिए स्केलेबल समाधान मिल सके और वे बड़े कार्यों या अधिक ट्रैफ़िक को संभालने के लिए तैयार रहें।

Docker के साथ CPU पर लोकली vLLM कैसे सेटअप करें

vLLM CUDA प्लेटफ़ॉर्म (आमतौर पर NVIDIA GPUs) के लिए अनुकूलित, कुशल सेटअप के साथ LLMs चलाना सरल बनाता है। लेकिन यदि हम मॉडल को CPU पर चलाना चाहते हैं, तो vLLM द्वारा खास तौर पर CPU उपयोग के लिए प्रदान की गई Docker इमेज का उपयोग कर सकते हैं। यह लचीलापन हमें CUDA-सक्षम वातावरण के बिना भी मॉडल होस्ट करने देता है। CUDA प्लेटफ़ॉर्म पर vLLM होस्ट करने के लिए उनकी क्विकस्टार्ट गाइड देखें।

चूंकि अधिकांश लोगों के पास हाई-एंड GPUs नहीं होते, हम CPU पर vLLM सेटअप करने पर ध्यान देंगे। इससे हम उपलब्ध संसाधनों के साथ भी LLMs पर प्रयोग कर सकते हैं।

प्रक्रिया को सरल बनाने के लिए, हम Docker का उपयोग करेंगे—यह एक लोकप्रिय टूल है जो एप्लिकेशन और उनकी निर्भरताओं को कंटेनरों में पैक करने देता है। कंटेनर को एक हल्की, पोर्टेबल इकाई समझें जिसमें किसी सॉफ़्टवेयर को चलाने के लिए आवश्यक सब कुछ शामिल होता है। Docker का उपयोग करके, हमें अपने सिस्टम पर vLLM को मैन्युअल रूप से इंस्टॉल करने या संभावित संगतता समस्याओं से निपटने की चिंता नहीं करनी होगी।

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

चरण 1: Docker इमेज बनाना

सबसे पहले, हमें एक Docker इमेज बनानी होगी जो हमें अपने कंप्यूटर पर vLLM चलाने देगी। vLLM रिपॉज़िटरी CPU पर vLLM चलाने के लिए आवश्यक निर्देशों सहित Dockerfiles प्रदान करती है।

• Dockerfile.cpu सामान्य CPUs के लिए।
• Dockerfile.arm ARM CPUs (जैसे आधुनिक मैक्स में) के लिए।

चूंकि मेरे पास M2 प्रोसेसर वाला मैक है, मैं .arm फ़ाइल का उपयोग करूंगा। इमेज बनाने के लिए, पहले रिपॉज़िटरी को क्लोन या डाउनलोड करें और फिर इसके भीतर से यह कमांड चलाएं:

docker build -f Dockerfile.arm -t vllm-cpu --shm-size=4g .संचालित द्वारा

यह कमांड क्या करता है, उसका त्वरित सार:

• docker build: Dockerfile से Docker इमेज बनाता है।
• -f Dockerfile.arm: उपयोग होने वाली Dockerfile निर्दिष्ट करता है।
• -t vllm-cpu: इमेज को vllm-cpu नाम से टैग करता है, ताकि संदर्भित करना आसान हो (कोई और नाम भी हो सकता था)।
• --shm-size=4g: 4 गीगाबाइट shared memory आवंटित करता है, जिससे प्रदर्शन बेहतर होता है।

चरण 2: Hugging Face सेटअप करना

vLLM मॉडल प्रबंधन को सुगम बनाने वाले प्लेटफ़ॉर्म Hugging Face का उपयोग होस्टिंग प्रक्रिया को स्ट्रीमलाइन करने के लिए करता है। आरंभ ऐसे करें:

1. Hugging Face खाता बनाएं: Hugging Face वेबसाइट पर जाएं और यदि अभी तक नहीं किया है तो साइन अप करें।
2. मॉडल के लिए एक्सेस अनुरोध करें: साइन इन करने के बाद, वह मॉडल खोजें जिसे हम उपयोग करना चाहते हैं। इस डेमो के लिए मैं meta-llama/Llama-3.2-1B-Instruct की सलाह देता हूं, क्योंकि यह शुरुआती परीक्षण के लिए उपयुक्त छोटा मॉडल है। मॉडल के पेज पर एक्सेस अनुरोध करने का विकल्प हो सकता है। एक्सेस पाने के लिए दिए गए निर्देशों का पालन करें।
3. टोकन बनाएं: Hugging Face के API टोकन पेज पर जाएं। "Create New Token" पर क्लिक करें और एक टोकन बनाएं। यह टोकन मॉडल्स तक पहुंचने और उन्हें डाउनलोड करने के लिए आवश्यक होगा।

चरण 3: Docker कंटेनर चलाना

जब हमारी Docker इमेज बन जाए और Hugging Face टोकन तैयार हो, तो हम निम्न कमांड से vLLM मॉडल चला सकते हैं:

docker run -it --rm -p 8000:8000 \
--env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>" \
vllm-cpu --model meta-llama/Llama-3.2-1B-Instruct \
--dtype float16संचालित द्वारा

आइए इस कमांड को समझें:

• docker run: निर्दिष्ट Docker इमेज पर आधारित कंटेनर चलाता है।
• -it: कंटेनर को इंटरैक्टिव मोड में टर्मिनल एक्सेस के साथ चलाता है।
• --rm: कंटेनर बंद होने पर उसे स्वतः हटा देता है।
• -p 8000:8000: कंटेनर के 8000 पोर्ट को हमारी मशीन के 8000 पोर्ट पर मैप करता है, ताकि सेवा लोकली उपलब्ध हो।
• --env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>": Hugging Face टोकन को environment variable के रूप में सेट करता है, जिससे vLLM Hugging Face API से कनेक्ट हो सके। <replace_with_hf_token> की जगह हमने जो वास्तविक टोकन बनाया है, उसे रखें।
• vllm-cpu: पहले बनाई गई Docker इमेज का नाम।
• --model meta-llama/Llama-3.2-1B-Instruct: कौन सा मॉडल चलाना है, यह बताता है।
• --dtype float16: float16 डेटा टाइप का उपयोग करें, क्योंकि CPU पर चलाते समय मॉडल को इसकी आवश्यकता होती है।

यह कमांड चलाने पर सर्वर को तैयार होने में कुछ समय लगेगा क्योंकि इसे LLM डाउनलोड करना होगा। जब टर्मिनल में इस तरह का आउटपुट दिखे, तो समझें सर्वर तैयार है:

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)संचालित द्वारा

LLM से इंटरैक्ट करना

vLLM की एक बड़ी ख़ूबी इसकी OpenAI API के साथ संगतता है। यानी यदि हमारे पास ऐसा मौजूदा कोड है जो OpenAI के इन्फ्रास्ट्रक्चर से बात करता है, तो हम उसी कोड का उपयोग vLLM के जरिए होस्ट किए गए मॉडल के साथ संवाद करने के लिए कर सकते हैं।

यह संगतता बिना मौजूदा कोडबेस में बदलाव किए सहज संक्रमण संभव बनाती है। इसलिए, जब हम vLLM सेटअप करते हैं, तो LLM से बातचीत के लिए अपने परिचित टूल्स और कमांड्स का उपयोग जारी रखना सीधा और सुविधाजनक हो जाता है।

Docker पर चल रहे हमारे लोकल सर्वर को संदेश भेजने का उदाहरण देखें:

from openai import OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
models = client.models.list()
model = models.data[0].id
completion = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello"},
    ]
)
print(completion.choices[0].message.content)संचालित द्वारा

ध्यान दें कि ऊपर हमने "EMPTY" API key का उपयोग किया है। यह डिफ़ॉल्ट कुंजी है। हम --api-key पैरामीटर देकर मॉडल तक पहुंच के लिए कुंजी आवश्यक कर सकते हैं। उदाहरण के लिए:

docker run -it --rm -p 8000:8000 \
--env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>" \
vllm-cpu --model meta-llama/Llama-3.2-1B-Instruct \
--dtype float16 --api-key supersecretkeyसंचालित द्वारा

फिर, इस स्थिति में, हमें कोड के शीर्ष पर कुंजी बदलनी होगी:

openai_api_key = "supersecretkey"संचालित द्वारा

Google Cloud पर vLLM CPU कैसे होस्ट करें

Google Cloud का उपयोग करके vLLM पर LLM होस्ट करना डिप्लॉयमेंट के लिए एक समाधान प्रदान कर सकता है। आइए बताए गए चरणों को स्पष्टता के साथ विस्तार से देखें।

चरण 1: Google Cloud Console तक पहुंच

सबसे पहले, हमें Google Cloud Console तक पहुंचना होगा। इसके लिए अपने वेब ब्राउज़र में Google Cloud Console पर जाएं। यदि हमारे पास पहले से Google खाता नहीं है, तो Google Cloud सेवाओं का उपयोग करने के लिए एक खाता बनाना होगा।

चरण 2: एक प्रोजेक्ट बनाएं

Google Cloud Console में, स्क्रीन के शीर्ष पर प्रोजेक्ट ड्रॉपडाउन मेनू ढूंढें और "New Project" चुनें। 

प्रोजेक्ट नाम के रूप में vllm-demo दर्ज करें, ताकि बाद में पहचानना आसान रहे।

यदि हमारे पास पहले से Google Cloud खाता है, तो ट्रायल बिलिंग खाता उपलब्ध न हो सकता है। ऐसे में, हमें नया बिलिंग खाता बनाना होगा। इसके लिए "Billing" सेक्शन में जाएं और मौजूदा बिलिंग खाता चुनने या नया बनाने के चरणों का पालन करें।

चरण 3: Artifact Registry सेवा सक्षम करें

Artifact Registry ऐसी सेवा है जो हमें कंटेनर इमेजेस को स्टोर और प्रबंधित करने देती है। हम इसका उपयोग उस Docker इमेज को स्टोर करने के लिए करेंगे जिससे vLLM चलाया जाएगा। 

Cloud Console में "artifact" खोजें और Artefact Registry खोलें।

फिर, इसे हमारे प्रोजेक्ट के लिए सक्षम करें। यह कदम हमारे vLLM सेटअप की Docker इमेज को स्टोर करने के लिए आवश्यक है।

चरण 4: एक आर्टिफैक्ट रेपोज़िटरी बनाएं

अब, हमें अपने कंटेनर इमेजेस को स्टोर करने के लिए एक आर्टिफैक्ट रेपोज़िटरी बनानी होगी। Artifact Registry पर जाएं और "Create Repository" पर क्लिक करें। 

रेपोज़िटरी का नाम vllm-cpu रखें और फॉर्मैट के रूप में "Docker" चुनें। लोकेशन us-central1 निर्दिष्ट करें ताकि हमारी डिप्लॉयमेंट आवश्यकताओं के आधार पर प्रदर्शन अनुकूल रहे। शेष कॉन्फ़िगरेशन डिफ़ॉल्ट मानों पर छोड़ सकते हैं।

चरण 5: Docker इमेज बनाएं और पुश करें

जैसे हमने अपनी लोकल मशीन के लिए किया था, वैसे ही हमें Docker इमेज बनानी होगी और फिर उसे अपने vllm-cpu Google Cloud रेपोज़िटरी पर अपलोड (push) करना होगा। हम यह काम दाएं ऊपर स्थित क्लाउड शेल का उपयोग करके करेंगे।

.

उस टर्मिनल में आवश्यक फ़ाइलें लाने के लिए निम्न कमांड से vLLM GitHub रिपॉज़िटरी क्लोन करें:

git clone https://github.com/vllm-project/vllm.gitसंचालित द्वारा

टर्मिनल का उपयोग करके क्लोन की गई vLLM डायरेक्टरी में जाएं।

cd vllmसंचालित द्वारा

CPU उपयोग के लिए कॉन्फ़िगर की गई प्रदत्त Dockerfile का उपयोग करते हुए निर्दिष्ट कमांड से Docker इमेज बनाएं:

docker build \
-t us-central1-docker.pkg.dev/vllm-demo/vllm-cpu/vllm-openai:latest \
-f Dockerfile.cpu .संचालित द्वारा

Docker इमेज बन जाने के बाद, उसे अपनी Artifact Repository पर पुश करें। इससे इमेज Google Cloud सेवाओं द्वारा आगे उपयोग के लिए उपलब्ध हो जाएगी:

docker push us-central1-docker.pkg.dev/vllm-demo/vllm-cpu/vllm-openai:latestसंचालित द्वारा

चरण 6: Cloud Run पर सेवा सेटअप करें

Google Cloud Run कंटेनराइज्ड एप्लिकेशन डिप्लॉय करने देता है। हम अभी बनी इमेज को डिप्लॉय करने के लिए इसी सेवा का उपयोग करेंगे। 

सर्च बार में "cloud run" टाइप करें और “Cloud Run” सेवा खोलें।

वहां से "Create Service" बटन पर क्लिक करें:

फिर ये कदम अपनाएं:

1. कंटेनर इमेज चुनें: वह कंटेनर इमेज चुनें जिसे हमने पहले पुश किया था।
2. पोर्ट कॉन्फ़िगर करें: डिफ़ॉल्ट पोर्ट को 8000 में बदलें, जिसे vLLM उपयोग करता है।
3. Hugging Face टोकन जोड़ें: "Variables & Secrets" सेक्शन में HUGGING_FACE_HUB_TOKEN नाम से नया variable जोड़ें और यहां अपना टोकन पेस्ट करें। यह टोकन vLLM को Hugging Face से मॉडल्स तक पहुंचने देता है।
4. कंटेनर आर्ग्युमेंट्स: कमांड सेक्शन में --model=meta-llama/Llama-3.2-1B आर्ग्युमेंट शामिल करें ताकि वांछित मॉडल निर्दिष्ट हो।
5. संसाधन आवंटित करें: मेमोरी 16 GiB और 4 CPUs सेट करें, ताकि कंटेनर के पास कुशल प्रसंस्करण के लिए पर्याप्त संसाधन हों।
6. इंस्टेंस सेटिंग्स: कोल्ड स्टार्ट समय कम करने के लिए कम से कम एक इंस्टेंस को जीवित रखें। इससे लागत बढ़ सकती है, लेकिन मॉडल डाउनलोड और स्पिन-अप समय घटने से प्रदर्शन बेहतर होता है।

सारी कॉन्फ़िगरेशन सेट होने पर (अन्य विकल्प डिफ़ॉल्ट पर छोड़े जा सकते हैं), पेज के नीचे “Create” बटन पर क्लिक करें। सेवा के तैयार होने की प्रतीक्षा करें और उस सेवा के पेज पर जाएं। वहां हमें सेवा का URL मिलेगा, जिसकी मदद से हम LLM से संवाद कर सकते हैं। 

यह कुछ ऐसा दिखेगा:

https://vllm-llama-577126904161.us-central1.run.appसंचालित द्वारा

LLM से इंटरैक्ट करना

हम Python का उपयोग करके LLM से वैसे ही इंटरैक्ट कर सकते हैं जैसे लोकली मॉडल चलाते समय किया था। हमें केवल स्क्रिप्ट में URL बदलना होगा:

# Replace with your service URL
openai_api_base = "https://vllm-llama-577126904161.us-central1.run.app/v1"संचालित द्वारा

महत्वपूर्ण लागत संबंधित बातें

चेतावनी: यदि आप इन चरणों का पालन कर रहे हैं, तो ध्यान रखें कि आर्टिफैक्ट रजिस्ट्री को सक्रिय रखना आपको पैसे खर्च कराएगा। इसलिए कृपया इस गाइड का पालन करने के बाद बिलिंग अकाउंट को अनलिंक करना याद रखें, नहीं तो आपसे तब भी शुल्क लिया जाएगा जब कोई इसका उपयोग न करे।

Google Cloud GPU सेटअप

इस ट्यूटोरियल को लिखते समय, Google Cloud Run के लिए GPU समर्थन अनुरोध पर उपलब्ध है। यानी हमें विशेष रूप से इस सुविधा तक पहुंच का अनुरोध करना होगा। एक बार अनुमति मिल जाने पर, GPU का उपयोग करके vLLM चलाना CPU की तुलना में इसके प्रदर्शन में उल्लेखनीय वृद्धि करेगा। यह बड़े भाषा मॉडलों को संभालने में विशेष रूप से लाभकारी है, क्योंकि GPUs समानांतर कार्यों को अधिक कुशलता से संसाधित करने के लिए बनाए गए हैं।

यदि हमें GPU समर्थन तक पहुंच मिलती है, तो हम अपने कार्यप्रवाह को सरल बना सकते हैं। इस स्थिति में, हमें अपनी स्वयं की Docker इमेज बनाने की प्रक्रिया से नहीं गुजरना होगा। इसके बजाय, हम सीधे vllm/vllm-openai:latest प्री-एक्सिस्टिंग इमेज का उपयोग करते हुए सेवा बना सकते हैं। यह इमेज GPU के साथ काम करने के लिए अनुकूलित है, जिससे CPU कॉन्फ़िगरेशन के लिए आवश्यक अतिरिक्त सेटअप चरणों के बिना हम अपने मॉडलों को तेज़ी और प्रभावी ढंग से डिप्लॉय कर सकते हैं।

GPU एक्सेस स्वीकृत होने और प्रदत्त इमेज का उपयोग करके सेवा सेटअप हो जाने पर, हमारा vLLM डिप्लॉयमेंट GPUs की शक्ति और गति का पूरा लाभ उठा सकेगा, जो रीयल-टाइम एप्लिकेशन और उच्च-डिमांड भाषा प्रसंस्करण कार्यों के लिए उपयुक्त है।

RunPod: वैकल्पिक होस्टिंग

जो लोग वैकल्पिक होस्टिंग विकल्प खोज रहे हैं, उनके लिए RunPod जैसे प्लेटफ़ॉर्म बड़े भाषा मॉडलों की होस्टिंग के लिए सुव्यवस्थित सेवाएं प्रदान करते हैं। उदाहरण के लिए, RunPod सर्वरलेस सेटअप प्रदान करता है जो डिप्लॉयमेंट प्रक्रिया को सरल बनाता है।

हालांकि यह विकल्प उपयोगकर्ता-अनुकूल है और जल्दी सेट हो जाता है, लेकिन ध्यान रखें कि सुविधा अक्सर अधिक कीमत के साथ आती है। यदि बजट एक कारक है, तो ऐसे सेवाओं की आसान उपयोगिता और उनसे जुड़ी लागत के बीच संतुलन पर विचार करें।

निष्कर्ष

इस ट्यूटोरियल में, हमने vLLM को लोकली और Google Cloud—दोनों पर सेटअप और होस्ट करने की प्रक्रिया देखी।

हमने खास तौर पर CPUs के लिए तैयार Docker इमेजेस को बनाना और चलाना सीखा, ताकि हाई-एंड GPU संसाधन न होने पर भी पहुंच सुनिश्चित की जा सके। इसके अलावा, हमने Google Cloud पर vLLM डिप्लॉय करना भी देखा, जो बड़े कार्यों को संभालने के लिए स्केलेबल समाधान प्रदान करता है।