> 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 | 4 000+ звезд на 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 — первоклассная, а не второстепенная функция. Для VLM (особенно InternVL2) LMDeploy — эталонный стек развертывания.

### Почему LMDeploy?

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

***

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

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

На [маркетплейсе clore.ai](https://clore.ai) маркетплейс:

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

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

```
Docker-образ: 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 (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)       | \~14 ГБ   | Нет             | Базовый уровень                |
| SmoothQuant W8A8 | \~8 ГБ    | Минимальная     | +20%                           |
| AWQ W4A16        | \~4 ГБ    | Низкая          | +15%                           |
| GPTQ W4A16       | \~4 ГБ    | Низкая          | +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": "Вы — полезный помощник."},
        {"role": "user", "content": "Кратко изложите историю ИИ в 3 предложениях."}
    ],
    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": "Напишите стихотворение о космосе."}],
    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

# Прямой pipeline (сервер не нужен)
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(('Опишите это изображение подробно', 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,   # Размер чанка prefill
    max_prefill_token_num=8192, # Максимальная длина prefill
)

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 80 ГБ ожидайте примерно в 2,2× более высокую пропускную способность, чем на RTX 4090, при высокой конкуренции запросов благодаря пропускной способности памяти HBM2e (2 ТБ/с против 1 ТБ/с).

***

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

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

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

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

**Выбор по скорости:** RTX 4090 — самая быстрая по цене для моделей 7–13B; TurboMind выжимает каждый ГБ/с из ее пропускной способности 1 ТБ/с.

**Выбор для продакшена:** A100 80 ГБ — запускайте Qwen2-72B или Llama 3 70B в полном bf16 без компромиссов по качеству квантизации; легко подходит для многoэкземплярного 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 %}

***

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

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

| GPU         | VRAM  | Цена Clore.ai                               | Пропускная способность Llama 3 8B | Llama 3 70B Q4     |
| ----------- | ----- | ------------------------------------------- | --------------------------------- | ------------------ |
| RTX 3090    | 24 ГБ | $0.07–0.21/ч                                | \~120 ток/с (fp16)                | ❌ Слишком большой  |
| RTX 4090    | 24 ГБ | $0.14–0.42/ч                                | \~200 ток/с (fp16)                | ❌ Слишком большой  |
| A100 40 ГБ  | 40 ГБ | [голое железо](https://clore.ai/bare-metal) | \~160 ток/с (fp16)                | \~55 ток/с (W4A16) |
| A100 80 ГБ  | 80 ГБ | [голое железо](https://clore.ai/bare-metal) | \~175 ток/с (fp16)                | \~80 ток/с (fp16)  |
| 2× RTX 4090 | 48 ГБ | $0.28–0.84/ч                                | \~380 ток/с (tensor parallel)     | \~60 ток/с         |

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

Для моделей 70B: A100 40 ГБ ([голое железо](https://clore.ai/bare-metal)) с квантизацией 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.