Inference

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

Коротко

Коротко. Inference — это работа модели на новых данных после обучения. Запрос проходит через слои сети, веса умножаются на входы, активации перетекают вперёд — и через миллисекунды или секунды появляется ответ. Параметры остаются прежними; инференс ничему не учит модель. Он быстрее обучения в тысячи раз и доступен на любом железе — от смартфона до браузера.

Что это такое

Январь 2023-го. Пользователь открывает chat.openai.com, пишет «расскажи про квантизацию», и через пару секунд получает ответ. Под капотом — миллиарды операций матричного умножения с теми же параметрами GPT, что обучили несколько месяцев назад. Это и есть inference в самом обыденном виде.

Слово простое: «вывод», «получение результата». Технически — однократный прогон входных данных через готовую сеть с фиксированными весами. На вход — текст, картинка, звук. На выход — текст, картинка, классификация, маска, эмбеддинг.

Главное отличие inference от training — отсутствие обновления весов. Сеть не учится, не запоминает, не меняется. Каждый запрос обрабатывается независимо. Если задать тот же вопрос дважды (с тем же seed, температурой 0, идентичным контекстом), модель ответит ровно одинаково.

Эта разница — водораздел всей экономики AI. Обучение крупной модели стоит миллионы долларов и занимает месяцы. Inference того же запроса — копейки и секунды. Поэтому компания обучает модель один раз и сдаёт её через API: вы платите за каждый запрос (token in / token out), а одна и та же модель обслуживает миллионы пользователей одновременно.

Как это работает

Цикл одного запроса в LLM выглядит так:

1. Tokenization. Текст промпта режется на токены. «Расскажи про квантизацию» → ~5 токенов.
2. Embedding lookup. Каждый токен заменяется на свой вектор-эмбеддинг из таблицы (часть весов модели).
3. Forward pass через слои трансформера. Внутри каждого блока — attention, MLP, layer-norm. Для GPT-3 это 96 блоков, каждый с миллиардами операций.
4. Output projection. Финальные активации проецируются на словарь модели (50–100 тысяч токенов).
5. Softmax + sampling. Получается распределение вероятностей следующего токена. По seed и параметрам (temperature, top-p, top-k) выбирается один токен.
6. Декодинг. Выбранный токен добавляется в ответ, и цикл повторяется — модель снова делает forward pass, но уже с расширенным контекстом. И так пока не сгенерируется EOS-токен или не упрётся в лимит ответа.

Это называется autoregressive inference. Каждый токен — отдельный forward pass. Поэтому LLM «печатает» ответ постепенно: одно слово может занимать 20–50 мс на GPU. Для генерации абзаца в 100 токенов требуется 2–5 секунд.

Для диффузионных моделей inference устроен иначе:

1. Начальный шум. Тензор случайных чисел, заданный seed.
2. N шагов денойзинга. Сэмплер постепенно убирает шум; на каждом шаге модель предсказывает, что добавить, что убрать.
3. VAE-декодер. Latent-представление превращается в изображение в пиксельном пространстве.

Для SDXL это 20–50 шагов, по 100–300 мс на каждый. Полная картинка — 2–10 секунд.

Что НЕ происходит во время inference:

• Веса не пересчитываются.
• Градиент не считается (без requires_grad=True PyTorch экономит память в 3 раза).
• Сеть не «помнит» прошлые запросы. Контекст хранится только в текущем запросе через context window.

Пример на практике

Видеомонтажёр запускает локальный ассистент для кодирования промптов к Flux. Стек: Llama 3.1 8B Instruct в Q4_K_M квантизации.

Конфигурация на RTX 4060 16 GB:

• Модель: 4.6 ГБ в VRAM.
• KV-кэш на контекст 8K: ~4 ГБ.
• Активации и оверхед: ~1 ГБ.
• Итого: ~10 ГБ VRAM из 16.

Запрос: «Сделай детальный промпт для Flux: cinematic portrait, golden hour».

Что происходит на inference:

1. Текст промпта токенизируется → 12 токенов.
2. Forward pass через 32 слоя трансформера. На RTX 4060 это занимает ~150 мс.
3. Первый ответ-токен начинает печататься через 200 мс (TTFT — Time To First Token).
4. Дальше токены идут поток: ~25 токенов в секунду (TPOT — Time Per Output Token).
5. Полный ответ в 200 токенов — около 8 секунд.

В ComfyUI это всё собирается визуально: нода LLM Chat принимает промпт, нода Sampler запускает Flux с готовым ответом LLM. Один workflow — две модели на инференсе подряд.

Та же модель в облаке (Together AI, Groq) с оптимизированным inference-сервером:

• TTFT: 50–80 мс.
• TPOT: 200–400 токенов в секунду (на специальных LPU-чипах Groq).
• Стоимость: ~$0.20 за миллион входных токенов, ~$0.20 за миллион выходных.

Разница в скорости — за счёт батчинга (модель обрабатывает десятки запросов параллельно) и специализированного железа.

С чем часто путают

• Inference и Training — это два режима жизни модели. Training строит, inference использует. Между ними сохранение весов в файл. Один раз обучили — потом тысячи раз запускаем.
• Inference и forward pass — почти синонимы, но forward pass — один проход через сеть, а inference — это полная процедура запроса (плюс токенизация, постобработка, sampling). Один запрос LLM = много forward pass'ов.
• Inference и API-запрос — API-запрос это пользовательский интерфейс к удалённому inference-серверу. Сам inference происходит на стороне сервера. Локальный inference (через ComfyUI, Ollama, llama.cpp) не делает API-запросов — модель крутится на вашем железе.
• Inference и предсказание (prediction) — синонимы в большинстве контекстов. «Prediction» чаще применяется к ML-моделям классификации, «inference» — к нейросетям в целом и LLM в частности.

Частые ошибки и заблуждения

• «Если запрос медленный — модель плохая». Часто проблема не в модели, а в инфраструктуре: батч-сайз, KV-кэш, hardware, сетевой задержке. GPT-4o через Groq отвечает быстрее, чем Llama 7B на ноутбуке.
• Inference на CPU всегда медленный. Не всегда. Маленькие модели (BERT-base, MobileNet) на CPU крутятся за миллисекунды. Большие LLM на CPU действительно медленны (1–5 токенов в секунду), но не всегда нужна максимальная скорость.
• Inference точно повторяемый. Только если seed зафиксирован, температура 0, идентичный контекст, та же версия модели и железа. Float-арифметика на разных GPU может давать чуть разные результаты — это не баг, а особенность параллельных вычислений.
• Можно ускорить inference, докинув RAM. Нет. RAM влияет только на то, влезает ли модель. Скорость определяется compute (FLOPS) GPU и пропускной способностью памяти. Часто узкое место — memory bandwidth, а не вычисления.
• Один inference-запрос = одно использование модели. В LLM один запрос = десятки или сотни forward pass'ов (по одному на каждый сгенерированный токен). В диффузии — 20–50 проходов. Поэтому стоимость зависит от длины ответа.

Связанные термины

• Training — обратная стадия: обучение модели на данных.
• Forward pass — один прогон входа через сеть; элемент inference.
• Token — единица текста; в LLM каждый токен — отдельный шаг inference.
• Context Window — сколько токенов модель может удерживать в одном запросе.
• KV-кэш — оптимизация: сохранённые ключи и значения от прошлых токенов.
• Quantization — сжатие весов ради быстрого inference на слабом железе.
• Batch inference — обработка нескольких запросов параллельно, экономит compute.
• TTFT / TPOT — стандартные метрики скорости inference.

Частые вопросы

Какое железо нужно для inference LLM 7B? В Q4-квантизации — любая GPU от RTX 3060 12 GB. В FP16 — от RTX 4090 24 GB. На CPU — работает, но 1–3 токена в секунду. На Apple Silicon (M2/M3 с unified memory) — нативная поддержка через MLX, скорость близка к средней GPU.

Можно ли запускать inference в браузере? Да, через WebGPU и WebAssembly. Библиотеки: transformers.js (HuggingFace), web-llm (MLC). Скорость ниже нативной (10–20 токенов в секунду на Llama 8B Q4), но никакого облака — модель крутится в браузере пользователя.

Что такое batching и почему он ускоряет inference? GPU обрабатывает матрицы. Один запрос — это маленькая матрица. Десять запросов в batch — большая матрица, которая считается почти за то же время. Поэтому облачные API-провайдеры запускают модели в больших batch'ах: тот же compute обслуживает десятки пользователей одновременно. Локальный inference (один пользователь, один запрос) — медленнее на токен, но мгновенный отклик.

Чем отличается streaming inference от обычного? В streaming каждый сгенерированный токен сразу отправляется клиенту. Пользователь видит ответ «по словам». В обычном — модель генерирует весь ответ полностью, потом отправляет. Streaming улучшает UX (видно прогресс), но требует поддержки на клиенте.

Почему модель «забывает» прошлые сообщения? Каждый inference-запрос — независимый. Память между ними — только context window: вся история диалога подаётся в новый запрос как часть промпта. Если она длиннее контекстного окна, старые сообщения отбрасываются. «Память» через ChatGPT, Claude — это надстройка: специальный сервис, который сохраняет факты и подсовывает их в каждый новый запрос.

Главное

Inference — это рабочая часть жизни модели: обучили один раз, используем тысячи. Скорость зависит от размера модели, длины ответа, железа и инфраструктуры; стоимость — от того, кто платит за GPU. Это та часть AI, к которой имеет дело пользователь: каждый запрос в ChatGPT, каждая генерация в Stable Diffusion, каждое распознавание лица — отдельный inference-запрос. Понимая, что происходит внутри одного запроса, проще выбирать модели, оптимизировать промпты и планировать локальные пайплайны.