Инференс LLM: почему локальные модели тормозят и при чём тут память

На моей домашней машине жил стенд с локальными моделями: llama.cpp, модели в формате GGUF и большие планы на приватный ИИ без интернета и подписок. В сентябре я снёс этот зоопарк и перенёс всё в облако. Причина простая: работы стало больше, а имеющаяся мощность на моём железе не позволяла работать продуктивно.

Разобраться, почему так вышло, оказалось интереснее самой затеи. Ответ прячется в инференсе (от английского inference, «вывод»): так называется этап, на котором обученная модель вычисляет ответы на запросы. Понять его механику достаточно, чтобы отвечать себе на практические вопросы: почему одна модель отвечает мгновенно, другая думает минутами, и почему счета за токены отличаются в тысячи раз. В будущем я планирую вернуться к локальным LLM, как только обзаведусь нужным стендом.

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

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

Направление вычислений. Обучение гоняет данные туда-обратно: прямой проход, подсчёт ошибки, обратное распространение (backpropagation), правка весов. Инференс движется только в одну сторону, от входа к выходу (forward pass). Исправлять на ходу нечего, веса уже настроены.

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

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

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

Языковые модели не видят слова целиком. Вход режется на токены (за счёт токенизатора), куски слов длиной в несколько символов, каждый превращается в вектор, и дальше поток идёт через слои трансформера, где механизм внимания оценивает связи между фрагментами.

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

Так устроены популярные сегодня LLM: почти все они построены на архитектуре трансформер, и пошаговая генерация для них стандарт. Но это не единственный способ считать токены: диффузионные языковые модели вроде Mercury от Inception Labs генерируют ответ блоками, параллельно уточняя все позиции сразу, а state space модели вроде Mamba проходят последовательность за линейное время и обходятся без кеша предыдущих токенов. Массовыми такие подходы пока не стали, но направление живое.

Чтобы не пересчитывать всё заново, придумали KV-cache: матрицы ключей и значений для уже обработанных токенов складываются в память, и новые вычисления считаются только для свежего токена. У кеша есть цена: он растёт вместе с длиной диалога и съедает видеопамять. Одна из причин, почему длинный контекст обходится дороже короткого, живёт прямо здесь.

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

Мои сценарии скромнее: агенты, тексты, разбор данных. Но механика у них та же, что и у всего перечисленного.

Мой стенд это Ryzen 9 9950X3D с 64 ГБ памяти DDR5 и видеокарта из народного класса, вроде 5060 Ti с 16 ГБ видеопамяти (обновляю железо потихоньку). Сначала я поставил llama.cpp, скачал модели в GGUF и поднял локальный чат. Сейчас проще пользоваться LM Studio. Модели поменьше отвечали сносно, но на серьёзных размерах начиналось уныние.

Дальше случился эксперимент с кластером: я соединил две машины через llama.cpp RPC, рассчитывая, что вместе они заживут повеселее. Вместимость действительно выросла: запускались модели от 32 миллиардов параметров в квантизациях от Q6 до Q8. А скорость осталась на уровне от 1,5 до 3 токенов в секунду.

Причина выяснилась быстро: узкое место это пропускная способность памяти. Процессорные ядра простаивали в ожидании данных, потому что модели нужно прочитать из памяти все свои веса, а это десятки гигабайт на каждый токен. Память в моём Ryzen отдаёт несколько десятков гигабайт в секунду, вот счётчик и ползёт посимвольно. Вторая машина это не лечит: слои считаются последовательно, и сосед по кластеру большую часть времени ждёт коллегу.

Заглядывал я и в сторону видеокарт для инференса. Там свой барьер: объём памяти. Если модель не влезает в VRAM целиком, часть слоёв уходит на процессор, и скорость проваливается. Домашняя GPU с памятью под сотню гигабайт это отдельный бюджет.

Картину смягчает квантование. Q6 из примера выше не прихоть: без сжатия модель на 32 миллиарда параметров занимала бы под 70 ГБ, и на домашнее железо она не влезла бы целиком, пришлось бы делить её между видеопамятью и оперативной памятью. Квантование снижает разрядность весов с 16 бит до 8 или 4, и модель занимает меньше места.

Прикинуть потребность в видеопамяти можно грубо: число параметров умножается на их размер в байтах. В FP16 это два байта на параметр, в Q8 около байта, в Q6 около 0,8 байта, в Q4 примерно половина. Модель на 8 миллиардов параметров в Q4 займёт около 4 ГБ, на 32 миллиарда около 16 ГБ, что впритык к памяти народных карт, а 70 миллиардов в Q8 потребуют уже 70 ГБ. Плюс запас на контекст и служебные расходы.

По факту вышло так: для экспериментов с моделями поменьше домашний стенд годится, для серьёзных моделей терпения не хватает. Держать обвязку дальше смысла не было: агенты, статьи и разбор данных уехали в облако. Схему подключения через шлюзы и прокси я разбирал в статье «Доступные ИИ-модели в России в 2026».

Метрики скорости инференса постоянно путают. Latency это время инференса от запроса до полного ответа, а TTFT (time to first token) это отдельная метрика: задержка до первого токена. Throughput это суммарная пропускная способность: сколько токенов в секунду перемалывает система на всех пользователей сразу. Интерактивный чат оптимизируют под latency, ночную обработку тысяч документов под throughput.

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

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

Квантование. Снижение разрядности весов до 8 или 4 бит. На домашнем железе это первое, что стоит попробовать, на серверах приём тоже прижился: INT8 и INT4 заметно урезают требования к памяти.

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

Специализированные движки. vLLM с алгоритмом PagedAttention, TensorRT-LLM и их аналоги перекраивают работу с памятью и эффективнее используют железо. Чаще всего они живут на GPU-серверах и обслуживают серверный инференс, хотя при подходящей видеокарте такой движок поднимают и дома. А лёгкий ONNX Runtime встречается даже на локальных и edge-устройствах.

Пакетная обработка. Запросы собирают в пачки (батчи), чтобы железо не простаивало. Непрерывный вариант добавляет задачи в пакет сразу после завершения предыдущих и держит загрузку GPU почти на 100%.

Спекулятивное декодирование. Маленькая модель пишет черновик ответа, большая его проверяет. Там, где совпадения частые, генерация ускоряется в разы.

Прунинг. Удаление малозначимых связей внутри сети. Выигрыш в скорости приходит не всегда: он зависит от структуры разреживания и поддержки со стороны движка и железа.

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

На практике эти варианты комбинируют. Чувствительные данные обрабатывают рядом с источником, тяжёлые вычисления отдают в облако. Получается гибрид, и он потихоньку становится нормой: локальный инференс оправдан на моделях до десятков миллиардов параметров, и то с оговорками. Остаются и практические расходы: электричество и счета за аренду железа растут вместе с нагрузкой.

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

В пользу облака говорит и динамика цен. В разборе интервью главы Yandex Cloud есть цифры: за год цена вывода на том же объёме токенов просела примерно вшестеро. Дешёвый инференс уже меняет экономику агентов.

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

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

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