MLC-LLM

एमएल कम्पाइलेशन के माध्यम से सार्वभौमिक LLM परिनियोजन — मशीन लर्निंग कम्पाइलेशन का उपयोग करके किसी भी हार्डवेयर पर किसी भी बड़े लैंग्वेज मॉडल को अधिकतम प्रदर्शन के साथ चलाएँ।

🌟 20,000+ GitHub स्टार्स | MLC AI टीम द्वारा मेंटained | Apache-2.0 लाइसेंस

---

MLC-LLM क्या है?

MLC-LLM (Machine Learning Compilation for Large Language Models) एक सार्वभौमिक फ्रेमवर्क है जो विविध हार्डवेयर बैकएंड्स पर बड़े लैंग्वेज मॉडलों के कुशल परिनियोजन को सक्षम बनाता है। का लाभ उठाकर TVM (Tensor Virtual Machine) अपनी कम्पाइलेशन बैकएंड के रूप में, MLC-LLM LLM मॉडलों को सीधे नेटिव हार्डवेयर कोड में कम्पाइल करता है — बिना हार्डवेयर-विशेष इंजीनियरिंग के लगभग अनुकूल प्रदर्शन प्राप्त करता है।

मुख्य क्षमताएँ

• सर्वव्यापी हार्डवेयर समर्थन — NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, WebGPU

• OpenAI-अनुकूल REST API — मौजूदा वर्कफ़्लो के लिए ड्रॉप-इन रिप्लेसमेंट

• कई मॉडल फ़ॉर्मैट — Llama, Mistral, Gemma, Phi, Qwen, Falcon, और अधिक

• 4-बिट / 8-बिट क्वांटाइजेशन — उपभोक्ता GPUs पर बड़े मॉडल चलाएँ

• चैट इंटरफ़ेस — त्वरित परीक्षण के लिए बिल्ट-इन वेब UI

• Python और CLI टूल्स — लचीले एकीकरण विकल्प

Clore.ai पर MLC-LLM क्यों उपयोग करें?

Clore.ai GPU मार्केटप्लेस आपको प्रतियोगी किराये की दरों पर उच्च-प्रदर्शन NVIDIA GPUs तक पहुँच देता है। MLC-LLM की कम्पाइलेशन अप्रोच प्रत्येक GPU से अधिकतम थ्रुपुट निकालती है — जिससे यह आदर्श है:

• स्केल पर प्रोडक्शन API इनफेरेंस

• मॉडल आकारों के पार रिसर्च और बेंचमार्किंग

• क्वांटाइज़्ड मॉडलों के साथ लागत-कुशल सर्विंग

• एक ही GPU इंस्टेंस पर मल्टी-मॉडल परिनियोजन

---

Clore.ai पर शीघ्र आरम्भ

चरण 1: एक GPU सर्वर खोजें

1. जाएँ clore.ai मार्केटप्लेस

2. सर्वरों को फ़िल्टर करें: NVIDIA GPU，न्यूनतम 8GB VRAM (7B+ मॉडलों के लिए 16GB+ अनुशंसित)

3. इष्टतम प्रदर्शन के लिए: RTX 3090, RTX 4090, A100, या H100

चरण 2: MLC-LLM परिनियोजित करें

नोट: MLC-LLM Docker Hub पर आधिकारिक प्री-बिल्ट Docker इमेज प्रकाशित नहीं करता। अनुशंसित परिनियोजन दृष्टिकोण यह है कि NVIDIA CUDA बेस इमेज का उपयोग करें और pip के माध्यम से MLC-LLM इंस्टॉल करें। उपयोग करें nvidia/cuda:12.1.0-devel-ubuntu22.04 को अपने Clore.ai बेस इमेज के रूप में।

Clore.ai ऑर्डर कॉन्फ़िगरेशन में NVIDIA CUDA बेस इमेज का उपयोग करें:

Docker Image: nvidia/cuda:12.1.0-devel-ubuntu22.04

पोर्ट मैपिंग्स:

कंटेनर पोर्ट	उद्देश्य
22	SSH पहुंच
8000	REST API सर्वर

अनुशंसित पर्यावरण चर:

MLC_MODEL=HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
MLC_HOST=0.0.0.0
MLC_PORT=8000

स्टार्टअप स्क्रिप्ट (SSH के बाद चलाएँ):

pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

चरण 3: SSH के जरिए कनेक्ट करें

ssh root@<clore-node-ip> -p <assigned-ssh-port>

---

स्थापन और सेटअप

विकल्प A: प्री-कम्पाइल्ड मॉडल का उपयोग करें (सबसे तेज)

MLC-AI Hugging Face पर प्री-कम्पाइल्ड मॉडलों का पुस्तकालय रखता है। किसी कम्पाइलेशन की आवश्यकता नहीं:

# एक प्री-कम्पाइल्ड Llama 3 8B (4-बिट क्वांटाइज़्ड) खींचें और चलाएँ
python -m mlc_llm serve HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000

विकल्प B: अपना स्वयं का मॉडल कम्पाइल करें

कस्टम मॉडलों या विशिष्ट क्वांटाइज़ेशन आवश्यकताओं के लिए:

# चरण 1: मॉडल वेट्स को कन्वर्ट करें
python -m mlc_llm convert_weight \
  ./path/to/model \
  --quantization q4f16_1 \
  --output ./compiled/model-q4f16_1

# चरण 2: मॉडल कॉन्फ़िगरेशन जनरेट करें
python -m mlc_llm gen_config \
  ./path/to/model \
  --quantization q4f16_1 \
  --conv-template llama-3 \
  --output ./compiled/model-q4f16_1

# चरण 3: मॉडल कम्पाइल करें
python -m mlc_llm compile \
  ./compiled/model-q4f16_1/mlc-chat-config.json \
  --device cuda \
  --output ./compiled/model-q4f16_1/lib.so

कम्पाइलेशन समय: एक 7B मॉडल को पहली बार चलाते समय आम तौर पर कम्पाइल करने में 10–30 मिनट लगते हैं। कम्पाइल किए गए आर्टिफैक्ट्स कैश किए जाते हैं और बाद के लॉन्च पर पुन: प्रयुक्त होते हैं।

---

API सर्वर चलाना

OpenAI-अनुकूल सर्वर प्रारम्भ करें

python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --max-batch-size 4 \
  --max-total-sequence-length 8192

सर्वर स्टार्टअप आउटपुट

[2024-01-01 12:00:00] INFO: HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC से मॉडल लोड किया जा रहा है
[2024-01-01 12:00:15] INFO: मॉडल सफलतापूर्वक लोड हो गया
[2024-01-01 12:00:15] INFO: सर्वर 0.0.0.0:8000 पर शुरू हो रहा है
[2024-01-01 12:00:15] INFO: OpenAI-अनुकूल API http://0.0.0.0:8000/v1 पर उपलब्ध है

उपलब्ध API एंडपॉइंट्स

एंडपॉइंट	विधि	विवरण
/v1/chat/completions	POST	चैट कंप्लीशंस (OpenAI फ़ॉर्मैट)
/v1/completions	POST	टेक्स्ट कंप्लीशंस
/v1/models	GET	उपलब्ध मॉडलों की सूची बनाएँ
/v1/debug/dump_event_trace	GET	प्रदर्शन डिबगिंग

---

API उपयोग उदाहरण

चैट कंप्लीशंस (Python)

from openai import OpenAI

# अपने Clore.ai सर्वर की ओर पॉइंट करें
client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"  # डिफ़ॉल्ट रूप से MLC-LLM को ऑथ की आवश्यकता नहीं है
)

response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "साधारण शब्दों में क्वांटम कंप्यूटिंग समझाइए."}
    ],
    temperature=0.7,
    max_tokens=512
)

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

स्ट्रीमिंग प्रतिक्रिया

stream = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "AI के बारे में एक छोटी कहानी लिखें."}],
    stream=True,
    max_tokens=1024
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

cURL उदाहरण

curl http://<clore-node-ip>:<api-port>/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Llama-3-8B-Instruct-q4f16_1-MLC",
    "messages": [
      {"role": "user", "content": "2+2 क्या है?"}
    ],
    "temperature": 0.7,
    "max_tokens": 100
  }'

---

उपलब्ध प्री-कम्पाइल्ड मॉडल

MLC-AI Hugging Face पर रेडी-टू-यूज़ कम्पाइल्ड मॉडल प्रदान करता है:

Llama 3 सीरीज़

# 8B Instruct (अधिकांश उपयोग मामलों के लिए अनुशंसित)
HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

# 70B Instruct (40GB+ VRAM या मल्टी-GPU की आवश्यकता)
HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC

Mistral / Mixtral

HF://mlc-ai/Mistral-7B-Instruct-v0.3-q4f16_1-MLC
HF://mlc-ai/Mixtral-8x7B-Instruct-v0.1-q4f16_1-MLC

Gemma

HF://mlc-ai/gemma-2b-it-q4f16_1-MLC
HF://mlc-ai/gemma-7b-it-q4f16_1-MLC

Phi

HF://mlc-ai/phi-2-q4f16_1-MLC
HF://mlc-ai/Phi-3-mini-4k-instruct-q4f16_1-MLC

पूर्ण मॉडल सूची: सभी प्री-कम्पाइल्ड मॉडलों को ब्राउज़ करें: huggingface.co/mlc-ai

---

क्वांटाइज़ेशन विकल्प

MLC-LLM कई क्वांटाइज़ेशन स्कीम्स का समर्थन करता है। अपने VRAM बजट के आधार पर चुनें:

क्वांटाइजेशन	बिट्स	गुणवत्ता	VRAM (7B)	VRAM (13B)
q4f16_1	4-बिट	★★★★☆	~4GB	~7GB
q4f32_1	4-बिट (f32 एक्यूम)	★★★★☆	~4GB	~7GB
q8f16_1	8-बिट	★★★★★	~8GB	~14GB
q0f16	16-बिट (कोई क्वांट नहीं)	★★★★★	~14GB	~26GB
q0f32	32-बिट (कोई क्वांट नहीं)	★★★★★	~28GB	~52GB

VRAM अनुशंसा: CUDA ओवरहेड और KV कैश के लिए हमेशा 2–3GB हेडरूम छोड़ें। एक 7B मॉडल के साथ q4f16_1 आम वर्कलोड पर कुल लगभग 6–7GB की आवश्यकता होती है।

---

मल्टी-GPU परिनियोजन

बड़े मॉडलों (70B+) के लिए जो मल्टी-GPU की आवश्यकता रखते हैं:

# 2 GPUs पर टेन्सर पैरेललिज़्म सक्षम करें
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-70B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --tensor-parallel-shards 2

परिनियोजन से पहले GPU टोपोलॉजी जांचें:

nvidia-smi topo -m  # NVLink/PCIe कनेक्टिविटी जांचें

सबसे अच्छा प्रदर्शन: मल्टी-GPU NVLink से जुड़े कार्ड्स (जैसे A100 80GB SXM जोड़े) के साथ सबसे अच्छा काम करता है। PCIe-से जुड़े GPUs बड़े मॉडलों पर बॉटलनेक्स दिखाएँगे।

---

वेब चैट इंटरफ़ेस

MLC-LLM में एक बिल्ट-इन वेब UI शामिल है जो सर्वर चलने पर पहुँचा जा सकता है:

# वेब UI सक्षम करके सर्वर शुरू करें
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --enable-debug  # वैकल्पिक: डिबग एंडपॉइंट सक्षम करता है

UI पर पहुँचें: http://<clore-node-ip>:<api-port>

---

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

बैच साइज का अनुकूलन करें

# उच्च थ्रुपुट के लिए बैच साइज बढ़ाएँ (अधिक VRAM की आवश्यकता होती है)
python -m mlc_llm serve \
  HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC \
  --host 0.0.0.0 \
  --port 8000 \
  --max-batch-size 8 \
  --max-total-sequence-length 16384 \
  --prefill-chunk-size 2048

GPU उपयोग की निगरानी करें

# एक अलग टर्मिनल में
watch -n 1 nvidia-smi

# और अधिक विस्तृत मॉनिटरिंग
nvidia-smi dmon -s u  # उपयोगिता मेट्रिक्स का स्ट्रीमिंग

थ्रुपुट का बेंचमार्क करें

import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

start = time.time()
response = client.chat.completions.create(
    model="Llama-3-8B-Instruct-q4f16_1-MLC",
    messages=[{"role": "user", "content": "1 से 100 तक गिनती करें"}],
    max_tokens=512
)
elapsed = time.time() - start

tokens = response.usage.completion_tokens
print(f"Throughput: {tokens/elapsed:.1f} tokens/sec")

---

Docker Compose सेटअप

Clore.ai पर उत्पादन-तैयार परिनियोजन के लिए NVIDIA CUDA बेस इमेज के साथ और pip के माध्यम से MLC-LLM इंस्टॉल करके:

version: '3.8'
services:
  mlc-llm:
    image: nvidia/cuda:12.1.0-devel-ubuntu22.04
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - "8000:8000"
    volumes:
      - ./models:/root/models
      - mlc-cache:/root/.cache/mlc_llm
    command: >
      bash -c "pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121 &&
      python -m mlc_llm serve
      HF://mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC
      --host 0.0.0.0
      --port 8000
      --max-batch-size 4"
    restart: unless-stopped

volumes:
  mlc-cache:

---

समस्या निवारण

मॉडल डाउनलोड विफल

# इंटरनेट कनेक्टिविटी जांचें
curl -I https://huggingface.co

# huggingface-cli के साथ मैन्युअली डाउनलोड करें
pip install huggingface_hub
huggingface-cli download mlc-ai/Llama-3-8B-Instruct-q4f16_1-MLC

मेमोरी खत्म (OOM)

# संदर्भ लंबाई कम करें
python -m mlc_llm serve MODEL \
  --max-total-sequence-length 4096  # डिफ़ॉल्ट से घटाएँ

# अधिक आक्रामक क्वांटाइज़ेशन का उपयोग करें
# q8f16_1 से q4f16_1 पर स्विच करें

CUDA संस्करण मेल नहीं खाता

# CUDA संस्करण जांचें
nvcc --version
nvidia-smi | grep CUDA

# CUDA 12.1 सर्वरों के लिए, इंस्टॉल करें:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

# CUDA 12.2+ सर्वरों के लिए, इंस्टॉल करें:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu122 mlc-ai-nightly-cu122

सामान्य चिंता: MLC-LLM pip व्हील्स CUDA-версन विशिष्ट होते हैं। सुनिश्चित करें कि आपने अपने सर्वर की CUDA वर्शन से मेल खाता सही वेरिएंट इंस्टॉल किया है। उपलब्ध व्हील्स जांचें: mlc.ai/wheels.

सर्वर पहुँच योग्य नहीं

# जांचें कि पोर्ट सुन रहा है
ss -tlnp | grep 8000

# फ़ायरवाल जांचें
iptables -L -n | grep 8000

# पहले स्थानीय रूप से परीक्षण करें
curl http://localhost:8000/v1/models

---

Clore.ai GPU सिफारिशें

MLC-LLM की कम्पाइलेशन अप्रोच प्रत्येक GPU टियर पर लगभग अनुकूल थ्रुपुट देती है। मॉडल आकार और बजट के आधार पर चुनें:

GPU	VRAM	Clore.ai कीमत	माध्य/दिन	थ्रुपुट (Llama 3 8B Q4)
RTX 3090	24 GB	~$0.12/घंटा	7B–13B मॉडल, बजट सर्विंग	~85 tok/s
RTX 4090	24 GB	~$0.70/घंटा	7B–34B मॉडल, तेज़ सर्विंग	~140 tok/s
A100 40GB	40 GB	~$1.20/घंटा	34B–70B, प्रोडक्शन API	~110 tok/s
A100 80GB	80 GB	~$2.00/घंटा	70B+, मल्टी-मॉडल सर्विंग	~130 tok/s
H100 SXM	80 GB	~$3.50/hr	अधिकतम थ्रुपुट, FP8	~280 tok/s

अनुशंसित शुरुआत बिंदु: RTX 3090 लगभग ~$0.12/hr पर Llama 3 8B और Mistral 7B सर्विंग के लिए सर्वश्रेष्ठ कीमत-प्रदर्शन अनुपात है जब MLC-LLM के माध्यम से उपयोग किया जाए। कम्पाइल्ड कर्नेल उपभोक्ता GPUs से लगभग अधिकतम उपयोगिता निकालते हैं।

70B मॉडलों (उदा., Llama 3 70B Q4) के लिए: A100 40GB (~$1.20/hr) या टेन्सर पैरेललिज़्म के माध्यम से दो RTX 3090s का उपयोग करें।

---

संसाधन

• 📦 Pip व्हील्स: mlc.ai/wheels (pip के माध्यम से इंस्टॉल करें, Docker Hub इमेज उपलब्ध नहीं है)

• 🐙 GitHub: github.com/mlc-ai/mlc-llm

• 📚 डॉक्यूमेंटेशन: llm.mlc.ai/docs

• 🤗 प्री-कम्पाइल्ड मॉडल्स: huggingface.co/mlc-ai

• 💬 डिसकोर्ड: discord.gg/9Xpy2HGBuD