# LMDeploy

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

> 🏛️ विकसित किया गया द्वारा **OpenMMLab / शंघाई AI लैब** | Apache-2.0 लाइसेंस | 4,000+ GitHub स्टार्स

***

## LMDeploy क्या है?

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

* **TurboMind इंजन** — CUDA अनुकूलनों के साथ उच्च-प्रदर्शन C++ इनफेरेंस बैकएंड
* **PyTorch इंजन** — व्यापक मॉडल संगतता के लिए लचीला पायथन-आधारित इंजन
* **निरंतर बैचिंग** — समकालिक अनुरोधों के बीच GPU उपयोगिता को अधिकतम करता है
* **PagedAttention** — कुशल KV कैश प्रबंधन (vLLM जैसा)
* **4-बिट / 8-बिट क्वांटाइजेशन** — AWQ और SmoothQuant समर्थन
* **विजन-भाषा मॉडल्स** — InternVL, LLaVA, Qwen-VL समर्थन

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

### क्यों LMDeploy?

| फ़ीचर                  | LMDeploy | vLLM  | 🆕 — KV कैश साझा करने के लिए RadixAttention, MoE पर vLLM की तुलना में 2–5× थ्रूपुट — |
| ---------------------- | -------- | ----- | ------------------------------------------------------------------------------------ |
| निरंतर बैचिंग          | ✅        | ✅     | ✅                                                                                    |
| AWQ क्वांटाइजेशन       | ✅        | ✅     | ❌                                                                                    |
| स्पेकुलेटिव डिकोडिंग   | ✅        | ✅     | ✅                                                                                    |
| विजन-भाषा              | ✅        | सीमित | सीमित                                                                                |
| OpenAI API             | ✅        | ✅     | ✅                                                                                    |
| TurboMind (कस्टम इंजन) | ✅        | ❌     | ❌                                                                                    |

***

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

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

पर [clore.ai](https://clore.ai) मार्केटप्लेस:

* **न्यूनतम:** NVIDIA GPU with 8GB VRAM (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 और सत्यापित करें

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

# स्थापना सत्यापित करें
python -c "import lmdeploy; print(lmdeploy.__version__)"
lmdeploy --help
```

***

## API सर्वर शुरू करना

### OpenAI-अनुकूल सर्वर (अनुशंसित)

```bash
# 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 इंजन (व्यापक संगतता)

```bash
# उन मॉडलों के लिए PyTorch इंजन का उपयोग करें जिनको TurboMind समर्थन नहीं करता
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: Loading model: meta-llama/Meta-Llama-3-8B-Instruct
[2024-01-01 12:00:20,000] INFO: TurboMind engine initialized
[2024-01-01 12:00:20,000] INFO: Server started at http://0.0.0.0:23333
[2024-01-01 12:00:20,000] INFO: API docs: http://0.0.0.0:23333/docs
```

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

***

## समर्थित मॉडल

### टेक्स्ट मॉडल्स

```bash
# Llama 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
```

### विजन-भाषा मॉडल्स

```bash
# 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-बिट पर उत्कृष्ट गुणवत्ता उत्पन्न करता है:

```bash
# किसी मॉडल को 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-बिट वेट और एक्टिवेशन क्वांटाइजेशन (थ्रूपुट-नाज़ुक परिनियोजनों के लिए बेहतर):

```bash
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%        |

{% hint style="info" %}
**AWQ सिफारिश:** अधिकांश उपयोग मामलों के लिए, AWQ 4-बिट गुणवत्ता और VRAM बचत का सबसे अच्छा संतुलन है। उपयोग करें `--w-group-size 128` बेहतर गुणवत्ता के लिए, थोड़ी अधिक मेमोरी उपयोग के साथ।
{% endhint %}

***

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

### Python क्लाइंट

```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": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize the history of AI in 3 sentences."}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)
```

### स्ट्रीमिंग

```python
stream = client.chat.completions.create(
    model="llama3-8b",
    messages=[{"role": "user", "content": "Write a poem about space."}],
    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("What is the capital of France?")
print(response.text)

# बैच इनफेरेंस
responses = pipe([
    "Explain gravity",
    "What is DNA?",
    "How does Bitcoin work?"
])
for r in responses:
    print(r.text)
    print("---")
```

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

```python
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(('Describe this image in detail', image))
print(response.text)
```

***

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

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

```bash
# 70B मॉडल को 4 GPUs में वितरित करें
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
```

```python
from lmdeploy import pipeline, TurbomindEngineConfig

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

***

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

### TurboMind इंजन कॉन्फ़िग

```python
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=4bit KV कैश, 8=8bit 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)
```

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

```python
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)
```

***

## मानिटरिंग और मीट्रिक्स

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

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

# उपलब्ध मॉडलों की सूची बनाएं
curl http://localhost:23333/v1/models

# सर्वर सांख्यिकी
curl http://localhost:23333/stats
```

### GPU मॉनिटरिंग

```bash
# रीयल-टाइम GPU सांख्यिकी
watch -n 1 'nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu --format=csv'
```

***

## Docker Compose उदाहरण

```yaml
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:
```

***

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

```bash
# बिल्ट-इन बेंचमार्क टूल
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) के कारण RTX 4090 की तुलना में \~2.2× अधिक थ्रूपुट की अपेक्षा करें।

***

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

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

| उपयोग केस                 | GPU           | VRAM  | क्यों                                                               |
| ------------------------- | ------------- | ----- | ------------------------------------------------------------------- |
| 7–13B मॉडल्स, dev/staging | **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-बिट — लगभग 280 tok/s batch=8 पर Llama 3 8B सर्व करता है, जो अधिकांश API उपयोग मामलों को कवर करता है।

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

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

***

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

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

```bash
# जांचें कि 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 मेमोरी खत्म (Out of Memory)

```bash
# 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 कैश
```

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

```bash
# देखें कि क्या पोर्ट 23333 किसके द्वारा उपयोग हो रहा है
ss -tlnp | grep 23333
fuser 23333/tcp

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

{% hint style="warning" %}
**Docker नेटवर्क मोड:** Docker में चलाते समय, सुनिश्चित करें कि कंटेनर उपयोग करता है `--network host` या सही पोर्ट मैपिंग (`-p 23333:23333`) ताकि API बाहर से पहुँचा जा सके।
{% endhint %}

***

## 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.12/घंटा  | \~120 tok/s (fp16)            | ❌ बहुत बड़ा        |
| RTX 4090    | 24 GB | \~$0.70/घंटा  | \~200 tok/s (fp16)            | ❌ बहुत बड़ा        |
| A100 40GB   | 40 GB | \~$1.20/घंटा  | \~160 tok/s (fp16)            | \~55 tok/s (W4A16) |
| A100 80GB   | 80 GB | \~$2.00/घंटा  | \~175 tok/s (fp16)            | \~80 tok/s (fp16)  |
| 2× RTX 4090 | 48 GB | \~$1.40/hr    | \~380 tok/s (tensor parallel) | \~60 tok/s         |

{% hint style="info" %}
**RTX 3090 at \~$0.12/hr** 7B–13B मॉडलों के लिए यह शीर्ष विकल्प है। LMDeploy का TurboMind इंजन कंज्यूमर GPUs से लगभग-अधिकतम थ्रूपुट निकालता है। एकल RTX 3090 Llama 3 8B सर्व करते समय 120 tok/s हैं — 10–20 समकालिक उपयोगकर्ताओं वाले प्रोडक्शन APIs के लिए पर्याप्त।

70B मॉडलों के लिए: A100 40GB (\~$1.20/hr) W4A16 क्वांटाइजेशन के साथ \~55 tok/s देता है — दो RTX 4090s से अधिक किफायती।
{% endhint %}

***

## संसाधन

* 📦 **Docker Hub:** [hub.docker.com/r/openmmlab/lmdeploy](https://hub.docker.com/r/openmmlab/lmdeploy)
* 🐙 **GitHub:** [github.com/InternLM/lmdeploy](https://github.com/InternLM/lmdeploy)
* 📚 **डॉक्यूमेंटेशन:** [lmdeploy.readthedocs.io](https://lmdeploy.readthedocs.io)
* 💬 **डिसकोर्ड:** [discord.gg/xa29JuW84p](https://discord.gg/xa29JuW84p)
* 🤗 **प्री-क्वांटाइज़्ड मॉडल्स:** [huggingface.co/lmdeploy](https://huggingface.co/lmdeploy)