Запуск больших языковых моделей на своём железе

В прошлом году я потратил 4 200 долларов на сборку локальной системы для инференса, которая тянула модель на 70B параметров с приемлемой скоростью. Коллега посмотрел на мою конфигурацию и задал очевидный вопрос: «Зачем вообще, если можно просто использовать API? Это же примерно восемь лет кредитов API». По математике он был прав. Но вот с расчётом выгоды — нет.

Раньше запускать большие языковые модели локально было уделом исследовательских лабораторий с серверными стойками из GPU. Всё изменилось очень быстро. Потребительское железо, методы квантизации и оптимизированные движки инференса сделали модели на 70B+ доступными энтузиастам и небольшим командам. Устройства вроде Tinybox идут ещё дальше — это специализированное железо, созданное для работы моделей на 120B параметров офлайн, без облака.

Но «возможно» и «практично» — разные вещи. Давайте разберём, что реально нужно для локального запуска больших моделей, когда это имеет смысл и когда выгоднее заплатить за API.

Зачем вообще запускать модели локально?

Модель с API — отправляете данные облачному провайдеру и получаете результат — подходит для большинства сценариев. Это проще, дешевле за запрос при небольших объёмах и всегда даёт доступ к последним моделям. Так зачем кому-то возиться с локальным инференсом?

• Приватность и соответствие требованиям. Некоторые данные не могут покидать вашу сеть. Медицинские карты, юридические документы, проприетарный код, финансовые данные — в регулируемых отраслях часто жёсткие требования к местонахождению данных. Отправка медицинских записей на API, даже зашифрованный, может нарушать HIPAA. Локальный инференс оставляет всё внутри периметра.
• Задержка. Вызовы API включают сетевые задержки, возможное ожидание в очереди и rate limits. У локального инференса нет сетевой задержки, и в очереди вы никогда не стоите. Для интерактивных приложений — ассистентов для кода в реальном времени, перевода на устройстве, голосовых интерфейсов — разница между 50 мс и 500 мс это разница между «отзывчиво» и «вяло».
• Стоимость при масштабе. Цены API считаются за токен. При малых объёмах это ничтожно. При больших — расходы растут жестоко. Команда, которая активно занимается ревью кода, анализом документов или пакетной обработкой, может тратить тысячи долларов в месяц на API. Железо — фиксированная стоимость: раз заплатив, инференс фактически бесплатен.
• Доступность. Облачные API падают. Вводятся лимиты. Цены меняются без предупреждения. Модели выводятся из эксплуатации. Если ваш продукт зависит от стороннего API, вы во власти их бизнес-решений. Локальный инференс означает, что ваши возможности не исчезнут, потому что у чужого сервера выдался плохой день.
• Свобода экспериментов. У API-провайдеров есть правила использования. Они решают, что вы можете и чего не можете делать с моделью. На локальные модели таких ограничений нет: их можно дообучать, модифицировать, использовать в любых целях и запускать сколько угодно раз.

Суровая реальность железа

Главное ограничение для инференса LLM — память, а не вычисления. Параметры модели должны поместиться в памяти (VRAM GPU или оперативная память системы), прежде чем с ними можно что-то делать. Модель на 70B параметров в 16-битной плавающей точке требует около 140 ГБ памяти. Это больше, чем есть у любой потребительской видеокарты.

Здесь на сцену выходит квантизация. Снижая точность весов модели с 16 бит до 8, 4 или даже 2 бит, можно существенно уменьшить требования к памяти:

Memory requirements for a 70B parameter model:
FP16 (full precision):  ~140 GB  → requires multiple A100s
INT8 (8-bit quant):     ~70 GB   → requires 2x RTX 4090 (48GB total)
Q4_K_M (4-bit quant):   ~40 GB   → fits on 2x RTX 3090 or 1x A6000
Q2_K (2-bit quant):     ~25 GB   → fits on 1x RTX 4090 (24GB)
For a 120B parameter model:
FP16:                   ~240 GB  → enterprise GPU territory
INT8:                   ~120 GB  → 5x RTX 4090 or purpose-built device
Q4_K_M:                 ~70 GB   → 3x RTX 4090
Q2_K:                   ~40 GB   → 2x RTX 4090

4-битная квантизация (Q4_K_M в экосистеме llama.cpp) сейчас — золотая середина. Деградация качества измерима, но для практических задач зачастую приемлема: большинство людей в слепых тестах не отличат вывод Q4 от полной точности. 2-битная квантизация заметно бьёт по качеству, особенно в задачах, требующих рассуждений, но для простых сценариев вроде классификации текста или суммаризации всё ещё работает.

Сборки на потребительском железе

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

Путь с одним GPU

Одна RTX 4090 (24 ГБ VRAM, около 1 600 долларов) комфортно тянет модели с 4-битной квантизацией до примерно 30B параметров или 70B при агрессивной 2-битной квантизации. Для большинства моделей 7B–13B это избыточно: выдача будет 40+ токенов в секунду, что быстрее, чем большинство людей читают. Это самый простой путь: купить видеокарту, установить llama.cpp или Ollama и поехали.

Путь с несколькими GPU

Два и более GPU позволяют распределить модель между устройствами (тензорный параллелизм). Две RTX 3090 (48 ГБ VRAM суммарно, около 2 200 долларов с рук) спокойно тянут 4-битные модели на 70B. Подвох: нужна материнская плата с достаточным количеством линий PCIe и физическое место для нескольких полноразмерных видеокарт. Охлаждение становится реальной проблемой — две карты по 350 Вт в одном корпусе выделяют серьёзное тепло.

Путь с унифицированной памятью

Mac на Apple Silicon с большой унифицированной памятью — неожиданно жизнеспособный вариант. M2 Ultra с 192 ГБ унифицированной памяти может целиком разместить модель на 70B в полной точности. Скорость инференса ниже, чем у выделенных GPU — примерно 10–15 токенов в секунду для модели на 70B, — но простота трудно перебиваема. Никаких проблем с драйверами, никакой настройки нескольких GPU, никакого управления теплом. Просто Mac Studio на столе, который крутит модель на 70B.

Чипы серии M добиваются этого благодаря архитектуре унифицированной памяти: CPU и GPU используют один пул памяти, поэтому нет узкого места из-за копирования данных между оперативной памятью CPU и VRAM GPU. Пропускная способность памяти ниже, чем у выделенной GPU-конфигурации, поэтому инференс медленнее, но 192 ГБ адресуемой памяти в устройстве, которое потребляет 60 Вт, — это по-настоящему впечатляет.

Специализированные устройства для инференса

Самая новая категория — специализированное железо для локального инференса: выделенные устройства, созданные именно для эффективного запуска больших моделей. Их цель — избавить от мороки с несколькими GPU: вместо сборки потребительских видеокарт с кошмаром из проводов вы получаете готовую appliance, спроектированную с нуля под инференс.

Привлекательность очевидна. Вы подключаете устройство, направляете на него своё приложение, и оно запускает вашу модель. Никаких конфликтов драйверов, никакого управления версиями CUDA, никакого троттлинга из-за того, что кто-то поставил три GPU слишком близко друг к другу. Цена вопроса — стоимость: специализированные устройства обычно дороже за FLOP, чем эквивалентные потребительские GPU. Вы платите за интеграцию, надёжность и за то, что не нужно разбираться с распределением линий PCIe.

Для небольших компаний, которым нужен локальный инференс, но нет штатных инженеров по железу, такие устройства имеют смысл. Для энтузиастов, которым нравится что-то собирать, самодельные системы с несколькими GPU по-прежнему дешевле и гибче.

Программный стек

Железо — только половина истории. Стек программного обеспечения для инференса развивается стремительно, и правильный выбор софта может удвоить пропускную способность на том же железе.

• llama.cpp — швейцарский армейский нож локального инференса. Написан на C/C++, работает на всём — от Raspberry Pi до серверов с несколькими GPU. Поддерживает десятки архитектур моделей и форматов квантизации. Не всегда самый быстрый, но самый переносимый и активно поддерживаемый.
• vLLM — оптимизирован под пропускную способность на GPU NVIDIA. Использует PagedAttention для эффективного управления памятью GPU, что заметно улучшает батчевый инференс. Если вы обслуживаете нескольких пользователей с одной машины, vLLM обычно лучший выбор.
• Ollama — подход «Docker для LLM». Оборачивает llama.cpp в удобный интерфейс с реестром моделей. Выполните ollama run llama3:70b, и он скачает модель, настроит квантизацию и начнёт обслуживание запросов. Отлично для старта, но настраивается хуже, чем чистый llama.cpp.
• MLX — фреймворк машинного обучения от Apple, оптимизированный под Apple Silicon. Если вы на Mac с чипом серии M, MLX обычно даёт лучшую производительность, чем llama.cpp, за счёт более эффективного использования унифицированной памяти.

# Getting started with Ollama (the easiest path)
# Install: https://ollama.ai
# Run a 7B model (downloads automatically, ~4GB)
$ ollama run mistral
# Run a 70B model (needs ~40GB RAM/VRAM)
$ ollama run llama3:70b-instruct-q4_K_M
# Serve as an API endpoint (OpenAI-compatible)
$ ollama serve
$ curl http://localhost:11434/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "mistral",
"messages": [{"role": "user", "content": "Explain TCP handshakes"}]
}'

Честное сравнение стоимости

Давайте посчитаем то, что действительно важно. Допустим, вы запускаете модель на 70B и обрабатываете около миллиона токенов в день (это примерно анализ 50–100 документов или несколько сотен чат-диалогов).

Cloud API (approximate pricing for 70B-class model):
Input:  $0.50 per million tokens
Output: $1.50 per million tokens
Daily cost: ~$2.00
Monthly cost: ~$60
Yearly cost: ~$720
Local inference (2x RTX 4090 build):
Hardware: $4,200 (one-time)
Electricity: ~$30/month (assuming 700W, 8h/day, $0.15/kWh)
Break-even: ~5.5 years
Local inference (Mac Studio M2 Ultra 192GB):
Hardware: $5,800 (one-time)
Electricity: ~$3/month (60W)
Break-even: ~8 years

При миллионе токенов в день облачный API дешевле на протяжении многих лет. Но расчёт резко меняется, если объём растёт. При 10 миллионах токенов в день API обойдётся в 7 200 долларов в год, а локальное железо окупится примерно за 7 месяцев. При 50 миллионах токенов в день локальный инференс окупается за недели.

Сравнение стоимости также не учитывает нефинансовые факторы: приватность, задержку, доступность и свободу экспериментов. Если любой из них — требование, а не приятный бонус, финансовый расчёт отходит на второй план.

Что теряется при квантизации

Квантизация — то, что делает локальный инференс больших моделей возможным, но она не бесплатна. Снижение точности означает потерю части информации, и деградация неравномерна для разных задач.

По моим тестам, модели с 4-битной квантизацией работают почти так же, как в полной точности, в задачах: генерация текста, суммаризация, простые вопросы и ответы, перевод и генерация кода для типовых шаблонов. Деградация заметна в: многошаговых рассуждениях, математических вычислениях, задачах, требующих точного воспроизведения данных обучения, и тонком следовании инструкциям.

Практический вывод: если вы используете локальную модель для автодополнения кода, суммаризации документов или диалогового ИИ, 4-битная квантизация вполне подходит. Если же вы применяете её для сложных аналитических рассуждений или в задачах, где важны тонкие различия в точности, стоит тщательно тестировать и, возможно, использовать более высокую точность ценой большего объёма памяти или модели меньшего размера.

Как принять решение

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

Используйте облачные API, когда: вам нужно абсолютно лучшее качество модели, объём низкий или средний, у вас нет экспертизы в железе, вам часто нужно менять модели или задержка не критична (несколько сотен миллисекунд — приемлемо).

Запускайте локально, когда: ваши данные не могут покидать сеть, вам нужна стабильная задержка меньше 100 мс, объём токенов достаточно велик, чтобы оправдать затраты на железо, вы хотите свободно экспериментировать без оплаты за каждый запрос или вам нужна доступность инференса, не зависящая от аптайма сторонних сервисов.

Ландшафт меняется быстро. Модели становятся меньше и эффективнее. Методы квантизации улучшаются. Железо дешевеет. Порог объёма, при котором локальный инференс имеет финансовый смысл, снижается каждый год. Если сегодня это не имеет смысла для вас, через восемнадцать месяцев может начать иметь — и тем временем софтовый стек станет только проще в использовании.