MLC-LLM

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

🌟 20,000+ GitHub स्टार्स | MLC AI टीम द्वारा अनुरक्षित | Apache-2.0 लाइसेंस

---

MLC-LLM क्या है?

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

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

• सार्वभौमिक हार्डवेयर समर्थन — NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, WebGPU

• OpenAI-संगत REST API — मौजूदा वर्कफ़्लो के लिए बिना बदलाव वाला प्रतिस्थापन

• कई मॉडल प्रारूप — Llama, Mistral, Gemma, Phi, Qwen, Falcon, और भी बहुत कुछ

• 4-बिट / 8-बिट क्वांटीकरण — उपभोक्ता GPU पर बड़े मॉडल चलाएँ

• चैट इंटरफ़ेस — तुरंत परीक्षण के लिए अंतर्निर्मित वेब 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.8.1-devel-ubuntu22.04 Clore.ai पर अपने बेस इमेज के रूप में।

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

Docker इमेज: nvidia/cuda:12.8.1-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": "आप एक सहायक सहायक हैं."},
        {"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 का हेडरूम छोड़ें। q4f16_1 7B मॉडल को सामान्य वर्कलोड पर कुल मिलाकर लगभग 6–7GB की आवश्यकता होती है।

---

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

कई GPUs की आवश्यकता वाले बड़े मॉडलों (70B+) के लिए:

# 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"थ्रूपुट: {tokens/elapsed:.1f} tokens/sec")

---

Docker Compose सेटअप

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

version: '3.8'
services:
  mlc-llm:
    image: nvidia/cuda:12.8.1-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.8 सर्वरों के लिए, इंस्टॉल करें:
pip install --pre -U -f https://mlc.ai/wheels mlc-llm-nightly-cu121 mlc-ai-nightly-cu121

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

आम गलती: MLC-LLM pip wheels CUDA संस्करण-विशिष्ट होते हैं। सुनिश्चित करें कि अपने सर्वर के CUDA संस्करण से मेल खाने वाला सही वैरिएंट इंस्टॉल करें। उपलब्ध wheels यहाँ देखें 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.07–0.21/hr	7B–13B मॉडल, बजट सर्विंग	~85 tok/s
RTX 4090	24 GB	$0.14–0.42/hr	7B–34B मॉडल, तेज़ सर्विंग	~140 tok/s
A100 40GB	40 GB	bare metal	34B–70B, प्रोडक्शन API	~110 tok/s
A100 80GB	80 GB	bare metal	70B+, बहु-मॉडल सर्विंग	~130 tok/s
H100 SXM	80 GB	~$1.04/घंटा	अधिकतम थ्रूपुट, FP8	~280 tok/s

अनुशंसित प्रारंभिक बिंदु: $0.07–0.21/घंटा पर RTX 3090, MLC-LLM के माध्यम से Llama 3 8B और Mistral 7B सर्विंग के लिए मूल्य-प्रदर्शन अनुपात के लिहाज़ से सबसे अच्छा है। संकलित कर्नेल्स उपभोक्ता GPUs से लगभग-अधिकतम उपयोगिता निकालते हैं।

70B मॉडलों के लिए (उदा., Llama 3 70B Q4): A100 40GB (bare metal) या tensor parallelism के माध्यम से दो 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: discord.gg/9Xpy2HGBuD