> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/lmdeploy.md).

# LMDeploy

**Набор инструментов для эффективного развёртывания LLM от Shanghai AI Lab** — промышленного уровня инференс, квантование и сервис для больших языковых моделей с непрерывной пакетной обработкой и PagedAttention.

> 🏛️ Разработано **OpenMMLab / Shanghai AI Lab** | Лицензия Apache-2.0 | 4000+ звёзд на GitHub

***

## Что такое LMDeploy?

LMDeploy — это всесторонний набор инструментов для сжатия, развёртывания и обслуживания больших языковых моделей в продакшене. Создан командой, стоящей за OpenMMLab (MMDetection, MMSeg), он приносит оптимизации исследовательского уровня в практическое развёртывание:

* **Движок TurboMind** — высокопроизводительный бэкенд инференса на C++ с оптимизациями для CUDA
* **Движок PyTorch** — гибкий движок на Python с широкой совместимостью моделей
* **Непрерывная пакетная обработка** — максимизирует загрузку GPU при одновременных запросах
* **PagedAttention** — эффективное управление KV-кэшем (аналогично vLLM)
* **Квантование 4-бит / 8-бит** — поддержка AWQ и SmoothQuant
* **Визионно-языковые модели** — поддержка InternVL, LLaVA, Qwen-VL

По сравнению с vLLM, движок TurboMind в LMDeploy обеспечивает примерно в 1.36× большую пропускную способность на Llama 3 8B при batch=32, а квантование AWQ в LMDeploy — первоклассное, а не побочный продукт. Для VLM (особенно InternVL2) LMDeploy является эталонным стеком для развёртывания.

### Почему LMDeploy?

| Функция                            | LMDeploy | vLLM       | TGI        |
| ---------------------------------- | -------- | ---------- | ---------- |
| Непрерывная пакетная обработка     | ✅        | ✅          | ✅          |
| Квантование AWQ                    | ✅        | ✅          | ❌          |
| Спекулятивное декодирование        | ✅        | ✅          | ✅          |
| Визионно-языковое                  | ✅        | Ограничено | Ограничено |
| API OpenAI                         | ✅        | ✅          | ✅          |
| TurboMind (самостоятельный движок) | ✅        | ❌          | ❌          |

***

## Быстрый старт на Clore.ai

### Шаг 1: Выберите GPU-сервер

На [clore.ai](https://clore.ai) рынок:

* **Минимум:** NVIDIA GPU с 8 ГБ видеопамяти (для моделей 7B)
* **Рекомендуется:** RTX 3090/4090 (24 ГБ) или A100 (40/80 ГБ)
* **CUDA:** Требуется 11.8 или 12.x

### Шаг 2: Разверните LMDeploy в Docker

```
Docker Image: openmmlab/lmdeploy
```

**Проброс портов:**

| Порт контейнера | Назначение          |
| --------------- | ------------------- |
| `22`            | Доступ по SSH       |
| `23333`         | API-сервер LMDeploy |

**Переменные окружения:**

```
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
# Развернуть Llama 3 8B с движком TurboMind
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: Загрузка модели: 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
```

{% 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-бит

AWQ (взвешенное квантование с учётом активаций) в LMDeploy даёт отличное качество при 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)       | \~14 ГБ   | Нет             | Базовый уровень                |
| SmoothQuant W8A8 | \~8 ГБ    | Минимальная     | +20%                           |
| AWQ W4A16        | \~4 ГБ    | Низкая          | +15%                           |
| GPTQ W4A16       | \~4 ГБ    | Низкая          | +10%                           |

{% hint style="info" %}
**Рекомендация по AWQ:** Для большинства сценариев AWQ 4-бит — лучший баланс между качеством и экономией видеопамяти. Используйте `--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"
)

# Chat completion
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()
```

### Нативный Python-клиент 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 GPU
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=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)
```

### Конфигурация генерации

```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 ожидайте примерно в 2.2× большую пропускную способность по сравнению с RTX 4090 при высокой конкуренции из-за пропускной способности памяти HBM2e (2 TB/s против 1 TB/s).

***

## Рекомендации Clore.ai по GPU

Выбирайте в зависимости от размера целевой модели и нагрузки на сервис:

| Сценарий использования                     | GPU           | VRAM  | Почему                                                                            |
| ------------------------------------------ | ------------- | ----- | --------------------------------------------------------------------------------- |
| Модели 7–13B, dev/staging                  | **RTX 3090**  | 24 ГБ | Лучшее соотношение $/VRAM; поддерживает 7B bf16 или 13B AWQ                       |
| Модели 7–13B, продакшен                    | **RTX 4090**  | 24 ГБ | \~40% быстрее, чем 3090 при той же видеопамяти; 412 ток/с на Llama 3 8B           |
| Модели 70B, командное обслуживание         | **A100 40GB** | 40 ГБ | Вмещает 70B AWQ; ECC-память для надёжности                                        |
| Модели 70B, высокая пропускная способность | **A100 80GB** | 80 ГБ | Вмещает 70B bf16; 2× пропускная способность по сравнению с A100 40GB при batch=32 |

**Бюджетный выбор:** RTX 3090 + AWQ 4-бит — обслуживает Llama 3 8B примерно на \~280 ток/с при batch=8, покрывает большинство сценариев API.

**Выбор по скорости:** RTX 4090 — самый быстрый по соотношению цена/производительность для моделей 7–13B; TurboMind выжимает максимум из 1 TB/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: недостаточно памяти

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

Движок TurboMind и квантование W4A16 в LMDeploy обеспечивают лучшую в своём классе пропускную способность — особенно на GPU архитектур Ampere/Hopper.

| GPU         | VRAM  | Цена Clore.ai | Пропускная способность Llama 3 8B   | Llama 3 70B Q4     |
| ----------- | ----- | ------------- | ----------------------------------- | ------------------ |
| RTX 3090    | 24 ГБ | \~$0.12/ч     | \~120 ток/с (fp16)                  | ❌ Слишком большой  |
| RTX 4090    | 24 ГБ | \~$0.70/ч     | \~200 ток/с (fp16)                  | ❌ Слишком большой  |
| A100 40GB   | 40 ГБ | \~$1.20/ч     | \~160 ток/с (fp16)                  | \~55 ток/с (W4A16) |
| A100 80GB   | 80 ГБ | \~$2.00/ч     | \~175 ток/с (fp16)                  | \~80 ток/с (fp16)  |
| 2× RTX 4090 | 48 ГБ | \~$1.40/час   | \~380 ток/с (тензорный параллелизм) | \~60 ток/с         |

{% hint style="info" %}
**RTX 3090 при \~$0.12/час** является лучшим выбором для моделей 7B–13B. Движок TurboMind в LMDeploy извлекает почти максимум пропускной способности из потребительских GPU. Один RTX 3090, обслуживающий Llama 3 8B, обрабатывает 120 ток/с — этого достаточно для продакшен API с 10–20 одновременными пользователями.

Для моделей 70B: A100 40GB (\~$1.20/час) с квантованием W4A16 даёт \~55 ток/с — более экономично, чем две RTX 4090.
{% 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:** [discord.gg/xa29JuW84p](https://discord.gg/xa29JuW84p)
* 🤗 **Предварительно квантованные модели:** [huggingface.co/lmdeploy](https://huggingface.co/lmdeploy)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/lmdeploy.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.