LMDeploy

शंघाई AI लैब द्वारा एक कुशल LLM परिनियोजन टूलकिट — बड़े भाषा मॉडलों के लिए उत्पादन-स्तरीय इन्फ़रेंस, क्वांटाइज़ेशन, और सर्विंग, जिसमें सतत बैचिंग और PagedAttention शामिल हैं।

🏛️ द्वारा विकसित OpenMMLab / Shanghai AI Lab | Apache-2.0 लाइसेंस | 4,000+ GitHub स्टार्स

---

LMDeploy क्या है?

LMDeploy उत्पादन में बड़े भाषा मॉडलों को संपीड़ित करने, परिनियोजित करने और सर्व करने के लिए एक व्यापक टूलकिट है। OpenMMLab (MMDetection, MMSeg) के पीछे वाली उसी टीम द्वारा बनाया गया, यह शोध-स्तर के अनुकूलनों को व्यावहारिक परिनियोजन में लाता है:

• TurboMind इंजन — CUDA अनुकूलनों के साथ उच्च-प्रदर्शन C++ इन्फ़रेंस बैकएंड

• PyTorch इंजन — व्यापक मॉडल संगतता के लिए लचीला Python-आधारित इंजन

• निरंतर बैचिंग — समवर्ती अनुरोधों के बीच GPU उपयोग को अधिकतम करता है

• PagedAttention — कुशल KV कैश प्रबंधन (vLLM जैसा)

• 4-बिट / 8-बिट क्वांटाइज़ेशन — AWQ और SmoothQuant समर्थन

• विज़न-भाषा मॉडल — InternVL, LLaVA, Qwen-VL समर्थन

vLLM की तुलना में, LMDeploy का TurboMind इंजन batch=32 पर Llama 3 8B में लगभग 1.36× अधिक थ्रूपुट देता है, और इसका AWQ क्वांटाइज़ेशन प्रथम श्रेणी का है — बाद में सोचा गया नहीं। VLMs (विशेषकर InternVL2) के लिए, LMDeploy संदर्भ परिनियोजन स्टैक है।

LMDeploy क्यों?

विशेषता	LMDeploy	vLLM	TGI
निरंतर बैचिंग	✅	✅	✅
AWQ क्वांटाइज़ेशन	✅	✅	❌
स्पेकुलेटिव डिकोडिंग	✅	✅	✅
विज़न-भाषा	✅	सीमित	सीमित
OpenAI API	✅	✅	✅
TurboMind (कस्टम इंजन)	✅	❌	❌

---

Clore.ai पर त्वरित शुरुआत

चरण 1: GPU सर्वर चुनें

पर clore.ai मार्केटप्लेस:

• न्यूनतम: 8GB VRAM वाला NVIDIA GPU (7B मॉडलों के लिए)

• अनुशंसित: RTX 3090/4090 (24GB) या A100 (40/80GB)

• CUDA: 11.8 या 12.x आवश्यक

चरण 2: LMDeploy Docker परिनियोजित करें

Docker इमेज: openmmlab/lmdeploy

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

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

पर्यावरण चर:

HUGGING_FACE_HUB_TOKEN=your_hf_token_here  # गेटेड मॉडलों के लिए

चरण 3: SSH करें और सत्यापित करें

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

# इंस्टॉलेशन सत्यापित करें
python -c "import lmdeploy; print(lmdeploy.__version__)"
lmdeploy --help

---

API सर्वर प्रारंभ करना

OpenAI-संगत सर्वर (अनुशंसित)

# TurboMind इंजन के साथ Llama 3 8B सर्व करें
lmdeploy serve api_server \
  meta-llama/Meta-Llama-3-8B-Instruct \
  --server-port 23333 \
  --server-name 0.0.0.0 \
  --model-name llama3-8b

# स्पष्ट इंजन चयन के साथ
lmdeploy serve api_server \
  meta-llama/Meta-Llama-3-8B-Instruct \
  --backend turbomind \
  --server-port 23333 \
  --server-name 0.0.0.0 \
  --tp 1 \
  --max-batch-size 128 \
  --cache-max-entry-count 0.8

PyTorch इंजन (व्यापक संगतता)

# TurboMind द्वारा समर्थित नहीं होने वाले मॉडलों के लिए PyTorch इंजन का उपयोग करें
lmdeploy serve api_server \
  mistralai/Mistral-7B-Instruct-v0.2 \
  --backend pytorch \
  --server-port 23333 \
  --server-name 0.0.0.0

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

[2024-01-01 12:00:00,000] INFO: मॉडल लोड हो रहा है: meta-llama/Meta-Llama-3-8B-Instruct
[2024-01-01 12:00:20,000] INFO: TurboMind इंजन प्रारंभ किया गया
[2024-01-01 12:00:20,000] INFO: सर्वर यहाँ शुरू हुआ http://0.0.0.0:23333
[2024-01-01 12:00:20,000] INFO: API डॉक्स: http://0.0.0.0:23333/docs

शुरू होने के बाद, LMDeploy इंटरैक्टिव API डॉक्स यहाँ उपलब्ध कराता है http://<your-ip>:23333/docs — ब्राउज़र से सीधे एंडपॉइंट्स का परीक्षण करने के लिए उपयोगी।

---

समर्थित मॉडल

टेक्स्ट मॉडल

# लामा 3
meta-llama/Meta-Llama-3-8B-Instruct
meta-llama/Meta-Llama-3-70B-Instruct

# Mistral / Mixtral
mistralai/Mistral-7B-Instruct-v0.2
mistralai/Mixtral-8x7B-Instruct-v0.1

# Qwen
Qwen/Qwen2-7B-Instruct
Qwen/Qwen2-72B-Instruct

# InternLM
internlm/internlm2-chat-7b
internlm/internlm2-chat-20b

# Yi
01-ai/Yi-1.5-9B-Chat
01-ai/Yi-1.5-34B-Chat

# Gemma
google/gemma-7b-it
google/gemma-2b-it

विज़न-भाषा मॉडल

# InternVL (अनुशंसित VLM)
OpenGVLab/InternVL2-8B
OpenGVLab/InternVL2-26B

# LLaVA
llava-hf/llava-1.5-7b-hf

# Qwen-VL
Qwen/Qwen-VL-Chat

---

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

AWQ 4-बिट क्वांटाइज़ेशन

LMDeploy का AWQ (Activation-aware Weight Quantization) 4-बिट पर उत्कृष्ट गुणवत्ता देता है:

# मॉडल को AWQ 4-बिट में क्वांटाइज़ करें
lmdeploy lite auto_awq \
  meta-llama/Meta-Llama-3-8B-Instruct \
  --calib-dataset ptb \
  --calib-samples 128 \
  --calib-seqlen 2048 \
  --w-bits 4 \
  --w-group-size 128 \
  --work-dir ./quantized/llama3-8b-awq

# क्वांटाइज़्ड मॉडल सर्व करें
lmdeploy serve api_server \
  ./quantized/llama3-8b-awq \
  --server-port 23333 \
  --server-name 0.0.0.0

SmoothQuant W8A8

8-बिट वज़न और एक्टिवेशन क्वांटाइज़ेशन (थ्रूपुट-निर्णायक परिनियोजन के लिए बेहतर):

lmdeploy lite smooth_quant \
  meta-llama/Meta-Llama-3-8B-Instruct \
  --work-dir ./quantized/llama3-8b-sq \
  --calib-dataset ptb \
  --calib-samples 512

क्वांटाइज़ेशन प्रभाव

क्वांटाइज़ेशन	VRAM (7B)	गुणवत्ता हानि	थ्रूपुट लाभ
कोई नहीं (bf16)	~14GB	कोई नहीं	आधाररेखा
SmoothQuant W8A8	~8GB	न्यूनतम	+20%
AWQ W4A16	~4GB	कम	+15%
GPTQ W4A16	~4GB	कम	+10%

AWQ अनुशंसा: अधिकांश उपयोग मामलों के लिए, AWQ 4-बिट गुणवत्ता और VRAM बचत का सर्वोत्तम संतुलन है। बेहतर गुणवत्ता के लिए --w-group-size 128 का उपयोग करें, जिसमें थोड़ी अधिक मेमोरी लगेगी।

---

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

Python क्लाइंट

from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<api-port>/v1",
    api_key="none"
)

# चैट पूर्णता
response = client.chat.completions.create(
    model="llama3-8b",
    messages=[
        {"role": "system", "content": "आप एक सहायक सहायक हैं."},
        {"role": "user", "content": "AI का इतिहास 3 वाक्यों में संक्षेप करें।"}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)

स्ट्रीमिंग

stream = client.chat.completions.create(
    model="llama3-8b",
    messages=[{"role": "user", "content": "अंतरिक्ष पर एक कविता लिखें।"}],
    stream=True
)

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

LMDeploy नेटिव Python क्लाइंट

from lmdeploy import pipeline, TurbomindEngineConfig

# सीधे पाइपलाइन (सर्वर की आवश्यकता नहीं)
pipe = pipeline(
    'meta-llama/Meta-Llama-3-8B-Instruct',
    backend_config=TurbomindEngineConfig(max_batch_size=16)
)

# एकल इन्फ़रेंस
response = pipe("फ्रांस की राजधानी क्या है?")
print(response.text)

# बैच इन्फ़रेंस
responses = pipe([
    "गुरुत्वाकर्षण समझाएँ",
    "DNA क्या है?",
    "Bitcoin कैसे काम करता है?"
])
for r in responses:
    print(r.text)
    print("---")

विज़न-भाषा मॉडल

from lmdeploy import pipeline
from lmdeploy.vl import load_image

pipe = pipeline('OpenGVLab/InternVL2-8B')

image = load_image('https://example.com/photo.jpg')
response = pipe(('इस छवि का विस्तार से वर्णन करें', image))
print(response.text)

---

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

टेंसर पैरललिज़्म

# 4 GPUs में 70B मॉडल वितरित करें
lmdeploy serve api_server \
  meta-llama/Meta-Llama-3-70B-Instruct \
  --backend turbomind \
  --server-port 23333 \
  --server-name 0.0.0.0 \
  --tp 4 \
  --max-batch-size 64

from lmdeploy import pipeline, TurbomindEngineConfig

pipe = pipeline(
    'meta-llama/Meta-Llama-3-70B-Instruct',
    backend_config=TurbomindEngineConfig(tp=4)
)

---

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

TurboMind इंजन कॉन्फ़िगरेशन

from lmdeploy import pipeline, TurbomindEngineConfig

engine_config = TurbomindEngineConfig(
    max_batch_size=64,          # अधिकतम समवर्ती अनुरोध
    cache_max_entry_count=0.8,  # KV कैश अनुपात (0.0-1.0)
    quant_policy=0,             # 0=कोई क्वांट नहीं, 4=4-बिट KV कैश, 8=8-बिट KV कैश
    rope_scaling_factor=1.0,    # विस्तारित संदर्भ के लिए
    num_tokens_per_iter=4096,   # प्रीफ़िल चंक आकार
    max_prefill_token_num=8192, # अधिकतम प्रीफ़िल लंबाई
)

pipe = pipeline('meta-llama/Meta-Llama-3-8B-Instruct', backend_config=engine_config)

जनरेशन कॉन्फ़िगरेशन

from lmdeploy import GenerationConfig

gen_config = GenerationConfig(
    temperature=0.7,
    top_p=0.9,
    top_k=40,
    repetition_penalty=1.1,
    max_new_tokens=1024,
    stop_words=['<|eot_id|>', '<|end_of_text|>'],
)

response = pipe("Hello, world!", gen_config=gen_config)

---

निगरानी एवं मीट्रिक्स

सर्वर स्वास्थ्य जाँचें

# स्वास्थ्य जाँच एंडपॉइंट
curl http://localhost:23333/health

# उपलब्ध मॉडल सूचीबद्ध करें
curl http://localhost:23333/v1/models

# सर्वर आँकड़े
curl http://localhost:23333/stats

GPU निगरानी

# रीयल-टाइम GPU आँकड़े
watch -n 1 'nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu --format=csv'

---

Docker Compose उदाहरण

version: '3.8'
services:
  lmdeploy:
    image: openmmlab/lmdeploy:latest
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    ports:
      - "23333:23333"
      - "22:22"
    volumes:
      - hf-cache:/root/.cache/huggingface
      - ./models:/models
    command: >
      lmdeploy serve api_server
      meta-llama/Meta-Llama-3-8B-Instruct
      --server-port 23333
      --server-name 0.0.0.0
      --model-name llama3-8b
      --max-batch-size 64
    restart: unless-stopped
    shm_size: '2g'

volumes:
  hf-cache:

---

बेंचमार्किंग

# अंतर्निहित बेंचमार्क टूल
lmdeploy benchmark \
  meta-llama/Meta-Llama-3-8B-Instruct \
  --backend turbomind \
  --concurrency 1 4 8 16 32 \
  --num-prompts 1000 \
  --prompt-len 128 \
  --output-len 256

नमूना आउटपुट (RTX 4090, TurboMind, bf16):

concurrency=1:  throughput=42.3 tokens/s, latency_p50=23ms
concurrency=8:  throughput=287.1 tokens/s, latency_p50=156ms
concurrency=32: throughput=412.6 tokens/s, latency_p50=621ms

A100 80GB पर, HBM2e मेमोरी बैंडविड्थ (2 TB/s बनाम 1 TB/s) के कारण उच्च concurrency पर RTX 4090 की तुलना में लगभग 2.2× अधिक थ्रूपुट की अपेक्षा करें।

---

Clore.ai GPU अनुशंसाएँ

अपने लक्षित मॉडल आकार और सर्विंग लोड के आधार पर चुनें:

उपयोग-प्रकरण	GPU	VRAM	क्यों
7–13B मॉडल, डेवलपमेंट/स्टेजिंग	RTX 3090	24 GB	सबसे अच्छा $/VRAM अनुपात; 7B bf16 या 13B AWQ संभालता है
7–13B मॉडल, उत्पादन	RTX 4090	24 GB	समान VRAM पर 3090 से लगभग 40% तेज; Llama 3 8B पर 412 tok/s
70B मॉडल, टीम सर्विंग	A100 40GB	40 GB	70B AWQ फिट करता है; विश्वसनीयता के लिए ECC मेमोरी
70B मॉडल, उच्च थ्रूपुट	A100 80GB	80 GB	70B bf16 फिट करता है; batch=32 पर A100 40GB की तुलना में 2× थ्रूपुट

बजट विकल्प: RTX 3090 + AWQ 4-बिट — Llama 3 8B को लगभग 280 tok/s batch=8 पर सर्व करता है, अधिकांश API उपयोग मामलों को कवर करता है।

गति विकल्प: RTX 4090 — 7–13B मॉडलों के लिए प्रति डॉलर सबसे तेज; TurboMind अपने 1 TB/s बैंडविड्थ के हर GB/s का पूरा उपयोग करता है।

उत्पादन विकल्प: A100 80GB — क्वांटाइज़ेशन गुणवत्ता से समझौता किए बिना Qwen2-72B या Llama 3 70B को पूर्ण bf16 में चलाएँ; मल्टी-इंस्टेंस GPU सर्विंग में आसानी से फिट होता है।

---

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

मॉडल लोड नहीं हो रहा

# जाँचें कि HuggingFace टोकन सेट है
echo $HUGGING_FACE_HUB_TOKEN

# मॉडल को मैन्युअल रूप से डाउनलोड करें
pip install huggingface_hub
huggingface-cli download meta-llama/Meta-Llama-3-8B-Instruct --local-dir ./llama3-8b

# इसके बजाय स्थानीय पथ का उपयोग करें
lmdeploy serve api_server ./llama3-8b --server-port 23333

CUDA मेमोरी समाप्त

# KV कैश आवंटन कम करें
lmdeploy serve api_server MODEL \
  --cache-max-entry-count 0.5  # 0.8 से कम करें

# क्वांटाइज़्ड KV कैश का उपयोग करें
lmdeploy serve api_server MODEL \
  --quant-policy 8  # 8-बिट KV कैश

पोर्ट पहले से उपयोग में है

# जाँचें कि पोर्ट 23333 का उपयोग कौन कर रहा है
ss -tlnp | grep 23333
fuser 23333/tcp

# मौजूदा प्रक्रिया समाप्त करें
kill -9 $(fuser 23333/tcp)

Docker नेटवर्क मोड: Docker में चलाते समय, सुनिश्चित करें कि कंटेनर उपयोग करता है --network host या उचित पोर्ट मैपिंग (-p 23333:23333) ताकि API बाहर से पहुँच योग्य हो।

---

Clore.ai GPU अनुशंसाएँ

LMDeploy का TurboMind इंजन और W4A16 क्वांटाइज़ेशन सर्वोत्तम-स्तरीय थ्रूपुट देते हैं — विशेषकर Ampere/Hopper GPUs पर।

GPU	VRAM	Clore.ai मूल्य	Llama 3 8B थ्रूपुट	Llama 3 70B Q4
RTX 3090	24 GB	$0.07–0.21/hr	~120 tok/s (fp16)	❌ बहुत बड़ा
RTX 4090	24 GB	$0.14–0.42/hr	~200 tok/s (fp16)	❌ बहुत बड़ा
A100 40GB	40 GB	bare metal	~160 tok/s (fp16)	~55 tok/s (W4A16)
A100 80GB	80 GB	bare metal	~175 tok/s (fp16)	~80 tok/s (fp16)
2× RTX 4090	48 GB	$0.28–0.84/hr	~380 tok/s (टेंसर पैरेलल)	~60 tok/s

$0.07–0.21/घंटा पर RTX 3090 7B–13B मॉडलों के लिए शीर्ष विकल्प है। LMDeploy का TurboMind इंजन उपभोक्ता GPUs से लगभग अधिकतम थ्रूपुट निकालता है। Llama 3 8B सर्व करने वाला एकल RTX 3090 120 tok/s संभालता है — 10–20 समवर्ती उपयोगकर्ताओं वाली उत्पादन APIs के लिए पर्याप्त।

70B मॉडलों के लिए: A100 40GB (bare metal) W4A16 क्वांटाइज़ेशन के साथ लगभग 55 tok/s देता है — दो RTX 4090s से अधिक किफायती।

---

संसाधन

• 📦 Docker Hub: hub.docker.com/r/openmmlab/lmdeploy

• 🐙 GitHub: github.com/InternLM/lmdeploy

• 📚 दस्तावेज़ीकरण: lmdeploy.readthedocs.io

• 💬 Discord: discord.gg/xa29JuW84p

• 🤗 पूर्व-क्वांटाइज़्ड मॉडल: huggingface.co/lmdeploy