vLLM Quickstart: Высокопроизводительное обслуживание LLM

vLLM — это высокопроизводительный, энергоэффективный движок для инференса и развертывания больших языковых моделей (LLM), разработанный лабораторией Sky Computing Университета Калифорнии в Беркли.

С революционным алгоритмом PagedAttention vLLM достигает 14-24-кратного увеличения пропускной способности по сравнению с традиционными методами хостинга, что делает его предпочтительным выбором для производственных развертываний LLM.

Что такое vLLM?

vLLM (виртуальная LLM) — это открытая библиотека для быстрого инференса и обслуживания LLM, которая быстро стала промышленным стандартом для производственных развертываний. Выпущенная в 2023 году, она представила PagedAttention — прорывную технику управления памятью, которая значительно улучшает эффективность обслуживания.

Ключевые особенности

Высокая пропускная способность: vLLM обеспечивает 14-24-кратное увеличение пропускной способности по сравнению с HuggingFace Transformers на том же оборудовании. Это значительное увеличение производительности достигается за счет непрерывного батчинга, оптимизированных CUDA-ядер и алгоритма PagedAttention, который устраняет фрагментацию памяти.

Совместимость с API OpenAI: vLLM включает встроенный сервер API, полностью совместимый с форматом OpenAI. Это позволяет беспрепятственному переходу от OpenAI к саморазвертываемой инфраструктуре без изменения кода приложения. Просто укажите клиенту API на конечную точку vLLM, и он будет работать прозрачно.

Алгоритм PagedAttention: Основное новшество, стоящее за производительностью vLLM, — это PagedAttention, который применяет концепцию виртуального памяти к механизмам внимания. Вместо выделения непрерывных блоков памяти для кешей KV (что приводит к фрагментации), PagedAttention делит память на блоки фиксированного размера, которые можно выделять по требованию. Это уменьшает потерю памяти до 4 раз и позволяет использовать значительно большие размеры батчей.

Непрерывное батчирование: В отличие от статического батчирования, где приходится ждать завершения всех последовательностей, vLLM использует непрерывное (перекатывающееся) батчирование. Как только одна последовательность завершается, новая может быть добавлена в батч. Это максимизирует использование GPU и минимизирует задержки для входящих запросов.

Поддержка нескольких GPU: vLLM поддерживает тензорное и конвейерное параллелизм для распределения больших моделей между несколькими GPU. Он может эффективно обслуживать модели, которые не помещаются в память одного GPU, поддерживая конфигурации от 2 до 8+ GPU.

Широкий выбор моделей: Совместим с популярными архитектурами моделей, включая LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma и многие другие. Поддерживает как инструкционно-настроенные, так и базовые модели из HuggingFace Hub.

Когда использовать vLLM

vLLM преуспевает в определенных сценариях, где его сильные стороны наиболее заметны:

Производственные API-сервисы: Когда необходимо обслуживать LLM для множества одновременных пользователей через API, высокая пропускная способность и эффективное батчирование vLLM делают его лучшим выбором. Компании, работающие с чат-ботами, кодовыми ассистентами или сервисами генерации контента, выигрывают от его способности обрабатывать сотни запросов в секунду.

Высоконагруженные рабочие нагрузки: Если ваше приложение имеет множество одновременных пользователей, отправляющих запросы, непрерывное батчирование и PagedAttention vLLM позволяют обслуживать больше пользователей на том же оборудовании по сравнению с альтернативами.

Оптимизация затрат: Когда стоимость GPU является проблемой, высокая пропускная способность vLLM означает, что вы можете обслуживать тот же трафик с меньшим количеством GPU, что напрямую снижает затраты на инфраструктуру. 4-кратная эффективность памяти от PagedAttention также позволяет использовать более мелкие и дешевые GPU.

Развертывания в Kubernetes: Безсостояние архитектура vLLM и дружелюбная к контейнерам структура делают его идеальным для кластеров Kubernetes. Его стабильная производительность под нагрузкой и простое управление ресурсами хорошо интегрируются с облачной инфраструктурой.

Когда НЕ использовать vLLM: Для локальной разработки, экспериментов или сценариев с одним пользователем инструменты вроде Ollama обеспечивают лучший пользовательский опыт с более простой настройкой. Сложность vLLM оправдана, когда вам нужны его преимущества в производительности для производственных рабочих нагрузок.

Как установить vLLM

Предварительные требования

Перед установкой vLLM убедитесь, что ваша система соответствует следующим требованиям:

• GPU: NVIDIA GPU с вычислительной способностью 7.0+ (V100, T4, A10, A100, H100, серии RTX 20/30/40)
• CUDA: Версия 11.8 или выше
• Python: 3.8 до 3.11
• VRAM: Минимально 16ГБ для моделей 7B, 24ГБ+ для 13B, 40ГБ+ для более крупных моделей
• Драйвер: NVIDIA драйвер 450.80.02 или новее

Установка через pip

Самый простой способ установки — использование pip. Это работает на системах с CUDA 11.8 или новее:

# Создайте виртуальное окружение (рекомендуется)
python3 -m venv vllm-env
source vllm-env/bin/activate

# Установите vLLM
pip install vllm

# Проверьте установку
python -c "import vllm; print(vllm.__version__)"

Для систем с различными версиями CUDA установите соответствующий wheel:

# Для CUDA 12.1
pip install vllm==0.4.2+cu121 -f https://github.com/vllm-project/vllm/releases

# Для CUDA 11.8
pip install vllm==0.4.2+cu118 -f https://github.com/vllm-project/vllm/releases

Установка с Docker

Docker предоставляет наиболее надежный метод развертывания, особенно для производства:

# Загрузите официальный образ vLLM
docker pull vllm/vllm-openai:latest

# Запустите vLLM с поддержкой GPU
docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-7B-Instruct-v0.2

Флаг --ipc=host важен для многопроцессорных настроек, так как он обеспечивает правильное межпроцессное взаимодействие.

Сборка из исходного кода

Для получения последних функций или пользовательских модификаций соберите из исходного кода:

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

Быстрый старт с vLLM

Запуск первой модели

Запустите vLLM с моделью с помощью командной строки:

# Загрузите и обслуживайте Mistral-7B с API, совместимым с OpenAI
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000

vLLM автоматически загрузит модель из HuggingFace Hub (если она не в кэше) и запустит сервер. Вы увидите вывод, указывающий, что сервер готов:

INFO:     Запущен процесс сервера [12345]
INFO:     Ожидание завершения запуска приложения.
INFO:     Завершение запуска приложения.
INFO:     Uvicorn работает на http://0.0.0.0:8000

Отправка API-запросов

Как только сервер запущен, вы можете отправлять запросы с использованием клиента OpenAI Python или curl:

Использование curl:

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.2",
        "prompt": "Объясните, что такое vLLM, одним предложением:",
        "max_tokens": 100,
        "temperature": 0.7
    }'

Использование клиента OpenAI Python:

from openai import OpenAI

# Укажите на ваш сервер vLLM
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM по умолчанию не требует аутентификации
)

response = client.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    prompt="Объясните, что такое vLLM, одним предложением:",
    max_tokens=100,
    temperature=0.7
)

print(response.choices[0].text)

API для чат-завершений:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "system", "content": "Вы — полезный ассистент."},
        {"role": "user", "content": "Что такое PagedAttention?"}
    ],
    max_tokens=200
)

print(response.choices[0].message.content)

Дополнительная настройка

vLLM предлагает множество параметров для оптимизации производительности:

python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000 \
    --gpu-memory-utilization 0.95 \  # Используйте 95% памяти GPU
    --max-model-len 8192 \            # Максимальная длина последовательности
    --tensor-parallel-size 2 \        # Используйте 2 GPU с тензорным параллелизмом
    --dtype float16 \                 # Используйте точность FP16
    --max-num-seqs 256                # Максимальный размер батча

Ключевые параметры, объясненные:

• --gpu-memory-utilization: Сколько памяти GPU использовать (0.90 = 90%). Более высокие значения позволяют использовать большие батчи, но оставляют меньше запаса для пиковых нагрузок.
• --max-model-len: Максимальная длина контекста. Уменьшение этой величины экономит память для больших батчей.
• --tensor-parallel-size: Количество GPU для распределения модели.
• --dtype: Тип данных для весов (float16, bfloat16 или float32). FP16 обычно оптимален.
• --max-num-seqs: Максимальное количество последовательностей для обработки в одном батче.

Сравнение vLLM и Ollama

Оба инструмента, vLLM и Ollama, популярны для локального хостинга LLM, но они ориентированы на разные сценарии использования. Понимание, когда использовать каждый из них, может значительно повлиять на успех вашего проекта.

Производительность и пропускная способность

vLLM разработан для максимальной пропускной способности в сценариях с несколькими пользователями. Его PagedAttention и непрерывное батчирование позволяют эффективно обрабатывать сотни одновременных запросов. Бенчмарки показывают, что vLLM достигает пропускной способности в 14-24 раза выше, чем стандартные реализации, и в 2-4 раза выше, чем у Ollama при высокой конкуренции.

Ollama оптимизирован для интерактивного использования одним пользователем с акцентом на низкую задержку для отдельных запросов. Хотя он не достигает пропускной способности vLLM для нескольких пользователей, он обеспечивает отличную производительность для разработки и личного использования с более быстрыми холодными запусками и меньшим потреблением ресурсов в режиме ожидания.

Простота использования

Ollama однозначно побеждает в простоте. Установка выполняется одной командой (curl | sh), а запуск моделей так же прост, как ollama run llama2. Он включает библиотеку моделей с квантованными версиями, оптимизированными для разных аппаратных профилей. Пользовательский опыт напоминает Docker – pull, run, и go.

vLLM требует большей настройки: управление окружением Python, установка CUDA, понимание параметров обслуживания и ручное указание моделей. Кривая обучения круче, но вы получаете точную настройку производительности. Эта сложность оправдана для производственных развертываний, где необходимо максимально эффективно использовать аппаратное обеспечение.

API и интеграция

vLLM предоставляет совместимые с OpenAI REST API из коробки, что делает его прямой заменой API OpenAI в существующих приложениях. Это критически важно для миграции производственных сервисов от облачных провайдеров на самоуправляемую инфраструктуру без изменений в коде.

Ollama предлагает более простой REST API и специализированную библиотеку Python/JavaScript. Хотя она функциональна, она не совместима с OpenAI, что требует изменений в коде при интеграции с приложениями, ожидающими формат OpenAI. Однако сообщество разработало проекты, такие как адаптеры Ollama-OpenAI, чтобы закрыть этот пробел.

Управление памятью

Алгоритм PagedAttention в vLLM обеспечивает превосходную эффективность использования памяти для одновременных запросов. Он может обслуживать в 2-4 раза больше одновременных пользователей с тем же объемом VRAM по сравнению с наивными реализациями. Это напрямую переводится в экономию затрат в производственных развертываниях.

Ollama использует более простое управление памятью, подходящее для сценариев с одним пользователем. Он автоматически управляет загрузкой/разгрузкой моделей на основе активности, что удобно для разработки, но не оптимально для производственных сценариев с высокой конкуренцией.

Поддержка нескольких GPU

vLLM преуспевает с нативным тензорным и пайплайновым параллелизмом, эффективно распределяя модели на 2-8+ GPU. Это необходимо для обслуживания крупных моделей, таких как LLM с 70 миллиардами параметров, которые не помещаются в один GPU.

Ollama в настоящее время имеет ограниченную поддержку нескольких GPU, работая в основном с одним GPU. Это делает его менее подходящим для очень крупных моделей, требующих распределенного вывода.

Рекомендации по сценариям использования

Выбирайте vLLM, когда:

• Обслуживание производственных API с множеством одновременных пользователей
• Оптимизация затрат на запрос в облачных развертываниях
• Работа в Kubernetes или платформах оркестрации контейнеров
• Необходимость совместимости с API OpenAI для существующих приложений
• Обслуживание крупных моделей, требующих поддержки нескольких GPU
• Производительность и пропускная способность являются критическими требованиями

Выбирайте Ollama, когда:

• Локальная разработка и эксперименты
• Интерактивное использование одним пользователем (персональные помощники, чат-боты)
• Быстрое прототипирование и оценка моделей
• Изучение LLM без сложностей инфраструктуры
• Работа на персональных рабочих станциях или ноутбуках
• Простота и удобство использования являются приоритетами

Многие команды используют оба инструмента: Ollama для разработки и экспериментов, а затем vLLM для производственного развертывания. Это сочетание обеспечивает продуктивность разработчиков при сохранении производственной производительности.

vLLM vs Docker Model Runner

Docker недавно представил Model Runner (ранее GenAI Stack) как официальное решение для локального развертывания моделей ИИ. Как он сравнивается с vLLM?

Философия архитектуры

Docker Model Runner стремится стать “Docker для ИИ” – простым, стандартизированным способом запуска моделей ИИ локально с такой же легкостью, как запуск контейнеров. Он абстрагирует сложность и предоставляет единообразный интерфейс для разных моделей и фреймворков.

vLLM – это специализированный движок инференса, сосредоточенный исключительно на обслуживании LLM с максимальной производительностью. Это инструмент более низкого уровня, который вы контейнеризируете с Docker, а не полная платформа.

Настройка и начало работы

Установка Docker Model Runner проста для пользователей Docker:

docker model pull llama3:8b
docker model run llama3:8b

Это сходство с рабочим процессом образов Docker делает его сразу знакомым разработчикам, уже использующим контейнеры.

vLLM требует большей начальной настройки (Python, CUDA, зависимости) или использования предварительно собранных образов Docker:

docker pull vllm/vllm-openai:latest
docker run --runtime nvidia --gpus all vllm/vllm-openai:latest --model <model-name>

Характеристики производительности

vLLM обеспечивает превосходную пропускную способность для сценариев с несколькими пользователями благодаря PagedAttention и непрерывному батчированию. Для производственных API-сервисов, обрабатывающих сотни запросов в секунду, оптимизации vLLM обеспечивают в 2-5 раз лучшую пропускную способность по сравнению с общими методами обслуживания.

Docker Model Runner делает упор на простоте использования, а не на максимальной производительности. Он подходит для локальной разработки, тестирования и умеренных нагрузок, но не реализует продвинутые оптимизации, которые делают vLLM выдающимся в масштабах.

Поддержка моделей

Docker Model Runner предоставляет отобранную библиотеку моделей с доступом к популярным моделям в один клик. Он поддерживает несколько фреймворков (не только LLM), включая Stable Diffusion, Whisper и другие модели ИИ, что делает его более универсальным для разных рабочих нагрузок ИИ.

vLLM специализируется на инференсе LLM с глубокой поддержкой языковых моделей на основе трансформеров. Он поддерживает любые совместимые с HuggingFace LLM, но не распространяется на другие типы моделей ИИ, такие как генерация изображений или распознавание речи.

Производственное развертывание

vLLM проверен в производстве в компаниях, таких как Anthropic, Replicate и многих других, обслуживающих миллиарды токенов ежедневно. Его характеристики производительности и стабильность при высокой нагрузке делают его де-факто стандартом для производственного обслуживания LLM.

Docker Model Runner новее и позиционирует себя больше для сценариев разработки и локального тестирования. Хотя он мог бы обслуживать производственный трафик, ему не хватает проверенной репутации и оптимизаций производительности, необходимых для производственных развертываний.

Экосистема интеграции

vLLM интегрируется с инструментами производственной инфраструктуры: операторы Kubernetes, метрики Prometheus, Ray для распределенного обслуживания и обширная совместимость с API OpenAI для существующих приложений.

Docker Model Runner естественно интегрируется с экосистемой Docker и Docker Desktop. Для команд, уже стандартизированных на Docker, эта интеграция обеспечивает единый опыт, но с меньшим количеством специализированных функций обслуживания LLM.

Когда использовать каждый

Используйте vLLM для:

• Производственных сервисов LLM API
• Высокопроизводительных, много пользовательских развертываний
• Экономически чувствительных облачных развертываний, требующих максимальной эффективности
• Сред Kubernetes и облачных сред
• Когда вам нужна проверенная масштабируемость и производительность

Используйте Docker Model Runner для:

• Локальной разработки и тестирования
• Запуска различных типов моделей ИИ (не только LLM)
• Команд, сильно инвестировавших в экосистему Docker
• Быстрого экспериментирования без настройки инфраструктуры
• Образовательных и учебных целей

Гибридный подход: Многие команды разрабатывают с Docker Model Runner локально для удобства, а затем развертывают с vLLM в производстве для производительности. Изображения Docker Model Runner также могут использоваться для запуска контейнеров vLLM, сочетая оба подхода.

Лучшие практики развертывания в производственной среде

Развертывание с использованием Docker

Создайте конфигурацию Docker Compose для производственной среды:

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    environment:
      - CUDA_VISIBLE_DEVICES=0,1
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --tensor-parallel-size 2
      --gpu-memory-utilization 0.90
      --max-num-seqs 256
      --max-model-len 8192      
    restart: unless-stopped
    shm_size: '16gb'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

Развертывание в Kubernetes

Разверните vLLM в Kubernetes для масштабирования в производственной среде:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.2
          - --tensor-parallel-size
          - "2"
          - --gpu-memory-utilization
          - "0.90"
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: cache
        hostPath:
          path: /mnt/huggingface-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Мониторинг и наблюдаемость

vLLM предоставляет метрики Prometheus для мониторинга:

import requests

# Получение метрик
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

Ключевые метрики для мониторинга:

• vllm:num_requests_running - Активные запросы
• vllm:gpu_cache_usage_perc - Использование кэша KV
• vllm:time_to_first_token - Метрика задержки
• vllm:time_per_output_token - Скорость генерации

Настройка производительности

Оптимизация использования памяти GPU: Начните с --gpu-memory-utilization 0.90 и настройте в зависимости от наблюдаемого поведения. Более высокие значения позволяют использовать большие пакеты, но рискуют вызвать ошибки нехватки памяти при пиковых нагрузках.

Настройка максимальной длины последовательности: Если ваше применение не требует полной длины контекста, уменьшите --max-model-len. Это освобождает память для больших пакетов. Например, если вам нужен контекст 4K, установите --max-model-len 4096 вместо использования максимальной длины модели (часто 8K-32K).

Выбор подходящей квантования: Для моделей, которые поддерживают это, используйте квантованные версии (8 бит, 4 бита) для уменьшения использования памяти и увеличения пропускной способности:

--quantization awq  # Для квантованных моделей AWQ
--quantization gptq # Для квантованных моделей GPTQ

Включение кэширования префиксов: Для приложений с повторяющимися запросами (например, чат-боты с системными сообщениями), включите кэширование префиксов:

--enable-prefix-caching

Это кэширует значения KV для общих префиксов, уменьшая вычисления для запросов с одинаковыми префиксами запросов.

Устранение распространенных проблем

Ошибки нехватки памяти

Симптомы: Сервер аварийно завершает работу с ошибками CUDA нехватки памяти.

Решения:

• Уменьшите --gpu-memory-utilization до 0.85 или 0.80
• Уменьшите --max-model-len, если это допустимо для вашего применения
• Уменьшите --max-num-seqs для уменьшения размера пакета
• Используйте квантованную версию модели
• Включите тензорное параллелизм для распределения на большее количество GPU

Низкая пропускная способность

Симптомы: Сервер обрабатывает меньше запросов, чем ожидалось.

Решения:

• Увеличьте --max-num-seqs для разрешения больших пакетов
• Увеличьте --gpu-memory-utilization, если есть запас
• Проверьте, не является ли CPU узким местом с помощью htop – рассмотрите возможность использования более быстрых CPU
• Проверьте использование GPU с помощью nvidia-smi – должно быть 95%+
• Включите FP16, если используется FP32: --dtype float16

Медленное время первого токена

Симптомы: Высокая задержка перед началом генерации.

Решения:

• Используйте меньшие модели для приложений, критичных к задержкам
• Включите кэширование префиксов для повторяющихся запросов
• Уменьшите --max-num-seqs для приоритета задержки над пропускной способностью
• Рассмотрите возможность использования спекулятивного декодирования для поддерживаемых моделей
• Оптимизируйте конфигурацию тензорного параллелизма

Ошибки загрузки модели

Симптомы: Сервер не запускается, не может загрузить модель.

Решения:

• Убедитесь, что имя модели точно соответствует формату HuggingFace
• Проверьте сетевое подключение к HuggingFace Hub
• Убедитесь в наличии достаточного места на диске в ~/.cache/huggingface
• Для моделей с ограниченным доступом, установите переменную окружения HF_TOKEN
• Попробуйте вручную скачать с помощью huggingface-cli download <model>

Дополнительные функции

Спекулятивное декодирование

vLLM поддерживает спекулятивное декодирование, где меньшая черновая модель предлагает токены, которые проверяет большая целевая модель. Это может ускорить генерацию в 1.5-2 раза:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-70b-chat-hf \
    --speculative-model meta-llama/Llama-2-7b-chat-hf \
    --num-speculative-tokens 5

Адаптеры LoRA

Обслуживайте несколько адаптеров LoRA поверх базовой модели без загрузки нескольких полных моделей:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-hf \
    --enable-lora \
    --lora-modules sql-lora=./path/to/sql-adapter \
                   code-lora=./path/to/code-adapter

Затем укажите, какой адаптер использовать для каждого запроса:

response = client.completions.create(
    model="sql-lora",  # Использовать адаптер SQL
    prompt="Преобразуйте это в SQL: Покажите всех пользователей, созданных в этом месяце"
)

Многоадаптерное обслуживание LoRA

Многоадаптерное обслуживание vLLM позволяет размещать десятки адаптеров с минимальными затратами памяти. Это идеально для обслуживания вариантов моделей, специфичных для клиентов или задач:

# Запрос с конкретным адаптером LoRA
response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[{"role": "user", "content": "Напишите SQL запрос"}],
    extra_body={"lora_name": "sql-lora"}
)

Кэширование префиксов

Включите автоматическое кэширование префиксов для избежания повторного вычисления кэша KV для повторяющихся префиксов запросов:

--enable-prefix-caching

Это особенно эффективно для:

• Чат-ботов с фиксированными системными подсказками
• Приложений RAG с постоянными шаблонами контекста
• Применений few-shot learning с повторяющимися подсказками

Кэширование префиксов может уменьшить время до первого токена на 50-80% для запросов с одинаковыми префиксами запросов.

Примеры интеграции

Интеграция с LangChain

from langchain.llms import VLLMOpenAI

llm = VLLMOpenAI(
    openai_api_key="EMPTY",
    openai_api_base="http://localhost:8000/v1",
    model_name="mistralai/Mistral-7B-Instruct-v0.2",
    max_tokens=512,
    temperature=0.7,
)

response = llm("Объясните PagedAttention простыми словами")
print(response)

Интеграция с LlamaIndex

from llama_index.llms import VLLMServer

llm = VLLMServer(
    api_url="http://localhost:8000/v1",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    temperature=0.7,
    max_tokens=512
)

response = llm.complete("Что такое vLLM?")
print(response)

Приложение FastAPI

from fastapi import FastAPI
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

@app.post("/generate")
async def generate(prompt: str):
    response = await client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.2",
        prompt=prompt,
        max_tokens=200
    )
    return {"result": response.choices[0].text}

Бенчмарки производительности

Реальные данные о производительности помогают проиллюстрировать преимущества vLLM:

Сравнение пропускной способности (Mistral-7B на GPU A100):

• vLLM: ~3,500 токенов/секунда с 64 одновременными пользователями
• HuggingFace Transformers: ~250 токенов/секунда при такой же одновременности
• Ollama: ~1,200 токенов/секунда при такой же одновременности
• Результат: vLLM обеспечивает 14-кратное улучшение по сравнению с базовыми реализациями

Эффективность использования памяти (LLaMA-2-13B):

• Стандартная реализация: 24ГБ VRAM, 32 одновременные последовательности
• vLLM с PagedAttention: 24ГБ VRAM, 128 одновременные последовательности
• Результат: в 4 раза больше одновременных запросов при том же использовании памяти

Задержка под нагрузкой (Mixtral-8x7B на 2xA100):

• vLLM: P50 задержка 180мс, P99 задержка 420мс при 100 req/s
• Стандартное обслуживание: P50 задержка 650мс, P99 задержка 3,200мс при 100 req/s
• Результат: vLLM поддерживает стабильную задержку при высокой нагрузке

Эти бенчмарки демонстрируют, почему vLLM стал де-факто стандартом для производственного обслуживания LLM, где важна производительность.

Анализ затрат

Понимание последствий выбора vLLM для затрат:

Сценарий: Обслуживание 1M запросов/день

Стандартное обслуживание:

• Требуется: 8x GPU A100 (80ГБ)
• Стоимость AWS: ~$32/час × 24 × 30 = $23,040/месяц
• Стоимость за 1M токенов: ~$0.75

С vLLM:

• Требуется: 2x GPU A100 (80ГБ)
• Стоимость AWS: ~$8/час × 24 × 30 = $5,760/месяц
• Стоимость за 1M токенов: ~$0.19
• Экономия: $17,280/месяц (75% сокращение)

Это преимущество в затратах растет с масштабом. Организации, обслуживающие миллиарды токенов ежемесячно, экономят сотни тысяч долларов, используя оптимизированное обслуживание vLLM вместо наивных реализаций.

Рассмотрение вопросов безопасности

Аутентификация

vLLM по умолчанию не включает аутентификацию. Для продакшена реализуйте аутентификацию на уровне обратного прокси:

# Конфигурация Nginx
location /v1/ {
    auth_request /auth;
    proxy_pass http://vllm-backend:8000;
}

location /auth {
    proxy_pass http://auth-service:8080/verify;
    proxy_pass_request_body off;
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

Или используйте API-шлюзы вроде Kong, Traefik или AWS API Gateway для корпоративного уровня аутентификации и ограничения скорости.

Сетевая изоляция

Запускайте vLLM в приватных сетях, а не напрямую в интернете:

# Пример NetworkPolicy для Kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: vllm-access
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: api-gateway
    ports:
    - protocol: TCP
      port: 8000

Ограничение скорости

Реализуйте ограничение скорости для предотвращения злоупотреблений:

# Пример с использованием Redis для ограничения скорости
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import redis
from datetime import datetime, timedelta

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.middleware("http")
async def rate_limit_middleware(request, call_next):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"

    requests = redis_client.incr(key)
    if requests == 1:
        redis_client.expire(key, 60)  # Окно в 60 секунд

    if requests > 60:  # 60 запросов в минуту
        raise HTTPException(status_code=429, detail="Превышен лимит запросов")

    return await call_next(request)

Контроль доступа к моделям

Для многопользовательских развертываний контролируйте, какие пользователи могут получать доступ к каким моделям:

ALLOWED_MODELS = {
    "user_tier_1": ["mistralai/Mistral-7B-Instruct-v0.2"],
    "user_tier_2": ["mistralai/Mistral-7B-Instruct-v0.2", "meta-llama/Llama-2-13b-chat-hf"],
    "admin": ["*"]  # Все модели
}

def verify_model_access(user_tier: str, model: str) -> bool:
    allowed = ALLOWED_MODELS.get(user_tier, [])
    return "*" in allowed or model in allowed

Руководство по миграции

От OpenAI к vLLM

Миграция с OpenAI на самоподдерживаемый vLLM проста благодаря совместимости API:

До (OpenAI):

from openai import OpenAI

client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello"}]
)

После (vLLM):

from openai import OpenAI

client = OpenAI(
    base_url="https://your-vllm-server.com/v1",
    api_key="your-internal-key"  # Если вы добавили аутентификацию
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Hello"}]
)

Только два изменения нужны: обновите base_url и имя модели. Все остальное остается идентичным.

От Ollama к vLLM

Ollama использует другой формат API. Вот преобразование:

API Ollama:

import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'llama2',
        'prompt': 'Why is the sky blue?'
    })

Эквивалент vLLM:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.completions.create(
    model="meta-llama/Llama-2-7b-chat-hf",
    prompt="Why is the sky blue?"
)

Вам нужно будет обновить вызовы API по всему коду, но клиентские библиотеки OpenAI предоставляют лучшее управление ошибками и функции.

От HuggingFace Transformers к vLLM

Прямая миграция использования Python:

HuggingFace:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

inputs = tokenizer("Hello", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])

vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.2")
sampling_params = SamplingParams(max_tokens=100)

outputs = llm.generate("Hello", sampling_params)
result = outputs[0].outputs[0].text

API Python vLLM проще и значительно быстрее для пакетной инференции.

Будущее vLLM

vLLM продолжает быстрое развитие с захватывающими функциями в дорожной карте:

Разделенное обслуживание: Разделение префикса (обработка запроса) и декодирования (генерация токенов) на разные GPU для оптимизации использования ресурсов. Префикс ограничен вычислительными мощностями, а декодирование - памятью, поэтому их выполнение на специализированном оборудовании повышает эффективность.

Многоузловая инференция: Распределение очень больших моделей (100B+ параметров) между несколькими машинами, что позволяет обслуживать модели, слишком большие для однозначных настроек.

Улучшенная квантование: Поддержка новых форматов квантования вроде GGUF (используется в llama.cpp) и улучшенная интеграция AWQ/GPTQ для лучшей производительности с квантованными моделями.

Улучшения специфического декодирования: Более эффективные модели черновиков и адаптивные стратегии спекуляции для достижения более высоких ускорений без потери точности.

Оптимизации внимания: FlashAttention 3, кольцевое внимание для очень длинных контекстов (100K+ токенов) и другие передовые механизмы внимания.

Лучшее покрытие моделей: Расширение поддержки мультимодальных моделей (визуально-языковые модели), аудиомоделей и специализированных архитектур по мере их появления.

Проект vLLM поддерживает активное развитие с вкладами от UC Berkeley, Anyscale и более широкого сообщества с открытым исходным кодом. По мере того как развертывание LLM становится все более критичным для производственных систем, роль vLLM как стандарта производительности продолжает расти.

Полезные ссылки

Статьи на этом сайте

• Хостинг локальных LLM: Полное руководство 2025 - Ollama, vLLM, LocalAI, Jan, LM Studio & другие - Всестороннее сравнение 12+ инструментов для локального хостинга LLM, включая детальный анализ vLLM наряду с Ollama, LocalAI, Jan, LM Studio и другими. Охватывает зрелость API, поддержку вызовов инструментов, совместимость с GGUF и бенчмарки производительности для выбора правильного решения.

• Шпаргалка по Ollama - Полное руководство по командам Ollama, охватывающее установку, управление моделями, использование API и лучшие практики для локального развертывания LLM. Необходимо разработчикам, использующим Ollama наряду с или вместо vLLM.

• Docker Model Runner vs Ollama: Что выбрать? - Глубокое сравнение Docker Model Runner и Ollama для локального развертывания LLM, анализирующее производительность, поддержку GPU, совместимость API и сценарии использования. Помогает понять конкурентную среду, в которой работает vLLM.

• Шпаргалка по Docker Model Runner: Команды и примеры - Практическая шпаргалка по Docker Model Runner с командами и примерами для развертывания моделей ИИ. Полезно для команд, сравнивающих подход Docker с специализированными возможностями обслуживания LLM vLLM.

Внешние ресурсы и документация

• Репозиторий vLLM на GitHub - Официальный репозиторий vLLM с исходным кодом, всесторонней документацией, руководствами по установке и активными обсуждениями сообщества. Основной ресурс для слежения за последними функциями и устранения проблем.

• Документация vLLM - Официальная документация, охватывающая все аспекты vLLM от базовой настройки до продвинутой конфигурации. Включает ссылки на API, руководства по настройке производительности и лучшие практики развертывания.

• Статья PagedAttention - Академическая статья, представляющая алгоритм PagedAttention, который обеспечивает эффективность vLLM. Основное чтение для понимания технических инноваций, лежащих в основе преимуществ производительности vLLM.

• Блог vLLM - Официальный блог vLLM с объявлениями о выпуске, бенчмарками производительности, техническими глубокими анализами и кейсами сообщества из производственных развертываний.

• HuggingFace Model Hub - Всесторонний репозиторий открытых моделей LLM, работающих с vLLM. Поиск моделей по размеру, задаче, лицензии и характеристикам производительности для выбора правильной модели для вашего случая использования.

• Документация Ray Serve - Документация фреймворка Ray Serve для создания масштабируемых, распределенных развертываний vLLM. Ray предоставляет продвинутые функции, такие как автоскейлинг, обслуживание нескольких моделей и управление ресурсами для производственных систем.

• NVIDIA TensorRT-LLM - TensorRT-LLM от NVIDIA для высокооптимизированной инференции на GPU NVIDIA. Альтернатива vLLM с разными стратегиями оптимизации, полезная для сравнения и понимания ландшафта оптимизации инференции.

• Справочник API OpenAI - Официальная документация API OpenAI, с которой совместим API vLLM. Обращайтесь к ней при создании приложений, которые должны работать с обоими API OpenAI и самоподдерживаемыми конечными точками vLLM взаимозаменяемо.