Локальный инференс LLM: от понятий до тюнинга на своём ПК
Эта книга — самостоятельный курс о том, как большая языковая модель (LLM) работает на обычном компьютере: что происходит внутри, почему генерация упирается в память, как квантование и MoE позволяют запустить 30–70-миллиардную модель на потребительской видеокарте и как всё это измерить, чтобы не обмануть себя.
Она не привязана к конкретному проекту, фреймворку или модели. Примеры — учебные: «карта на 16 ГБ», «модель на 35 млрд параметров», «Mac с объединённой памятью». Числа в расчётах взяты типичные и явно помечены как пример, если это не свойство стандарта или документации.
Для кого
- Вы умеете запускать
llama-serverили Ollama, но хотите понимать, что означают флаги и почему скорость именно такая. - Вы читаете карточки моделей и бенчмарки, но не понимаете, какие цифры относятся к вам.
- Вы хотите сами подобрать квант, контекст и конфигурацию под своё железо, а не повторять чужие команды.
Предполагается базовое знакомство с Python и матричным умножением. Всё остальное объясняется по ходу.
Как читать
Книга устроена как последовательность: первые восемь глав дают модель мышления, без которой тюнинг превращается в перебор флагов; главы 9–11 — про ускорение и управление генерацией; главы 12–13 — про измерения и выбор модели; 14 — коротко про речь и OCR; 15 — куда двигаться дальше.
Карта книги
Стрелка A → B означает, что глава B опирается на главу A: перед главой полезно прочитать те, из которых в неё входят стрелки.
flowchart LR
C1["1. Токены<br/>и трансформер"] --> C2["2. Prefill и decode,<br/>roofline"]
C2 --> C3["3. Иерархия памяти"]
C2 --> C4["4. Квантование"]
C1 --> C6["6. KV-кэш<br/>и контекст"]
C2 --> C6
C3 --> C5["5. MoE и выгрузка"]
C4 --> C5
C6 --> C7["7. Кэш промпта"]
C6 --> C8["8. Батчинг и слоты"]
C5 --> C8
C2 --> C9["9. Спекулятивное<br/>декодирование"]
C5 --> C9
C1 --> C10["10. Сэмплинг<br/>и рассуждения"]
C10 --> C11["11. Tool calling"]
C7 --> C11
C3 --> C12["12. Методика<br/>бенчмарка"]
C4 --> C12
C6 --> C12
C12 --> C13["13. Выбор модели"]
C5 --> C13
C3 --> C14["14. Речь и OCR"]
C13 --> C15["15. Куда расти"]
C11 --> C15
C14 --> C15
Три маршрута
| Маршрут | Главы | Кому |
|---|---|---|
| Быстро | 1, 2, 4, 6, 12 | Понять, почему медленно, и начать мерить. Хватит выходных. |
| Практик | 1–6, 8, 12, 13, затем 7, 9, 11 по задаче | Подобрать модель, квант и флаги под своё железо; агентам — обязательно 7 и 11. |
| Подробно | все по порядку + источники | Разобраться в устройстве и литературе. |
Если торопитесь, в каждой главе можно прочитать только блок «За 30 секунд» и «Ключевые идеи» — получится конспект всей книги на 15 минут.
Что есть в каждой главе
- За 30 секунд — 3–4 главные мысли в самом начале;
- Посчитай сам — небольшая задача с разобранным решением (раскрывается по клику);
- выноски-алерты GitHub (Note, Tip, Warning) — частые ошибки и практические советы; на сайте они оформлены так же, как на GitHub;
- Ключевые идеи — что забрать с собой;
- Проверь себя — 3–5 вопросов, ответы в конце главы;
- Источники главы — что читать дальше и зачем.
Схемы нарисованы в Mermaid прямо в тексте. Графики лежат в figures/ и построены скриптами из figures/src/ — только по формулам книги, без замеров; пересобрать их можно командой MPLBACKEND=Agg python3 -I figures/src/build_all.py (нужен matplotlib).
Полная аннотированная библиография — в sources.md, краткие определения терминов — в глоссарии.
Оглавление
- Токены, эмбеддинги и трансформер на пальцах
- Prefill и decode: почему генерация упирается в память
- Иерархия памяти: VRAM, PCIe, ОЗУ, диск и mmap
- Квантование весов: GGUF, k-quants, imatrix
- MoE: эксперты, роутинг и выгрузка в ОЗУ
- KV-кэш, контекстное окно и позиционные кодировки
- Кэш промпта и агентские нагрузки
- Батчинг, слоты и PagedAttention
- Спекулятивное декодирование: черновик, MTP, acceptance rate
- Сэмплинг, температура и бюджет рассуждений
- Вызов инструментов: шаблоны чата, грамматики, JSON Schema
- Методика бенчмарка и тюнинга
- Выбор модели под железо
- Речь и OCR локально
- Куда расти
Приложения: Глоссарий — короткие определения всех терминов; Частые заблуждения — каталог по симптомам; Порядок анализа — шпаргалка на один экран.
Соглашения
- ГиБ — гибибайты (1 ГиБ = 1,0737 ГБ), ГБ — десятичные. В формулах памяти удобнее ГиБ, в размерах файлов производители часто пишут ГБ.
- ток/с — токенов в секунду; pp (prompt processing) — обработка промпта, tg (text generation) — генерация.
- Q4_K_M, IQ4_XS, UD-Q4_K_M — названия квантов GGUF; разбираются в главе 4.
- Пометка [пример] означает вымышленные, но правдоподобные числа для иллюстрации; [оценка] — расчёт по формуле, а не измерение. Подпись «Расчёт» на графике означает то же самое.
- Все ссылки проверены на момент написания. Если источник самозаявленный (карточка модели, блог вендора), это сказано явно.
Чего здесь нет
- Обучения моделей с нуля и тонкой настройки: книга про инференс.
- Сравнения «какая модель самая умная»: такого универсального ответа нет, а глава 13 объясняет почему.
- Готовых конфигов под конкретную видеокарту: их надо подбирать по методике из главы 12.
1. Токены, эмбеддинги и трансформер на пальцах
Зачем эта глава. Почти все странности локального инференса — размер файла, скорость, требование к памяти — растут из трёх вещей: модель хранит миллиарды чисел, на каждый токен читает их из памяти и делает это последовательно. Чтобы это увидеть, нужно представлять, что именно лежит в файле модели.
За 30 секунд
- Модель работает с токенами — кусками слов; скорость и контекст считают в токенах.
- Каждый токен проходит через стопку одинаковых слоёв: attention смешивает информацию между позициями, FFN обрабатывает каждую позицию отдельно.
- Параметров в слое ≈
12 d², размер файла ≈ параметры × байт на параметр.- На каждый новый токен модель читает из памяти все свои (активные) веса — отсюда все ограничения по памяти и скорости.
1.1 Токены: единица работы модели
Модель не видит буквы и не видит слова. Текст сначала режется на токены — куски, которые встречаются в обучающем корпусе достаточно часто. Алгоритм чаще всего один и тот же: BPE (byte-pair encoding) или его варианты. Он начинает с отдельных байтов и постепенно склеивает частые пары в более длинные фрагменты.
Примерно так выглядит разбиение фразы:
"локальный инференс" → ["лок", "альный", " ин", "ферен", "с"]
Это не точное разбиение конкретного токенизатора, а иллюстрация: частые части слова становятся одним токеном, редкие — дробятся на несколько. У современных моделей словарь (vocabulary) содержит от 32 тысяч до 256 тысяч токенов. Чем больше словарь, тем короче текст в токенах, но тем больше весит выходной слой модели.
Два следствия, важных для практики:
- Токен — не слово. «Технические условия» может стать 3–6 токенами, а может и 10 — зависит от токенизатора и языка.
- Русский текст обычно дороже английского. Русские словоформы реже попадают в словарь целиком, поэтому на одну и ту же мысль уходит больше токенов. Прикидка: английский текст — примерно 1,3 токена на слово, русский технический — 2–3 токена на слово. Это именно прикидка: точное число зависит от модели и текста.
Токены важны потому, что все скорости измеряются в токенах в секунду, а все лимиты контекста — в токенах, а не в символах и не в страницах.
1.2 Эмбеддинг: токен становится вектором
Каждому токену соответствует строка в большой таблице эмбеддингов (embedding matrix). Если в словаре 128 тысяч токенов, а размерность модели 4096, таблица содержит
128 000 × 4096 ≈ 524 млн чисел
При 16 битах на число это около 1 ГиБ только на входную таблицу. У некоторых моделей входная и выходная таблицы — это одна и та же матрица (tied embeddings), у некоторых — две разные; это видно по числу параметров в карточке.
Полученный вектор — это и есть представление токена, с которым дальше работает сеть. Он сам по себе ничего не «значит»: смысл появляется из комбинации с позицией и контекстом.
1.3 Один слой трансформера
Модель — стопка одинаковых слоёв (обычно от 24 до 80+). В каждом слое два основных блока.
Сначала несколько понятий, которые понадобятся дальше. d_model — ширина вектора, с которым работает слой (обычно 2048–8192). d_head — ширина одной головы attention; обычно 64–128, а d_head = d_model / число_голов. Больше голов — больше независимых подпространств, но каждая голова уже.
Softmax — функция, которая превращает произвольные числа в вероятности: возводит каждое в экспоненту и делит на сумму. Результат неотрицателен и в сумме даёт единицу.
Attention: обмен информацией между позициями
Для каждого токена из его вектора вычисляются три вектора:
- Query (Q) — «что я ищу»;
- Key (K) — «что я могу предложить»;
- Value (V) — «какую информацию я передаю, если меня выберут».
Это делается умножением на три матрицы: Wq, Wk, Wv. Затем для токена i считается, насколько он похож на каждый предыдущий токен j:
score(i, j) = (Q_i · K_j) / sqrt(d_head)
Деление на корень из размерности головы нужно, чтобы масштаб скалярных произведений не рос вместе с d_head и softmax не становился слишком «острым».
К результатам применяется causal mask — запрет смотреть на будущие токены: позиции справа от текущей получают минус бесконечность до softmax. Иначе предсказание следующего токена потеряло бы смысл. После маски — softmax по всем допустимым j, и выход:
out_i = сумма_j softmax(score(i, j)) × V_j
То есть каждый токен собирает взвешенную смесь значений предыдущих токенов. Веса — это и есть «внимание».
Multi-head attention. Вместо одного набора Q/K/V используется несколько голов. При d_model = 4096 и 32 головах размер одной головы d_head = 128. Каждая голова учится на своём подпространстве, потом результаты склеиваются и проходят через выходную матрицу Wo.
Именно на этом шаге появляется KV-кэш: чтобы не пересчитывать K и V прошлых токенов заново, их сохраняют. Если несколько Q-голов делят одну пару K/V, это grouped-query attention (GQA) — она уменьшает KV-кэш в несколько раз. Обе темы подробно разобраны в главе 6.
FFN: преобразование каждой позиции отдельно
После attention вектор каждого токена независимо проходит через feed-forward network:
h = активация(x · W1)
y = h · W2
Обычно внутренняя размерность d_ff в 4 раза больше d_model, то есть при 4096 это 16 384. В современных моделях часто используют SwiGLU — вариант с «воротами»: одна матрица даёт значение, другая — коэффициент пропускания, и они перемножаются; поэтому матриц три, а d_ff берут примерно 8/3 · d_model, чтобы число параметров осталось прежним.
В FFN хранится значительная часть «знаний» модели. У плотной (dense) модели на каждом токене работают все веса FFN. У MoE (mixture of experts) — только несколько «экспертов»; об этом глава 5.
Остаточные связи и нормировка
Вокруг каждого блока есть residual connection: x = x + block(x). Она позволяет сигналу и градиенту проходить через десятки слоёв, не затухая. Перед блоками стоит нормировка: LayerNorm вычитает среднее и делит на стандартное отклонение, а RMSNorm — более дешёвый вариант, который делит только на среднеквадратичное значение, без вычитания среднего. Для инференса важно, что residual-поток — это вектор размерности d_model, который переносится от слоя к слою; он маленький по сравнению с весами.
Слой целиком
Вот как всё это складывается в путь одного токена — от текста до следующего токена:
flowchart TB
TXT["Текст"] --> TOK["Токенизатор (BPE)"]
TOK --> IDS["ID токенов"]
IDS --> EMB["Таблица эмбеддингов<br/>vocab × d_model"]
EMB --> X
subgraph LAYER ["Слой трансформера — повторяется N раз"]
direction TB
X["вектор x<br/>(residual-поток)"] --> N1["RMSNorm"]
N1 --> ATT["Attention<br/>Q·K → веса, смесь V<br/>по прошлым позициям"]
ATT --> A1(("+"))
X -->|"остаточная связь"| A1
A1 --> N2["RMSNorm"]
N2 --> FFN["FFN / SwiGLU<br/>каждая позиция отдельно"]
FFN --> A2(("+"))
A1 -->|"остаточная связь"| A2
end
ATT -.->|"K и V сохраняются"| KV[("KV-кэш, гл. 6")]
A2 --> NF["Финальная нормировка"]
NF --> OUT["Выходная матрица<br/>d_model × vocab"]
OUT --> LOG["Логиты → softmax → выбор токена (гл. 10)"]
LOG --> NEXT["Следующий токен"]
NEXT -.->|"дописывается к входу,<br/>цикл повторяется"| IDS
Обратите внимание на пунктирную петлю внизу: чтобы получить следующий токен, весь путь через все слои проходится заново. Из этой петли и вырастает вся глава 2.
1.4 Сколько параметров и откуда берётся размер файла
Оценим число параметров одного слоя при d_model = d:
| Компонент | Параметров |
|---|---|
Wq, Wk, Wv, Wo | 4 d² |
| FFN с расширением 4× (две матрицы) | 8 d² |
| Итого на слой | 12 d² |
Плюс эмбеддинги vocab × d и выходной слой (иногда связанный с эмбеддингами).
Пример: d = 4096, 32 слоя.
32 × 12 × 4096² ≈ 6,4 млрд параметров
эмбеддинги: 128 000 × 4096 ≈ 0,52 млрд
итого ≈ 7 млрд
Так получается модель класса 7B. У 70B-модели та же логика, но больше слоёв и шире размерность.
Note
Формула
12 d²— упрощение для FFN с расширением 4× и обычного multi-head attention. SwiGLU сd_ff ≈ 8/3 · dдаёт те же8 d²на FFN, а GQA немного уменьшаетWkиWv. Для прикидки размера модели этой точности хватает.
Дальше просто: размер файла ≈ число параметров × байт на параметр. В FP16 это 2 байта, в реальном 4-битном кванте Q4_K_M — около 0,6 байта (4,8 бита) с учётом масштабов. Поэтому 7B в FP16 весит ~14 ГБ, а в Q4_K_M — ~4,2 ГБ. Именно это делает возможным запуск на потребительской карте; подробности и таблица форматов — в главе 4.
Warning
Размер файла — это ещё не вся нужная память. Сверху добавляются KV-кэш (растёт с длиной контекста, глава 6) и рабочие буферы рантайма. Модель «на 4,2 ГБ» в карту на 4 ГБ не поместится.
Посчитай сам. Модель [пример]: d = 5120, 40 слоёв, словарь 32 000 токенов, входная и выходная таблицы раздельные. Сколько в ней параметров и сколько весит файл в Q4_K_M?
Решение
слои: 40 × 12 × 5120² = 40 × 12 × 26,2 млн ≈ 12,6 млрд
таблицы: 2 × 32 000 × 5120 ≈ 0,33 млрд
итого ≈ 12,9 млрд → модель класса 13B
Q4_K_M: 12,9 млрд × 0,6 байта ≈ 7,7 ГБ (≈ 7,2 ГиБ)
FP16: 12,9 млрд × 2 байта ≈ 26 ГБ
В Q4_K_M такая модель помещается в карту на 12 ГБ — с запасом под KV-кэш, — а в FP16 не помещается даже в 24 ГБ.
1.5 Как из вектора получается следующий токен
Последний слой выдаёт вектор размерности d_model. Его умножают на выходную матрицу vocab × d_model и получают логиты — по одному числу на каждый токен словаря. Затем softmax превращает их в вероятности, и специальный алгоритм выбирает токен (глава 10).
Важно: модель всегда выдаёт распределение по всему словарю, даже если ответ очевиден. Для словаря 128 тысяч это 128 тысяч чисел на каждый шаг — немного по сравнению с чтением весов, но заметно, если словарь огромный.
1.6 Что из этого следует для инференса
Три вывода, которые дальше будут повторяться:
- Память под веса фиксирована. Модель не «подгружает знания по мере надобности»: все параметры должны быть доступны на каждом шаге (у MoE — не все, но об этом позже).
- Вычисления на токен примерно равны
2 × Nопераций, гдеN— число активных параметров: одно умножение и одно сложение на вес. Одна такая операция называется FLOP (floating point operation); для 7B это ~14 млрд FLOP на токен. - Но главное — не операции, а байты. На каждый токен нужно прочитать веса из памяти. Соотношение «операций на байт» и определяет, во что упирается модель. Это тема следующей главы.
Ключевые идеи
- Текст режется на токены; скорость и контекст измеряются в токенах, а не в словах.
- Токен становится вектором; вектор проходит через стопку слоёв, в каждом — attention и FFN.
- Attention смешивает информацию между позициями, FFN преобразует каждую позицию отдельно.
- Число параметров слоя ≈
12 d²; размер файла ≈ параметры × байт на параметр. - Модель хранит все веса и читает их на каждом шаге генерации — отсюда все ограничения по памяти и скорости.
Проверь себя
- Почему число параметров и число операций на один токен — не одно и то же?
- При
d_model = 8192и 80 слоях сколько примерно параметров в блоках трансформера (без эмбеддингов)? - Зачем в attention делят на
sqrt(d_head)? - Почему русский текст может быть медленнее английского при одинаковой скорости в ток/с?
- Где в трансформере хранится большая часть параметров у плотной модели?
Ответы
- Плотная модель 35B выполняет на токен примерно
2 × 35 = 70млрд операций: на каждый вес приходится умножение и сложение, это два FLOP. Поэтому у плотной модели операций на токен примерно вдвое больше, чем параметров. У MoE к этому добавляется второй слой различия: хранятся все параметры, а на токен активируется лишь часть экспертов, поэтому операций ещё меньше. 80 × 12 × 8192² ≈ 64 млрдпараметров. Это модель класса 70B.- Скалярное произведение Q и K растёт с размерностью; без масштабирования softmax становится слишком резким, а градиенты — плохо обусловленными. Деление на
sqrt(d_head)возвращает дисперсию к единице. - Русские слова чаще дробятся на несколько токенов, поэтому на ту же фразу уходит больше токенов. При одинаковом ток/с русский текст выдаётся медленнее в пересчёте на слова и символы.
- В FFN: при расширении 4× на неё приходится
8 d²из12 d², то есть две трети параметров слоя.
Источники главы
- Vaswani et al., «Attention Is All You Need» (2017) — arXiv:1706.03762. Первоисточник архитектуры; читать после объяснения, чтобы увидеть точные формулы.
- Andrej Karpathy, «Let's build GPT: from scratch, in code, spelled out» (2023) — YouTube. Пошаговая реализация tiny-трансформера; лучший способ «пощупать» главу.
- 3Blue1Brown, «Transformers, the tech behind LLMs» (глава 5) и «Attention in transformers, step-by-step» (глава 6) — видео 1, видео 2. Визуальная интуиция attention без формул.
- Stanford CS336, «Language Modeling from Scratch» — курс. Лекции и задания по токенизации, архитектуре и обучению; полезно для систематического изучения.
- Dive into Deep Learning, главы про attention и трансформеры — d2l.ai. Бесплатный учебник с кодом.
- Lilian Weng, «The Transformer Family Version 2.0» (2023) — пост. Обзор вариантов attention и нормализаций.
2. Prefill и decode: почему генерация упирается в память
Зачем эта глава. Это главная глава книги. Если понять разницу между обработкой промпта и генерацией, становится ясно, почему одни флаги ускоряют модель в разы, другие не дают ничего, а «просто добавить видеокарту» не всегда помогает.
За 30 секунд
- Prefill (чтение промпта) обрабатывает все токены разом и упирается в вычисления.
- Decode (генерация) идёт по одному токену и на каждом шаге заново читает все веса — он упирается в пропускную способность памяти.
- Главная формула книги: скорость декода ≈ пропускная способность ÷ байт весов на токен.
- Формула даёт потолок; реально получается 50–75% от него.
2.1 Две фазы работы модели
Генерация ответа состоит из двух принципиально разных режимов.
Prefill (обработка промпта). Модель получает весь промпт сразу — например, 8 тысяч токенов. Все они известны заранее, поэтому их можно прогнать через сеть параллельно, одной большой матричной операцией. Это ровно то, для чего видеокарта построена: тысячи ядер считают одновременно.
Decode (генерация). Модель выдаёт один токен, добавляет его к последовательности, снова прогоняет и так далее. Каждый следующий токен зависит от предыдущего, поэтому распараллелить шаги нельзя. На каждом шаге через сеть проходит один новый токен (в расчёте на слот; батчинг нескольких запросов — отдельная история, глава 8).
Метрики так и называют:
- pp (prompt processing) — токенов промпта в секунду;
- tg (text generation) — токенов ответа в секунду;
- TTFT (time to first token) — время до первого токена, примерно prefill + один шаг decode;
- ITL (inter-token latency) — время между токенами, обратная величина к tg.
sequenceDiagram
participant U as Пользователь
participant M as Модель
participant W as Память с весами
U->>M: промпт, 8000 токенов
Note over M,W: Prefill: все 8000 токенов за один проход.<br/>Веса читаются один раз, много вычислений на байт
M->>W: прочитать все веса
M-->>U: токен 1 (здесь заканчивается TTFT)
loop Decode: по одному токену
M->>W: снова прочитать все веса
Note over M,W: на один токен — те же байты,<br/>но в тысячи раз меньше вычислений
M-->>U: токен 2, 3, 4…
end
Обе фазы читают одни и те же веса, но prefill делит это чтение на тысячи токенов, а decode — на один.
2.2 Сколько операций и сколько байт
Для одного прохода через плотную модель с N параметрами нужно примерно
FLOPs ≈ 2 × N × B
где B — число токенов в батче. Двойка — это умножение и сложение на каждый вес. Для декода B = 1, для prefill B равно длине промпта (с точностью до чанкинга — разбиения промпта на куски, подробнее в главе 8).
FLOP (floating point operation) — одна операция с плавающей точкой. FLOP/s — сколько таких операций в секунду выполняет железо.
Байты, которые нужно прочитать из памяти:
байты ≈ N × b
где b — байт на параметр с учётом служебных данных кванта. Веса читаются один раз на проход, независимо от B; именно поэтому батчинг так выгоден для prefill.
Важно не путать «идеальные 4 бита» и реальный формат. Вот принятая в книге конвенция (подробная таблица — в главе 4):
| Формат | Бит на вес | b, байт | I ≈ 2/b |
|---|---|---|---|
| FP16 | 16 | 2,0 | 1,0 |
| Q8_0 | ~8,5 | 1,06 | 1,9 |
| Q4_K_M | ~4,8 | 0,60 | 3,3 |
| идеальный 4-бит | 4,0 | 0,50 | 4,0 |
Дальше в примерах используется Q4_K_M: именно он чаще всего стоит на домашних машинах. Идеальный 4-бит оставлен только для того, чтобы показать нижнюю границу.
Отношение этих величин называется арифметической интенсивностью (arithmetic intensity):
I = FLOPs / байты ≈ 2B / b
Для декода B = 1 интенсивность равна 2/b: от 1 FLOP/байт для FP16 до 3,3 для Q4_K_M. Для prefill при B = 2048 и Q4_K_M:
I ≈ 2 × 2048 / 0,60 ≈ 6800 FLOP/байт
Это в две тысячи раз больше, чем при декоде.
2.3 Roofline: два потолка
Roofline-модель говорит простую вещь: производительность ограничена либо пиковой вычислительной способностью, либо пропускной способностью памяти.
достижимые FLOP/s ≈ min( пиковые FLOP/s, пропускная способность × I )
Точка перелома — там, где эти две величины равны:
I* = пиковые FLOP/s / пропускная способность
Для современной видеокарты с 50 TFLOP/s и 1 ТБ/с I* ≈ 50 FLOP/байт. Для карты с 500 ГБ/с и 20 TFLOP/s — I* ≈ 40.
Сравним с декодом:
- Q4_K_M даёт
I ≈ 3,3FLOP/байт; - это в 12–25 раз меньше точки перелома
I* ≈ 40–80.
Значит, декод упирается в память, а не в вычисления. Вычислительные блоки видеокарты в это время в основном простаивают: они ждут, пока веса приедут из видеопамяти.
Prefill при B = 2048 даёт I ≈ 6800, что намного выше точки перелома. Значит, prefill упирается в вычисления.
Обратите внимание: I* — свойство железа, а I — рабочая точка нагрузки. Квантование меняет I, а не I*.
Рисунок 2.1. Roofline в логарифмическом масштабе. Наклонный участок — потолок памяти (пропускная способность × I), горизонтальный — потолок вычислений. Декод (I ≈ 1–3) у всех трёх устройств попадает на наклонный участок, prefill — на горизонтальный. Расчёт по формуле выше, параметры устройств условные.
Это не философское наблюдение, а рабочее правило:
скорость декода ≈ достижимая пропускная способность памяти ÷ байт, прочитанных на один токен
2.4 Практические оценки скорости
Возьмём плотную модель 7B в Q4_K_M. Вес — около 4,2 ГБ. На карте с достижимой пропускной способностью 400 ГБ/с:
400 / 4,2 ≈ 95 ток/с
Это теоретический потолок. Реально будет 50–75% от него: сказываются накладные расходы, attention, сэмплинг (выбор токена из распределения, глава 10), неполная загрузка памяти. Разумное ожидание — 50–70 ток/с.
Теперь 70B в Q4_K_M: около 42 ГБ. На той же карте:
400 / 42 ≈ 9,5 ток/с
А на карте с 1 ТБ/с — около 24 ток/с теоретически и 12–18 реально. Разница между 7B и 70B — ровно в 10 раз по объёму весов, и скорость падает примерно во столько же. Это и есть память, а не «слабость вычислений».
Для MoE (mixture of experts, глава 5) формула меняется: читаются не все веса, а только активные эксперты. Поэтому 35B-A3B может работать со скоростью, близкой к плотной 3B-модели, хотя занимает память как 35B.
Рисунок 2.2. Потолок декода для Q4_K_M: линия — пропускная способность ÷ размер весов, полоса — реалистичные 50–75% от потолка. Вертикальные ориентиры — диапазоны из таблицы главы 3. Расчёт, не замер.
Tip
Чтобы прикинуть скорость любой модели, хватит двух чисел: размера файла (или активной части для MoE) и пропускной способности памяти из спецификации. Разделите одно на другое и возьмите половину–три четверти — это и есть разумное ожидание до любых замеров.
2.5 Почему prefill всё-таки важен
Если в обычном чате большую часть времени занимает декод, зачем ускорять prefill? Причины три.
- TTFT. Пользователь ждёт первый токен. При промпте 30 тысяч токенов и скорости 1000 ток/с это 30 секунд молчания.
- Длинные документы. Если модель читает 100 тысяч токенов, prefill становится заметной частью работы, даже если ответ короткий.
- Стоимость attention на длинном контексте. При prefill сложность attention растёт квадратично по длине, и на очень длинных промптах баланс смещается.
Но главное правило остаётся: для интерактивной генерации основной рычаг — декод, а для пакетной обработки длинных документов — prefill и кэш промпта.
2.6 Где формула ломается
Простая модель полезна, но у неё есть ограничения.
- Квантованные веса распаковываются. При 4-битном хранении байт меньше, но перед умножением значения часто приводятся к 16 битам. Это добавляет вычисления и может снизить эффективную пропускную способность.
- Attention тоже читает память. На длинном контексте KV-кэш — сохранённые K и V прошлых токенов (глава 6) — становится сопоставим с весами по объёму чтения.
- Пропускная способность зависит от шаблона доступа. Последовательное чтение быстрее случайного; выгрузка экспертов в ОЗУ меняет не только объём, но и задержку.
- Attention — тоже кернел. Наивный attention материализует матрицу «каждый токен с каждым», и на длинном контексте это становится узким местом по памяти. FlashAttention считает блоками, не выгружая матрицу целиком, поэтому на длинных промптах разница особенно заметна.
- Пиковые FLOP/s — маркетинг. Указывают разреженность тензорных ядер (structured sparsity, например 2:4 — это не то же самое, что условная активация экспертов MoE, глава 5), FP8 или INT4 (форматы низкой точности, глава 4); реальная матричная операция в llama.cpp может идти на других типах.
Поэтому расчёт даёт порядок величины и потолок, а не точное число. Точное число даёт бенчмарк (глава 12).
2.7 Небольшой расчёт «на салфетке»
Модель 13B, квант Q4_K_M, весит около 7,9 ГБ. Карта 12 ГБ, пропускная способность 360 ГБ/с.
потолок декода: 360 / 7,9 ≈ 46 ток/с
реалистично: 25–35 ток/с
Хватит ли 12 ГБ (это 11,2 ГиБ)? Веса 7,9 ГБ ≈ 7,4 ГиБ. KV-кэш в FP16 на 8k [пример: 32 слоя, GQA с 8 KV-головами по 128] — 2 × 32 × 8 × 128 × 2 байта = 128 КиБ на токен, то есть ровно 1 ГиБ на 8192 токена (формула — в главе 6). Служебные буферы — 0,5–1 ГиБ. Итого 8,9–9,4 ГиБ: помещается с запасом около 2 ГиБ. Если поднять контекст до 32k, KV вырастет до 4 ГиБ, сумма дойдёт до 11,9–12,4 ГиБ — и в 12-гигабайтную карту модель уже не поместится вовсе. Это типичный выбор: контекст или запас по памяти, а не «всё сразу».
Посчитай сам. Mac с объединённой памятью 614 ГБ/с [пример] и плотная модель 35B в Q4_K_M. Каков потолок декода и какую скорость ждать? А если взять MoE 35B-A3B в том же кванте?
Решение
35B dense: 35 × 0,6 = 21 ГБ на токен → 614 / 21 ≈ 29 ток/с → реально 15–22
35B-A3B: 3 × 0,6 = 1,8 ГБ на токен → 614 / 1,8 ≈ 340 ток/с — формальный потолок
Обе модели занимают в памяти около 21 ГБ, но MoE читает на токен в 12 раз меньше. Её реальная скорость будет заметно ниже формального потолка — начнут мешать attention и накладные расходы (глава 5), — но всё равно в разы выше, чем у плотной модели.
2.8 TTFT и ITL: две метрики, которые нельзя складывать
В §2.1 они уже названы, но здесь важно разделить их по смыслу — это две разные задержки, и оптимизируются они разными рычагами.
TTFT = t_1 − t_0
ITL_j = t_{j+1} − t_j (j = 1 … N − 1)
T_ответа = TTFT + Σ_{j=1}^{N−1} ITL_j
TTFT (time to first token) — сколько пользователь ждёт до первого символа. В него входят ожидание в очереди, prefill всего промпта и один шаг декода:
TTFT ≈ W_очереди + P / pp + T_шага
где P — длина промпта, pp — скорость обработки промпта, T_шага — шаг декода, порождающий первый токен. ITL_1 — уже интервал между первым и вторым выходными токенами, поэтому в TTFT он не входит. На длинном промпте доминирует P / pp; на перегруженном сервере — W_очереди.
ITL (inter-token latency) — время между токенами после первого. Оно определяется декодом: чтением весов и KV, батчем и спекуляцией. ITL не константа: на длинном контексте он растёт, при вставке чужого prefill — подскакивает, поэтому смотрят не только среднее, но и медиану с p95.
Отсюда два разных «ток/с»:
- скорость декода
tg ≈ 1 / медианный ITL— то, что показываетllama-bench; - воспринимаемая скорость
N / T_ответа— сколько токенов в секунду получает пользователь с учётом ожидания первого.
Они расходятся тем сильнее, чем длиннее промпт и короче ответ.
Посчитай сам. Промпт 30 000 токенов, pp = 800 ток/с, ответ 300 токенов, медианный ITL 30 мс. Каковы TTFT, полное время и воспринимаемая скорость? Что улучшать, если пользователь жалуется на медленный ответ?
Решение
TTFT = 30 000 / 800 = 37,5 с
T = 37,5 + 299 × 0,030 ≈ 46,5 с
воспринимаемая скорость = 300 / 46,5 ≈ 6,5 ток/с
скорость декода = 1 / 0,030 ≈ 33 ток/с
Пользователь видит 6,5 ток/с, хотя декод идёт на 33. Жалоба почти наверняка про TTFT: лечить нужно prefill — кэш префикса (глава 7), более быстрый prefill или сокращение промпта. Ускорять декод в пять раз бессмысленно: полное время упадёт с 46,5 до 39,3 с, потому что 37,5 с — это ожидание первого токена.
Tip
Если жалуются «долго думает, потом быстро печатает» — это TTFT и prefill. Если «начинает сразу, но печатает медленно» — это ITL и декод. Если «всё медленно и очередь» — смотрите загрузку сервера и число одновременных запросов (глава 8), а не модель.
Ключевые идеи
- Prefill параллелен и упирается в вычисления; decode последователен и упирается в пропускную способность памяти.
- Арифметическая интенсивность декода ≈
2/b; для Q4_K_M это около 3,3 FLOP/байт, что в десятки раз ниже точки перелома. - Скорость декода ≈ пропускная способность ÷ байт весов на токен.
- Батчинг ускоряет prefill, но почти не помогает декоду одного запроса (речь о latency; про throughput сервера — глава 8).
- TTFT и ITL — разные метрики: TTFT определяется очередью и prefill, ITL — декодом; полное время — их сумма.
- Формула даёт потолок; реальная скорость — 50–75% от него.
Проверь себя
- Почему увеличение батча промпта с 512 до 4096 токенов может ускорить prefill почти линейно, а декод — нет?
- У модели 30B в Q4_K_M (около 18 ГБ) и карты с 700 ГБ/с: какой порядок скорости декода?
- Что такое точка перелома roofline и что её двигает?
- Почему на длинном контексте простая формула «пропускная способность ÷ веса» начинает завышать скорость?
- Если TTFT 20 секунд, а генерация идёт со скоростью 40 ток/с, что нужно улучшать для интерактивного чата?
Ответы
- Prefill обрабатывает все токены параллельно: веса читаются один раз, а вычисления растут с батчем. Декод обрабатывает по одному токену на слот, и веса приходится читать заново на каждом шаге, поэтому батч не уменьшает объём чтения.
700 / 18 ≈ 39 ток/стеоретически, реально 50–75% от этого — примерно 20–29 ток/с (если модель помещается в память целиком).- Это интенсивность
I* = пиковые FLOP/s / пропускная способность, при которой память и вычисления дают одинаковую производительность. Она зависит только от железа. Квантование меняет рабочую точкуI = 2/b: сильнее сжатый вес означает меньше байт и вышеI, поэтому точка приближается кI*, но самаI*не смещается. - На длинном контексте добавляется чтение KV-кэша и вычисление attention, которые растут с длиной. Кроме того, падает эффективность доступа к памяти.
- TTFT определяется в основном prefill. Нужно ускорять обработку промпта (батчи, более быстрый prefill, кэш префикса) или сокращать промпт; скорость генерации на TTFT почти не влияет.
Источники главы
- Pope et al., «Efficiently Scaling Transformer Inference» (2022) — arXiv:2211.05102. Анализ компромиссов память/вычисления/батч для инференса трансформеров.
- Horace He, «Making Deep Learning Go Brrrr From First Principles» — horace.io. Лучшее введение в compute-bound vs memory-bound без тяжёлой математики.
- kipply, «Transformer Inference Arithmetic» — kipp.ly. Подробные расчёты FLOPs, байт и задержек для декода.
- Databricks, «LLM Inference Performance Engineering: Best Practices» — блог. Практические метрики и узкие места в продакшене.
- NVIDIA H100 — страница продукта. Пример спецификации: 3,35 ТБ/с HBM3 у SXM-версии.
- Apple Mac Studio, технические характеристики — apple.com. Пример объединённой памяти: 460–614 ГБ/с у M5 Max, до 1,2 ТБ/с у M5 Ultra.
3. Иерархия памяти: VRAM, PCIe, ОЗУ, диск и mmap
Зачем эта глава. Локальный инференс — это в первую очередь задача о том, где лежат веса и как быстро их можно прочитать. Понимание иерархии объясняет, почему 35-миллиардная модель может работать с приличной скоростью на 16 ГБ видеопамяти, а может внезапно упасть в 15 раз медленнее.
За 30 секунд
- Память — это лестница: регистры → VRAM → ОЗУ → PCIe → диск. Каждая ступень больше, но медленнее.
- Скорость декода задаёт самая медленная ступень, с которой читаются веса.
- Выгруженные в ОЗУ веса выгоднее считать на CPU, чем гонять по PCIe.
- Главные ловушки: mmap для CPU-весов и тихая выгрузка VRAM в системную память на Windows.
3.1 Лестница памяти
Данные в компьютере живут на разных уровнях, и каждый следующий уровень больше, но медленнее.
| Уровень | Объём | Пропускная способность | Задержка |
|---|---|---|---|
| Регистры / shared memory GPU | килобайты–мегабайты | десятки ТБ/с | единицы наносекунд |
| Кэш L2 GPU | десятки МБ | несколько ТБ/с | ~100–200 нс |
| VRAM (GDDR/HBM) | 8–192 ГБ | 300–3500 ГБ/с | ~300–800 нс |
| ОЗУ (DDR) | 16–512 ГБ | 40–100 ГБ/с | ~80–120 нс |
| PCIe между GPU и ОЗУ | — | 25–60 ГБ/с | микросекунды |
| NVMe SSD | терабайты | 3–7 ГБ/с | десятки микросекунд |
| HDD / сеть | терабайты | 0,1–1 ГБ/с | миллисекунды |
Числа — порядки величин для потребительского железа. Точные значения зависят от модели карты, числа каналов памяти и версии PCIe.
Та же лестница в виде схемы — с тем, что по какому пути ходит при инференсе:
flowchart LR
subgraph GPU ["Видеокарта"]
direction TB
REG["Регистры, shared memory<br/>десятки ТБ/с"] --- L2["Кэш L2<br/>несколько ТБ/с"]
L2 --- VRAM["VRAM: 8–192 ГБ<br/>300–3500 ГБ/с"]
end
subgraph HOST ["Компьютер"]
direction TB
RAM["ОЗУ: 16–512 ГБ<br/>40–100 ГБ/с"] --- CPU["CPU"]
end
DISK[("NVMe SSD<br/>3–7 ГБ/с")]
VRAM <-->|"PCIe 25–60 ГБ/с:<br/>активации, не веса"| RAM
DISK -->|"загрузка модели<br/>при старте"| RAM
DISK -.->|"mmap: подкачка страниц —<br/>в генерации быть не должно"| RAM
Чем дальше уровень от регистров GPU, тем он медленнее. Хорошая конфигурация держит активные веса как можно ближе к вычислителю, который их использует.
Обратите внимание: у VRAM выше пропускная способность, но не обязательно ниже задержка. Доступ к одному случайному значению в GDDR может занимать сотни наносекунд — сравнимо с DDR или даже дольше. Для декода это не главное: веса читаются потоком, и важна именно пропускная способность. А для случайного доступа к экспертам задержка уже имеет значение.
Ключевое отношение: VRAM в 5–15 раз быстрее ОЗУ и в десятки раз быстрее PCIe. Поэтому «положить веса в ОЗУ и читать их на GPU» — плохая идея: вы меняете быструю память на медленную шину.
3.2 Что происходит при декоде
На каждом токене нужно прочитать все активные веса. Если они в VRAM, чтение идёт на сотни гигабайт в секунду. Если часть в ОЗУ, есть два варианта:
- Перегнать веса по PCIe на GPU и посчитать там. Тогда на каждый токен 8 ГБ весов поедут по шине 25 ГБ/с — это
8 / 25 ≈ 0,32 столько на передачу, то есть максимум ~3 ток/с, и это без вычислений. - Посчитать эти веса на CPU прямо в ОЗУ. Тогда чтение идёт на скорости ОЗУ (40–100 ГБ/с), что в 2–4 раза быстрее PCIe, но всё равно в 5–15 раз медленнее VRAM.
Именно поэтому в llama.cpp выгрузка экспертов MoE (--n-cpu-moe) считает выгруженную часть на CPU, а не гоняет её туда-обратно. По PCIe передаются только маленькие активации: вектор размерности d_model на слой, а не матрицы весов.
3.3 mmap: удобно, но коварно
mmap (memory-mapped file) — способ не читать файл целиком, а «отобразить» его в адресное пространство. Операционная система подгружает страницы с диска по мере обращения. Это удобно: программа стартует быстро, а память расходуется лениво.
Для инференса это создаёт проблему.
- Веса на GPU копируются в VRAM один раз, и mmap для них почти не важен.
- Веса, которые считаются на CPU (например, выгруженные эксперты), читаются на каждом токене и в случайном порядке. Если страницы вытеснены из page cache, каждое обращение — это чтение с диска. Скорость падает не на проценты, а в разы.
Симптом: prefill в несколько раз медленнее ожидаемого, свободная ОЗУ почти нулевая, диск активно читается. Лечение — загрузить модель в память явно:
- в llama.cpp:
--load-mode none(короткая форма-lm none), при необходимости--mlock; - в других рантаймах — аналогичные флаги «держать модель в RAM».
Старый флаг --no-mmap в современных сборках llama.cpp убран; если он ещё работает в вашей версии, считайте это совместимостью, а не рекомендацией. Проверьте --help своей сборки: семантика режимов загрузки менялась.
Цена — более долгий старт (десятки секунд вместо секунд) и занятая ОЗУ. Для постоянно работающего сервера это нормальный размен.
3.4 Тихая выгрузка в системную память
На Windows драйвер NVIDIA по умолчанию включает sysmem fallback: если видеопамять закончилась, данные молча размещаются в системной ОЗУ, а GPU читает их через PCIe. Приложение не получает ошибку «out of memory» — оно просто становится очень медленным.
Это одна из самых частых причин «модель запустилась, но выдаёт 3 ток/с». Признаки:
- занятая VRAM упирается в предел карты;
- свободная ОЗУ падает;
- скорость на порядок ниже расчётной;
nvidia-smiпоказывает высокую загрузку шины.
Warning
Запас VRAM. Оставляйте 1,5–2 ГБ видеопамяти свободными и смотрите пик потребления под нагрузкой — на длинном промпте и со всеми слотами, — а не только сразу после загрузки модели. Это правило действует для всей книги; главы 12 и 13 на него ссылаются.
На Linux такого тихого fallback обычно нет, и вы получите ошибку — это лучше, чем молчаливая деградация.
3.5 Объединённая память: Mac и интегрированные GPU
У Apple Silicon и некоторых интегрированных решений нет отдельной VRAM: CPU и GPU используют один пул объединённой памяти (unified memory). Это даёт два преимущества:
- не нужно копировать веса по PCIe — GPU читает их из того же пула;
- можно держать модель больше видеопамяти дискретной карты: 64–128 ГБ против 16–24 ГБ.
Но есть ограничения:
- пропускная способность ниже, чем у топовых дискретных карт: сотни ГБ/с против 1–3 ТБ/с;
- память делится с системой и приложениями;
- вычисления на GPU слабее, чем у дискретной карты того же ценового уровня.
Для декода, который упирается в память, объединённая память с 400–800 ГБ/с может быть вполне конкурентоспособна на моделях, которые целиком помещаются. Для prefill, который упирается в вычисления, дискретная карта обычно быстрее.
3.6 Диск: загрузка, а не работа
NVMe SSD со скоростью 3–7 ГБ/с кажется быстрым, но на фоне VRAM это в сотни раз медленнее. Диск влияет на:
- время загрузки модели: 20 ГБ файл читается 3–7 секунд теоретически, на практике дольше;
- первый запуск после вытеснения страниц;
- подкачку, если модель не помещается в ОЗУ.
В установившемся режиме диск не должен участвовать в генерации. Если он участвует — значит, модель не помещается в память или mmap работает против вас.
3.7 Практическая арифметика выгрузки
Пример: модель 70B в Q4_K_M, около 42 ГБ. Карта 16 ГБ, ОЗУ 64 ГБ. Нужно выгрузить примерно 28 ГБ, оставив в VRAM около 14 ГБ под веса, KV и буферы.
Если считать выгруженную часть на CPU:
28 ГБ на токен / 50 ГБ/с ≈ 0,56 с
Это потолок около 1,8 ток/с, и он почти не зависит от того, насколько быстрая видеокарта: узкое место — ОЗУ и CPU.
Если выгрузить только 8 ГБ (на карте, где в VRAM помещается 34 ГБ):
8 / 50 ≈ 0,16 с → потолок ~6 ток/с
Отсюда правило: чем меньше выгружено, тем лучше, а выгрузка — компромисс между объёмом модели и скоростью. Для MoE это работает хорошо, потому что на токен нужна лишь часть экспертов; для плотной модели выгрузка почти всегда означает кратное падение скорости.
Посчитай сам. Та же модель 70B в Q4_K_M (42 ГБ), но карта на 24 ГБ с пропускной способностью 1 ТБ/с [пример]. В VRAM кладём 20 ГБ весов (4 ГБ остаются под KV-кэш и буферы), остальное считается на CPU при 60 ГБ/с. Каков потолок декода и какая часть времени уходит на GPU?
Решение
GPU: 20 ГБ / 1000 ГБ/с = 0,02 с
CPU: 22 ГБ / 60 ГБ/с ≈ 0,37 с
итого ≈ 0,39 с на токен → потолок ≈ 2,6 ток/с
На GPU уходит около 5% времени. Даже бесконечно быстрая видеокарта подняла бы потолок лишь до 1 / 0,37 ≈ 2,7 ток/с. Ускорять здесь надо не карту, а объём выгрузки: взять квант поменьше, MoE-модель или машину с большей VRAM.
Ключевые идеи
- Иерархия памяти: VRAM быстрее ОЗУ в 5–15 раз, PCIe — в десятки раз медленнее VRAM. Скорость декода задаёт самый медленный уровень, с которого читаются веса.
- Выгруженные веса надо считать там, где они лежат: по PCIe ходят активации, а не матрицы.
- mmap откладывает загрузку и может привести к чтению весов с диска на каждом токене.
- Windows может молча выгрузить часть модели в системную память; следите за пиком VRAM.
- Объединённая память Apple — не «магически быстрая», а другой компромисс: больше объём и нет копирования, но пропускная способность ниже, чем у топовых дискретных карт.
Проверь себя
- Почему выгоднее считать выгруженные эксперты на CPU, а не передавать их на GPU?
- Модель 20 ГБ, VRAM 16 ГБ, ОЗУ 32 ГБ. Что произойдёт на Windows при нехватке VRAM и как это заметить?
- Зачем
--load-mode none, если mmap экономит память? - У Mac 64 ГБ объединённой памяти и 500 ГБ/с. Можно ли запустить модель 70B в Q4_K_M целиком и с какой примерно скоростью?
- Почему быстрый NVMe не спасает, если модель не помещается в ОЗУ?
Ответы
- Передача 28 ГБ по PCIe со скоростью 25 ГБ/с занимает больше секунды на токен — это порядка 1 ток/с. CPU читает те же данные из ОЗУ на 40–100 ГБ/с, то есть в 2–4 раза быстрее, и не тратит время на копирование.
- Драйвер молча разместит не влезшее в системной памяти, и генерация замедлится в разы. Заметить можно по пику VRAM у предела, падению свободной ОЗУ, активности диска/шины и скорости, которая ниже расчётной в 5–15 раз.
- При mmap страницы файла подкачиваются по мере обращения. Для весов, которые считаются на CPU в случайном порядке, это означает чтение с диска.
--load-mode noneзагружает их в ОЗУ один раз и убирает этот эффект. - 70B в Q4_K_M — около 42 ГБ, то есть по объёму помещается, но на систему остаётся ~22 ГБ. По скорости:
500 / 42 ≈ 12 ток/стеоретически, реально примерно 6–9 ток/с, если память не делится с другими приложениями. - Если модель не помещается в ОЗУ, ОС будет вытеснять страницы на диск и подкачивать их обратно. Скорость тогда определяется диском (3–7 ГБ/с), а не ОЗУ, и падает на порядок.
Источники главы
- Alizadeh et al., «LLM in a flash: Efficient LLM Inference with Limited Memory» (2023) — arXiv:2312.11514. Про выгрузку весов на флеш-память и цену чтения с диска; не путать со StreamingLLM (Xiao et al., attention sinks), которая разбирается в главе 6.
- llama.cpp,
tools/server/README.md— GitHub. Флаги--load-mode,--mlock,--n-cpu-moe; старый--no-mmapв новых сборках отсутствует. - GGUF specification — ggml/docs/gguf.md. Как устроен файл модели и его метаданные.
- llama.cpp Discussion #4167, «Performance of llama.cpp on Apple Silicon M-series» — GitHub. Практические замеры на объединённой памяти.
- Apple, Mac Studio — Technical Specifications — apple.com. Пропускная способность объединённой памяти M5 Max/Ultra.
- Ulrich Drepper, «What Every Programmer Should Know About Memory» (2007) — PDF. Классика про кэши, задержки и пропускную способность; глубже, чем нужно для начала.
4. Квантование весов: GGUF, k-quants, imatrix
Зачем эта глава. Квантование — главный трюк, который позволяет запустить модель на потребительской видеокарте. Но названия вроде
Q4_K_M,IQ3_XXSиUD-Q4_K_Mвыглядят как случайный набор букв, а разница между ними — это разница между «работает» и «работает, но врёт в числах».
За 30 секунд
- Квантование хранит веса меньшим числом бит с масштабом на каждый блок; «4-битный» Q4_K_M на деле занимает ~4,8 бита на вес.
- Меньше байт — меньше памяти и быстрее декод: Q4_K_M в 3,3 раза легче FP16.
- Начинайте с
Q4_K_M; есть запас памяти — поднимайтесь до Q5/Q6, нет — пробуйтеIQ4_XS.- Ниже 4 бит проверяйте качество на своих задачах: первыми ломаются числа, JSON и вызовы инструментов.
4.1 Зачем сжимать веса
Веса модели — это миллиарды чисел. В FP16 каждое занимает 2 байта, поэтому 7B-модель весит 14 ГБ, а 70B — 140 ГБ. Для декода важно не только место, но и сколько байт читается на каждый токен: скорость обратно пропорциональна объёму.
Сжатие до Q4_K_M (около 4,8 бита) уменьшает и память, и трафик примерно в 3,3 раза по сравнению с FP16. Именно поэтому 7B в Q4_K_M весит ~4,2 ГБ и может генерировать в разы быстрее, чем та же модель в FP16, — при условии, что качество не пострадало.
4.2 Как устроено блочное квантование
Самая простая схема — аффинное квантование:
w_q = round(w / s) + z
w ≈ s × (w_q − z)
где s — масштаб (scale), z — смещение (zero point). Если хранить один масштаб на всю матрицу, ошибка будет большой: веса имеют разный размах в разных частях матрицы.
Поэтому веса делят на блоки (обычно 32, 64 или 128 чисел), и у каждого блока свой масштаб. Чем меньше блок, тем точнее, но тем больше служебных данных: масштаб тоже надо хранить.
Схема с блоками:
[ 32 веса ][ 32 веса ][ 32 веса ] ...
scale scale scale
При 4 битах на вес и 32 весах в блоке один FP16-масштаб добавляет 16 / 32 = 0,5 бита на вес. Итого ~4,5 бита. Отсюда реальные 4,5–4,9 бита у «4-битных» форматов.
4.3 Форматы GGUF
GGUF — формат файла, придуманный в проекте ggml/llama.cpp. В одном файле лежат:
- тензоры весов (в выбранных типах квантования);
- метаданные: архитектура, число слоёв, размерности, контекст;
- токенизатор;
- шаблон чата (chat template);
- при необходимости — данные для мультимодальности.
Метаданные позволяют рантайму понять модель без отдельных конфигов. Именно поэтому GGUF стал де-факто стандартом для локального инференса.
Основные семейства квантов в llama.cpp:
| Семейство | Идея | Примеры |
|---|---|---|
Q*_0, Q*_1 | раннее простое блочное квантование | Q4_0, Q4_1, Q8_0 |
Q*_K | k-quants: суперблоки и квантованные масштабы | Q4_K_M, Q5_K_M, Q6_K |
IQ* | i-quants: кодовые книги и решётки, часто с imatrix (подробнее в §4.6) | IQ3_XXS, IQ4_XS |
UD-* | динамический выбор типов по тензорам (Unsloth) | UD-Q4_K_M |
K-quants
В k-quants веса группируются в суперблок из 256 значений, внутри — подблоки (у Q4_K — 8 по 32). Масштабы подблоков хранятся в сжатом виде, а не как полные FP16. Это даёт лучшее качество при том же размере, чем простое блочное квантование.
Буква после Q4_K означает режим смешивания:
S(small) — сильнее сжимает, часть тензоров в более низком бите;M(medium) — компромисс: важные тензоры точнее, остальные грубее;L(large) — больше точных тензоров, файл больше.
Поэтому Q4_K_M — не «ровно 4 бита», а смесь: где-то 4, где-то 5–6 бит. Среднее — около 4,8 бита на вес.
Tip
Название кванта читается по частям:
Q4_K_M— «около 4 бит, семейство k-quants, режим medium»;IQ4_XS— «i-quant, около 4 бит, extra small»;UD-спереди — рецепт Unsloth Dynamic поверх обычных типов.
I-quants
IQ-форматы используют кодовые книги (наборы типовых векторов) и решётки. Они лучше сохраняют качество на очень низких битах (2–3), но:
- требуют imatrix для хорошего результата;
- медленнее распаковываются на некоторых бэкендах;
- сильнее зависят от реализации.
Для 4-битного уровня IQ4_XS (около 4,4–4,5 бита) часто оказывается чуть меньше Q4_K_M при сопоставимом качестве, но это надо проверять на своей модели и задачах.
GGUF и другие форматы
GGUF — не единственный способ сжать модель. Краткая карта:
| Формат | Где обычно используется | Особенности |
|---|---|---|
| GGUF | llama.cpp, Ollama, LM Studio | Много квантов, CPU/GPU-гибрид, выгрузка экспертов |
| safetensors | исходные веса, Transformers | Не сжат для инференса; нужен движок и отдельное квантование |
| AWQ / GPTQ | vLLM, TGI, GPU-серверы | Обычно 4-битные веса, калибровка, обычно без CPU-выгрузки |
| EXL2 | ExLlamaV2 | Смешанная точность по слоям, только NVIDIA (CUDA) |
| MLX | Apple Silicon | Использует объединённую память, свои кванты |
| FP8 | Hopper/Ada, vLLM, TensorRT-LLM | Почти без потерь, нужна поддержка железа |
Правило выбора простое: одна карта и нужен CPU-offload — GGUF; сервер на NVIDIA и важна пропускная способность — AWQ/FP8 в vLLM; Mac — MLX или GGUF через Metal.
4.4 Сколько это весит
Приблизительные биты на вес и размеры. Это та самая конвенция, на которую опираются расчёты в главах 2, 3 и 13:
| Формат | Бит/вес | 7B | 13B | 35B | 70B |
|---|---|---|---|---|---|
| FP16 | 16,0 | 14 ГБ | 26 ГБ | 70 ГБ | 140 ГБ |
| Q8_0 | ~8,5 | 7,4 ГБ | 13,8 ГБ | 37 ГБ | 74 ГБ |
| Q6_K | ~6,6 | 5,8 ГБ | 10,7 ГБ | 29 ГБ | 58 ГБ |
| Q5_K_M | ~5,7 | 5,0 ГБ | 9,3 ГБ | 25 ГБ | 50 ГБ |
| Q4_K_M | ~4,8 | 4,2 ГБ | 7,9 ГБ | 21 ГБ | 42 ГБ |
| IQ4_XS | ~4,4–4,5 | 3,9 ГБ | 7,2 ГБ | 19,5 ГБ | 39 ГБ |
| Q4_0 | 4,5 | 3,9 ГБ | 7,3 ГБ | 19,7 ГБ | 39 ГБ |
| IQ3_XXS | ~3,1 | 2,7 ГБ | 5,0 ГБ | 13,6 ГБ | 27 ГБ |
| IQ2_XXS | ~2,1 | 1,8 ГБ | 3,4 ГБ | 9,2 ГБ | 18 ГБ |
Рисунок 4.1. Та же таблица в виде графика: каждая линия — модель, вертикали — форматы, пунктир — объём типовых карт. Видно, например, что 35B в Q4_K_M уже выше линии 16 ГБ, а в IQ3_XXS — ниже. Расчёт по таблице, без KV-кэша и буферов.
Числа округлены и не учитывают KV-кэш, буферы и служебные данные. Точный размер зависит от архитектуры, размера словаря и рецепта кванта; для планирования памяти прибавляйте 10–20%. IQ4_XS в опубликованных замерах llama.cpp даёт ~4,4–4,5 бита на вес (см. tools/quantize/README.md и обсуждение типов), а не 4,25, как иногда пишут в упрощённых таблицах.
4.5 Что теряется при сжатии
Квантование — это шум, добавленный к каждому весу. Модель не «забывает» факты целиком, но её ответы становятся менее уверенными и более чувствительными к формулировке.
Типичная картина:
- Q8_0 — потери почти незаметны на большинстве задач;
- Q6_K — очень близко к оригиналу, разница видна на длинных рассуждениях и редких фактах;
- Q4_K_M — золотая середина: заметно меньше памяти, качество падает умеренно;
- Q3 и ниже — начинаются реальные проблемы: ошибки в числах, путаница в терминах, деградация следования формату;
- 2 бита — годится для экспериментов и очень больших моделей, но не для задач, где важна точность.
Perplexity (перплексия) — экспонента средней отрицательной лог-вероятности правильного токена на тексте. Грубо: насколько модель «удивлена» текстом; чем ниже, тем лучше. Сравнивать перплексию можно только на одном токенизаторе, одном тексте и одинаковой длине контекста.
Важно: perplexity — не единственная метрика. Модель может сохранить низкую perplexity, но начать хуже следовать JSON-схеме или путать единицы измерения. Для агентских задач проверяйте именно их (глава 12).
4.6 Imatrix: важность весов
Не все веса одинаково важны. Некоторые сильнее влияют на активации при типичных входах. Идея importance matrix (imatrix): прогнать через модель калибровочный текст, собрать статистику активаций и квантовать веса с учётом их вклада.
Практически это означает:
- при квантовании в
IQ-форматы imatrix почти обязательна; - для
Q4_K_Mона тоже помогает, особенно на маленьких моделях и редких языках; - калибровочный текст должен быть похож на ваши данные: русский технический текст даст лучший результат для русских технических задач, чем английская википедия.
В llama.cpp imatrix собирается отдельной утилитой и передаётся при квантовании. Это лишний шаг, но он заметно улучшает низкие биты.
4.7 «UD» и динамические кванты
UD (Unsloth Dynamic) — не отдельный формат, а рецепт выбора типов для каждого тензора. Авторы кванта измеряют чувствительность слоёв и оставляют важные части в более высоком бите, а менее важные сжимают сильнее.
Это может дать лучший баланс, чем равномерный Q4_K_M, но:
- качество заявлено авторами кванта, а не независимо проверено;
- рецепт меняется от версии к версии;
- на вашей задаче результат может отличаться.
Относитесь к UD как к ещё одному кандидату, который надо прогнать на своём наборе проверок.
4.8 Как выбирать квант
Практический порядок:
- Посчитайте бюджет памяти. Веса + KV + буферы + запас 1,5–2 ГБ.
- Начните с
Q4_K_M. Это лучший универсальный компромисс. - Если память позволяет — поднимитесь до
Q5_K_MилиQ6_K. Для моделей до 13B это часто приемлемо. - Если не влезает — попробуйте
IQ4_XS. Он меньше при близком качестве. - Ниже 4 бит — только с проверкой на ваших задачах. Особенно если важны числа, единицы, JSON и вызов инструментов.
- KV-кэш квантуйте отдельно (
q8_0— безопасно,q4— рискованно). Это не то же самое, что квантование весов; подробнее — в главе 6.
Посчитай сам. Модель 13B [пример], карта 12 ГБ. KV-кэш на нужный контекст — 1 ГБ, буферы — 0,75 ГБ, запас — 1,5 ГБ. Какой самый «толстый» квант из таблицы §4.4 поместится, если к размеру весов прибавлять 10% на неточность таблицы?
Решение
бюджет на веса: 12 − 1 − 0,75 − 1,5 = 8,75 ГБ
Q6_K: 10,7 × 1,1 ≈ 11,8 ГБ — нет
Q5_K_M: 9,3 × 1,1 ≈ 10,2 ГБ — нет
Q4_K_M: 7,9 × 1,1 ≈ 8,7 ГБ — да, впритык
Ответ — Q4_K_M. Если хочется запаса побольше или контекста подлиннее, следующий кандидат — IQ4_XS (7,2 × 1,1 ≈ 7,9 ГБ).
Warning
Не сравнивайте кванты по одной perplexity и по чужим отзывам. Модель в Q3 может писать гладкий текст и при этом путать числа в таблице или ломать JSON. Прогоните 20–50 своих типовых задач (глава 12) — это единственная проверка, которая относится к вам.
4.9 Квантование не бесплатно
Сжатие экономит память, но добавляет работу:
- веса нужно распаковать перед умножением;
- не все форматы одинаково быстры на CPU, CUDA и Metal;
- на некоторых бэкендах
IQ-форматы медленнееQ4_K; - смешанные типы усложняют оптимизацию.
Поэтому «самый маленький квант» не всегда самый быстрый. На практике Q4_K_M часто оказывается оптимумом и по скорости, и по качеству.
Ключевые идеи
- Квантование уменьшает и память, и трафик; для декода второе важнее.
- GGUF — контейнер: веса, метаданные, токенизатор, шаблон чата.
Q4_K_M— смесь типов, а не ровно 4 бита; среднее около 4,8 бита на вес.IQ-форматы хороши на низких битах, но требуют imatrix и проверки скорости.- Imatrix учитывает важность весов и особенно полезна для низких битов и неанглийских данных.
- Ниже 4 бит качество надо проверять на своей задаче, а не по одной perplexity.
Проверь себя
- Почему «4-битный» файл весит не ровно половину от 8-битного?
- Что означает
MвQ4_K_M? - Зачем нужна imatrix и почему калибровочный текст должен быть релевантным?
- Модель 35B в Q4_K_M занимает ~21 ГБ. Сколько примерно будет весить та же модель в Q6_K и Q8_0?
- Почему низкий квант может ухудшить вызов инструментов сильнее, чем обычный текст?
Ответы
- Кроме самих весов хранятся масштабы блоков, а у k-quants — ещё и сжатые масштабы суперблоков. Поэтому реальные 4,8 бита, а не 4,0; к тому же разные тензоры квантуются по-разному.
- Medium: смешанный режим, в котором важные тензоры (например, часть attention и выходные) квантуются точнее, а остальные — грубее. Это компромисс между размером и качеством.
- Imatrix содержит статистику важности весов по активациям на калибровочном тексте. Если текст не похож на ваши данные, статистика будет нерелевантной, и низкие биты пострадают именно на вашем домене.
- Q6_K — около 29 ГБ, Q8_0 — около 37 ГБ. Это уже не помещается в 16 ГБ и требует выгрузки или другой карты.
- Структурированный вывод требует точного следования формату и редким токенам (скобки, кавычки, имена полей). Квантование сильнее искажает именно редкие и «хрупкие» части распределения, поэтому JSON и вызовы инструментов ломаются раньше, чем свободный текст.
Источники главы
- Frantar et al., «GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers» (2022) — arXiv:2210.17323. Пост-тренировочное квантование с компенсацией ошибки.
- Lin et al., «AWQ: Activation-aware Weight Quantization» (2023) — arXiv:2306.00978. Идея защиты важных каналов по активациям.
- Xiao et al., «SmoothQuant» (2022) — arXiv:2211.10438. Перенос сложности квантования с активаций на веса.
- Dettmers et al., «LLM.int8()» (2022) — arXiv:2208.07339. 8-битное матричное умножение с обработкой выбросов.
- Dettmers & Zettlemoyer, «The case for 4-bit precision» (2022) — arXiv:2212.09720. Эмпирика: 4 бита часто достаточно, ниже — уже нет.
- llama.cpp PR #1684, «k-quants» — GitHub. Исходное обсуждение форматов k-quants.
- llama.cpp PR #4861, «Importance Matrix calculation» — GitHub. Как собирается imatrix.
- llama.cpp,
tools/quantize/README.md— GitHub. Практика квантования и флаги. - llama.cpp Discussion #5063, «Even more quantization types?» — GitHub. Эволюция типов и компромиссы.
- Unsloth, «Unsloth Dynamic GGUFs» — docs.unsloth.ai. Описание динамических квантов; заявления авторов.
- Hugging Face, «Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA» — блог. Доступное введение в 4-битное квантование.
5. MoE: эксперты, роутинг и выгрузка в ОЗУ
Зачем эта глава. MoE (mixture of experts) — причина, по которой модель на 35 млрд параметров может работать быстрее, чем плотная 13B, и при этом занимать память как 35B. Это же — главный механизм, позволяющий запускать большие модели на домашней видеокарте.
За 30 секунд
- В MoE вместо одного большого FFN — много маленьких «экспертов», и роутер выбирает для каждого токена лишь несколько.
- Память определяется всеми параметрами, скорость — только активными:
35B-A3Bхранится как 35B, а генерирует почти как 3B.- Экспертов можно выгрузить в ОЗУ и считать на CPU: по PCIe тогда ходят только активации.
- Батчинг и спекулятивное декодирование расширяют набор активных экспертов и съедают часть выигрыша.
5.1 Идея: не все веса нужны каждому токену
В плотной модели каждый токен проходит через все веса FFN. В MoE FFN заменён на набор экспертов — небольших независимых FFN — и роутер (router), который для каждого токена выбирает несколько экспертов.
flowchart LR
X["вектор токена<br/>после attention"] --> R{"Роутер:<br/>логиты по экспертам,<br/>выбор top-k"}
R -->|"вес 0,6"| E3["Эксперт 3"]
R -->|"вес 0,4"| E7["Эксперт 7"]
R -.-x|"не выбран"| E1["Эксперт 1"]
R -.-x|"не выбран"| EN["…эксперт N"]
X --> S["Общий эксперт<br/>(shared, если есть)"]
E3 --> SUM(("Σ"))
E7 --> SUM
S --> SUM
SUM --> Y["выход слоя"]
На схеме top-k = 2: работают только эксперты 3 и 7 (плюс общий, если он есть в архитектуре), их выходы складываются с весами роутера. Остальные эксперты для этого токена не читаются из памяти и не считаются.
Остальные эксперты для этого токена не вычисляются. Отсюда два разных числа:
- всего параметров — сколько нужно хранить в памяти;
- активных параметров — сколько читается и считается на один токен.
Модель с обозначением 35B-A3B имеет около 35 млрд параметров всего и около 3 млрд активных на токен. По скорости она ближе к плотной 3B, по «знаниям» — к 35B.
5.2 Как устроен роутер
Для каждого токена роутер выдаёт логиты по числу экспертов, затем:
- выбирает
top-kэкспертов (обычно 2, 4 или 8); - нормирует их веса через softmax;
- смешивает выходы выбранных экспертов.
В современных моделях часто есть shared experts — эксперты, которые работают для всех токенов и не выбираются роутером. Они берут на себя общие знания, а маршрутизируемые эксперты специализируются.
Проблема обучения — балансировка нагрузки: без специального лосса роутер может «полюбить» несколько экспертов, а остальные будут простаивать. Поэтому в обучении добавляют auxiliary loss или используют bias-коррекцию. Для инференса важно, что распределение экспертов по токенам неравномерно: какие-то эксперты «горячие», какие-то почти не используются.
5.3 Сколько весит эксперт
Числа в этом разделе вымышлены для арифметики. Реальные конфиги отличаются: например, у моделей класса 30B-A3B бывает 48 слоёв и 128 экспертов, а 256 экспертов — примета гораздо более крупных MoE. Возьмём для примера 35B-модель, 40 слоёв, 256 экспертов в слое, 8 активных плюс общий. Грубая раскладка:
- attention, эмбеддинги и общие части — несколько миллиардов параметров;
- маршрутизируемые эксперты — основная масса, например ~30 млрд;
- на слой приходится
30 / 40 ≈ 0,75млрд параметров экспертов; - на одного эксперта —
0,75 / 256 ≈ 3млн параметров.
В Q4_K_M (около 4,8 бита) слой экспертов весит примерно 0,75 × 0,6 ≈ 0,45 ГБ. Это удобная единица для тюнинга: выгружая экспертов одного слоя в ОЗУ, вы освобождаете около 0,4–0,5 ГБ VRAM.
5.4 Почему MoE выгоден для локального инференса
Сравним две гипотетические модели (пример):
| Плотная 13B | MoE 35B-A3B | |
|---|---|---|
| Вес в Q4_K_M | ~7,9 ГБ | ~21 ГБ |
| Активных параметров | 13B | ~3B |
| Читается на токен | ~7,9 ГБ | ~1,8 ГБ |
| Потолок декода при 500 ГБ/с | ~63 ток/с | ~280 ток/с |
Плотная модель читает все 13B на каждый токен. MoE читает только активных экспертов, поэтому может быть в разы быстрее при большем объёме «знаний». Плата — память: все эксперты должны где-то лежать, даже если не используются.
Именно это делает возможной схему «горячее на GPU, холодное в ОЗУ»: на токен нужна малая часть экспертов, и не все они обязаны быть в видеопамяти.
5.5 Выгрузка экспертов в ОЗУ
В llama.cpp есть несколько флагов:
| Флаг | Что делает |
|---|---|
--n-cpu-moe N (-ncmoe) | экспертные FFN первых N слоёв оставить на CPU |
--cpu-moe | все эксперты на CPU |
--moe-cache-mib N | кэш «горячих» экспертов в VRAM для тех, что остались на CPU |
-ot "\.ffn_.*_exps\.weight=CPU" | точечная выгрузка экспертов по шаблону тензоров (имена зависят от архитектуры — проверьте в своей модели) |
Семантика --n-cpu-moe в разных версиях и гайдах может отличаться («первые N» или «с конца»), поэтому её надо проверять эмпирически на своей сборке.
Схема работы:
- attention, роутер, shared experts и эмбеддинги остаются на GPU;
- выбранные слои экспертов лежат в ОЗУ и считаются на CPU;
- по PCIe передаются только активации — маленькие векторы, а не матрицы весов.
Это принципиально лучше, чем «держать веса в ОЗУ и перегонять их на GPU»: передача 0,45 ГБ на слой по PCIe была бы катастрофой, а вычисление на CPU идёт на скорости ОЗУ.
Warning
Флаги выгрузки в llama.cpp развиваются быстро, а имена тензоров экспертов зависят от архитектуры. Перед тюнингом сверяйтесь с
--helpсвоей сборки и списком тензоров модели, а не с чужой командой из форума.
5.6 Арифметика выгрузки
Пусть модель читает на токен 3B активных параметров в Q4_K_M — около 1,8 ГБ. Половина экспертов выгружена.
VRAM: 0,9 ГБ / 500 ГБ/с = 1,8 мс
ОЗУ: 0,9 ГБ / 50 ГБ/с = 18 мс
итого: ~20 мс → потолок ~50 ток/с
Если выгрузить 70% экспертов:
0,54 / 500 + 1,26 / 50 ≈ 1,1 + 25,2 = 26 мс → ~38 ток/с
Это объясняет, почему выгрузка «ещё пары слоёв» может стоить заметной скорости, а не копеек. И почему для MoE выгодно держать в VRAM как можно больше экспертов — но не ценой выхода за объём карты, иначе включится тихий fallback (глава 3).
Посчитай сам. MoE-модель [пример]: 100B параметров всего, из них 90B — маршрутизируемые эксперты в 60 слоях, остальные 10B — attention, эмбеддинги и общие части. Квант Q4_K_M (0,6 байта на параметр), карта 24 ГБ, KV-кэш и буферы — 2 ГБ, запас — 2 ГБ. Сколько слоёв экспертов поместится в VRAM и какое значение --n-cpu-moe взять для начала?
Решение
общие части на GPU: 10 млрд × 0,6 = 6 ГБ
один слой экспертов: 90 млрд / 60 × 0,6 = 0,9 ГБ
бюджет на экспертов: 24 − 6 − 2 − 2 = 14 ГБ
слоёв в VRAM: 14 / 0,9 ≈ 15
В VRAM помещается около 15 слоёв экспертов из 60, значит начинать стоит с --n-cpu-moe 45 и дальше подбирать по пику VRAM (§5.10). Семантику «какие именно N слоёв» проверьте в своей сборке.
5.7 Кэш горячих экспертов
Если одни эксперты используются часто, их можно держать в VRAM даже при выгрузке остальных. --moe-cache-mib N выделяет под это N мегабайт.
Помогает, когда:
- распределение экспертов стабильно;
- активный набор маленький;
- кэш достаточно велик, чтобы накрыть горячую часть.
Не помогает или вредит, когда:
- на каждом шаге активируется много разных экспертов (например, при спекулятивном декодировании, где за один шаг проверяется несколько токенов);
- кэш отнимает VRAM у основной модели;
- распределение зависит от домена и меняется.
Это один из флагов, которые надо проверять на реальном трафике, а не на синтетике. Отдельно про то, почему спекулятивное декодирование может сломать кэш, — в главе 9, §9.7.
5.8 MoE и батчинг
Чем больше токенов в батче, тем больше разных экспертов активируется, и при достаточно большом батче в работу вовлекается почти весь слой. Из-за этого prefill большим батчем у MoE может быть менее выгодным, чем у плотной модели, а параллельные слоты увеличивают нагрузку на экспертов. Подробнее про батчинг и PagedAttention — в главе 8.
5.9 Качество и риски
MoE — не бесплатный обмен «память на скорость». Есть нюансы:
- Специализация экспертов может быть неравномерной; на редком домене модель проваливается сильнее, чем плотная.
- Квантование затрагивает всех экспертов; редкие эксперты могут пострадать заметнее.
- Выгрузка добавляет задержку и делает поведение менее предсказуемым.
- Память нужна под всех экспертов, даже «холодных».
Поэтому MoE-модель стоит проверять на своих задачах так же, как любую другую, а не только по заявленным бенчмаркам.
5.10 Практический порядок настройки
- Запустите модель с
-nglна все слои и без выгрузки экспертов — если помещается. (-ngl N— сколько слоёв держать на GPU.) - Если не помещается, увеличивайте
--n-cpu-moeпо одному слою, пока пик VRAM не опустится до «объём карты минус 1,5–2 ГБ» (правило запаса — в главе 3). - Проверьте скорость на реальной задаче, а не только на пустом промпте.
- Если есть запас VRAM, попробуйте
--moe-cache-mibи сравните на своём трафике. - Уменьшайте выгрузку, пока хватает памяти: каждый слой в VRAM обычно ускоряет декод.
- Не включайте одновременно спекулятивное декодирование и большой кэш экспертов, не измерив эффект: рабочий набор экспертов растёт.
Ключевые идеи
- MoE хранит всех экспертов, но на токен активирует нескольких.
- Скорость определяется активными параметрами, память — всеми.
- Выгрузка экспертов в ОЗУ работает, потому что по PCIe идут активации, а вычисления — на CPU.
- Единица тюнинга — один слой экспертов:
параметры экспертов ÷ число слоёв × байт на вес(в примере главы — около 0,45 ГБ). - Батчинг и спекуляция увеличивают рабочий набор экспертов и снижают выгоду разреженности.
Проверь себя
- Чем «35B-A3B» отличается от плотной 3B-модели?
- Почему выгрузка экспертов в ОЗУ не убивает скорость так, как выгрузка плотной модели?
- Модель активирует 3B параметров в Q4_K_M, из них 40% выгружено в ОЗУ. Оцените потолок декода при 600 ГБ/с VRAM и 60 ГБ/с ОЗУ.
- Почему
--moe-cache-mibможет перестать помогать при спекулятивном декодировании? - Что произойдёт с преимуществом MoE при батче в тысячи токенов?
Ответы
- Плотная 3B читает все 3B параметров на токен и хранит только их. MoE 35B-A3B хранит 35B, но читает около 3B активных; знаний больше, памяти тоже больше, скорость сопоставима.
- Плотную модель нельзя «посчитать на CPU» так же выгодно: на токен нужны все веса, и если они в ОЗУ, чтение упирается в 40–100 ГБ/с. У MoE в ОЗУ лежит только часть, и на токен читается малая доля. Плюс по PCIe не гоняются матрицы.
- Активные 3B в Q4_K_M — около 1,8 ГБ. 60% в VRAM:
1,08 / 600 ≈ 1,8 мс; 40% в ОЗУ:0,72 / 60 = 12 мс; итого ~14 мс, потолок ~70 ток/с. - За один шаг верификации проверяется несколько токенов, и они могут активировать больше разных экспертов. Рабочий набор растёт, фиксированный кэш перестаёт в него попадать.
- При большом батче активируется много разных экспертов, и за один проход в работу вовлекается почти весь слой. Преимущество разреженности уменьшается, а стоимость памяти остаётся.
Источники главы
- Fedus, Zoph, Shazeer, «Switch Transformers» (2021) — arXiv:2101.03961. Простейший MoE с top-1 роутингом и проблемы балансировки.
- Jiang et al., «Mixtral of Experts» (2024) — arXiv:2401.04088. Популярная MoE-модель и её поведение.
- Dai et al., «DeepSeekMoE» (2024) — arXiv:2401.06066. Fine-grained эксперты и shared experts.
- Hugging Face, «Mixture of Experts Explained» — блог. Доступное введение с картинками.
- llama.cpp,
tools/server/README.md— GitHub. Флаги--n-cpu-moe,--cpu-moe,--moe-cache-mib. - Hugging Face, «Performant local mixture-of-experts CPU inference with GPU acceleration in llama.cpp» — блог. Практическая схема выгрузки экспертов.
- DeepSeek-AI, «DeepSeek-V3 Technical Report» (2024) — arXiv:2412.19437. Пример большой MoE с shared experts и MTP.
6. KV-кэш, контекстное окно и позиционные кодировки
Зачем эта глава. Контекст — самая дорогая часть локального инференса после весов. Модель, которая «помещается» на карту с контекстом 8k, может не поместиться с 64k. А скорость на длинном контексте падает даже у моделей, которые формально его поддерживают.
За 30 секунд
- KV-кэш хранит K и V всех прошлых токенов, чтобы не пересчитывать историю; он растёт линейно с контекстом и с числом слотов.
- Размер:
2 × слои × KV-головы × d_head × контекст × байт. Посчитать его можно за минуту по конфигу модели.- Экономят память GQA, MLA, гибридное и скользящее внимание, а также квантование кэша (
q8_0— безопасный дефолт).- «Поддерживает 128k» не значит «одинаково хорошо работает на 128k» — проверяйте на своих задачах.
6.1 Зачем нужен KV-кэш
На каждом шаге attention токен сравнивает свой Query с Key всех предыдущих токенов и смешивает их Value. Если бы K и V пересчитывались заново, на каждом шаге пришлось бы снова прогонять через все слои всю историю: генерация n токенов стоила бы порядка n² токен-проходов вместо n.
Поэтому K и V сохраняют. Для каждого слоя и каждого обработанного токена в памяти лежат два вектора. Это и есть KV-кэш (KV cache). При генерации нового токена:
- считаются его Q, K, V;
- K и V дописываются в кэш;
- attention использует весь кэш.
Пересчитывается только новый токен, а не вся история. Именно поэтому генерация вообще возможна.
6.2 Формула размера
Для обычного (не MLA) attention:
KV-байт = 2 × L_full × n_kv_heads × d_head × ctx × bytes_per_element
Где:
2— K и V;L_full— число слоёв с полным attention;n_kv_heads— число KV-голов (при GQA их меньше, чем Q-голов);d_head— размерность одной головы;ctx— длина контекста в токенах;bytes_per_element— 2 для FP16, около 1,06 для q8_0, около 0,56 для q4_0.
Пример 1: плотная 8B-модель
32 слоя, 8 KV-голов, d_head = 128, FP16:
2 × 32 × 8 × 128 × 2 = 131 072 байт = 128 КиБ на токен
| Контекст | KV в FP16 | KV в q8_0 |
|---|---|---|
| 8k | 1 ГиБ | 0,5 ГиБ |
| 32k | 4 ГиБ | 2,1 ГиБ |
| 128k | 16 ГиБ | 8,5 ГиБ |
Даже у 8B-модели контекст 128k съедает больше памяти, чем веса в Q4.
Пример 2: плотная 70B-модель
80 слоёв, 8 KV-голов, d_head = 128, FP16:
2 × 80 × 8 × 128 × 2 = 327 680 байт = 320 КиБ на токен
| Контекст | KV в FP16 | KV в q8_0 |
|---|---|---|
| 8k | 2,5 ГиБ | 1,3 ГиБ |
| 32k | 10 ГиБ | 5,3 ГиБ |
| 128k | 40 ГиБ | 21 ГиБ |
Вот почему длинный контекст на большой модели — это отдельная проблема, даже если веса помещаются.
Рисунок 6.1. KV-кэш условной 8B-модели (32 слоя, d_head = 128) на один слот. Каждая ступень экономии — GQA (32 → 8 KV-голов), гибридная архитектура (полное внимание только в 8 слоях из 32), квантование кэша в q8_0 — сдвигает линию вниз в несколько раз, но наклон остаётся прежним: кэш всё равно растёт линейно. Расчёт по формуле §6.2.
Tip
Нужные числа лежат в
config.jsonмодели на Hugging Face или в метаданных GGUF:num_hidden_layers,num_key_value_heads,head_dim(если его нет —hidden_size / num_attention_heads). У гибридных моделей ищите список типов слоёв, чтобы узнатьL_full.
6.3 GQA и MQA: меньше KV-голов
В классическом multi-head attention у каждой Q-головы свои K и V. Это дорого. Есть два способа сэкономить:
- MQA (multi-query attention): одна KV-голова на все Q-головы. KV-кэш уменьшается в
n_headsраз, но качество может страдать. - GQA (grouped-query attention): несколько Q-голов делят одну KV-голову. Компромисс: например, 32 Q-головы и 8 KV-голов дают кэш в 4 раза меньше.
В формуле используется именно n_kv_heads, а не число Q-голов. Поэтому при планировании памяти смотрите в конфиг модели: num_key_value_heads, num_attention_heads, head_dim.
6.4 MLA: сжатие в латент
В DeepSeek-V2 придумали MLA (multi-head latent attention): K и V не хранятся в явном виде, а сжимаются в латентный вектор меньшей размерности — «латент» здесь означает скрытое представление, из которого восстанавливаются нужные проекции. На инференсе они разворачиваются.
Это описание упрощённое: в оригинале часть проекций «поглощается» матрицами внимания, и выигрыш зависит от того, насколько хорошо рантайм реализовал этот путь. Не все сборки поддерживают MLA одинаково; проверяйте, что ваша версия действительно использует оптимизированный вариант, а не разворачивает всё в обычный KV-кэш.
6.5 Гибридное и линейное внимание
Классический attention хранит кэш, который растёт линейно с длиной. Линейное внимание (linear attention) заменяет его фиксированным по размеру состоянием: при генерации оно обновляется, но не растёт с контекстом.
Семейства:
- Linear attention (Katharopoulos et al.) — аппроксимация softmax-attention через ядро;
- Mamba / SSM — рекуррентные модели с выборочными состояниями;
- Gated DeltaNet — гибрид дельта-правила и гейтирования, используется в современных гибридных моделях.
Многие новые модели строят гибрид: часть слоёв — полный attention, часть — линейный. Например, 40 слоёв, из них 10 с полным attention и 30 с линейным. Тогда KV-кэш считается только по 10 слоям:
KV ≈ 2 × 10 × n_kv_heads × d_head × ctx × bytes
Это может уменьшить память под контекст в 4 раза и больше. Но есть оговорки:
- линейное состояние тоже занимает память — фиксированную, не зависящую от длины;
- качество на очень длинном контексте зависит от архитектуры и обучения;
- не все рантаймы одинаково оптимизируют такие слои.
Посчитай сам. Гибридная модель [пример]: 40 слоёв, из них 10 с полным вниманием, 4 KV-головы, d_head = 256. Сколько займёт KV-кэш на 64k токенов в q8_0 — и сколько занял бы, будь все 40 слоёв полными?
Решение
на токен: 2 × 10 × 4 × 256 × 1,0625 байта = 21 760 байт ≈ 21,25 КиБ
на 64k: 65 536 × 21,25 КиБ ≈ 1,33 ГиБ
все 40 слоёв полные: в 4 раза больше ≈ 5,3 ГиБ
Гибрид экономит 4 ГиБ на одном слоте. При четырёх слотах (глава 8) разница — уже 16 ГиБ.
6.6 Скользящее окно
Ещё один способ ограничить KV — sliding window attention: каждый токен видит только последние W токенов. Тогда кэш не превышает W на слой. Модели вроде Mistral используют окно 4096, некоторые — 1024.
Плюсы: память ограничена, внимание дешевле. Минусы: информация за пределами окна теряется, если только модель не чередует слои с полным attention.
При планировании памяти смотрите, есть ли у модели sliding window и чередуются ли слои. Это может радикально изменить оценку.
6.7 Позиционные кодировки: RoPE и расширение контекста
Модель должна знать порядок токенов. Современные модели чаще всего используют RoPE (rotary position embedding). Интуиция: пары чисел в векторе Q и K можно рассматривать как точки на плоскости, и для каждой позиции они поворачиваются на свой угол. Скалярное произведение двух повёрнутых векторов зависит от разности углов, то есть от относительной позиции, а не от абсолютной. Это удобно: модель учится «на расстоянии», а не «на номере места».
Проблема: модель обучалась на одной длине (например, 8k), а вы хотите подать 32k. Позиции за пределами обученного диапазона дают распределение, которого модель не видела.
Способы расширения:
- Position Interpolation (PI) — сжать все позиции в обученный диапазон, как будто текст стал «плотнее»;
- NTK-aware scaling — изменить частоты RoPE нелинейно: медленные частоты растянуть сильнее, быстрые — слабее;
- YaRN — комбинация масштабирования частот и коррекции attention (в том числе «температуры»), обычно с дообучением на длинных данных;
- ALiBi — альтернатива RoPE, линейный штраф за расстояние; реже используется в новых моделях.
Расширение контекста — не бесплатно: качество на длинных последовательностях может падать, а скорость prefill — расти. «Поддерживает 128k» в карточке часто означает «обучено с YaRN до 128k», а не «одинаково хорошо на всех 128k».
6.8 Квантование KV-кэша
KV-кэш можно хранить в меньшей точности:
- FP16 — эталон;
- q8_0 — примерно вдвое меньше, качество обычно не страдает;
- q4_0 / q4_1 — в 3–4 раза меньше, но риск деградации выше, особенно для tool calling и структурированного вывода.
В llama.cpp это флаги -ctk и -ctv. Практика: q8_0 — безопасный дефолт; q4 — только если памяти реально не хватает и вы проверили качество.
Отдельно: квантование KV не то же самое, что квантование весов. Веса сжимаются один раз в файле, KV — динамически во время работы.
Warning
Квантованный KV-кэш не ломается громко. Симптомы тихие: модель чаще ошибается в длинных JSON, путает поля, пропускает закрывающие скобки. Если включили
q4для кэша, перепроверьте вызов инструментов на своём наборе (глава 12).
6.9 Сжатие KV: вытеснение, окна, квантование
Исследования предлагают разные стратегии:
- H2O — хранить только «тяжёлые» токены (heavy hitters), которые чаще получают внимание;
- StreamingLLM — держать несколько первых токенов (attention sinks) и скользящее окно последних;
- KIVI — асимметричное 2-битное квантование KV;
- SnapKV — выбирать важные позиции по наблюдению за attention.
В локальных рантаймах эти методы пока применяются ограниченно: они меняют поведение модели и требуют проверки. Но понимать их полезно: именно там ищут следующий большой выигрыш по памяти.
6.10 Практические правила
- Считайте KV до покупки железа. Формула выше и конфиг модели дают ответ за минуту.
- Начинайте с контекста, который нужен задаче, а не с максимума модели. 32k часто достаточно; 128k — отдельный проект.
- Квантуйте KV в q8_0, если не хватает памяти; q4 — только с проверкой.
- Следите за числом слотов. Каждый параллельный слот — свой KV-кэш.
- Проверяйте скорость на глубине контекста, а не на пустом промпте: attention дорожает с длиной.
- Не путайте «поддерживает» и «эффективно использует»: тест на иголку в стоге сена и реальные задачи важнее числа в карточке.
Ключевые идеи
- KV-кэш хранит K и V прошлых токенов; без него генерация была бы квадратично дорогой.
- Размер KV =
2 × слои × KV-головы × d_head × контекст × байт. - GQA/MQA уменьшают число KV-голов; MLA сжимает кэш в латент; линейное внимание заменяет его фиксированным состоянием.
- KV можно квантовать, но q4 рискован для структурированного вывода.
- Длинный контекст стоит памяти, времени prefill и качества; расширение через RoPE/YaRN — компромисс.
Проверь себя
- Почему KV-кэш растёт линейно с контекстом, а вычисление attention на каждом шаге — тоже линейно, хотя наивный пересчёт был бы квадратичным?
- У модели 48 слоёв, 8 KV-голов,
d_head = 128, FP16. Сколько KV на 16k токенов? - Как GQA влияет на размер кэша и почему это не бесплатно?
- Зачем нужны attention sinks в StreamingLLM?
- Модель заявляет 128k контекста. Почему не стоит сразу ставить
-c 131072?
Ответы
- Кэш хранит по вектору на токен, поэтому его размер линеен по длине. На каждом новом токене attention сравнивает его со всеми предыдущими — это линейно по длине, а не квадратично. Квадратичной была бы полная пересборка всех пар на каждом шаге.
2 × 48 × 8 × 128 × 2 = 196 608байт = 192 КиБ на токен;16 384 × 192 КиБ = 3 ГиБ.- GQA уменьшает число KV-голов, поэтому кэш меньше в
n_heads / n_kv_headsраз. Но меньшее число KV-голов ограничивает разнообразие представлений; качество может немного снизиться, особенно на задачах, требующих точного сопоставления. - Первые токены часто получают непропорционально большое внимание и служат «стоком» для softmax. Если их выбросить, распределение attention ломается. Поэтому их сохраняют вместе со скользящим окном.
- Потому что память под KV может не поместиться, prefill станет очень долгим, а качество на длинных позициях — не гарантированным. Нужно измерить реальную задачу и проверить запас VRAM.
Источники главы
- Su et al., «RoFormer: Enhanced Transformer with Rotary Position Embedding» (2021) — arXiv:2104.09864. Первоисточник RoPE.
- Peng et al., «YaRN: Efficient Context Window Extension of Large Language Models» (2023) — arXiv:2309.00071. Расширение контекста через масштабирование частот.
- Chen et al., «Extending Context Window via Positional Interpolation» (2023) — arXiv:2306.15595. Простое сжатие позиций.
- Ainslie et al., «GQA: Training Generalized Multi-Query Transformer Models» (2023) — arXiv:2305.13245. Групповые KV-головы.
- Shazeer, «Fast Transformer Decoding: One Write-Head is All You Need» (2019) — arXiv:1911.02150. MQA.
- DeepSeek-AI, «DeepSeek-V2» (2024) — arXiv:2405.04434. MLA и сжатие KV.
- Yang, Kautz, Hatamizadeh, «Gated Delta Networks» (2024) — arXiv:2412.06464. Гибридное линейное внимание.
- Katharopoulos et al., «Transformers are RNNs» (2020) — arXiv:2006.16236. Линейное внимание.
- Gu, Dao, «Mamba» (2023) — arXiv:2312.00752. State-space модели.
- Zhang et al., «H2O» (2023) — arXiv:2306.14048. Вытеснение неважных токенов из KV.
- Xiao et al., «Efficient Streaming Language Models with Attention Sinks» (2023) — arXiv:2309.17453. StreamingLLM.
- Liu et al., «KIVI» (2024) — arXiv:2402.02750. 2-битное квантование KV.
- Li et al., «SnapKV» (2024) — arXiv:2404.14469. Выбор важных позиций.
- Li et al., «A Survey on KV Cache Management» (2024) — arXiv:2412.19442. Обзор методов.
- llama.cpp,
tools/server/README.md— GitHub. Флаги-c,-np,-ctk/-ctv,--swa-full.
7. Кэш промпта и агентские нагрузки
Зачем эта глава. Агент, который вызывает инструменты, делает десятки запросов подряд. Каждый следующий запрос — это почти тот же промпт плюс небольшой хвост. Если это не использовать, вы будете платить за обработку одного и того же текста снова и снова. Кэш промпта превращает prefill из главной статьи расходов в почти бесплатную операцию.
За 30 секунд
- Агент шлёт почти один и тот же промпт много раз подряд; кэш промпта сохраняет KV общего начала и считает prefill только для нового хвоста.
- Совпадение проверяется по токенам с самого начала: одно изменение в начале — и всё после него считается заново.
- Отсюда правило: стабильное — в начало, изменчивое — в конец.
- Кэш ускоряет prefill, но не декод; в агентских нагрузках после включения кэша узким местом становится генерация.
7.1 Как выглядит агентский запрос
Типичный шаг агента:
[ системный промпт ]
[ описания инструментов ]
[ история диалога: 20 предыдущих шагов ]
[ результат последнего инструмента ]
[ инструкция: что делать дальше ]
Следующий шаг — это тот же текст плюс ответ модели и новый результат инструмента. Общий префикс может составлять 95–99% запроса.
Если сервер каждый раз обрабатывает весь промпт, он делает одну и ту же работу заново. Кэш промпта (prompt cache, prefix cache) сохраняет KV-кэш для общего начала и переиспользует его.
7.2 Как это работает
Сервер хранит KV-кэш обработанных токенов. При новом запросе он ищет наибольший общий префикс (longest common prefix, LCP) с тем, что уже есть в кэше. Совпавшая часть берётся готовой, а prefill считается только для хвоста.
запрос: A B C D E F G
кэш: A B C D E
итог: [A B C D E] — из кэша, [F G] — prefill
Выигрыш огромен. Пример: промпт 20 000 токенов, новый хвост 500 токенов, скорость prefill 1000 ток/с.
| Сценарий | Обработано токенов | Время prefill |
|---|---|---|
| Без кэша | 20 000 | 20 с |
| С кэшем | 500 | 0,5 с |
Это разница между «агент думает полминуты на каждый шаг» и «агент отвечает почти сразу».
7.3 Главное правило: стабильный префикс
Кэш работает по точному совпадению токенов. Если изменить один токен в начале, всё, что после него, перестаёт совпадать.
Warning
Самая частая ловушка — «Сегодня 7 ноября, 14:32» в первой строке системного промпта. Строка меняется на каждом запросе, и кэш не срабатывает ни разу, хотя формально включён. Дату и время передавайте в конце, рядом с вопросом.
Плохие привычки, которые убивают кэш:
- дата, время или счётчик в начале системного промпта;
- случайный порядок описаний инструментов;
- перестановка истории или сжатие середины диалога;
- добавление уникального идентификатора запроса в системную часть;
- разные пробелы и переводы строк при каждом запросе.
Хорошая структура:
[ стабильный системный промпт ]
[ стабильные описания инструментов ]
[ растущая история ]
[ новый хвост ]
Всё изменчивое — в конец. Это одновременно улучшает кэш и упрощает отладку.
7.4 Кэш и слоты
В llama.cpp у каждого слота (-np) свой контекст и свой кэш. Когда приходит запрос, сервер выбирает слот по наибольшему совпадению префикса. Поэтому:
- один слот с длинной историей лучше, чем четыре слота с короткой, если запросы идут последовательно;
- каждый слот добавляет ещё один KV-объём:
Nслотов — примерно вNраз больше памяти под KV, а не «чуть больше»; при последовательных запросах лишние слоты не помогают; - при параллельных запросах с общим началом кэш может переиспользоваться между слотами, если реализация это поддерживает.
Флаг --cache-prompt включает кэш (в актуальных сборках он включён по умолчанию, выключается --no-cache-prompt). --cache-reuse N позволяет переиспользовать часть KV при изменении в середине, сдвигая кэш; это полезнее для редактирования промпта, чем для агента, который всегда дописывает в конец.
7.5 Продвинутые реализации
- vLLM поддерживает automatic prefix caching: блоки KV хранятся по хешу токенов и переиспользуются между запросами.
- SGLang использует RadixAttention: префиксы хранятся в дереве (radix tree), что позволяет эффективно разделять общие начала между многими запросами и ветвями диалога.
- Prompt Cache (исследование 2023) предлагает модульное переиспользование attention-состояний для повторяющихся частей промпта.
В локальном llama.cpp реализация проще: кэш на слот плюс выбор по LCP. Этого достаточно для последовательного агента, но для сервера с сотнями пользователей нужен движок вроде vLLM или SGLang.
7.6 Где кэш не помогает
- Первый запрос всегда холодный.
- Изменение начала сбрасывает всё после него.
- Разные документы в RAG дают разные префиксы, если документ вставлен в начало. Ставьте стабильные инструкции первыми, документы — после.
- Смена модели или кванта — другой кэш.
- Очень длинный хвост (например, вставили новый документ на 50k токенов) всё равно требует prefill этого хвоста.
- Параллельные разные запросы не делят префикс, если он у них разный.
7.7 RAG как нагрузка
RAG (retrieval-augmented generation) — поиск внешних фрагментов и вставка их в промпт. Для кэша это особая нагрузка:
- инструкции и формат ответа стабильны, а документы меняются;
- если вставить документ в начало, общий префикс с прошлым запросом оборвётся;
- порядок фрагментов влияет на качество и на кэш.
Практика: стабильные инструкции — первыми, найденные фрагменты — после них, вопрос — в конце. Если фрагменты большие, кэш сэкономит хотя бы инструкции и историю. Для самого поиска нужны эмбеддинги и, возможно, reranker — это отдельные модели, которые тоже занимают память и время.
7.8 Кэш и качество
Кэш не меняет ответ: это те же KV-векторы, которые были бы вычислены заново. Но есть нюансы:
- KV, посчитанный одним большим батчем, и KV, накопленный по кускам, могут отличаться в последних битах: другие формы матриц — другой порядок сложения чисел с плавающей точкой (подробнее про детерминизм — §10.4); на длинной генерации это иногда меняет выбор токена;
- при сдвиге кэша (
--cache-reuse) позиционные кодировки должны быть скорректированы, иначе модель «увидит» не те позиции; - разные реализации могут по-разному обрабатывать границы блоков.
Для детерминированных задач (температура 0) кэш обычно безопасен. Для тонких проверок стоит сравнить ответы с кэшем и без.
7.9 Агентская нагрузка в цифрах
Пусть агент делает 60 шагов, каждый шаг добавляет 300 токенов, контекст растёт с 8k до 26k, prefill 1200 ток/с, декод 40 ток/с, ответ 150 токенов.
Без кэша:
средний промпт ~17k → 14 с prefill + 3,75 с декод на шаг
≈ 18 с × 60 = 18 минут
С кэшем (обрабатывается только хвост ~300 токенов):
0,25 с prefill + 3,75 с декод ≈ 4 с на шаг
≈ 4 минуты
Цифры условные, но соотношение типичное: время шага сократилось в 4,5 раза, и теперь почти всё оно — декод (3,75 с из 4). Вывод: кэш промпта убирает prefill из критического пути, и дальше время определяется декодом. Именно поэтому в агентских нагрузках оптимизация генерации важнее оптимизации prefill.
Посчитай сам. Тот же агент из 60 шагов, но в первой строке системного промпта стоит текущее время с секундами. Кэш включён. Сколько теперь займёт задача?
Решение
Время меняется на каждом запросе, поэтому общий префикс заканчивается уже на первой строке и кэш не срабатывает ни разу. Получаем сценарий «без кэша»: около 18 с на шаг и ~18 минут на задачу вместо ~4. Одна строка в начале промпта сделала агента в 4,5 раза медленнее.
7.10 Практические правила
- Держите системный промпт и инструменты неизменными. Версия, дата, счётчик — в конец или в отдельное поле.
- Не сжимайте историю в середине без необходимости. Это ломает префикс.
- Ставьте самые стабильные части первыми. Инструкции → примеры → документы → вопрос.
- Меряйте, сколько токенов реально обрабатывается. В логах сервера видно
prompt evalи размер кэша.
Tip
Быстрая проверка, что кэш работает: отправьте один и тот же длинный запрос дважды. Во второй раз в логе сервера число обработанных токенов промпта должно упасть до единиц, а TTFT — до долей секунды. Если нет — ищите, что меняется в начале промпта.
- Не держите лишние слоты. Каждый слот — это KV-память.
- Для мультипользовательского сервера смотрите в сторону vLLM/SGLang, а не только llama.cpp.
Ключевые идеи
- Кэш промпта переиспользует KV для общего префикса и пересчитывает только хвост.
- Любое изменение в начале промпта обнуляет кэш после этого места.
- В агентских нагрузках кэш убирает prefill из критического пути, оставляя декод главным узким местом.
- Стабильный префикс — это архитектурное решение, а не флаг сервера.
- Для многих пользователей нужны движки с разделяемым кэшем (vLLM, SGLang).
Проверь себя
- Почему дата в начале системного промпта может замедлить агента в разы?
- Промпт 30k токенов, хвост 400, prefill 1000 ток/с. Во сколько раз кэш ускоряет prefill?
- Чем кэш на слот отличается от разделяемого кэша в vLLM/SGLang?
- Почему сжатие истории в середине диалога может быть вредным для скорости?
- Кэш промпта ускоряет декод?
Ответы
- Каждый день (или каждый запрос) дата меняется, поэтому общий префикс с прошлым запросом заканчивается на ней. Всё, что после, пересчитывается заново, и агент платит полный prefill на каждом шаге.
- Без кэша 30 000 / 1000 = 30 с; с кэшем 400 / 1000 = 0,4 с. Ускорение prefill в 75 раз.
- Кэш на слот привязан к конкретному слоту и его контексту; разделяемый кэш хранит блоки по хешу токенов и может переиспользовать их между разными запросами и слотами.
- Сжатие переписывает середину промпта, поэтому общий префикс с предыдущим запросом обрывается раньше. Агенту приходится заново обрабатывать большой кусок.
- Нет. Декод по-прежнему генерирует по одному токену и читает веса на каждом шаге. Кэш ускоряет только prefill.
Источники главы
- Gim et al., «Prompt Cache: Modular Attention Reuse for Low-Latency Inference» (2023) — arXiv:2311.04934. Идея модульного переиспользования частей промпта.
- Zheng et al., «SGLang: Efficient Execution of Structured Language Model Programs» (2023) — arXiv:2312.07104. RadixAttention и разделяемый кэш префиксов.
- vLLM, «Automatic Prefix Caching» — docs.vllm.ai. Как это устроено в vLLM.
- vLLM blog, «Easy, Fast, and Cheap LLM Serving with PagedAttention» (2023) — blog.vllm.ai. Контекст: PagedAttention и управление KV.
- llama.cpp,
tools/server/README.md— GitHub.--cache-prompt,--cache-reuse, слоты. - Databricks, «LLM Inference Performance Engineering» — блог. Метрики TTFT/ITL и влияние кэша в продакшене.
8. Батчинг, слоты и PagedAttention
Зачем эта глава. До сих пор мы говорили про один запрос. Но сервер может обслуживать несколько, а обработка промпта вообще выгодна только батчами. Здесь появляются два разных смысла слова «батч» — и путаница между ними стоит людям дней тюнинга.
За 30 секунд
- Батч из нескольких запросов читает веса один раз на всех: суммарная пропускная способность сервера растёт, а задержка отдельного запроса — нет.
- В llama.cpp
-b— логический батч,-ub— физический;-ubускоряет prefill и ест VRAM, на декод почти не влияет.- Каждый слот (
-np) — свой KV-кэш: память под контекст умножается на число слотов.- Выгода батча по памяти кончается, когда чтение KV догоняет чтение весов:
b* = W / (C × k).- Непрерывный батчинг и PagedAttention — то, за счёт чего vLLM/SGLang обслуживают сотни пользователей.
8.1 Зачем батчить
Декод одного токена читает все активные веса, но делает мало вычислений. Если обрабатывать несколько запросов одновременно, веса читаются один раз, а полезная работа умножается. Это главный источник роста пропускной способности (throughput, токенов в секунду на весь сервер).
Но есть компромисс:
- Пропускная способность растёт с батчем;
- задержка (latency) одного запроса может расти, потому что он ждёт соседей;
- память под KV растёт с числом одновременных запросов.
Поэтому «батч побольше» — не всегда хорошо. Для интерактивного чата важна задержка, для пакетной обработки — пропускная способность.
Это не противоречие, а разные метрики. Батч одного запроса не ускоряет его собственный декод (latency), но позволяет серверу выдать больше токенов в секунду суммарно (throughput). Когда в главе 2 сказано «батчинг почти не помогает декоду», речь именно про задержку одного запроса.
Где выгода батча упирается в KV
При батче b сервер за один раунд читает активные веса W и KV всех запросов: b × C × k, где C — длина контекста, k — байт KV на токен. На один выходной токен приходится
W / b + C × k
Первое слагаемое падает с ростом батча, второе — нет: KV каждого запроса читается отдельно. Выгода от повторного использования весов кончается там, где эти слагаемые равны:
b* = W / (C × k)
b* — вещественная оценка; минимальный целый батч получается округлением вверх. Если b* < 1, KV доминирует уже при одном запросе.
Для 8B в Q4_K_M (W ≈ 4,2 ГБ, k = 128 КиБ) на контексте 8k:
| Контекст | C × k | b* | Что это значит |
|---|---|---|---|
| 2k | 0,27 ГБ | ≈ 16 | батч до 16 ещё заметно снижает байты на токен |
| 8k | 1,07 ГБ | ≈ 4 | дальше выигрыш по памяти почти исчезает |
| 16k | 2,15 ГБ | ≈ 2 | батч почти не помогает |
| 32k | 4,29 ГБ | ≈ 1 | KV читается больше весов уже при одном запросе |
Это оценка «по байтам». На практике раньше может включиться вычисление attention или нехватка KV-памяти, а у MoE W — только активные веса, поэтому b* меньше. Но порядок величины она даёт правильно: чем длиннее контекст, тем раньше батч перестаёт экономить память.
Посчитай сам. MoE 35B-A3B в Q4_K_M: активных весов около 1,8 ГБ, KV 64 КиБ на токен. При каком батче на контексте 16k чтение KV догоняет веса? А на 32k?
Решение
16k: C × k = 16 384 × 64 КиБ = 1 ГиБ ≈ 1,074 ГБ
b* = 1,8 / 1,074 ≈ 1,7 → уже второй запрос не даёт выигрыша по байтам
32k: C × k = 2 ГиБ ≈ 2,147 ГБ
b* = 1,8 / 2,147 ≈ 0,84 → KV доминирует с первого запроса
У MoE маленькие активные веса — это плюс для скорости, но именно поэтому батч упирается в KV раньше, чем у плотной модели. Для длинного контекста выгоднее экономить KV (GQA, окно, сжатие), чем надеяться на батч.
8.2 Два батча в llama.cpp: -b и -ub
В llama.cpp есть два разных параметра:
| Флаг | Смысл |
|---|---|
-b, --batch-size | логический максимум токенов, которые сервер собирает за один вызов декодирования |
-ub, --ubatch-size | физический максимум токенов, которые GPU обрабатывает за один проход вычислительного графа |
Логический батч может быть больше физического: сервер накопил 2048 токенов, но обрабатывает их кусками по 512 или 1024. Это нужно, чтобы не выделять огромный буфер вычислений и не упасть по памяти.
Что это значит на практике:
-ubвлияет на prefill: больше микро-батч — плотнее загрузка GPU и выше скорость обработки промпта;-ubне влияет на декод: при генерации на слот всё равно один токен;- слишком большой
-ubсъедает VRAM и может не влезть вместе с моделью; -bдолжен быть не меньше-ub; иначе логический батч искусственно ограничивает физический.
Типичная история: -b 2048 -ub 512 — безопасный дефолт. Подняли -ub до 1024 — prefill ускорился в 1,5 раза, VRAM вырос на сотни мегабайт. Подняли до 2048 — prefill ещё быстрее, но модель перестала помещаться. Это не «магия флага», а прямая связь с буфером вычислений.
Как отличить OOM буфера от других проблем: если сервер падает с ошибкой аллокации сразу после увеличения -ub, а при возврате значения работает, — это нехватка памяти под вычислительный буфер. Если же падение происходит только на длинном промпте, дело может быть в KV-кэше или в сумме буферов; смотрите пик VRAM.
8.3 Параллельные слоты
-np (или --parallel) задаёт число слотов — независимых контекстов, которые сервер может обслуживать одновременно. У каждого слота свой KV-кэш.
Следствия:
- больше слотов — больше параллельных запросов и выше пропускная способность;
- больше слотов — больше памяти под KV;
- контекст делится между слотами (в разных сборках семантика отличается; в новых есть отдельный лимит на слот, проверяйте документацию своей версии);
- при последовательной нагрузке лишние слоты только тратят память.
Пример: модель с KV 128 КиБ на токен, контекст 32k. Один слот — 4 ГиБ KV. Четыре слота — уже 16 ГиБ, что больше, чем вся видеопамять средней карты. Поэтому «поставлю -np 4, пусть будет быстрее» — плохая идея без расчёта.
Warning
Обратная ловушка: в части сборок
-cзадаёт общий контекст, который делится между слотами. Тогда-c 32768 -np 4даёт каждому слоту лишь 8k, и длинный запрос неожиданно обрезается. Посмотрите в логе запуска, какой контекст получил каждый слот.
Посчитай сам. Карта 24 ГБ, веса модели 14 ГБ, буферы 1 ГБ, запас 2 ГБ. KV — 96 КиБ на токен в FP16. Нужно обслуживать 4 пользователей одновременно. Какой контекст на слот можно дать в FP16 и в q8_0?
Решение
на KV: 24 − 14 − 1 − 2 = 7 ГБ ≈ 6,5 ГиБ
на один слот: 6,5 / 4 ≈ 1,63 ГиБ
FP16: 1,63 ГиБ / 96 КиБ ≈ 17 800 токенов → 16k на слот
q8_0: в 1,88 раза меньше на токен → ~33 500 токенов → 32k на слот
Квантование KV в q8_0 здесь удваивает контекст каждого пользователя — тот же выигрыш, что и сокращение слотов вдвое, но без потери параллельности.
8.4 Непрерывный батчинг
Статический батчинг: собрали пачку запросов, обработали, ждём самый длинный. Короткие запросы простаивают, новые ждут конца пачки.
Непрерывный батчинг (continuous batching, dynamic batching): на каждом шаге генерации освободившиеся слоты занимаются новыми запросами. Это повышает загрузку GPU и снижает среднее время ожидания.
В llama.cpp непрерывный батчинг включён по умолчанию (-cb); отключить можно -nocb. В vLLM и SGLang это основа движка.
Аналогия: статический батч — автобус, который ждёт, пока все пассажиры доедут до конечной; непрерывный — маршрутка, которая подбирает новых на каждой остановке.
Так это выглядит на шкале времени (условные шаги генерации; запросы C и D приходят, пока A ещё генерируется).
Статический батч. Слот 2 простаивает, пока слот 1 не закончит самую длинную пачку (красное — простой):
gantt
dateFormat ss
axisFormat %S
section Слот 1
A — длинный ответ :t1, 00, 10
C :t2, 10, 14
section Слот 2
B :t3, 00, 03
простой :crit, t4, 03, 10
D :t5, 10, 13
Непрерывный батч. Освободившийся слот сразу берёт следующий запрос, очереди нет:
gantt
dateFormat ss
axisFormat %S
section Слот 1
A — длинный ответ :t6, 00, 10
section Слот 2
B :t8, 00, 03
C :t9, 03, 07
D :t7, 07, 10
В первом случае все четыре запроса закончились к шагу 14, во втором — к шагу 10; запрос C получил ответ на семь шагов раньше, D — на три. На реальном сервере с десятками слотов и разной длиной ответов разница намного больше.
Закон Литтла: сколько запросов одновременно
Очередь и параллелизм удобно проверять одной формулой. Если запросы приходят со средней интенсивностью λ (запросов в секунду) и проводят в системе T секунд (ожидание + prefill + генерация), то в системе одновременно находятся
N = λ × T
Это закон Литтла. Он не про железо и не про модель — он верен для любой устойчивой системы. Полезен он тем, что связывает нагрузку, задержку и память: каждому из N запросов нужен свой KV-кэш.
Пример: λ = 2 запроса/с, полное время T = 25 с. Тогда N = 50 запросов одновременно. При KV 1 ГиБ на запрос на 8k это 50 ГиБ только под кэш — больше, чем вся память средней карты. Значит, сервер не сможет держать 50 запросов: часть будет ждать в очереди, и T вырастет ещё сильнее. Очередь — это не «медленный декод», а нехватка памяти или мощности.
Отсюда практические следствия:
- при
λ, близкой кμ(мощности сервера), очередь растёт неограниченно; держите загрузку заметно ниже 1; - средняя загрузка 0,8 не спасает от всплесков: считайте
Nпо окнам и пикам; - если запрос ждёт ответа инструмента, он всё равно занимает место в системе, даже если GPU простаивает;
- ограничение приёма и отмена — такие же рычаги, как более быстрый декод.
Посчитай сам. Сервер принимает 0,5 запроса/с, среднее время ответа — 40 с. Сколько запросов одновременно в системе? Сколько нужно KV, если на 4k контекста один запрос занимает 512 МиБ?
Решение
N = 0,5 × 40 = 20 запросов
KV = 20 × 512 МиБ = 10 ГиБ
Плюс веса (например, 4,2 ГБ), буферы и запас. На карте 24 ГБ это помещается, на 16 ГБ — уже нет: 10 ГиБ KV плюс веса и буферы не оставляют запаса. Если интенсивность вырастет до 1 запроса/с, в системе окажется 40 запросов и 20 ГиБ KV: очередь начнёт расти, даже если средняя мощность сервера формально достаточна.
8.5 PagedAttention и проблема фрагментации
Наивный KV-кэш выделяется под максимальную длину контекста для каждого запроса. Если запрос сгенерировал 100 токенов, а лимит был 32k, память всё равно занята под 32k. Это внутренняя фрагментация.
PagedAttention (vLLM) решает проблему по аналогии с виртуальной памятью:
- KV хранится блоками фиксированного размера (например, 16 токенов);
- блоки не обязаны лежать подряд;
- таблица страниц отображает логические позиции на физические блоки;
- блоки можно разделять между запросами с общим префиксом (copy-on-write).
Плюсы: меньше потерь памяти, больше одновременных запросов, эффективное разделение префиксов. Минусы: сложнее реализация, накладные расходы на таблицы, не все модели и бэкенды поддерживаются одинаково.
В llama.cpp управление KV проще: контекст выделяется под слот. Для одного пользователя этого достаточно; для сотен одновременных запросов vLLM выигрывает.
8.6 vLLM против llama.cpp
Это не «кто лучше», а разные задачи.
| llama.cpp | vLLM | |
|---|---|---|
| Основной сценарий | локальный запуск, GGUF, CPU/GPU-гибрид | серверный инференс на GPU |
| Квантование | широкий набор GGUF | в основном GPU-форматы |
| Выгрузка экспертов в ОЗУ | да | не основной сценарий |
| PagedAttention | нет (свой менеджмент KV) | да, ключевая особенность |
| Непрерывный батчинг | есть, проще | развитый |
| Пропускная способность на многих запросах | ниже | выше |
| Простота локального запуска | выше | требует Linux/GPU-стека |
Для домашней машины с одной картой и моделью в GGUF llama.cpp обычно практичнее. Для сервера с десятками пользователей и GPU-памятью vLLM или SGLang дают больше пропускной способности.
Подробный разбор каждого движка, практические команды и сравнение — в главах «Движки инференса: llama.cpp», «vLLM», «SGLang» и «сравнение и выбор».
Параллелизм и разделение фаз
Когда одна карта не вмещает модель, используют несколько. Tensor parallelism делит матрицы одного слоя между картами; pipeline parallelism раздаёт слои разным картам. Оба требуют быстрой связи между GPU и сложной синхронизации, поэтому на одной карте смысла не имеют.
Отдельный приём — disaggregated prefill/decode: prefill и decode выполняются на разных пулах GPU. Prefill упирается в вычисления, decode — в память, и разделение позволяет подобрать железо под каждую фазу. Это серверная история; для локального запуска достаточно знать, что такие схемы существуют.
8.7 Как батчинг сочетается с MoE
У MoE большой батч означает больше разных экспертов на шаг. Если каждый токен выбирает 8 из 256 экспертов, но токенов тысячи, в работу вовлекается почти весь слой, и преимущество разреженности падает (это уже обсуждалось в §5.8). Для батчинга отсюда три следствия: prefill большим батчем у MoE выигрывает меньше, чем у плотной модели; параллельные слоты увеличивают нагрузку на экспертов; кэш горячих экспертов (§5.7) может не справиться с разнообразием. Это ещё одна причина мерить, а не экстраполировать.
8.8 Практические правила
- Для одного пользователя ставьте
-np 1и не тратьте KV на пустые слоты. - Для чата на несколько человек считайте память:
слоты × KV на токен × контекст. -ub— главный рычаг prefill, но он ест VRAM. Поднимайте, пока есть запас 1,5–2 ГБ.-bдержите ≥-ub, иначе микро-батч не реализуется.- Не ждите ускорения декода от батча одного запроса: декод всегда по одному токену на слот.
- Для многих одновременных запросов смотрите в сторону PagedAttention-движков.
Ключевые идеи
- Батчинг повышает пропускную способность, но может увеличить задержку и память.
- Выгода батча по памяти кончается при
b* = W / (C × k): дальше KV каждого запроса читается отдельно. - Закон Литтла
N = λ × Tсвязывает интенсивность, задержку и число одновременно живущих запросов. -b— логический батч,-ub— физический;-ubускоряет prefill и ест VRAM.-npсоздаёт независимые KV-кэши; лишние слоты — лишняя память.- Непрерывный батчинг заполняет освободившиеся слоты новыми запросами.
- PagedAttention уменьшает фрагментацию KV и позволяет делить префиксы; это сильная сторона vLLM/SGLang.
Проверь себя
- Почему
-ub 1024ускоряет prefill, но почти не влияет на декод? - У вас 16 ГБ VRAM, KV 64 КиБ на токен, контекст 16k. Сколько слотов максимум по памяти, если на модель и буферы уходит 12 ГБ?
- Чем статический батчинг хуже непрерывного для чата?
- Какую проблему решает PagedAttention?
- Почему большой батч может уменьшить преимущество MoE?
Ответы
- Prefill обрабатывает много токенов параллельно, и больший микро-батч лучше загружает GPU. Декод генерирует по одному токену на слот, поэтому размер батча не меняет объём вычислений на шаг.
- На KV остаётся 4 ГБ, а это 3,7 ГиБ. Один слот: 16 384 × 64 КиБ = 1 ГиБ. Значит, по памяти максимум 3 слота — и то впритык. С правилом запаса 1,5–2 ГБ из главы 3 остаётся 2–2,5 ГБ, то есть практически 1–2 слота.
- Статический батч ждёт самый длинный запрос и не принимает новые, пока пачка не закончится. Непрерывный подставляет новые запросы на освободившиеся слоты, поэтому GPU загружен плотнее, а ожидание короче.
- Внутреннюю фрагментацию KV: при наивном выделении под максимальный контекст память тратится впустую. PagedAttention хранит KV блоками и отображает их через таблицу страниц.
- Чем больше токенов в батче, тем больше разных экспертов активируется. При достаточно большом батче в работу вовлекается почти весь слой, и разреженность перестаёт экономить вычисления.
Источники главы
- Yu et al., «Orca: A Distributed Serving System for Transformer-Based Generative Models» (OSDI 2022) — USENIX. Итеративное (iteration-level) планирование — прообраз непрерывного батчинга — и selective batching.
- Kwon et al., «Efficient Memory Management for Large Language Model Serving with PagedAttention» (2023) — arXiv:2309.06180. PagedAttention и vLLM.
- vLLM blog, «Easy, Fast, and Cheap LLM Serving with PagedAttention» — blog.vllm.ai. Доступное объяснение.
- Anyscale, «How continuous batching enables 23x throughput» — блог. Наглядный разбор continuous batching.
- llama.cpp Discussion #10260, «what does u and s stand for in ubatch and sbatch?» — GitHub. Разница между логическим и физическим батчем.
- llama.cpp,
tools/server/README.md— GitHub.-b,-ub,-np,-cb.
9. Спекулятивное декодирование: черновик, MTP, acceptance rate
Зачем эта глава. Декод упирается в память: на каждый токен читаются все активные веса. Спекулятивное декодирование обходит это ограничение, заставляя модель проверять несколько токенов за один проход. Это один из немногих способов ускорить генерацию без потери качества.
За 30 секунд
- Маленький черновик быстро предлагает несколько токенов, большая модель проверяет их все за один проход — веса читаются один раз на несколько токенов.
- Распределение ответа не меняется: при
T = 0текст тот же, приT > 0— та же статистика.- Выигрыш определяет acceptance rate
α— насколько часто черновик угадывает. Реально это 1,5–2,5×, при низкомα— замедление.- Меряйте на своём трафике: повторяющийся синтетический промпт даёт фантастические и бесполезные цифры.
9.1 Идея
Обычная генерация:
прочитать веса → получить 1 токен → прочитать веса → получить 1 токен → ...
Спекулятивное декодирование:
flowchart TB
CTX["Контекст:<br/>«Столица Франции —»"] --> DR["Черновик предлагает γ = 4 токена:<br/>«Париж» «,» «а» «Германии»"]
DR --> VER["Целевая модель проверяет<br/>все 4 + 1 за один проход"]
VER --> CMP{"Сравнение<br/>по позициям"}
CMP -->|"«Париж» ✓ «,» ✓ «а» ✓"| ACC["Приняты 3 токена"]
CMP -->|"«Германии» ✗ —<br/>модель хотела «столица»"| FIX["Берём токен<br/>целевой модели"]
ACC --> OUT["+4 токена за один<br/>проход по весам"]
FIX --> OUT
OUT -->|"следующий цикл"| CTX
За один проход целевой модели получено четыре токена: три угаданных черновиком и один исправленный. Без спекуляции на это ушло бы четыре прохода. Если бы черновик угадал все четыре, целевая модель добавила бы пятый — «бонусный» (§9.2).
Проверка нескольких токенов почти так же дешева, как генерация одного: веса всё равно читаются один раз, а вычисления растут незначительно. Если черновик угадал k токенов, вы получили k токенов за одну операцию чтения весов.
Ключевое свойство: распределение результата не меняется. При жадной генерации (temperature 0) выход в теории совпадает с обычным токен в токен: проверку делает целевая модель, и принимаются только её собственные argmax-токены. На практике проверка идёт батчем из нескольких токенов, и из-за другого порядка вычислений с плавающей точкой при почти равных вероятностях изредка выбирается другой токен (§10.4) — это особенность арифметики, а не метода. При T > 0 сохраняется распределение, а не конкретная последовательность: для этого нужна корректная схема rejection sampling (Leviathan et al.). Конкретный текст может отличаться — ровно так же, как отличались бы два обычных запуска с сэмплированием.
9.2 Формальная схема
- Черновик (draft) генерирует
γтокенов авторегрессионно. - Целевая модель получает исходный контекст плюс эти
γтокенов и считает вероятности для каждого шага. - Сравниваем:
- если токен черновика совпал с выбором целевой модели — принимаем;
- на первом несовпадении берём токен целевой модели и отбрасываем остаток черновика.
- К принятым токенам добавляется один «бонусный» токен от целевой модели — итого до
γ + 1токенов за шаг.
Для жадной генерации (temperature 0) это просто сравнение argmax. Для сэмплирования нужна схема rejection sampling, которая сохраняет распределение целевой модели; иначе ответы начнут отличаться статистически. Именно это имеет в виду Leviathan et al.: спекуляция не «улучшает» и не «портит» распределение, а воспроизводит его быстрее.
9.3 Сколько это даёт
Пусть α — вероятность принять один токен черновика (acceptance rate), а стоимость черновика — d от стоимости одного прохода целевой модели.
Ожидаемое число выходных токенов за раунд (принятые плюс один бонусный) обозначим E[N]:
E[N] = 1 + α + α² + ... + α^γ = (1 − α^(γ+1)) / (1 − α)
Ускорение примерно:
speedup ≈ E[N] / (1 + γ × d)
Пример: α = 0,8, γ = 4, черновик стоит d = 0,05:
E[N] = (1 − 0,8^5) / 0,2 = (1 − 0,328) / 0,2 = 3,36
speedup ≈ 3,36 / (1 + 0,2) = 2,8
Это оптимистичная оценка: на практике добавляются накладные расходы, неидеальное распараллеливание и падение acceptance на сложных токенах. Реалистичный выигрыш — 1,5–2,5×.
E[N] и безубыточный черновик
Из формулы видно условие, при котором спекуляция вообще имеет смысл. Раунд стоит T_plain + T_draft, где T_plain — обычный шаг целевой модели, а T_draft — подготовка черновика. Тогда
speedup = E[N] × T_plain / (T_plain + T_draft)
Спекуляция окупается, только если числитель больше знаменателя:
E[N] > 1 + T_draft / T_plain
Отсюда бюджет на черновик:
T_draft < (E[N] − 1) × T_plain
d < (E[N] − 1) / γ (если черновик стоит d на токен)
Это и есть «безубыточный черновик»: максимальная стоимость, при которой раунд ещё быстрее обычного шага. При E[N] = 1,33 (α = 0,25, γ = 4) и шаге 26,3 мс бюджет около 8,7 мс; при E[N] = 3,05 (α = 0,75, γ = 4) — около 54 мс. Чем выше acceptance, тем дороже может быть черновик.
Посчитай сам. α = 0,5, γ = 4, обычный шаг 30 мс, черновик 8 мс на токен. Окупается ли спекуляция? Каков бюджет на черновик?
Решение
E[N] = (1 − 0,5^5) / 0,5 = 1,94
T_draft = 4 × 8 = 32 мс
speedup = 1,94 × 30 / (30 + 32) = 58,2 / 62 ≈ 0,94
бюджет = (1,94 − 1) × 30 = 28,2 мс, то есть 7,05 мс на токен
Спекуляция не окупается: раунд 62 мс даёт 1,94 токена, то есть 32 мс на токен против 30 мс без неё. Черновик должен стоить дешевле 7 мс на токен — или acceptance должен быть выше. Это типичный случай, когда «включил спекуляцию» означает «стало медленнее».
Зависимость от α сильная:
| α | E[N] при γ=4 | Оценка speedup (d=0,05) | Бюджет d, чтобы окупилось |
|---|---|---|---|
| 0,5 | 1,94 | 1,6 | 0,234 |
| 0,6 | 2,31 | 1,9 | 0,326 |
| 0,7 | 2,77 | 2,3 | 0,443 |
| 0,8 | 3,36 | 2,8 | 0,590 |
| 0,9 | 4,10 | 3,4 | 0,774 |
Поэтому главный вопрос — не «какой γ поставить», а насколько хорошо черновик предсказывает именно ваш трафик.
Рисунок 9.1. Идеальное ускорение по формуле Leviathan et al. для дешёвого (d = 0,05) и дорогого (d = 0,2) черновика. Длинный черновик (γ = 8) выигрывает только при высоком α, а при низком — проигрывает даже обычной генерации. Чем дороже черновик, тем правее точка, где спекуляция начинает окупаться. Расчёт; реальные числа ниже из-за накладных расходов.
9.4 Выбор γ
γ — длина черновика. Слишком маленький даёт мало выигрыша; слишком большой тратит время на проверку токенов, которые всё равно будут отброшены.
Оптимум зависит от α и стоимости черновика. При высоком α выгодно увеличивать γ; при низком — уменьшать. На практике:
- на свободной прозе
αчасто 0,5–0,7, оптимумγоколо 2–3; - на структурированном выводе, JSON и повторяющихся формулировках
αвыше, иγ = 4–5может быть лучше; - при
α < 0,4спекуляция часто не окупается.
Посчитай сам. Проза, α = 0,6, черновик стоит d = 0,1 шага целевой модели. Какой γ из 2, 3, 4 даёт наибольшее ускорение по формуле §9.3?
Решение
γ = 2: E[N] = (1 − 0,6³) / 0,4 = 1,96; speedup = 1,96 / 1,2 ≈ 1,63
γ = 3: E[N] = (1 − 0,6⁴) / 0,4 = 2,18; speedup = 2,18 / 1,3 ≈ 1,67
γ = 4: E[N] = (1 − 0,6⁵) / 0,4 = 2,31; speedup = 2,31 / 1,4 ≈ 1,65
Оптимум — γ = 3, но кривая очень пологая: между 2 и 4 разница меньше 3%. Поэтому подбирать γ до единицы бессмысленно — гораздо важнее поднять α.
9.5 Откуда взять черновик
Сразу оговорка про llama.cpp: в нём реализованы draft-simple (отдельная модель), draft-eagle3 (для ограниченного набора архитектур), draft-mtp и n-граммные варианты (ngram-simple, ngram-cache, ngram-mod и др.), а также более новые draft-dflash/draft-dspark. Medusa и EAGLE-1/2 в llama.cpp нет — это архитектурный экскурс, а не готовые флаги.
Отдельная маленькая модель
Берут модель того же семейства и токенизатора, например 0,5–1,5B, и запускают рядом. Плюсы: просто, работает с любой целевой моделью. Минусы: занимает память, добавляет задержку, acceptance на вашем домене может быть низким.
N-gram / lookup decoding
Черновик не модель, а поиск по уже имеющемуся тексту: если последовательность встречалась раньше, её можно предложить. Плюсы: почти бесплатно, не занимает память. Минусы: хорошо работает на копировании и повторяющемся тексте, плохо — на новом.
Важная ловушка: на синтетическом тесте с повторяющимся промптом acceptance может быть близок к 1, и вы получите фантастические цифры. На реальном трафике всё иначе.
MTP-головы
Multi-token prediction (MTP): модель обучают предсказывать не только следующий токен, но и, в общем случае, несколько следующих — через дополнительные головы. У DeepSeek-V3 один MTP-модуль (глубина D = 1), то есть на один шаг вперёд; в других моделях глубина может быть больше. Черновик получается почти бесплатно и хорошо откалиброван, потому что головы обучались вместе с моделью.
В llama.cpp поддержка MTP появилась для моделей с соответствующими тензорами: сервер создаёт draft-контекст на основе головы целевой модели.
Плюсы: высокий acceptance, нет отдельного файла модели. Минусы: нужна модель с MTP-головами; не все архитектуры поддерживаются; голова и её KV занимают память.
Medusa
Medusa добавляет несколько выходных голов к целевой модели и строит «дерево» кандидатов. Проверка идёт с attention-маской, чтобы кандидаты не видели друг друга. Плюсы: не нужна отдельная модель. Минусы: головы надо обучать, дерево усложняет реализацию.
EAGLE
EAGLE использует признаки целевой модели (hidden states), а не только токены, и предсказывает следующие представления. EAGLE-2 строит динамическое дерево кандидатов. EAGLE-3 отказывается от предсказания признаков в пользу прямого предсказания токенов и использует приём training-time test — обучение на поведении, которое модель увидит на инференсе, а не масштабирование рассуждений во время генерации. Плюсы: высокий acceptance. Минусы: привязка к архитектуре целевой модели, сложная конвертация.
9.6 Почему проверка дешева
Проверка γ + 1 токенов — это маленький prefill. Веса читаются один раз, а вычисления на нескольких токенах всё ещё намного меньше, чем позволяет GPU. Поэтому декод остаётся memory-bound, и дополнительные токены почти не добавляют времени.
Но есть пределы:
- при больших
γвычисления и KV-кэш начинают расти заметно; - у MoE каждый дополнительный токен может активировать новых экспертов, и рабочий набор растёт;
- на длинном контексте attention по проверяемым токенам тоже стоит времени.
9.7 Взаимодействие с другими оптимизациями
- Кэш экспертов. При спекуляции за один шаг через экспертов проходит несколько токенов, рабочий набор «горячих» экспертов растёт. Фиксированный кэш может перестать попадать.
- KV-квантование. Черновик может иметь свой KV; его точность влияет на acceptance.
- Батчинг. Спекуляция и параллельные слоты конкурируют за память и вычисления.
- Промпт-кэш. Спекуляция не отменяет выгоду кэша префикса.
Warning
N-граммный черновик на бенчмарке, где один и тот же промпт гоняется по кругу, легко показывает acceptance около 1 и ускорение «в 3–4 раза». На живых задачах с новым текстом то же самое может дать 1,1× или замедление. Проверяйте на реальных запросах (глава 12).
9.8 Как измерять
Меряйте на реальном трафике, а не на повторяющемся промпте:
- acceptance rate (доля принятых токенов);
- средняя длина принятой цепочки;
- ток/с декода;
- время на задачу целиком;
- качество (для жадной генерации оно не должно меняться).
Если acceptance на вашем домене низкий, спекуляция может сделать хуже: вы платите за черновик и проверку, но мало принимаете.
9.9 Практические правила
- Сначала измерьте baseline. Без него вы не отличите эффект спекуляции от шума.
- Начните с
γ = 3–4. Дальше двигайте по acceptance. - Проверяйте на своих данных. Повторяющийся тест даёт завышенный acceptance.
- Следите за памятью. Черновик, его KV и буферы проверки стоят VRAM.
- Не включайте спекуляцию вместе с кэшем экспертов, не измерив взаимный эффект.
- Помните: качество не улучшается. Это ускорение, а не новая модель.
Ключевые идеи
- Спекуляция проверяет несколько токенов за один проход целевой модели.
- Выигрыш определяется acceptance rate и стоимостью черновика.
E[N] = (1 − α^(γ+1)) / (1 − α)— ожидаемое число выходных токенов за раунд.- Черновик бывает отдельной моделью, n-граммным, MTP-головой, Medusa или EAGLE.
- На реальном трафике acceptance может сильно отличаться от синтетики.
Проверь себя
- Почему спекулятивное декодирование не меняет ответ при temperature 0?
- При α = 0,7 и γ = 4 чему равно ожидаемое число принятых токенов?
- Почему большой γ может ухудшить результат?
- Чем MTP отличается от отдельной draft-модели?
- Почему спекуляция может конфликтовать с кэшем горячих экспертов?
Ответы
- При temperature 0 целевая модель выбирает argmax. Проверка принимает токен только если он совпал с argmax целевой модели, поэтому итоговая последовательность та же, что при обычной жадной генерации.
E[N] = (1 − 0,7^5) / 0,3 = (1 − 0,168) / 0,3 = 2,77.- Черновик генерирует больше токенов, а проверка стоит времени. Если acceptance невысок, большая часть черновика отбрасывается, и вы платите за неё зря.
- MTP — это дополнительные головы внутри целевой модели, обученные предсказывать будущие токены. Отдельная draft-модель — другой файл и другой процесс, её нужно загружать и держать в памяти.
- За один шаг проверки через экспертов проходит несколько токенов, поэтому активируется больше разных экспертов. Рабочий набор растёт, и фиксированный кэш перестаёт в него попадать.
Источники главы
- Leviathan, Kalman, Matias, «Fast Inference from Transformers via Speculative Decoding» (2022) — arXiv:2211.17192. Формализация и анализ ускорения.
- Chen et al., «Accelerating Large Language Model Decoding with Speculative Sampling» (2023) — arXiv:2302.01318. Схема с сохранением распределения.
- Cai et al., «Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads» (2024) — arXiv:2401.10774. Множественные головы и дерево.
- Li et al., «EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty» (2024) — arXiv:2401.15077. Черновик на признаках.
- Li et al., «EAGLE-2» (2024) — arXiv:2406.16858. Динамическое дерево.
- Li et al., «EAGLE-3» (2025) — arXiv:2503.01840. Отказ от предсказания признаков в пользу прямых токенов и приём training-time test.
- DeepSeek-AI, «DeepSeek-V3 Technical Report» (2024) — arXiv:2412.19437. MTP как часть архитектуры.
- llama.cpp,
docs/speculative.md— GitHub. Типы спекуляции и флаги. - llama.cpp PR #22673, «llama + spec: MTP Support» — GitHub. Поддержка MTP-голов.
10. Сэмплинг, температура и бюджет рассуждений
Зачем эта глава. Модель выдаёт вероятности, а не готовый ответ. То, какой токен будет выбран, определяет отдельный алгоритм. Неправильная температура превращает точную модель в болтливую или, наоборот, в зацикленную. А «рассуждающие» модели добавляют скрытые токены, которые стоят времени.
За 30 секунд
- Модель выдаёт распределение вероятностей; какой токен выбрать, решает сэмплер.
- Температура делает распределение острее (
T < 1) или площе (T > 1);T = 0— всегда самый вероятный токен.- Top-k, top-p и min-p отрезают маловероятный хвост; штрафы за повторы полезны в прозе и вредны в JSON.
- Рассуждение («thinking») — это обычные токены декода: они стоят секунд и места в контексте, поэтому бюджет подбирают под задачу.
10.1 От логитов к вероятностям
Последний слой модели выдаёт логиты — по числу на каждый токен словаря. Softmax превращает их в вероятности:
p_i = exp(z_i / T) / сумма_j exp(z_j / T)
где T — температура.
T → 0— распределение концентрируется на самом вероятном токене (жадная генерация);T = 1— исходное распределение модели;T > 1— распределение «размазывается», растёт разнообразие и риск бессмыслицы.
Пример. Логиты [2, 1, 0]:
| T | Вероятности |
|---|---|
| 0,5 | 0,867 / 0,117 / 0,016 |
| 1,0 | 0,665 / 0,245 / 0,090 |
| 2,0 | 0,506 / 0,307 / 0,186 |
При T = 0 деление на ноль не происходит: реализация просто выбирает argmax.
10.2 Обрезка хвоста
Даже при разумной температуре в хвосте распределения остаются тысячи маловероятных токенов. Их выбор почти всегда портит текст. Поэтому хвост обрезают.
Top-k: оставить k самых вероятных токенов, остальным вероятность 0. Просто, но k не адаптируется к форме распределения: когда модель уверена, k = 50 лишний; когда не уверена — может быть мало.
Top-p (nucleus sampling): оставить минимальный набор токенов, суммарная вероятность которых ≥ p (например, 0,9). Набор адаптируется: при уверенном распределении он маленький, при неуверенном — большой.
Min-p: оставить токены с вероятностью не ниже min_p × p_max. Если самый вероятный токен имеет вероятность 0,6, а min_p = 0,1, порог — 0,06. Тоже адаптивный способ, популярный в локальных рантаймах.
Типичные комбинации:
- точные задачи:
T = 0, обрезка не нужна; - технический текст:
T = 0,2–0,5,top_p = 0,9; - творческий текст:
T = 0,7–1,0,top_p = 0,95; - код и JSON:
T = 0–0,2,top_p = 0,9–0,95.
Это ориентиры, а не рецепты: модель и задача меняют оптимум.
Обычно эти шаги выстраиваются в цепочку:
flowchart TB
L["Логиты<br/>по всему словарю"] --> P["Штрафы<br/>за повторы"]
P --> F["Фильтры хвоста:<br/>top-k → top-p → min-p"]
F --> T["Температура"]
T --> S["Softmax и случайный<br/>выбор с учётом seed"]
S --> TOK["Токен"]
L -.->|"T = 0: сразу argmax"| TOK
Note
Порядок шагов зависит от рантайма и настраивается: в llama.cpp цепочка сэмплеров задаётся флагом
--samplers, и температура в ней по умолчанию стоит после фильтров, а в других библиотеках её часто применяют первой. При одинаковых числовых параметрах это может давать немного разное поведение — ещё одна причина не переносить настройки между рантаймами вслепую.
Посчитай сам. После температуры у пяти токенов вероятности 0,50 / 0,20 / 0,15 / 0,10 / 0,05. Какие токены останутся при min_p = 0,25 и какие — при top_p = 0,9? Каковы вероятности после перенормировки в случае min-p?
Решение
min-p: порог = 0,25 × 0,50 = 0,125 → остаются 0,50 / 0,20 / 0,15
сумма 0,85 → после перенормировки 0,588 / 0,235 / 0,176
top-p: накопленная сумма 0,50 → 0,70 → 0,85 → 0,95 ≥ 0,9
→ остаются четыре токена: 0,50 / 0,20 / 0,15 / 0,10
Min-p здесь строже: он отсекает всё, что заметно слабее лидера. Top-p оставляет хвост, пока не набрана нужная масса.
10.3 Штрафы за повторения
Чтобы модель не зацикливалась, используют:
- repetition penalty — понижает вероятность уже встречавшихся токенов;
- frequency penalty — сильнее понижает часто встречавшиеся;
- presence penalty — понижает сам факт появления токена.
Осторожно: слишком большой штраф ломает технические тексты, где повторяются обозначения, единицы и имена полей. Для JSON и кода штрафы лучше не включать или держать минимальными.
10.4 Детерминизм
T = 0 означает «всегда выбирать самый вероятный токен», но не гарантирует побитово одинаковый ответ:
- батчинг и порядок вычислений с плавающей точкой могут менять логиты в последних битах;
- разные версии рантайма и разные бэкенды дают небольшие расхождения;
- кэш и спекулятивное декодирование могут влиять на траекторию.
Для воспроизводимости фиксируйте seed, версию рантайма и конфиг, а результаты сравнивайте статистически, а не по одному запросу.
10.5 Рассуждающие модели
Новые модели умеют сначала сгенерировать скрытое рассуждение (thinking), а потом ответ. С точки зрения инференса это обычные токены: они проходят через декод, занимают время и контекст.
Плюсы:
- лучше справляются с многошаговыми задачами, математикой, планированием;
- позволяют модели «перепроверить» себя;
- дают выигрыш на сложных задачах без изменения весов.
Минусы:
- каждое рассуждение — это токены, а значит, секунды;
- на простых задачах рассуждение избыточно;
- длинное рассуждение может не поместиться в контекст;
- для строгого JSON и вызова инструментов скрытый текст может мешать парсингу, если рантайм не отделяет его.
10.6 Бюджет рассуждений
Бюджет рассуждений (reasoning budget) — ограничение на число токенов, которые модель тратит на скрытое рассуждение. Если бюджет исчерпан, модель должна перейти к ответу.
Практика:
- для извлечения данных, классификации, форматирования — бюджет 0;
- для анализа и планирования — небольшой бюджет (несколько сотен токенов);
- для сложных задач — больше, но с контролем времени.
Некоторые рантаймы поддерживают флаг вида --reasoning-budget; проверьте, есть ли он в вашей сборке и как ведёт себя при исчерпании. В API рассуждение часто приходит отдельным полем (reasoning_content), а ответ — в content.
10.7 Сколько стоит рассуждение
Пример: модель генерирует 1500 токенов рассуждения и 200 токенов ответа при скорости 40 ток/с.
рассуждение: 1500 / 40 = 37,5 с
ответ: 200 / 40 = 5 с
итого: ~42,5 с
Без рассуждения — 5 секунд. Для сложной задачи 37 секунд могут быть оправданы; для «вытащить номер ГОСТа из абзаца» — нет.
Бюджет — это не только время, но и качество: слишком маленький бюджет обрывает рассуждение на середине, и ответ становится хуже, чем без него.
10.8 Рассуждение и структурированный вывод
Если модель должна вернуть JSON, а она сначала «думает», есть два подхода:
- Отделить канал рассуждения от ответа на уровне шаблона чата и парсера. Многие модели обучены класть рассуждение в специальные токены; сервер умеет их вырезать.
- Отключить рассуждение для задач, где оно не нужно, и включить грамматику/JSON-схему для ответа.
Смешивать нельзя: если рассуждение попадает в тот же поток, что и JSON, парсер сломается.
10.9 Практические рекомендации
| Задача | Температура | Обрезка | Рассуждение |
|---|---|---|---|
| Извлечение полей, JSON | 0 | top_p 0,9 | выключить |
| Вызов инструментов | 0 | top_p 0,9 | выключить или короткий бюджет |
| Проверка документа | 0–0,2 | top_p 0,9 | по задаче |
| Технический текст | 0,2–0,5 | top_p 0,9 | по задаче |
| Чат, идеи | 0,7–1,0 | top_p 0,95 | средний бюджет |
| Код | 0–0,2 | top_p 0,95 | короткий бюджет |
Правило: сначала детерминизм, потом творчество. Если задача допускает один правильный ответ, температура 0 — хороший старт.
Tip
Начните с
T = 0и выключенного рассуждения, прогоните свой набор задач (глава 12), а потом включайте рассуждение или поднимайте температуру только там, где это измеримо улучшает результат.
10.10 Чего не делать
- Не ставить
T = 0и одновременноtop_pс маленьким значением «для разнообразия» — это противоречивые сигналы. - Не включать repetition penalty для JSON: имена полей повторяются, и модель начнёт их избегать.
- Не сравнивать модели при разных температурах.
- Не считать, что «temperature 0» даёт побитово одинаковый ответ на разных машинах.
- Не держать большой бюджет рассуждений «на всякий случай»: это прямое время.
Ключевые идеи
- Температура управляет резкостью распределения; 0 — жадный выбор.
- Top-k, top-p и min-p обрезают маловероятный хвост; top-p адаптивен.
- Штрафы за повторения полезны в прозе и вредны в JSON/коде.
- Рассуждение — это обычные токены декода, которые стоят времени и контекста.
- Бюджет рассуждений надо подбирать под задачу, а не максимизировать.
Проверь себя
- Что произойдёт с распределением при
T = 0,5и приT = 2? - Чем top-p отличается от top-k?
- Почему repetition penalty может испортить JSON?
- Модель тратит 800 токенов на рассуждение при 50 ток/с. Сколько это секунд?
- Почему
temperature = 0не гарантирует идентичный ответ на разных машинах?
Ответы
- При
T = 0,5распределение становится острее, вероятный токен получает больше массы. ПриT = 2— площе, масса распределяется по большему числу токенов. - Top-k оставляет фиксированное число токенов. Top-p оставляет минимальный набор, суммарная вероятность которого достигает порога, поэтому размер набора зависит от уверенности модели.
- В JSON повторяются имена полей и служебные символы. Штраф понижает их вероятность, и модель начинает переименовывать поля или ломать структуру.
800 / 50 = 16секунд.- Порядок операций с плавающей точкой, батчинг, разные ядра и версии рантайма могут давать чуть разные логиты. На argmax это обычно не влияет, но вблизи границы — может.
Источники главы
- Holtzman et al., «The Curious Case of Neural Text Degeneration» (2019) — arXiv:1904.09751. Nucleus sampling и проблема жадного/лучевого поиска.
- Fan, Lewis, Dauphin, «Hierarchical Neural Story Generation» (2018) — arXiv:1805.04833. Top-k sampling.
- Nguyen et al., «Turning Up the Heat: Min-p Sampling» (2024) — arXiv:2407.01082. Min-p как адаптивная альтернатива.
- Wei et al., «Chain-of-Thought Prompting Elicits Reasoning in Large Language Models» (2022) — arXiv:2201.11903. Почему промежуточные рассуждения помогают.
- Wang et al., «Self-Consistency Improves Chain of Thought Reasoning» (2022) — arXiv:2203.11171. Несколько траекторий и голосование.
- Muennighoff et al., «s1: Simple test-time scaling» (2025) — arXiv:2501.19393. Бюджетное управление рассуждением.
- DeepSeek-AI, «DeepSeek-R1» (2025) — arXiv:2501.12948. Рассуждающая модель и обучение через RL.
- llama.cpp,
tools/server/README.md— GitHub. Параметры сэмплирования и шаблоны.
11. Вызов инструментов: шаблоны чата, грамматики, JSON Schema
Зачем эта глава. Модель не «вызывает функции» — она пишет текст. Весь вызов инструментов держится на договорённости: шаблоне чата, формате сообщений и парсере. Если договорённость нарушена, агент ломается, даже когда модель умная.
За 30 секунд
- Модель не вызывает функции, а пишет текст в формате, которому её обучили; сервер находит эту разметку и превращает её в
tool_calls.- Связующее звено — шаблон чата: неправильный шаблон ломает tool calling даже у сильной модели.
- Грамматика и JSON Schema гарантируют синтаксис ответа, но не правильность значений и не выбор инструмента.
- Агентский цикл ограничивают шагами, бюджетом и проверкой аргументов; всё, что пришло извне, считается недоверенным.
11.1 Модель пишет текст, сервер разбирает
Механика вызова инструментов:
- Приложение описывает доступные инструменты: имя, назначение, параметры.
- Сервер подставляет эти описания в промпт через шаблон чата (chat template) в формате, на котором модель обучалась.
- Модель отвечает специальной разметкой, например:
<tool_call>{"name": "get_weather", "arguments": {"city": "Москва"}}</tool_call>
- Сервер парсит разметку и отдаёт приложению стандартные OpenAI-совместимые
tool_calls. - Приложение выполняет инструмент и отправляет результат обратно сообщением с ролью
tool.
Важно: никакого встроенного механизма вызова у модели нет. Есть только обучение на текстовых форматах и парсер на сервере.
Весь круг одного вызова целиком:
sequenceDiagram
participant App as Приложение
participant Srv as Сервер (шаблон + парсер)
participant LLM as Модель
participant Tool as Инструмент
App->>Srv: messages + описания tools (JSON)
Srv->>LLM: промпт, собранный шаблоном чата
LLM-->>Srv: текст: #lt;tool_call#gt;{"name": "get_weather", ...}#lt;/tool_call#gt;
Srv-->>App: tool_calls (OpenAI-совместимый JSON)
App->>Tool: get_weather(city="Москва")
Tool-->>App: {"temp_c": 12, ...}
App->>Srv: история + сообщение с ролью tool
Srv->>LLM: тот же префикс + результат (кэш промпта, гл. 7)
LLM-->>Srv: обычный текст ответа
Srv-->>App: content без tool_calls — цикл окончен
Модель общается только с сервером и только текстом. Сам инструмент вызывает приложение — и именно приложение отвечает за проверку аргументов и права доступа.
11.2 Шаблон чата
Chat template — правило, как роли (system, user, assistant, tool), сообщения и описания инструментов превращаются в последовательность токенов. Он хранится в метаданных модели (в GGUF — внутри файла) и обычно написан на Jinja.
Пример упрощённо:
<|system|>
Ты — помощник. Доступные инструменты: ...
<|user|>
Какая погода в Москве?
<|assistant|>
<tool_call>...
Что ломается, если шаблон неправильный:
- модель не понимает, где заканчивается сообщение;
- описания инструментов попадают не туда;
- специальные токены превращаются в обычный текст;
- модель отвечает в формате другой модели.
В современных сборках llama.cpp Jinja включена по умолчанию. Флаг --jinja имеет смысл явно указывать для старых сборок или для совместимости; отключить шаблон можно --no-jinja. Если нужен свой шаблон, а не тот, что лежит в метаданных модели, используйте --chat-template (строка) или --chat-template-file (файл). Если шаблон неправильный или отключён, сервер может применить упрощённый формат, и tool calling перестанет работать.
Минимальный пример: от запроса до tool_calls
Клиент отправляет инструменты в OpenAI-совместимом формате:
{
"model": "local-model",
"messages": [{"role": "user", "content": "Какая погода в Москве?"}],
"tools": [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Погода в городе",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"]
}
}
}],
"tool_choice": "auto"
}
Сервер подставляет описание в шаблон, модель отвечает разметкой, парсер превращает её в:
{
"choices": [{
"message": {
"role": "assistant",
"content": null,
"tool_calls": [{
"id": "call_1",
"type": "function",
"function": {"name": "get_weather", "arguments": "{\"city\":\"Москва\"}"}
}]
},
"finish_reason": "tool_calls"
}]
}
Приложение выполняет get_weather, добавляет результат и отправляет новый запрос:
{"role": "tool", "tool_call_id": "call_1", "content": "{\"temp_c\": 12, \"condition\": \"облачно\"}"}
Дальше цикл повторяется, пока модель не вернёт обычный content без tool_calls.
11.3 Форматы tool calls
Разные семейства моделей обучены на разных форматах:
- JSON в специальных токенах;
- XML-подобные теги;
- отдельные маркеры ролей;
- массивы вызовов для параллельных инструментов.
Сервер знает формат благодаря шаблону и парсеру. Если вы меняете модель, проверьте:
- совместим ли шаблон с вашим клиентом;
- поддерживает ли сервер парсинг именно этого формата;
- как выглядят параллельные вызовы;
- что происходит при ошибке парсинга.
Универсального формата нет; «OpenAI-совместимость» — это про API, а не про внутренний текст модели.
11.4 Грамматики и JSON Schema
Даже хорошая модель иногда ломает JSON. Есть жёсткое решение: constrained decoding (ограниченное декодирование).
Идея: на каждом шаге парсер знает, какие токены допустимы в текущем состоянии грамматики, и запрещает все остальные: их логиты заменяются на минус бесконечность, то есть после softmax вероятность становится нулевой. Тогда синтаксически неверный JSON невозможно сгенерировать.
В llama.cpp для этого есть:
- GBNF — грамматика в нотации, похожей на BNF;
--grammarи--grammar-file;response_format: {"type": "json_schema", ...}— JSON Schema, преобразованная в грамматику;- серверный
--json-schema.
Другие реализации:
- Outlines — компиляция регулярных выражений и JSON Schema в маски;
- XGrammar — быстрый движок структурированной генерации;
- в vLLM — strict tool schema и guided decoding.
Что гарантирует грамматика:
- синтаксис (валидный JSON, нужные поля, типы);
- отсутствие «болтовни» вокруг JSON.
Чего она не гарантирует:
- правильность значений (модель может поставить выдуманное число);
- соответствие схеме по смыслу (например, «дата» может быть неверной);
- что модель выберет правильный инструмент;
- что аргументы будут полными по смыслу, а не только по форме.
Грамматика — это ремень безопасности, а не замена проверке.
Warning
Грамматика не спасает от обрыва по лимиту длины. Если
max_tokensзакончился посреди объекта, вы получите незакрытый JSON — синтаксически неверный, хотя каждый токен был «разрешён». Проверяйтеfinish_reason: значениеlengthозначает, что ответ обрезан.
11.5 Производительность грамматик
Ограниченное декодирование добавляет накладные расходы:
- на каждом шаге нужно вычислить маску допустимых токенов;
- сложные схемы (глубокая вложенность, большие перечисления) замедляют;
- некоторые реализации кэшируют состояния, другие пересчитывают.
На практике для типичной схемы на 10–20 полей overhead невелик, но на очень больших схемах может быть заметен. Если скорость критична, упрощайте схему.
11.6 Дизайн инструментов
Хорошая схема повышает надёжность сильнее, чем любая магия промптинга.
Правила:
- Мало инструментов. 5–15 лучше, чем 50. Каждый инструмент — это текст в промпте и шанс ошибиться.
- Ясные имена и описания. Модель выбирает по описанию, а не по вашему замыслу.
- Плоские аргументы. Глубокая вложенность увеличивает число ошибок.
- Enums вместо свободного текста. Если значение из фиксированного набора — перечислите его.
- Обязательные поля — действительно обязательные. Не делайте всё optional.
- Ошибки как данные. Возвращайте структурированную ошибку, чтобы модель могла исправиться.
- Ограничивайте размер результата. Огромный вывод инструмента съедает контекст и ломает кэш.
Посчитай сам. Каждое описание инструмента занимает в промпте около 150 токенов [пример]. Сколько prefill добавят 15 и 50 инструментов при скорости обработки промпта 1000 ток/с — без кэша промпта и с ним?
Решение
15 инструментов: 15 × 150 = 2 250 токенов → 2,25 с на каждый запрос
50 инструментов: 50 × 150 = 7 500 токенов → 7,5 с на каждый запрос
С кэшем промпта (глава 7) это время платится один раз — если описания стоят в начале и не меняются. Без кэша агент из 30 шагов с 50 инструментами потратит на перечитывание одних только описаний почти 4 минуты. И это не считая того, что модели труднее выбрать правильный инструмент из 50.
11.7 Цикл агента
Типичный цикл:
while not done and steps < max_steps:
response = model(messages, tools)
if response has tool_calls:
for call in tool_calls:
result = execute(call)
messages.append(tool_result)
else:
done
Проблемы, которые надо предусмотреть:
- модель не вызывает
finishи крутится до лимита; - повторяет один и тот же вызов;
- вызывает несуществующий инструмент;
- передаёт битые аргументы;
- теряет цель на длинной истории;
- переполняет контекст результатами инструментов.
Лечения:
- явное условие завершения и инструмент
finish; - лимит шагов и бюджета токенов;
- валидация аргументов на стороне приложения;
- напоминания о формате при ошибке;
- сжатие или суммаризация истории (осторожно с кэшем промпта);
- грамматика для аргументов.
11.8 Безопасность
Вызов инструментов — это исполнение действий. Даже локальная модель может:
- выполнить опасную команду, если инструмент ей это позволяет;
- передать данные из документа в нежелательное место;
- поддаться prompt injection в тексте документа или результате инструмента.
Правила:
- минимальные права у инструментов;
- подтверждение опасных действий человеком;
- изоляция файловой системы и сети;
- валидация входных данных, а не доверие модели;
- логирование вызовов.
Отдельно про prompt injection: вредоносная инструкция может прийти не от пользователя, а из документа, результата поиска, OCR-текста или ответа инструмента. Модель не всегда отличает данные от команд. Поэтому:
- считайте всё, что пришло из внешнего мира, недоверенным;
- не давайте инструментам больше прав, чем нужно для задачи;
- проверяйте пути к файлам и аргументы команд, а не только их наличие;
- ограничивайте сетевой доступ инструментов;
- для MCP-серверов и плагинов используйте отдельный процесс/контейнер и allowlist.
Секреты не должны попадать в промпт: модель может их повторить, а логи — сохранить. Ключи храните в переменных окружения или хранилище, а в промпт передавайте только необходимый минимум.
Локальность модели не делает её безопасной: она лишь убирает утечку в облако.
11.9 Как измерять качество вызова инструментов
Метрики:
- доля синтаксически валидных вызовов;
- доля вызовов с правильным инструментом;
- доля с правильными аргументами;
- среднее число шагов до завершения;
- доля незавершённых задач;
- доля повторных/зацикленных вызовов.
Прогоняйте на реальных сценариях, а не на одном примере. Полезны публичные бенчмарки (например, BFCL), но они не заменяют ваш домен.
Ключевые идеи
- Вызов инструментов — это текст плюс парсер, а не встроенная функция модели.
- Шаблон чата определяет формат; без правильного шаблона tool calling ломается.
- Грамматика и JSON Schema гарантируют синтаксис, но не смысл.
- Хороший дизайн инструментов важнее сложных промптов.
- Агентский цикл нужно ограничивать шагами, бюджетом и проверкой аргументов.
Проверь себя
- Почему модель «не знает», что у неё есть инструменты, без шаблона чата?
- Что гарантирует грамматика JSON и чего она не гарантирует?
- Почему 50 инструментов хуже 10?
- Как prompt injection может повлиять на агента с инструментами?
- Какую метрику вы бы смотрели в первую очередь при отладке tool calling?
Ответы
- Описания инструментов и формат вызова передаются модели только через промпт, собранный шаблоном. Без шаблона модель не получает ни описаний, ни разметки, на которой обучена.
- Гарантирует синтаксис: валидный JSON, нужные поля, типы. Не гарантирует правильность значений, выбор инструмента и смысловое соответствие.
- Каждый инструмент занимает место в промпте и увеличивает число вариантов. Модели труднее выбрать, растёт вероятность ошибки и стоимость prefill.
- Вредоносный текст в документе или результате инструмента может убедить модель вызвать инструмент с опасными аргументами. Модель не отличает данные от инструкций, если это не предусмотрено дизайном.
- Долю валидных вызовов с правильным инструментом и аргументами, а также долю задач, завершённых без зацикливания. Синтаксическая валидность без правильного инструмента бесполезна.
Источники главы
- Patil et al., «Gorilla: Large Language Model Connected with Massive APIs» (2023) — arXiv:2305.15334. Обучение моделей вызову API.
- Schick et al., «Toolformer» (2023) — arXiv:2302.04761. Модель учится вызывать инструменты.
- Willard & Louf, «Efficient Guided Generation for Large Language Models» (2023) — arXiv:2307.09702. Outlines и маскирование логитов.
- Dong et al., «XGrammar» (2024) — arXiv:2411.15100. Быстрая структурированная генерация.
- llama.cpp,
docs/function-calling.md— GitHub.--jinja,tool_choice, параллельные вызовы. - llama.cpp,
grammars/README.md— GitHub. Синтаксис GBNF. - Berkeley Function Calling Leaderboard — gorilla.cs.berkeley.edu. Публичный бенчмарк вызова функций.
- vLLM, «Tool Calling» — docs.vllm.ai. Строгие схемы и
tool_choice.
12. Методика бенчмарка и тюнинга
Зачем эта глава. Локальный тюнинг полон самообмана: кэш прогревает промпт, синтетика повторяет ответ, фоновая программа ест VRAM, а разница в 3% оказывается шумом. Здесь — как мерить так, чтобы цифрам можно было верить.
За 30 секунд
- Есть три уровня замеров: микробенчмарк (
llama-bench), серверный и сквозной (реальная задача). Решение принимают по сквозному.- Меняйте один параметр за раз, повторяйте минимум 3–5 раз и смотрите медиану и разброс.
- Разница меньше 3–5% на домашнем железе обычно шум; VRAM смотрят в пике под нагрузкой.
- Лучший конфиг — не максимальный ток/с, а самое короткое время задачи без потери качества.
- Сравнивайте с нижней границей и разбирайте, какой отрезок вырос: очередь, prefill, decode или число шагов.
12.1 Три уровня измерений
Не смешивайте их.
- Микробенчмарк —
llama-benchили аналог: фиксированные промпты, измерение pp и tg на разных глубинах контекста. Хорош для сравнения конфигов, плох для предсказания времени задачи. - Серверный замер — реальные запросы к
/v1/chat/completions, метрики из ответа и логов: prompt eval, eval, TTFT, общее время. - Сквозной замер — прогон реальной задачи: качество, число шагов, завершаемость, время на документ/запрос.
Конфиг, который выигрывает микробенчмарк, может проиграть сквозной замер. И наоборот.
Весь тюнинг — это цикл, в котором каждая итерация меняет ровно одну вещь:
flowchart TB
B["Базовая линия:<br/>фиксируем железо, сборку,<br/>модель, набор задач"] --> H["Гипотеза:<br/>какой один параметр<br/>и почему поможет"]
H --> M["Микробенчмарк<br/>llama-bench: pp/tg<br/>на нескольких глубинах"]
M --> V{"Пик VRAM<br/>с запасом 1,5–2 ГБ?"}
V -->|"нет"| REJ["Конфиг невалиден,<br/>записать и откатить"]
V -->|"да"| E2E["Сквозной замер:<br/>время задачи, качество,<br/>завершаемость, 3–5 повторов"]
E2E --> D{"Разница больше шума<br/>и качество не упало?"}
D -->|"да"| ACC["Новая базовая линия"]
D -->|"нет"| NEG["Отрицательный результат —<br/>тоже в отчёт"]
ACC --> H
NEG --> H
REJ --> H
12.2 llama-bench: что и как
llama-bench измеряет:
- pp (
-p N) — обработку промпта длиной N; - tg (
-n N) — генерацию N токенов; - depth (
-d ...) — на какой глубине контекста мерить; - repeats (
-r N) — число повторов; - load mode (
-lm) — как загружается модель.
Типичный запуск:
llama-bench -m model.gguf -p 512 -n 128 -d 0,8192,16384,32768 -r 3 -lm none
Почему важны глубина и режим загрузки:
- на пустом контексте всё быстро; на 32k attention дороже;
- при mmap страницы весов могут подкачиваться с диска, и prefill падает в разы. Для честного замера загружайте модель так же, как сервер (
-lm none). Старый--no-mmapв новых сборках llama.cpp уже не используется — проверьте--help.
В выводе смотрите медиану и разброс. Одно число без разброса почти бесполезно.
12.3 Контроль переменных
Меняйте один параметр за раз. Иначе не поймёте, что помогло.
Фиксируйте:
- модель и квант (хеш файла);
- версию рантайма и бэкенда;
- контекст;
- число слотов;
- температуру и другие параметры сэмплирования;
- набор промптов;
- фоновую нагрузку.
Записывайте всё это в отчёт. Через месяц вы не вспомните, на какой сборке получены цифры.
12.4 Шум и повторы
Источники шума:
- тепловой троттлинг и изменение частот GPU;
- фоновые процессы (браузер, обновления, антивирус);
- кэш промпта: первый запрос холодный, последующие горячие;
- разные длины ответов;
- округление и планировщик.
Практика:
- минимум 3 повтора, лучше 5;
- медиана устойчивее среднего;
- сообщайте стандартное отклонение или интерквартильный размах;
- сравнивайте конфиги на одних и тех же промптах;
- отдельно измеряйте холодный и горячий кэш.
Разница меньше 3–5% на потребительском железе часто находится в пределах шума. Не принимайте решение по одному прогону.
Tip
Перед серией замеров закройте браузер и другие программы, использующие GPU, дайте карте прогреться одним «холостым» прогоном и только потом начинайте записывать числа. Холодная карта в первые минуты может держать более высокие частоты и показать результат лучше устоявшегося.
12.5 Память: смотреть в пике
VRAM после загрузки модели — не показатель. Пик возникает под нагрузкой, на длинном промпте или при генерации.
Как мерить:
- опрашивайте
nvidia-smiнесколько раз в секунду во время прогона; - смотрите максимум, а не среднее;
- проверяйте свободную ОЗУ и активность диска;
- на Windows помните про тихую выгрузку в системную память (подробнее — глава 3).
Бюджет и запас — как в главе 3: оставляйте 1,5–2 ГБ VRAM. Если пик упирается в предел, конфиг нестабилен даже если «сейчас работает».
Минимальный набор команд для диагностики:
# пик и динамика VRAM/загрузки/частот
nvidia-smi --query-gpu=memory.used,memory.total,utilization.gpu,power.draw,clocks.sm \
--format=csv -l 1
# краткая сводка по памяти и загрузке
nvidia-smi dmon -s mu
В логах llama-server смотрите prompt eval time, eval time, draft acceptance и размер обработанного промпта. Если eval time растёт, а частоты падают — вероятен троттлинг; если падает prompt eval, проверьте mmap и диск.
12.6 Что именно измерять
Для декода:
- ток/с (tg), медиана по запросам;
- время до первого токена (TTFT);
- inter-token latency;
- acceptance rate, если включена спекуляция.
Для prefill:
- ток/с на разных длинах (4k, 16k, 32k);
- сколько токенов реально обработано (с учётом кэша).
Для задачи:
- время на документ/запрос;
- число шагов;
- доля завершённых;
- качество (recall, точность, доля валидного JSON).
Для памяти:
- пик VRAM;
- свободная ОЗУ под нагрузкой;
- размер KV.
12.7 Измерение против нижней границы
Обычный тюнинг сравнивает конфиг с прошлым конфигом: «стало на 20% быстрее». Этого мало. Прошлый конфиг мог быть плохим, а 20% — долей одной накладной расходной части. Правильная точка отсчёта — физическая нижняя граница для той же модели, кванта, контекста и батча.
Нижняя граница на тех же условиях
Для раунда с b одновременными запросами:
T_шага ≥ max( 2 × N_active × B / Π, (W_active + b × C × k) / β )
где B — число токенов, обрабатываемых за раунд: для декода B = b (по одному токену на запрос), для prefill B = P (длина промпта). N_active — активные параметры, Π — пиковая производительность нужной точности, W_active — байты активных весов, C — контекст, k — байты KV на токен, β — достижимая пропускная способность памяти. Первое слагаемое — вычисления, второе — чтение весов и KV. При больших b вычисления растут вместе с батчем и могут догнать чтение — тогда батч перестаёт быть бесплатным и по времени.
Это нижняя граница, а не прогноз: быстрее физически нельзя, медленнее — можно. Отношение
MBU = T_нижняя / T_измеренная
показывает, какая доля времени шага приходится на полезное чтение. Для prefill аналогично считают MFU по вычислениям.
Пример: 8B в Q4_K_M (W = 4,2 ГБ), контекст 8k (KV = 1,074 ГБ), β = 400 ГБ/с, измерено 32 ток/с.
T_нижняя = (4,2 + 1,074) / 400 = 13,2 мс
T_измер. = 1000 / 32 = 31,25 мс
MBU = 13,2 / 31,25 ≈ 0,42
разрыв = 18 мс
18 мс — это не «плохая память», а то, чего нет в формуле: запуск ядер, синхронизация, хост, сэмплинг, неполная загрузка. Разрыв нужно объяснить, а не просто замерить.
Две причины разрыва
Их всего две, и различаются они экспериментом.
- Неполнота модели. Разрыв растёт вместе с байтами или FLOPs: не учтены чтение KV, векторные операции, сэмплинг, дополнение до формы блока.
- Накладные расходы реализации. Разрыв почти не меняется, когда меняется объём: хост отправляет ядра по одному, синхронизация, журналирование, планировщик, выгрузка.
Проверка: измените объём, оставив всё остальное. Поднимите контекст с 8k до 32k. Нижняя граница вырастет на 3 × 1,074 / 400 ≈ 8,1 мс. Если измерение выросло примерно на столько же — вы упёрлись в чтение KV, модель неполна. Если почти не выросло — разрыв фиксированный, это накладные расходы. Аналогично с батчем: если нижняя граница выросла на 10 мс, а измерение на 3 мс, вы распределяете постоянную часть, а не ускоряете память.
Какой отрезок вырос
Прежде чем что-то менять, разложите время запроса:
flowchart TB
A["Запрос пришёл"] --> B["Очередь:<br/>ожидание слота"]
B --> C["Prefill:<br/>обработка промпта"]
C --> D["Decode:<br/>ITL × число шагов"]
D --> E["Ответ"]
B -.->|"TTFT растёт,<br/>ITL стабилен"| B1["Очередь/память KV"]
C -.->|"TTFT растёт<br/>с длиной промпта"| C1["Prefill"]
D -.->|"ITL растёт"| D1["Декод/контекст/<br/>батч/выгрузка"]
D -.->|"ITL тот же,<br/>шагов больше"| E1["Рассуждение,<br/>повторы, инструменты"]
| Что выросло | Признак | Что проверить | Что делать |
|---|---|---|---|
| Очередь | TTFT растёт, ITL стабилен | загрузка по окнам, N = λT, заполнение пула KV | мощность, допуск, отмена, меньше слотов/контекста |
| Prefill | TTFT растёт с длиной промпта | prompt eval time, -ub, mmap/диск | кэш префикса, -ub, загрузка в память |
| Decode | ITL растёт | длина контекста, батч, CPU-эксперты, троттлинг | квант, KV, спекуляция, раскладка слоёв |
| Число шагов | ITL тот же, ответ длиннее | бюджет рассуждений, повторы, циклы инструментов | ограничить reasoning, чинить промпт/парсер |
| Вне модели | GPU простаивает, ITL не меняется | инструменты, сеть, клиент, логирование | ускорять инструмент, а не модель |
В llama-server смотрите prompt eval time, eval time и draft acceptance; в vLLM — очередь, заполнение KV-пула и вытеснения. Если ITL подскакивает ровно в моменты, когда другой запрос делает длинный prefill, — это не «медленная модель», а планирование: лечится блочным prefill или ограничением бюджета токенов.
Одна гипотеза — одно изменённое условие
Правило простое и его трудно соблюсти: за один эксперимент меняется одна вещь. Если включили граф, выключили кэш префикса и заново собрали входы, вы не узнаете, что дало эффект. В примере книги одновременное отключение журналирования, кэша и пересборка входов дали падение с 26,5 до 12,1 мс — но вклад каждого условия не разделён.
Как сравнивать:
- чередуйте A и B: A, B, A, B, … — а не серию A, потом серию B;
- считайте медиану парной разницы на одинаковых запросах, а не разность двух медиан;
- заранее назовите ожидаемый эффект в миллисекундах и долю этапа по Амдалу;
- назовите порог, после которого исправление перестанет помогать.
Посчитай сам. TTFT = 30 с, ITL = 25 мс, промпт 6000 токенов, pp = 1500 ток/с, интенсивность 0,8 запроса/с. Где потеряно время и что проверять в первую очередь?
Решение
prefill = 6000 / 1500 = 4,0 с
один шаг decode = 0,025 с
TTFT_нижняя ≈ 4,025 с
очередь ≈ 30 − 4,025 ≈ 26 с
Почти всё время — очередь, а не prefill. Проверяем закон Литтла: N = 0,8 × 30 = 24 запроса в системе. Если каждому нужно 1 ГиБ KV на 8k, это 24 ГиБ только под кэш — на 24-гигабайтной карте невозможно. Значит, сервер держит очередь из-за памяти, а не из-за медленного prefill. Первый эксперимент — уменьшить контекст или число слотов и посмотреть, упадёт ли TTFT; ускорять pp бессмысленно.
12.8 Ловушки самообмана
Прогретый кэш. Первый запрос медленный, последующие быстрые. Если мерить только второй, вы измерите кэш, а не модель.
Синтетический повтор. Если промпт и ответ повторяются, n-граммная спекуляция и кэш дают фантастические цифры. Годится только реальный трафик.
Разные длины ответов. Время задачи зависит от того, сколько модель «наболтала». Сравнивайте ток/с, а не только секунды.
Кэш экспертов и VRAM. Флаг может ускорить генерацию и незаметно ухудшить завершаемость. Смотрите качество, а не только скорость.
Фон. Браузер с 50 вкладками, обновление Windows или другой сервер на той же карте меняют результат.
Версия рантайма. Поведение флагов меняется между сборками. Записывайте версию.
Один прогон. Разброс на потребительском железе легко достигает 10–20% на коротких задачах.
12.9 Пример: тюнинг на 16 ГБ (вымышленный)
Это пример. Числа вымышлены и приведены только для иллюстрации методики. Не переносите их на своё железо.
Железо: карта 16 ГБ, 32 ГБ ОЗУ, модель 30B MoE в Q4 (~18 ГБ), контекст 32k. Бюджет VRAM — 14,5 ГБ (запас 1,5 ГБ).
| Конфиг | pp, ток/с | tg, ток/с | Пик VRAM | Время задачи | Завершено |
|---|---|---|---|---|---|
База, -ub 512 | 900 | 38 | 13,6 ГБ | 95 с | 5/5 |
-ub 1024 | 1450 | 38 | 14,1 ГБ | 78 с | 5/5 |
-ub 2048 | 1900 | 37 | 15,2 ГБ | — | не влезло |
--n-cpu-moe 22 (+2 слоя) | 850 | 35 | 12,9 ГБ | 92 с | 5/5 |
-ub 1024 + MTP γ=4 | 1450 | 58 | 14,5 ГБ | 62 с | 5/5 |
-ub 1024 + MTP γ=5 | 1450 | 60 | 14,5 ГБ | 71 с | 4/5 |
Как читать:
-ub 2048не влез — это не «медленно», это невалидный конфиг;- выгрузка двух слоёв освободила память, но стоила скорости;
- MTP дал +53% к декоду, но γ=5 добавил 2 ток/с и сломал один прогон;
- итог:
-ub 1024+ MTP γ=4, потому что время задачи и завершаемость важнее пикового ток/с.
Warning
«5/5 против 4/5» на пяти прогонах — слабое доказательство. Это разница в один прогон, и §12.12 объясняет, почему её нельзя считать надёжной. В реальном тюнинге такой результат — повод прогнать 20–50 задач, а не повод для вывода.
Обратите внимание: выбран не самый быстрый по ток/с конфиг, а самый быстрый по времени задачи при сохранении качества. Это типичный результат.
12.10 Отчёт о замере
Минимальный шаблон:
Железо: GPU, VRAM, CPU, RAM, ОС
Рантайм: версия, бэкенд, флаги
Модель: имя, квант, хеш файла
Контекст: -c, -np, KV-квант
Нагрузка: набор промптов, длины, температура
Повторы: n, медиана, stdev
Результаты: pp/tg по глубинам, TTFT, время задачи
Память: пик VRAM, свободная RAM
Качество: метрики, доля завершённых
Вывод: что меняем и почему
Без этого отчёта через неделю вы будете гадать, что означала цифра «42».
12.11 Отрицательные результаты
Записывайте то, что не сработало:
- флаг, который не дал эффекта;
- конфиг, который не влез;
- квант, который ухудшил качество;
- спекуляцию, которая замедлила.
Это экономит время вам и другим. «Не помогло» — такой же результат, как «помогло».
12.12 Статистика без магии
- Для бинарных метрик (завершено/нет) используйте доверительные интервалы, а не проценты из 5 наблюдений.
- Для сравнения конфигов лучше парные прогоны на одних и тех же кейсах.
- Учитывайте, что при сравнении многих конфигов один может случайно оказаться лучшим.
- Эффект должен быть больше шума, чтобы ему верить.
Формальная статистика не нужна для домашнего тюнинга, но понимание разброса — обязательно.
Посчитай сам. Конфиг A завершил 5 задач из 5, конфиг B — 4 из 5. Насколько это различие надёжно? Оцените 95%-ные доверительные интервалы для доли успеха (удобная формула для малых выборок — интервал Уилсона).
Решение
A: 5/5 → интервал ≈ [0,57; 1,00]
B: 4/5 → интервал ≈ [0,38; 0,96]
Интервалы почти целиком перекрываются: по пяти прогонам нельзя утверждать, что A надёжнее B. Даже при 20 задачах результаты 20/20 и 18/20 дают интервалы [0,84; 1,00] и [0,70; 0,97] — всё ещё с перекрытием. Отсюда практическое правило: для решений о качестве нужны десятки задач, а не пять.
Ключевые идеи
- Микро-, серверный и сквозной замеры отвечают на разные вопросы.
- Сравнивайте измерение с нижней границей; разрыв — это либо неполнота модели, либо накладные расходы.
- Разложите время на очередь, prefill, decode и число шагов — и лечите тот отрезок, который вырос.
- Меняйте один параметр, фиксируйте версию, модель и нагрузку.
- Медиана и разброс важнее одного числа; меньше 3–5% — часто шум.
- VRAM смотрите в пике под нагрузкой, а не после загрузки.
- Лучший конфиг — не максимальный ток/с, а лучший баланс времени, качества и завершаемости.
- Записывайте отрицательные результаты.
Проверь себя
- Почему
llama-benchс mmap может показать prefill в разы ниже реального? - Вы получили 41 и 43 ток/с на двух конфигах. Можно ли утверждать, что второй лучше?
- Почему время задачи — плохая метрика, если модель сгенерировала разное число токенов?
- Зачем мерить VRAM в пике, а не после загрузки?
- Почему синтетический тест спекуляции на повторяющемся промпте бесполезен?
- Измеренный шаг 31 мс, нижняя граница 13 мс. Что это говорит и как понять, куда ушли 18 мс?
Ответы
- При mmap страницы весов подкачиваются с диска по мере обращения. На prefill это добавляет чтение с диска, и скорость падает в разы по сравнению с явной загрузкой в память.
- Нет. Разница 5% может быть шумом. Нужны повторы, одинаковая нагрузка и оценка разброса; лучше сравнить на нескольких прогонах.
- Время зависит от длины ответа, а она у конфигов может различаться. Время задачи остаётся итоговой метрикой (§12.9), но чтобы понять причину разницы, сравнивайте отдельно ток/с декода, длину ответов, качество и завершаемость.
- После загрузки модель может занимать мало, а под длинным промптом или при генерации пик вырастет. Именно пик определяет, не уйдёт ли часть в системную память.
- Повторяющийся промпт разогревает n-граммный пул и кэш, acceptance становится близок к 1. На реальном новом тексте он будет другим.
- Это значит, что MBU ≈ 0,42: большая часть шага — не чтение весов и KV. 18 мс могут быть неполнотой модели (сэмплинг, векторные операции, дополнение) или накладными расходами (запуск ядер, хост, синхронизация). Различить можно, меняя объём при прочих равных: если контекст 8k→32k поднимает нижнюю границу на 8 мс, а измерение — почти нет, разрыв фиксированный, это накладные расходы. Если измерение растёт вместе с границей — модель не учла чтение KV.
Источники главы
- llama.cpp,
tools/llama-bench/README.md— GitHub. Флаги и формат вывода. - Databricks, «LLM Inference Performance Engineering: Best Practices» — блог. Метрики и методика продакшн-замеров.
- MLCommons, MLPerf Inference — mlcommons.org. Пример строгой методологии бенчмарка.
- Miller, «Adding Error Bars to Evals» (2024) — arXiv:2411.00640. Статистика для оценок моделей.
- llama.cpp Discussion #4167 — GitHub. Пример аккуратных замеров на разном железе.
- Bojie Li, «AI Infra in Depth», гл. 1, §1.3.4 и гл. 8, §8.6.3 — GitHub, Apache-2.0. Разложение разрыва на неполноту модели и накладные расходы, MBU/MFU и закон Амдала; идея §12.7 адаптирована под локальный сервер.
Движки инференса: llama.cpp
Зачем эта глава. До сих пор речь шла о том, как устроена модель и как её считать. Теперь — о том, чем именно её запускают. llama.cpp — самый короткий путь от файла GGUF до OpenAI-совместимого сервера: один бинарь, широкая поддержка железа, гибридный запуск «часть на GPU, часть на CPU». Эта глава о том, что у него внутри, какие флаги действительно важны и где заканчиваются его возможности.
За 30 секунд
- llama.cpp — C/C++-движок над тензорной библиотекой ggml; создавался для локального инференса на разнородном железе, а не для кластерного сервинга.
- Его сильные стороны: GGUF, CPU/GPU-гибрид, выгрузка экспертов MoE в ОЗУ, Metal/Vulkan/ROCm/SYCL, простой сервер и кэш на слот.
- Слабое место — планировщик: слоты и непрерывный батчинг есть, но до многопользовательских vLLM/SGLang он не дотягивает.
- Версия на 8 ноября 2026 — v0.9.0 (4 ноября 2026); флаги меняются между сборками, сверяйтесь с
--help.
1. Архитектура и для чего создан
llama.cpp вырос из проекта ggml — небольшой тензорной библиотеки на C. Идея была простой: взять модель LLaMA, конвертировать веса в компактный формат и считать её на обычном компьютере, без Python, CUDA-стека и облака. Отсюда три свойства, которые сохранились до сих пор:
- минимум зависимостей — один исполняемый файл и файл модели;
- гибридный запуск — слои можно разложить между GPU и CPU;
- широкий набор бэкендов — от CUDA до Vulkan и Metal.
Упрощённо путь запроса выглядит так:
flowchart LR
G["GGUF:<br/>веса, токенизатор,<br/>метаданные"] --> L["llama_model<br/>загрузка и раскладка<br/>по устройствам"]
L --> GR["граф ggml<br/>операции слоя"]
GR --> B["бэкенд:<br/>CPU / CUDA / HIP /<br/>Metal / Vulkan / SYCL"]
B --> S["слоты:<br/>контекст + KV"]
S --> API["llama-server:<br/>HTTP / OpenAI API"]
Внутри есть несколько уровней:
| Уровень | Что делает |
|---|---|
| ggml | тензоры, граф вычислений, квантованные матричные операции, бэкенды |
| libllama | загрузка модели, токенизация, KV-кэш, сэмплирование, спекуляция |
| common | общий код утилит: чат-шаблоны, парсеры, параметры |
| tools | llama-cli, llama-server, llama-bench, llama-quantize и другие |
Для локального инференса это удачная раскладка: ядро маленькое, а всё, что нужно пользователю, собрано в утилитах. Для серверного инференса — наоборот: планировщик и управление памятью проще, чем в движках, которые строились вокруг многопользовательской нагрузки.
Note
В 2026 году у проекта появился единый CLI
llama(llama cli,llama serve). Исторические бинариllama-cliиllama-serverникуда не делись, и в этой главе используются они: так проще сверять флаги с документацией сервера. Если вы ставите свежий установщик, проверьте, какое имя команды у вас вPATH.
1.1 Чего llama.cpp не делает
- Не планирует сотни пользователей так же эффективно, как vLLM/SGLang. Непрерывный батчинг есть, но block manager, вытеснение и разделяемый кэш устроены проще (глава 8).
- Не является распределённой системой. Tensor parallelism появился недавно и в основном экспериментальный; pipeline parallelism и disaggregated prefill/decode — не его сценарий.
- Не заменяет GPU-стек для обучения. Это инференс-движок.
2. Форматы весов и квантование
Основной формат — GGUF: контейнер с метаданными модели, токенизатором и тензорами. В одном файле лежит всё, что нужно для запуска; поэтому GGUF так удобен для обмена моделями. Устройство формата и k-quants/i-quants разобраны в главе 4, здесь — только то, что важно для выбора движка.
| Формат | Что это | Типичный размер | Комментарий |
|---|---|---|---|
| F16 / BF16 | половинная точность | 2 байта на вес | максимум качества, но 8B — уже ~16 ГБ |
| Q8_0 | 8-битный блоковый квант | ~1,06 байта на вес | почти без потерь, удобен для проверки |
| Q4_K_M | 4-битный k-quant | ~0,60 байта на вес | рабочий дефолт для локального запуска |
| IQ4_XS / IQ3 | i-quants с imatrix | 3–4 бита | меньше при том же качестве, но медленнее в подготовке |
| MXFP4 / NVFP4 | 4-битные форматы с общими масштабами | ~4–4,5 бита | поддержка зависит от архитектуры и бэкенда |
| FP8 E4M3 | 8-битный float | ~1 байт на вес | добавлен в v0.9.0; полезен на новых GPU |
Квантовать можно штатной утилитой:
llama-quantize model-f16.gguf model-Q4_K_M.gguf Q4_K_M
Для i-quants полезно сначала посчитать imatrix на своём тексте — это меняет не размер, а качество квантования на вашем домене (глава 4, §4.6). Для обычного чата чаще достаточно Q4_K_M или Q5_K_M.
Warning
GGUF — не универсальный формат. vLLM и SGLang читают его ограниченно и не для всех архитектур; их родной формат — HF safetensors. Если вы планируете переносить модель между движками, заранее решите, какой формат будет основным, и проверьте поддержку конкретной архитектуры.
2.1 Квантование KV-кэша
Отдельный рычаг — тип KV-кэша. В llama.cpp он задаётся независимо для K и V:
-ctk q8_0 -ctv q8_0
Допустимые значения в текущей сборке: f32, f16, bf16, q8_0, q4_0, q4_1, iq4_nl, q5_0, q5_1. По умолчанию — f16. q8_0 обычно почти не заметен по качеству и экономит примерно вдвое; q4_0 экономит сильнее, но требует проверки на вашей модели. Квантованный KV работает через Flash Attention, поэтому включайте -fa on.
Формула размера KV и влияние GQA/MLA — в главе 6. Здесь важно запомнить: квантование KV не меняет веса и не ускоряет декод само по себе; оно позволяет держать более длинный контекст или больше слотов в той же VRAM.
3. Поддержка железа
llama.cpp — самый «всеядный» из трёх движков. Список бэкендов в v0.9.0:
| Бэкенд | Железо | Замечание |
|---|---|---|
| CPU | x86, ARM, RISC-V | AVX/AVX2/AVX512, NEON, SVE; работает всегда |
| CUDA | NVIDIA | основной быстрый путь |
| HIP / ROCm | AMD | Radeon и Instinct; на Linux |
| Metal | Apple Silicon | первый класс поддержки, объединённая память |
| Vulkan | NVIDIA, AMD, Intel | переносимый GPU-путь, хорош на нестандартных сборках |
| SYCL | Intel GPU | Arc, Data Center Max, встроенные GPU |
| CANN | Huawei Ascend | отдельная сборка |
| MUSA | Moore Threads | отдельная сборка |
| OpenCL | Adreno и др. | мобильные/встроенные GPU |
| WebGPU | браузер/эксперимент | не для продакшена |
| RPC | несколько машин | экспериментальная распределённая схема |
3.1 Сколько слоёв на GPU
Главный флаг — -ngl (--n-gpu-layers):
-ngl all # все слои на GPU
-ngl 32 # только 32 слоя
-ngl 0 # только CPU
Значение all (или большое число) означает «сколько влезет»; лишнее просто останется на CPU. В свежих сборках по умолчанию работает --fit on: сервер сам подгоняет незаданные параметры под память. Для воспроизводимых замеров лучше задавать -ngl, -c и -np явно, иначе конфиг будет меняться от запуска к запуску.
3.2 Гибридный запуск и выгрузка MoE
Если модель не влезает в VRAM целиком, есть два разных сценария.
Плотная модель. Часть слоёв остаётся на CPU:
-ngl 28 # остальное — на CPU
Каждый токен тогда проходит часть слоёв на GPU, часть на CPU. Это работает, но декод упирается в пропускную способность ОЗУ и PCIe; подробности — в главе 3.
MoE-модель. Выгоднее выгрузить не целые слои, а только экспертные FFN, оставив attention, роутер и общие части на GPU:
| Флаг | Что делает |
|---|---|
--n-cpu-moe N (-ncmoe) | экспертные FFN первых N слоёв считаются на CPU |
--cpu-moe (-cmoe) | все эксперты на CPU |
--moe-cache-mib N | кэш горячих экспертов в VRAM для тех, что остались на CPU |
-ot "\.ffn_.*_exps\.weight=CPU" | точечная выгрузка по шаблону имён тензоров |
-ncffn N | выгрузить плотные FFN первых N слоёв (для плотных моделей) |
Смысл тот же, что в главе 5: по PCIe едут только активации, а тяжёлые матрицы экспертов считаются там, где лежат. Это принципиально дешевле, чем «держать веса в ОЗУ и перегонять их на GPU на каждом токене».
Warning
В README
--n-cpu-moe Nописано как «первые N слоёв», но в разных сборках и гайдах семантика менялась. Проверяйте на своей версии: поднимите N, посмотрите на лог загрузки и пик VRAM. Если модель не стала помещаться, возможно, вы выгружаете не те слои.
Посчитай сам. MoE 35B-A3B в Q4_K_M весит около 21 ГБ, активных весов — около 1,8 ГБ. Карта 16 ГБ, ОЗУ 64 ГБ. Сколько примерно слоёв экспертов нужно оставить на CPU, чтобы модель поместилась с запасом 1,5 ГБ?
Решение
бюджет VRAM: 16 − 1,5 = 14,5 ГБ
на GPU остаётся: attention + роутер + общие части + буферы
Пусть неэкспертные части — около 5 ГБ, буферы — 1 ГБ.
Тогда на экспертов в VRAM: 14,5 − 5 − 1 = 8,5 ГБ.
Все эксперты — около 16 ГБ. Значит, на CPU уходит ~7,5 ГБ,
то есть примерно половина экспертных слоёв.
Точное число зависит от архитектуры и разбиения по слоям; начинайте с --n-cpu-moe 12–16 и подбирайте по пику VRAM. Оценка скорости такой конфигурации — по формуле §5.6: часть экспертов читается из ОЗУ, и именно она ограничивает декод.
3.3 Несколько GPU
Для нескольких карт есть -sm (--split-mode):
| Режим | Что делит | Когда использовать |
|---|---|---|
layer (по умолчанию) | слои и KV между GPU | самый простой и предсказуемый |
row | веса слоя по строкам | лучше параллелизм, больше обмена |
tensor | веса и KV | экспериментальный, ближе к tensor parallelism |
none | одна GPU | отладка |
Пропорции задаются -ts 3,1 (например, если карты разного объёма). Для равных карт можно не задавать. В v0.9.0 появилась поддержка NCCL для multi-node tensor parallelism, но это всё ещё не основной сценарий: для больших кластеров логичнее vLLM или SGLang.
4. Батчинг, слоты и кэш префиксов
4.1 Слоты
Сервер обслуживает несколько независимых контекстов — слотов. Число задаётся -np (--parallel). Исторически у каждого слота был свой KV-кэш; в новых сборках KV может быть общим пулом на все слоты, но логически слот по-прежнему остаётся отдельным запросом.
flowchart TB
Q["Очередь запросов"] --> S1["Слот 1<br/>контекст + KV"]
Q --> S2["Слот 2<br/>контекст + KV"]
Q --> S3["Слот 3<br/>контекст + KV"]
S1 --> B["Общие веса<br/>читаются один раз"]
S2 --> B
S3 --> B
Важно: в новых сборках KV может быть единым пулом на все слоты (--kv-unified, включён по умолчанию при автоматическом числе слотов). Тогда -c задаёт общий объём пула, а не «контекст каждого слота». Отдельный лимит на слот задаётся --kv-unified-per-slot N; если -c не указан, пул получается n_parallel × N.
Это удобнее старой схемы «-c делится на -np», но требует внимательности: проверяйте в логе, какой контекст реально получил слот. Подробнее про слоты и -b/-ub — в главе 8.
4.2 Два батча
-b— логический батч: сколько токенов сервер собирает за один вызов;-ub— физический микро-батч: сколько токенов GPU обрабатывает за один проход.
-ub ускоряет prefill и ест VRAM; на декод почти не влияет. Типичный безопасный дефолт — -b 2048 -ub 512; для длинных промптов и запаса VRAM можно поднять -ub до 1024. Разбор — в §8.2.
Непрерывный батчинг включён по умолчанию (-cb); отключается -nocb.
4.3 Кэш промпта
В llama.cpp кэш привязан к слоту. При новом запросе сервер ищет наибольший общий префикс с тем, что уже лежит в слоте, и считает только хвост. Флаги:
| Флаг | Смысл |
|---|---|
--cache-prompt / --no-cache-prompt | включить/выключить кэш (по умолчанию включён) |
--cache-reuse N | минимальный блок для переиспользования через сдвиг KV |
--cache-ram N | сколько МиБ отдать под кэш простаивающих слотов (по умолчанию 8192) |
--cache-idle-slots | сохранять простаивающие слоты в кэш и очищать их |
--ctx-checkpoints N | число контрольных точек контекста на слот |
--checkpoint-min-step N | минимальный шаг между контрольными точками |
--cache-reuse полезен, когда вы редактируете промпт в середине: сервер может сдвинуть KV, а не пересчитывать всё. Для агента, который всегда дописывает в конец, важнее обычный LCP-кэш и достаточно длинный контекст слота.
Tip
Если кажется, что кэш не работает, отправьте один и тот же длинный запрос дважды и посмотрите в лог
prompt eval time. Второй раз обработанных токенов должно быть мало. Если нет — ищите изменяющуюся строку в начале промпта (глава 7).
4.4 Чем это отличается от vLLM и SGLang
| llama.cpp | vLLM | SGLang | |
|---|---|---|---|
| Единица кэша | слот + LCP | блок KV по хешу | узел radix-дерева |
| Разделение между запросами | ограниченное, через unified KV | да | да, естественное |
| Вытеснение | проще | block manager | LRU/LFU и политики |
| Когда хватает | один пользователь, последовательные запросы | много пользователей | агенты с общим префиксом |
Если у вас один пользователь и последовательные запросы, разница между этими схемами невелика. Если десять агентов одновременно работают с одним системным промптом — она становится решающей (глава 7).
5. Спекулятивное декодирование и MTP
llama.cpp поддерживает несколько семейств спекуляции. Включаются они флагом --spec-type:
| Тип | Что использует |
|---|---|
draft-simple | отдельная маленькая draft-модель |
draft-eagle3 | EAGLE-3: читает скрытые состояния целевой модели |
draft-dflash | блок-диффузионный черновик, выдаёт блок за проход |
draft-dspark | DFlash + полуавторегрессивная Markov-голова |
draft-mtp | MTP-головы самой целевой модели |
ngram-cache, ngram-simple, ngram-map-k, ngram-map-k4v, ngram-mod | n-граммы без отдельной модели |
Типичный запуск с draft-моделью:
llama-server -m target-Q4_K_M.gguf \
-md draft-Q8_0.gguf \
--spec-type draft-simple \
--spec-draft-n-max 4 \
--spec-draft-p-min 0.0
Для EAGLE-3 черновик конвертируют с --target-model-dir, чтобы он унаследовал токенизатор и нужные слои (см. docs/speculative.md). Для MTP отдельный файл не нужен: --spec-type draft-mtp использует головы целевой модели, если они есть в GGUF.
Warning
Спекуляция не бесплатна. При низком acceptance rate она замедляет генерацию, потому что вы платите за черновик и проверку. Формула
E[N]и правило «черновик должен стоить дешевле(E[N] − 1) × T_plain» — в главе 9. Всегда меряйтеdraft acceptance rateв логе, а не включайте «на всякий случай».
Для повторяющегося текста (рефакторинг кода, переписывание документа, рассуждения с повторами) хорош ngram-mod: он не требует второй модели и делит пул n-грамм между слотами.
6. Структурированный вывод и tool calling
6.1 Грамматики
llama.cpp умеет ограничивать генерацию GBNF-грамматикой или JSON Schema:
llama-server -m model.gguf \
--grammar-file grammar.gbnf
или на уровне запроса:
{
"response_format": {
"type": "json_object",
"schema": {
"type": "object",
"properties": {
"answer": {"type": "string"},
"confidence": {"type": "number"}
},
"required": ["answer", "confidence"]
}
}
}
Грамматика гарантирует синтаксис, но не смысл. И помните: если max_tokens кончился посреди объекта, вы получите обрезанный JSON, хотя каждый токен был допустим (глава 11).
6.2 Tool calling
Сервер поддерживает OpenAI-style function calling. В текущих сборках Jinja-шаблоны включены по умолчанию (--no-jinja отключает); исторически для этого был нужен --jinja. Дальше работает одно из двух:
- нативный обработчик — если шаблон модели распознан (Llama 3.x, Hermes, Qwen 2.5, Mistral Nemo, Command R7B, GPT-OSS и др.);
- generic-обработчик — если шаблон не распознан; он универсальнее, но ест больше токенов.
Если модель вызывает инструменты «не тем» синтаксисом, задайте шаблон явно:
--chat-template-file my-template.jinja
Параллельные вызовы включаются в запросе:
{"parallel_tool_calls": true}
Подробно про шаблоны, парсеры и дизайн инструментов — в главе 11.
7. OpenAI-совместимый сервер
llama-server поднимает HTTP-сервер с OpenAI-совместимыми маршрутами:
| Маршрут | Назначение |
|---|---|
/v1/chat/completions | чат |
/v1/completions | генерация по тексту |
/v1/responses | Responses API |
/v1/embeddings | эмбеддинги |
/v1/rerank, /rerank | реранкинг |
/v1/models | список моделей |
/v1/messages | Anthropic-совместимый API |
/health, /props, /slots, /metrics | служебные |
Note
/v1/embeddingsработает только с embedding-моделью и флагами--embedding/--embeddings;/v1/rerankи/rerank— только с reranker-моделью и флагом--rerank/--reranking(по умолчанию реранкинг выключен). Без этого маршруты вернут ошибку, а не результат.
Минимальный запуск:
llama-server -m ./models/model-Q4_K_M.gguf \
--host 0.0.0.0 --port 8080 \
--alias local-model \
--api-key secret \
--jinja
По умолчанию сервер слушает 127.0.0.1:9931. Для доступа с другой машины нужен --host 0.0.0.0; для защиты — --api-key (можно несколько ключей через запятую или файл --api-key-file).
Warning
OpenAI-совместимость здесь практическая, а не побайтовая. Не все поля и не все ошибки совпадают с OpenAI; некоторые клиенты требуют
stream_options,tool_callsилиresponse_formatв конкретном виде. Проверяйте своим клиентом, а не толькоcurl.
8. Метрики и наблюдаемость
Включаются флагом --metrics; метрики отдаются в Prometheus-формате на /metrics:
| Метрика | Смысл |
|---|---|
llamacpp:prompt_tokens_total | обработано токенов промпта |
llamacpp:prompt_seconds_total | время prefill |
llamacpp:predicted_tokens_seconds | средняя скорость генерации |
llamacpp:requests_processing | запросов в работе |
llamacpp:requests_deferred | запросов в очереди |
llamacpp:n_tokens_max | максимум занятого контекста |
llamacpp:n_busy_slots_per_decode | средняя занятость слотов на шаг |
llamacpp:spec_decode_num_accepted_tokens_total | принято спекулятивных токенов |
Имена метрик — по README v0.9.0; в своей сборке проверьте curl /metrics.
Дополнительно:
/slots— состояние каждого слота: сколько токенов, скорость, параметры;/props— глобальные свойства и шаблон чата;/health— проверка живости;- лог сервера —
prompt eval time,eval time,draft acceptance rate; --log-jsonl— структурированный лог, удобно для парсинга.
Для микробенчмарка используйте llama-bench (глава 12):
llama-bench -m model.gguf -p 512 -n 128 -d 0,8192,32768 -r 3 -lm none
Флаг -lm относится к llama-bench, а не к серверу; он задаёт режим загрузки модели для замера.
9. Практика: установка, запуск, ошибки, тюнинг
9.1 Установка
Самый быстрый путь — установщик с llama.app:
curl -LsSf https://llama.app/install.sh | sh
Альтернативы:
- готовые бинари со страницы релизов;
- Docker (
ghcr.io/ggml-org/llama.cpp:server-cudaи другие теги); - сборка из исходников:
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j
Для AMD — -DGGML_HIP=ON, для Intel GPU — -DGGML_SYCL=ON, для Vulkan — -DGGML_VULKAN=ON. Metal на macOS включён по умолчанию. Полный список — в docs/build.md.
9.2 Одна потребительская карта: 16 ГБ VRAM + 64 ГБ ОЗУ, MoE 35B-A3B
Задача: запустить MoE 35B-A3B в Q4_K_M (~21 ГБ) на карте 16 ГБ, сохранив длинный контекст и один слот.
llama-server \
-m ./models/moe-35b-a3b-Q4_K_M.gguf \
-ngl all \
--n-cpu-moe 14 \
-c 32768 \
-np 1 \
-b 2048 -ub 512 \
-fa on \
-ctk q8_0 -ctv q8_0 \
--load-mode none \
--jinja \
--metrics \
--host 0.0.0.0 --port 8080 \
--alias local-moe
Что здесь важно:
-ngl all— все неэкспертные слои на GPU;--n-cpu-moe 14— первые 14 слоёв экспертов считаются на CPU; число подбирается по пику VRAM;-c 32768— контекст одного слота; при-np 1он же общий;-ub 512— безопасный prefill; поднимайте до 1024, если есть запас;-ctk q8_0 -ctv q8_0— KV в 8 битах, чтобы контекст поместился;--load-mode none— «без специального режима загрузки» (README:none: no special loading mode); это не отдельная настройка «только для CPU-экспертов» (глава 3).
Ожидания: декод будет заметно медленнее, чем у плотной 3B, потому что часть экспертов читается из ОЗУ. Оценка — по формуле §5.6; реальные цифры меряйте llama-bench и серверным логом (глава 12). Если 16 ГБ мало, сначала уменьшайте контекст и KV, потом увеличивайте --n-cpu-moe.
Tip
Если карта 24 ГБ, а модель 35B-A3B, часто удаётся уложить все эксперты в VRAM при контексте 8–16k; для 32k может понадобиться KV в
q8_0или меньший контекст. Тогда--n-cpu-moeне нужен, а декод будет близок к потолку памяти GPU. Это самый выгодный сценарий для MoE.
9.3 Сервер с несколькими GPU: 4×48 ГБ, плотная 70B
Задача: обслуживать несколько пользователей, модель 70B в Q4_K_M (~42 ГБ), контекст до 16k на запрос, 8 слотов.
llama-server \
-m ./models/70b-Q4_K_M.gguf \
-ngl all \
-sm layer \
--kv-unified \
--kv-unified-per-slot 16384 \
-np 8 \
-b 2048 -ub 512 \
-fa on \
-ctk q8_0 -ctv q8_0 \
--host 0.0.0.0 --port 8080 \
--metrics
Почему так:
-sm layerделит слои между картами; для равных карт пропорции можно не задавать;--kv-unified+--kv-unified-per-slot 16384создают общий пул на 8 × 16k и не требуют вручную считать-c;-np 8— восемь одновременных запросов;- KV в
q8_0экономит память; на 4×48 ГБ можно попробоватьf16, если контекст позволяет.
Для MoE на нескольких GPU вместо --n-cpu-moe лучше держать экспертов в VRAM и делить слои через -sm layer; если модель не влезает, комбинируйте --n-cpu-moe с -ts, но следите за балансом.
9.4 Типичные ошибки
| Симптом | Вероятная причина | Что делать |
|---|---|---|
CUDA error: out of memory при загрузке | слишком много слоёв/контекста | уменьшить -ngl, -c, -ub; включить --n-cpu-moe |
| OOM только на длинном промпте | KV и буферы | уменьшить -c, квантовать KV, уменьшить -ub |
| «контекст закончился» на коротком запросе | -c меньше, чем ждёт клиент, или контекст делится между слотами | проверить --kv-unified-per-slot, лог слотов |
| Модель печатает `< | im_start | >или< |
| Tool calls не разбираются | шаблон не распознан | проверить Chat format в логе, задать шаблон |
| GPU простаивает | -ngl 0, CPU-сборка или не тот бэкенд | -ngl all, проверить --list-devices |
| Очень медленный декод на CPU | слишком много потоков, mmap, эксперты в ОЗУ | -t по физическим ядрам, проверить --load-mode и --n-cpu-moe, глава 3 |
--n-cpu-moe не помогает | не та архитектура или семантика флага | проверить имена тензоров, -ot, лог |
| Спекуляция замедлила | низкий acceptance | выключить или сменить черновик, глава 9 |
| На Windows скорость резко падает | тихая выгрузка VRAM в ОЗУ | уменьшить -ngl/-c, глава 3 |
9.5 Порядок тюнинга
Ориентиры по теории: prefill/decode и потолок памяти — глава 2; размер KV и контекст — глава 6; кэш префиксов — глава 7; батчинг и слоты — глава 8; спекуляция — глава 9; методика замера — глава 12.
- Модель и квант. Сначала убедитесь, что модель влезает и качество достаточное (главы 4, 13).
- Контекст. Задайте
-cи-npпод реальную нагрузку; посчитайте KV по главе 6. - Слоты. Для одного пользователя
-np 1; для нескольких — столько, сколько выдерживает KV. - Prefill. Поднимайте
-ubдо 1024, пока есть запас VRAM 1,5–2 ГБ. - KV-квант.
q8_0почти всегда;q4_0— только с проверкой качества. - Выгрузка. Для MoE —
--n-cpu-moeи--moe-cache-mib; для плотной —-ngl. - Спекуляция. Включайте последней и только с замером acceptance.
- Замер. Один параметр за раз, 3–5 повторов, медиана (глава 12).
Ключевые идеи
- llama.cpp — C/C++-движок над ggml, созданный для локального инференса и разнородного железа.
- GGUF — его родной формат; кванты k-quants/i-quants, а также MXFP4/NVFP4/FP8 поддерживаются в зависимости от архитектуры и бэкенда.
-nglуправляет слоями на GPU;--n-cpu-moeвыгружает экспертов MoE в ОЗУ, оставляя вычисления на CPU.-npсоздаёт слоты,--kv-unified-per-slotзадаёт лимит на слот; кэш промпта привязан к слоту и ищет LCP.- Спекуляция: draft-модель, EAGLE-3, DFlash, DSpark, MTP и n-граммы; включать только по замеру.
- Сервер OpenAI-совместимый, с грамматиками, tool calling и Prometheus-метриками.
- Сильная сторона — простота и охват железа; слабая — многопользовательская пропускная способность.
Проверь себя
- Чем
--n-cpu-moeотличается от-nglпри запуске MoE? - Почему
-ubускоряет prefill, но не декод? - Что произойдёт с кэшем промпта, если в начало системного сообщения поставить текущее время?
- Зачем нужен
--kv-unified-per-slot, если есть-c? - Почему спекуляция с низким acceptance rate может замедлить генерацию?
- В каких случаях llama.cpp проигрывает vLLM и SGLang?
Ответы
-nglоставляет на CPU целые слои (attention + FFN), а--n-cpu-moe— только экспертные FFN первых N слоёв, оставляя attention и роутер на GPU. Второй вариант для MoE обычно выгоднее: по PCIe едут только активации.- Prefill обрабатывает много токенов параллельно, и больший микро-батч лучше загружает GPU. Декод генерирует по одному токену на слот, поэтому размер микро-батча не меняет объём вычислений на шаг.
- Кэш перестанет попадать: общий префикс с прошлым запросом закончится на изменяющейся строке, и всё после неё будет пересчитано.
-cзадаёт общий пул KV, а--kv-unified-per-slot— сколько из него может занять один запрос. Без второго длинный запрос может занять весь пул и вытеснить остальные.- Вы платите за генерацию черновика и проверку, а принимаете мало токенов. Если
E[N]недостаточно велик, раунд становится дороже обычного шага (глава 9). - При многих одновременных пользователях, необходимости в распределённом инференсе, сложном планировании KV и максимальной пропускной способности. Для одного пользователя и локального железа его преимущества часто перевешивают.
Источники главы
Версии и флаги проверены 8 ноября 2026 по документации и исходникам llama.cpp.
- llama.cpp, релиз v0.9.0 — ggml-org, 04.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, ggml 0.29.0, FP8 E4M3, unified KV, список бэкендов.
- llama.cpp,
tools/server/README.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: все флаги сервера, endpoints, метрики. - llama.cpp,
docs/speculative.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: типы спекуляции, EAGLE-3, DFlash, DSpark, MTP, n-граммы. - llama.cpp,
docs/build.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: сборка под CUDA, HIP, SYCL, Vulkan, Metal. - llama.cpp,
docs/function-calling.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: нативные и generic-обработчики tool calls. - llama.cpp,
docs/development/token_generation_performance_tips.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: потоки CPU, проверка offload. - llama.cpp,
grammars/README.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: синтаксис GBNF. - GGUF specification — ggml-org, 2026. GitHub. Уровень: продвинутый. Зачем: устройство контейнера.
Движки инференса: vLLM
Зачем эта глава. vLLM — один из основных серверных движков для NVIDIA/AMD GPU. В главе 8 уже разобраны PagedAttention, непрерывный батчинг и закон Литтла; здесь — как из этих идей собран конкретный движок, что означают его флаги и где он перестаёт быть удобным. Это не повторение теории, а разбор эксплуатации.
За 30 секунд
- vLLM — Python/C++/CUDA-движок для GPU-серверов: PagedAttention, непрерывный батчинг, V1-планировщик, prefix caching по хешу блоков.
- Его сильные стороны — много одновременных пользователей, tensor/pipeline/expert parallelism и широкая поддержка моделей и квантов.
- Слабые — Linux-only, требовательность к GPU-стеку, ограниченная поддержка GGUF и отсутствие удобного CPU-MoE-offload, как в llama.cpp.
- Версия на 8 ноября 2026 — v0.33.0 (тег
v0.33.0— 1 ноября 2026, релиз опубликован 2 ноября), PyTorch 2.14, CUDA 13.0, ROCm 10.0 — по release notes.
1. Архитектура и для чего создан
vLLM строился вокруг одной задачи: обслуживать много запросов к одной модели на GPU так, чтобы память под KV-кэш не превращалась в узкое место. PagedAttention (§8.5) решил проблему фрагментации, непрерывный батчинг (§8.4) — проблему простоя слотов. Дальше вырос полноценный серверный движок.
В v0.33.0 работает V1-архитектура:
flowchart LR
API["OpenAI API<br/>FastAPI"] --> EC["EngineCore"]
EC --> SCH["Планировщик:<br/>очередь, prefill/decode,<br/>вытеснение"]
SCH --> BM["Block manager:<br/>страницы KV"]
SCH --> EX["Исполнитель модели"]
BM --> KV["Paged KV cache<br/>блоки по 16 токенов"]
EX --> W["GPU-воркеры:<br/>TP / PP / EP / DP"]
W --> GPU["CUDA / ROCm / XPU"]
| Компонент | Роль |
|---|---|
| API-сервер | OpenAI-совместимые маршруты, стриминг, парсинг tool calls, метрики |
| EngineCore | цикл движка: принять запросы, спланировать, выполнить шаг, отдать токены |
| Планировщик | решает, какие запросы идут в prefill, какие в decode, кого вытеснить |
| Block manager | выдаёт и освобождает блоки KV, считает хеши префиксов |
| Исполнитель | запускает модель на GPU-воркерах, включая CUDA graphs и компиляцию |
1.1 Что важно в планировщике
- Chunked prefill включён по умолчанию. Длинный промпт режется на куски и подмешивается к декоду, чтобы не блокировать остальных (глава 8).
- Декод приоритетнее prefill. Планировщик сначала набирает декод-запросы, а остаток бюджета отдаёт prefill.
- Вытеснение (preemption). Если KV не хватает, vLLM вытесняет запросы; в V1 по умолчанию режим
RECOMPUTE— вытесненный запрос потом пересчитывается, а не хранится в ОЗУ. - Бюджеты.
--max-num-seqsограничивает число последовательностей,--max-num-batched-tokens— число токенов за итерацию.
Note
PagedAttention, внутренняя и внешняя фрагментация, закон Литтла и
b* = W / (C × k)уже разобраны в главе 8. Здесь мы не выводим их заново; важно лишь, что vLLM эксплуатирует эти идеи агрессивнее, чем llama.cpp.
1.2 Чего vLLM не делает
- Не работает на Windows нативно. Нужен Linux или WSL; это не «поставил и забыл» для домашнего ПК.
- Не является лучшим выбором для одной карты 16 ГБ. Ему нужен запас под CUDA graphs, компиляцию и KV; на маленькой карте llama.cpp часто практичнее.
- Не поддерживает GGUF так же полно, как llama.cpp. GGUF есть, но это не основной путь.
- Не выгружает экспертов MoE в ОЗУ так, как llama.cpp. Для модели, не влезающей в VRAM, обычно добавляют GPU или берут более сильный квант.
2. Форматы весов и квантование
vLLM работает с HF safetensors и конфигурацией модели. Это родной формат экосистемы Hugging Face: его отдают обученные модели, его же понимают квантователи.
| Формат | Что это | Типичное применение |
|---|---|---|
| BF16 / FP16 | половинная точность | базовый вариант на Hopper/Blackwell/Ada |
| FP8 W8A8 | веса и активации в FP8 | Hopper, Ada, Blackwell; хороший баланс |
| INT8 W8A8 | целочисленный 8-бит | Ampere и новее, CPU |
| INT4 W4A16 | 4-битные веса, 16-битные активации | экономия VRAM |
| AWQ / GPTQ | популярные 4-битные схемы | готовые чекпойнты с HF |
| bitsandbytes | динамическое квантование | быстрый старт, не для максимальной скорости |
| GGUF | формат llama.cpp | ограниченная поддержка; проверяйте архитектуру |
| NVFP4 / MXFP4 | 4-битные float-форматы | Blackwell и новее, где есть аппаратная поддержка |
| FP8 KV cache | квантование KV | экономия памяти под контекст |
Выбор кванта задаётся --quantization (или определяется из чекпойнта):
vllm serve ./models/model-awq --quantization awq
Warning
Если чекпойнт уже квантован, не включайте поверх него другой
--quantization: это не «улучшит», а сломает загрузку или качество. Сначала посмотритеquantization_configвconfig.json. Подробно про схемы квантования — глава 4.
2.1 KV-кэш
--kv-cache-dtype принимает auto, fp8, fp8_e4m3, fp8_e5m2 и (на новых платформах) FP4-варианты. FP8 KV удобен, когда нужно удвоить контекст или число одновременных запросов; качество обычно страдает мало, но проверять надо на своей модели (глава 6).
Есть и точечное исключение слоёв:
--kv-cache-dtype fp8 --kv-cache-dtype-skip-layers sliding_window
Это полезно для гибридных моделей, где скользящее окно чувствительнее к квантованию.
3. Поддержка железа
| Платформа | Поддержка | Комментарий |
|---|---|---|
| NVIDIA CUDA | основная | CUDA 13.0 в релизных колёсах v0.33.0; CUDA 12.9 больше не публикуется |
| AMD ROCm | да | ROCm 10.0 по умолчанию, 7.2 как -rocm72 |
| Intel XPU | да | отдельные сборки |
| CPU | да | x86, ARM, Apple Silicon, S390X; больше для совместимости, чем для скорости |
| Apple Silicon | через vLLM-Metal | отдельный проект, не основной ствол |
| TPU | через плагин | отдельная матрица возможностей |
| Vulkan / Metal native | нет | для этого есть llama.cpp |
3.1 Параллелизм
| Режим | Флаг | Когда нужен |
|---|---|---|
| Tensor parallelism | --tensor-parallel-size N | модель не влезает в одну карту или нужен больший KV |
| Pipeline parallelism | --pipeline-parallel-size N | очень глубокие модели, несколько узлов |
| Expert parallelism | --enable-expert-parallel | MoE: эксперты делятся между GPU |
| Data parallelism | --data-parallel-size N | копии модели для пропускной способности |
TP — самый частый вариант: он делит матрицы каждого слоя между картами. PP делит слои по стадиям и добавляет задержку; EP полезен для MoE, но требует поддержки модели. Подробнее о том, чем TP отличается от PP, — в §8.6.
3.2 Выгрузка в ОЗУ
У vLLM есть --cpu-offload-gb N: часть весов уходит в системную память и подтягивается по мере надобности через unified virtual addressing. Это позволяет запустить модель, которая чуть-чуть не влезает, но:
- пропускная способность PCIe на порядки ниже VRAM;
- на каждом токене возможны обращения к host-памяти;
- это не аналог
--n-cpu-moeв llama.cpp, где эксперты считаются на CPU.
Для MoE, который не влезает в VRAM, vLLM обычно предлагает не offload, а больше GPU, expert parallelism или более сильный квант. Если нужен именно «один GPU + ОЗУ», смотрите llama.cpp (глава 5) или Paged Experts в SGLang.
Warning
--cpu-offload-gbможет сделать запуск возможным, но не делает его быстрым. Если вы упираетесь в PCIe, лучше уменьшить модель/контекст или добавить GPU, чем надеяться на offload.
4. Батчинг, планировщик и кэш префиксов
4.1 Основные рычаги
| Флаг | Что делает | Осторожно |
|---|---|---|
--gpu-memory-utilization F | доля VRAM под модель, KV и буферы | слишком высоко — OOM на пике |
--max-model-len N | максимальный контекст | больше модели не влезет; меньше — обрежет запросы |
--max-num-seqs N | максимум последовательностей в батче | больше — больше KV и задержка |
--max-num-batched-tokens N | бюджет токенов на итерацию | больше — лучше TTFT, хуже ITL |
--kv-cache-memory-bytes N | точный размер KV | отключает профилирование, требует расчёта |
--enable-prefix-caching | кэш префиксов | по умолчанию включён |
--enforce-eager | без CUDA graphs | медленнее, но меньше памяти и быстрее старт |
Базовое значение max_num_batched_tokens в конфиге планировщика — 2048, но движок может его переопределить. Для пропускной способности документация рекомендует поднимать бюджет выше 8192, особенно для небольших моделей на больших GPU. Смотрите стартовый лог: там напечатаны реальные значения.
4.2 Prefix caching
vLLM кэширует KV блоками. Хеш блока считается не только по токенам блока, но и по хешу предыдущего блока:
Блок 1: [A gentle breeze stirred]
Блок 2: [the leaves as children] ← хеш = hash(хеш блока 1, токены блока 2)
Блок 3: [laughed in the distance] ← хеш = hash(хеш блока 2, токены блока 3)
Поэтому совпадение возможно только с начала последовательности: если изменить токен в середине, все блоки после него получат другие хеши. Кэшируются только полные блоки; при размере блока 16 токенов хвост короче 16 токенов не даст попадания.
| Параметр | Смысл |
|---|---|
--enable-prefix-caching | включить APC (по умолчанию True) |
--prefix-caching-hash-algo | sha256 (по умолчанию), sha256_cbor, xxhash, xxhash_cbor |
cache_salt в запросе | изолирует кэш между арендаторами |
--block-size | размер блока KV; по умолчанию 16 |
Note
Хеширование по умолчанию —
sha256. Это защищает от коллизий, но хеши не воспроизводимы между версиями Python/vLLM. Если нужна переносимость между средами, смотритеsha256_cbor.xxhashбыстрее, но не криптостойкий; в multi-tenant среде это риск.
4.3 Вытеснение и очередь
Когда KV-пул заполнен, vLLM вытесняет запросы. В V1 по умолчанию RECOMPUTE: запрос снимается, его KV освобождается, а при возобновлении prompt пересчитывается. Это дешевле swap в архитектуре V1, но добавляет работу.
Симптомы:
- в логе
Sequence group ... is preempted ... not enough KV cache space; - растёт
vllm:num_requests_waiting; - TTFT и ITL скачут.
Что делать: уменьшить --max-model-len или --max-num-seqs, поднять --gpu-memory-utilization (если есть запас), добавить TP. Формула N = λT из §8.4 помогает понять, сколько запросов вы пытаетесь удержать.
Посчитай сам. 70B в FP8 на 4×48 ГБ. Веса занимают около 70 ГБ. KV в FP8 — около 160 КиБ на токен. Сколько памяти останется под KV и сколько запросов с контекстом 32k поместится, если не оставлять запас?
Решение
всего VRAM: 4 × 48 = 192 ГБ
веса: 70 ГБ
доступно под KV: 192 − 70 = 122 ГБ
KV одного запроса: 32 768 × 160 КиБ ≈ 5 ГиБ
запросов: 122 / 5 ≈ 24
Без запаса и буферов — около 24 запросов на полном контексте. На практике часть VRAM уйдёт на активации, CUDA graphs и фрагментацию, поэтому планировщик сможет держать меньше; остальные будут ждать или вытесняться. Отсюда и смысл --max-num-seqs: не «сколько хотим», а «сколько реально помещается».
5. Спекулятивное декодирование и MTP
В vLLM спекуляция задаётся одним JSON-конфигом:
vllm serve ./models/target \
--speculative-config '{
"method": "mtp",
"num_speculative_tokens": 1
}'
| Метод | Что использует | Комментарий |
|---|---|---|
draft_model | отдельная draft-модель | универсально, нужен файл |
eagle3 | EAGLE-3-голова | высокий acceptance на своём домене |
mtp | MTP-головы целевой модели | не нужен отдельный чекпойнт |
ngram | n-граммы из промпта | дёшево, полезно для повторяющегося текста |
suffix | суффиксы из прошлых ответов | полезно для агентов и кода |
dflash, dspark | блок-диффузионные черновики | подтверждены в SpeculativeMethod v0.33.0; проверяйте поддержку конкретной модели |
Методы dflash и dspark есть в SpeculativeMethod v0.33.0 (vllm/config/speculative.py), а release notes упоминают DFlash/DSpark в разделе спекуляции. Это не значит, что любой чекпойнт подойдёт: нужен совместимый draft и поддержка архитектуры.
Для draft-модели можно задать отдельный TP:
--speculative-config '{
"method": "draft_model",
"model": "./models/draft",
"num_speculative_tokens": 4,
"draft_tensor_parallel_size": 1
}'
Warning
Спекуляция окупается не всегда. На высоком QPS декод и так загружен, а черновик отнимает ресурсы; выигрыш чаще на низком QPS и latency-чувствительных сценариях. Считайте
E[N]и меряйте acceptance (глава 9).
6. Структурированный вывод и tool calling
6.1 Structured outputs
vLLM поддерживает JSON Schema, regex, choice и грамматику через structured_outputs. Бэкенды — XGrammar и guidance (llguidance); lm-format-enforcer объявлен устаревшим в v0.33.0.
vllm serve ./models/model \
--structured-outputs-config.backend xgrammar
Запрос:
{
"model": "local-model",
"messages": [{"role": "user", "content": "Верни JSON с полями name и age"}],
"response_format": {
"type": "json_schema",
"json_schema": {
"name": "person",
"schema": {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "integer"}
},
"required": ["name", "age"]
}
}
}
}
По документации v0.33.0 старые поля guided_json, guided_regex, guided_choice удалены в v0.12.0; используйте structured_outputs или response_format. Подробнее — глава 11.
6.2 Tool calling
Нужны два флага: включить auto-tool-choice и выбрать парсер под шаблон модели.
vllm serve ./models/model \
--enable-auto-tool-choice \
--tool-call-parser hermes
Поддерживаются auto, required, none и именованный выбор функции. Для строгой схемы:
--tool-strict-level parameter— сервер сам требует соблюдения схемы аргументов;strict: trueв описании инструмента — то же на уровне запроса;--reasoning-parser— чтобы отделить рассуждения отtool_calls.
Если парсер не соответствует шаблону, модель может вернуть текст вместо tool_calls. Проверяйте chat_template в конфиге и документацию парсера. Дизайн инструментов — глава 11.
7. OpenAI-совместимый сервер
Запуск:
vllm serve ./models/model \
--host 0.0.0.0 \
--port 8000 \
--served-model-name local-model \
--api-key secret
Поддерживаются:
/v1/chat/completions,/v1/completions;/v1/responses;/v1/embeddings,/v1/audio/transcriptions;/v1/messages(Anthropic-совместимый);/metrics,/health.
Docker-вариант:
docker run --rm --gpus all --ipc=host \
-p 8000:8000 \
-v ~/.cache/huggingface:/root/.cache/huggingface \
-v "$PWD/models:/models" \
vllm/vllm-openai:v0.33.0 \
--model /models/model
Warning
--api-keyв vLLM защищает не все маршруты: часть служебных endpoints остаётся без аутентификации (документация). Не выставляйте сервер в интернет, полагаясь только на этот флаг; ставьте reverse proxy и сетевые ограничения.
8. Метрики и наблюдаемость
/metrics отдаёт Prometheus-метрики с префиксом vllm:. Основные:
| Метрика | Смысл |
|---|---|
vllm:num_requests_running | запросов в работе |
vllm:num_requests_waiting | запросов в очереди |
vllm:kv_cache_usage_perc | заполнение KV-пула |
vllm:prefix_cache_queries / hits | эффективность кэша префиксов |
vllm:prompt_tokens_total | обработано токенов промпта |
vllm:generation_tokens_total | сгенерировано токенов |
vllm:time_to_first_token_seconds | TTFT |
vllm:inter_token_latency_seconds | ITL |
vllm:request_time_per_output_token_seconds | TPOT |
vllm:e2e_request_latency_seconds | полное время |
vllm:request_prefill_time_seconds | prefill |
vllm:request_decode_time_seconds | decode |
vllm:request_success_total | завершённые запросы по причине |
Имена метрик — по документации v0.33.0; в своей сборке проверьте curl /metrics.
Для per-request метрик:
--enable-per-request-metrics
Тогда в ответе появится блок metrics с time_to_first_token_ms, generation_time_ms, queue_time_ms, mean_itl_ms. Это удобно для SLA и отладки, но на высокой конкурентности добавляет CPU-нагрузку.
Для замеров используйте vllm bench serve и vllm bench throughput (глава 12). В логах смотрите preemption, заполнение KV и среднюю длину очереди.
9. Практика: установка, запуск, ошибки, тюнинг
9.1 Установка
vLLM требует Linux, Python 3.11–3.14 и совместимый GPU-стек. В v0.33.0 релизные колёса собраны под CUDA 13.0; для ROCm — под ROCm 10.0.
uv venv --python 3.12
source .venv/bin/activate
uv pip install vllm
Или Docker:
docker pull vllm/vllm-openai:v0.33.0
Для AMD:
docker pull vllm/vllm-openai-rocm:v0.33.0
Проверка:
vllm --version
python -c "import torch; print(torch.cuda.is_available())"
9.2 Одна потребительская карта: 16 ГБ, 8B AWQ
Задача: запустить 8B в 4-битном AWQ (~5,5 ГБ) с контекстом 16k.
vllm serve ./models/qwen3-8b-awq \
--quantization awq \
--max-model-len 16384 \
--gpu-memory-utilization 0.90 \
--max-num-seqs 8 \
--max-num-batched-tokens 4096 \
--kv-cache-dtype fp8 \
--enable-prefix-caching \
--served-model-name local-8b \
--host 0.0.0.0 --port 8000
Что важно:
--gpu-memory-utilization 0.90оставляет около 1,6 ГБ на драйвер и пики; на 16 ГБ это разумно, но проверяйте пик.--max-num-seqs 8ограничивает KV и задержку; для одного пользователя можно 2–4.--max-num-batched-tokens 4096— компромисс между TTFT и ITL; для длинных промптов поднимите.--kv-cache-dtype fp8удваивает доступный контекст; проверьте качество.- Если в
config.jsonуже указан AWQ,--quantization awqможно опустить.
На 16 ГБ vLLM будет работать, но не ждите чудес: значительная часть VRAM уходит на веса, CUDA graphs и буферы. Для одного пользователя llama.cpp с GGUF обычно проще и не хуже по скорости.
9.3 Сервер с несколькими GPU: 4×48 ГБ, 70B FP8
Задача: обслуживать 70B в FP8 (~70 ГБ) на 4 картах, контекст 32k, до 32 одновременных запросов.
vllm serve ./models/70b-fp8 \
--tensor-parallel-size 4 \
--max-model-len 32768 \
--gpu-memory-utilization 0.90 \
--max-num-seqs 32 \
--max-num-batched-tokens 8192 \
--kv-cache-dtype fp8 \
--enable-prefix-caching \
--served-model-name local-70b \
--host 0.0.0.0 --port 8000
Почему так:
- TP=4 делит веса и KV между картами; модель помещается с запасом;
max-num-seqs 32— не потому, что столько влезет на полном контексте, а чтобы планировщик не держал слишком много KV; реальное число ограничит пул;max-num-batched-tokens 8192даёт хороший TTFT на длинных промптах;- FP8 KV экономит память; на Hopper/Blackwell это обычно безопасно.
Для MoE на нескольких GPU добавьте --enable-expert-parallel (вместо TP для экспертных слоёв) и проверьте, что архитектура поддерживается. Для пропускной способности можно поднять --data-parallel-size, если есть свободные GPU.
Tip
После старта посмотрите в лог строку с
max_num_seqs,max_model_lenи размером KV-пула. Именно эти числа, а не флаги, определяют, сколько запросов реально поместится.
9.4 Типичные ошибки
| Симптом | Вероятная причина | Что делать |
|---|---|---|
| OOM при старте | gpu-memory-utilization слишком высок, длинный max-model-len, CUDA graphs | снизить до 0.85–0.90, уменьшить контекст, --enforce-eager |
| OOM под нагрузкой | KV-пул мал, очередь | уменьшить max-num-seqs/max-model-len, поднять TP |
| Постоянные preemption | KV не хватает | то же; смотреть vllm:kv_cache_usage_perc |
| «context length exceeded» | max-model-len меньше запроса | поднять лимит или сократить промпт |
| Модель отвечает не по-человечески | неверный chat template | --chat-template, проверить шаблон |
| Tool calls не разбираются | неверный --tool-call-parser | выбрать парсер под модель, глава 11 |
| Ошибка divisibility | TP не делит число голов | изменить TP |
CUDA driver version is insufficient | драйвер старее CUDA 13 | обновить драйвер или взять сборку под свою CUDA |
| Зависание на нескольких узлах | NCCL/IB | проверить сеть, NCCL_DEBUG=INFO |
| Prefix cache не попадает | префикс короче блока или меняется | проверить размер блока, стабильный префикс, глава 7 |
9.5 Порядок тюнинга
Ориентиры по теории: prefill/decode и потолок памяти — глава 2; размер KV и контекст — глава 6; кэш префиксов — глава 7; батчинг и слоты — глава 8; спекуляция — глава 9; методика замера — глава 12.
- Модель и квант. Убедитесь, что чекпойнт поддерживается и влезает.
- Контекст.
--max-model-lenпод реальную задачу; больше — больше KV. - Память.
--gpu-memory-utilizationи--kv-cache-memory-bytes; смотрите лог. - Батч.
--max-num-seqsи--max-num-batched-tokens; баланс TTFT/ITL. - Prefix cache. Оставьте включённым; проверьте
prefix_cache_hits. - Параллелизм. TP/PP/EP только если модель не влезает или нужен KV.
- Спекуляция. Последней, с замером acceptance.
- Замер.
vllm bench serve, 3–5 повторов, медиана (глава 12).
Ключевые идеи
- vLLM — серверный GPU-движок с PagedAttention, непрерывным батчингом и V1-планировщиком.
- Родной формат — HF safetensors; кванты — FP8/INT8/INT4/AWQ/GPTQ/GGUF, KV — FP8.
- Сильная сторона — многопользовательская пропускная способность и параллелизм TP/PP/EP/DP.
- Prefix caching хеширует блоки с учётом предыдущего хеша; попадание возможно только с начала и по полным блокам.
- Chunked prefill включён по умолчанию; декод приоритетнее prefill.
- Вытеснение в V1 —
RECOMPUTE; следите за preemption и заполнением KV. - Спекуляция задаётся
--speculative-config; MTP, EAGLE-3, draft model, n-граммы. - Слабости — Linux-only, требовательность к GPU, ограниченный GGUF и отсутствие CPU-MoE-offload.
Проверь себя
- Почему prefix caching в vLLM не сработает, если изменить токен в середине промпта?
- Что означает preemption в V1 и почему он выбран вместо swap?
- Зачем нужен
--max-num-batched-tokens, если уже есть--max-num-seqs? - Когда
--cpu-offload-gbпомогает, а когда только вредит? - Почему для одной карты 16 ГБ vLLM не всегда лучший выбор?
- Чем
--enable-expert-parallelотличается от--tensor-parallel-sizeдля MoE?
Ответы
- Хеш блока включает хеш предыдущего блока. Изменение в середине меняет хеш этого блока и всех последующих, поэтому совпадение обрывается на изменённом месте.
- Это снятие запроса с освобождением KV и последующим пересчётом промпта. В V1 пересчёт дешевле swap, потому что не нужно копировать KV в host и обратно; но он добавляет prefill.
max-num-seqsограничивает число последовательностей, аmax-num-batched-tokens— общий бюджет токенов на итерацию. Второй управляет тем, насколько большой prefill можно выполнить за шаг, и влияет на TTFT/ITL.- Помогает, когда модель чуть-чуть не влезает и обращения к host-памяти редки. Вредит, когда веса постоянно читаются по PCIe: пропускная способность на порядки ниже VRAM.
- Потому что значительная часть VRAM уходит на веса, CUDA graphs и буферы, а GGUF-экосистема и гибридный запуск лучше у llama.cpp. vLLM раскрывается на нескольких GPU и многих пользователях.
- TP делит все веса слоя, включая экспертов, между GPU. EP распределяет именно экспертов MoE, что может быть эффективнее для разреженных моделей, но требует поддержки архитектуры.
Источники главы
Версии и флаги проверены 8 ноября 2026 по релизу v0.33.0 (тег v0.33.0rc3) и документации vLLM.
- vLLM, релиз v0.33.0 — vLLM Project, тег 01.11.2026, публикация 02.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, PyTorch 2.14, CUDA 13.0, ROCm 10.0, изменения.
- vLLM v0.33.0,
vllm/config/speculative.py— vLLM Project, 2026. GitHub. Уровень: продвинутый. Зачем:SpeculativeMethodвключаетdflashиdspark. - vLLM, «Automatic Prefix Caching» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: APC, ограничения, Mamba.
- vLLM, «Optimization and Tuning» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: chunked prefill, preemption, TP/PP/EP/DP.
- vLLM, «Conserving Memory» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: OOM и способы экономии.
- vLLM, «Speculative Decoding» — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: методы,
--speculative-config, MTP. - vLLM, «Structured Outputs» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: XGrammar/guidance и
response_format. - vLLM, «Tool Calling» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем:
--tool-call-parser, strict schema. - vLLM, «Production Metrics» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: метрики Prometheus.
- vLLM, «Per-Request Metrics» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем:
--enable-per-request-metrics. - vLLM, «Quantization» — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: поддерживаемые форматы и железо.
- vLLM, «Quantized KV Cache» — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: FP8 KV и калибровка.
- Kwon et al., «Efficient Memory Management for Large Language Model Serving with PagedAttention» — 2023. arXiv:2309.06180. Уровень: продвинутый. Зачем: первоисточник PagedAttention.
Движки инференса: SGLang
Зачем эта глава. SGLang вырос из идеи «язык программ для LLM» и стал серверным движком, который делает ставку на повторяющиеся префиксы: системные промпты агентов, многоходовые диалоги, RAG с одинаковыми инструкциями. Если vLLM — это про «много пользователей вообще», то SGLang — про «много запросов с общим началом». Здесь — как устроен RadixAttention, что даёт HiCache и Paged Experts и как этим пользоваться.
За 30 секунд
- SGLang — frontend-язык плюс runtime; главная идея — RadixAttention: KV-кэш хранится в radix-дереве и делится между запросами с общим префиксом.
- Сильные стороны: агентские нагрузки, многоходовые диалоги, MoE, структурированный вывод, HiCache на GPU/CPU/диск.
- Слабые: сложнее в настройке, чем llama.cpp; уже поддерживаемое железо, чем у llama.cpp; часть функций новая и требует проверки.
- Версия на 8 ноября 2026 — v0.5.23 (2 ноября 2026), CUDA 13, PyTorch 2.14.
1. Архитектура и для чего создан
SGLang начинался как исследовательский проект про structured language model programs: вместо одного запроса «промпт → ответ» вы описываете программу с ветвлениями, параллельными генерациями и ограничениями. Для таких программ нужен runtime, который умеет переиспользовать общий префикс между ветками. Отсюда RadixAttention.
Современный SGLang — это два слоя:
flowchart LR
F["Frontend:<br/>SGLang DSL / Python"] --> R["Runtime"]
API["OpenAI API<br/>/v1/chat/completions"] --> R
R --> SCH["Планировщик:<br/>prefill/decode,<br/>LPM, chunked prefill"]
SCH --> RT["RadixAttention:<br/>radix-дерево префиксов"]
RT --> KV["KV-пул:<br/>GPU + host + storage"]
SCH --> EX["Исполнитель:<br/>TP / DP / EP / PP"]
EX --> GPU["CUDA / ROCm / TPU / NPU"]
| Слой | Роль |
|---|---|
| Frontend | описание программ: gen, fork, select, ограничения; не обязателен для обычного OpenAI-клиента |
| Runtime | HTTP-сервер, планировщик, RadixAttention, батчинг, спекуляция |
| RadixAttention | дерево префиксов, в узлах которого лежат KV-блоки |
| HiCache | расширение кэша на host-память и внешнее хранилище |
| Paged Experts | выгрузка экспертов MoE в pinned host-память с вычислением на GPU |
1.1 RadixAttention
Представьте, что все промпты, которые видел сервер, сложены в дерево. Корень — пустой префикс, каждый узел — кусок токенов, а листья — полные последовательности. Если два запроса начинаются одинаково, они идут по одной ветке и делят одни и те же KV-блоки.
flowchart TB
Root["корень"] --> S["системный промпт<br/>общий для всех"]
S --> A["ветка A:<br/>история диалога 1"]
S --> B["ветка B:<br/>история диалога 2"]
A --> A1["новый вопрос A"]
B --> B1["новый вопрос B"]
Когда приходит новый запрос, runtime ищет самый длинный совпадающий путь, берёт KV из дерева и считает только новый хвост. Это не «кэш на слот», как в llama.cpp, и не «хеш блоков», как в vLLM: дерево само хранит структуру префиксов, поэтому ветвление диалога не требует копирования всего общего начала.
| Свойство | RadixAttention |
|---|---|
| Единица | узел дерева (кусок токенов + KV) |
| Совпадение | самый длинный префикс в дереве |
| Разделение | естественное, между любыми запросами |
| Вытеснение | LRU/LFU/SLRU/priority, настраивается |
| Отключение | --disable-radix-cache |
Флаги:
--disable-radix-cache # выключить кэш
--radix-eviction-policy lru # lru, lfu, slru, priority
--schedule-policy lpm # longest prefix match при планировании
--enable-cache-report # показывать число кэшированных токенов в usage
--schedule-policy lpm важен для агентов: планировщик сначала берёт запросы, у которых больше шансов попасть в кэш, а не просто в порядке прихода (по умолчанию fcfs). Это уменьшает prefill и выравнивает нагрузку.
Note
RadixAttention — это не «магический кэш на всё». Первый запрос всегда холодный; если префикс меняется в начале, дерево ветвится и общая часть уменьшается; при переполнении KV узлы вытесняются. Выигрыш зависит от того, насколько стабильно начало ваших промптов (глава 7).
1.2 Чем SGLang отличается от vLLM и llama.cpp
| llama.cpp | vLLM | SGLang | |
|---|---|---|---|
| Кэш префиксов | слот + LCP | хеш блоков | radix-дерево |
| Единица кэша | контекст слота | блок 16 токенов (v0.33.0) | узел дерева |
| Разделение между запросами | ограниченное | да | да, естественное |
| Планирование по префиксу | нет | косвенно | lpm |
| Расширение кэша | --cache-ram | KV offload | HiCache (GPU/CPU/диск) |
| Много пользователей | проще | сильнее | сильнее |
| Агенты с общим промптом | нормально | хорошо | лучше всего |
1.3 Чего SGLang не делает
- Не является самым простым способом запустить модель на ноутбуке. Для этого есть llama.cpp.
- Не поддерживает все GPU-сценарии vLLM. Матрица моделей и квантов уже, хотя AMD/Ascend/TPU/XPU поддерживаются.
- Не гарантирует, что новая функция подойдёт вашей модели. Paged Experts, HiCache и часть спекуляции имеют ограничения по архитектуре, кванту и параллелизму.
2. Форматы весов и квантование
SGLang работает с HF safetensors и конфигурацией Hugging Face. Поддерживаются предквантованные чекпойнты и онлайн-квантование.
| Формат | Что это | Комментарий |
|---|---|---|
| BF16 / FP16 | половинная точность | базовый вариант |
| FP8 W8A8 | веса и активации FP8 | NVIDIA Hopper/Blackwell, AMD |
| FP4 / NVFP4 / MXFP4 | 4-битные float | новые GPU; проверяйте модель и бэкенд |
| AWQ | 4-битные веса | готовые чекпойнты |
| GPTQ | 4/8-битные веса | поддержка зависит от ядра |
| INT8 W8A8 | целочисленный 8-бит | NVIDIA/AMD |
| GGUF | формат llama.cpp | ограниченный --load-format gguf; не основной путь |
| MLX q4/q8 | кванты для Apple Silicon | через MLX-бэкенд |
Выбор:
--quantization fp8 # онлайн-квантование FP16-чекпойнта
--kv-cache-dtype fp8_e4m3 # KV в FP8
Для готового AWQ/GPTQ-чекпойнта --quantization обычно не нужен: метод уже записан в config.json и определяется автоматически. Флаг нужен для онлайн-квантования FP16-модели, а не для «включения» готового AWQ.
Warning
Если чекпойнт уже квантован, не добавляйте
--quantization«для надёжности»: это может привести к повторному квантованию или ошибке загрузки. Смотритеquantization_configвconfig.json. Теория квантования — глава 4.
2.1 KV-кэш
SGLang поддерживает FP8 E4M3/E5M2 и экспериментальные FP4-форматы:
--kv-cache-dtype fp8_e4m3
--kv-cache-dtype fp8_e5m2
--kv-cache-dtype nvfp4 # экспериментально
--kv-cache-dtype fp4_mx_block16 # экспериментально
FP8 KV обычно удваивает доступный контекст; FP4 — ещё сильнее, но требует подходящего attention-бэкенда и проверки качества. Если бэкенд не умеет читать квантованный KV напрямую, деквантование может съесть весь выигрыш. Смотрите матрицу attention-бэкендов и главу 6.
3. Поддержка железа
| Платформа | Поддержка | Комментарий |
|---|---|---|
| NVIDIA CUDA | основная | CUDA 13 в v0.5.23 |
| AMD ROCm | да | MI300X/MI325X/MI350X и Radeon; отдельные инструкции |
| Huawei Ascend NPU | да | отдельная ветка документации и сборка |
| Google TPU | через SGLang-TorchTPU | PyTorch-плагин |
| Intel XPU | да | отдельные сборки |
| CPU | да | для совместимости и небольших моделей |
| NVIDIA Jetson | да | отдельные инструкции |
| Moore Threads | да | MUSA |
| Apple Silicon | через MLX | экспериментально, SGLANG_USE_MLX=1 |
3.1 Параллелизм
| Режим | Флаг | Когда нужен |
|---|---|---|
| Tensor parallelism | --tp-size N | модель не влезает или нужен KV |
| Data parallelism | --dp-size N | пропускная способность, несколько копий |
| Expert parallelism | --ep-size N | MoE |
| Pipeline parallelism | --pp-size N | глубокие модели, несколько узлов |
| PD disaggregation | отдельная конфигурация | prefill и decode на разных пулах |
Для нескольких узлов есть --nnodes, а для балансировки — SGLang Model Gateway (бывший router). PD disaggregation — серверная история: prefill и decode разводятся по разным GPU-пулам, чтобы подобрать железо под каждую фазу (глава 8).
3.2 Выгрузка в ОЗУ и Paged Experts
У SGLang два разных механизма:
--cpu-offload-gb N— часть весов в host-памяти, вычисления могут уходить на CPU; это медленный путь, близкий к--cpu-offload-gbв vLLM;--enable-paged-experts— эксперты MoE хранятся в pinned host-памяти, но вычисляются на GPU: на каждом шаге нужные эксперты копируются в K-слотовую таблицу на GPU. Это позволяет запустить MoE, который не влезает в VRAM, на одной карте.
Paged Experts — главное отличие SGLang для домашнего сценария «модель больше VRAM». Ограничения (по документации v0.5.23):
- только один GPU; TP/EP/PP/DP и EPLB не поддерживаются;
- поддерживаются не все кванты: unquantized, FP8, INT8, GPTQ int4/int8, AWQ int4, некоторые NVFP4/MXFP4 — через соответствующие MoE-runner'ы;
- спекулятивное декодирование не поддерживается;
- host-память должна быть достаточно большой, чтобы pinned-буфер вместил всех экспертов;
- CUDA graphs работают, но с ограничениями.
python3 -m sglang.launch_server \
--model-path ./models/moe-35b-a3b-gptq-int4 \
--enable-paged-experts \
--paged-experts-num-resident 16 \
--context-length 16384 \
--mem-fraction-static 0.80 \
--max-running-requests 2
В текущей документации --paged-experts-num-resident по умолчанию равен auto: K подбирается после загрузки всех весов, а в лог печатается выбранное значение и подсказка для фиксации. В v0.5.23, на которой зафиксирована эта глава, флаг ещё обязателен — поэтому в примере стоит явное число; в более новой сборке его можно не указывать. Начните с 16–32 и подбирайте по логу и пику VRAM; явное значение полезно, когда нужно воспроизвести конфиг.
Авторы релиза заявляют до 30× быстрее CPU-offload; независимой проверки в этой книге нет, поэтому воспринимайте цифру как заявку, а не как гарантию.
Warning
Paged Experts — новая и узкая функция. Если ваша модель/квант/конфигурация не входит в поддерживаемый список, сервер откажется стартовать. Для универсального «MoE на 16 ГБ» по-прежнему надёжнее llama.cpp с
--n-cpu-moe; Paged Experts стоит пробовать, когда модель и квант точно поддерживаются.
4. Батчинг, планировщик и кэш
4.1 Основные рычаги
| Флаг | Что делает | Осторожно |
|---|---|---|
--mem-fraction-static F | доля GPU под веса + KV | слишком высоко — OOM на активациях |
--context-length N | максимальный контекст | больше — больше KV |
--max-running-requests N | одновременные запросы | больше — больше KV и задержка |
--max-total-tokens N | размер KV-пула | обычно auto |
--chunked-prefill-size N | размер chunked prefill | меньше — лучше ITL, хуже TTFT |
--schedule-policy | fcfs, lpm, random, dfs-weight, priority | для агентов — lpm |
--schedule-conservativeness F | насколько осторожно принимать запросы | больше — меньше retraction |
--page-size N | размер страницы KV | по умолчанию 1 |
--mem-fraction-static — главный рычаг памяти. SGLang выделяет под веса и KV долю GPU, а остальное оставляет на активации и CUDA graphs. Если в логе available_gpu_mem слишком велик (10–20 ГБ), можно поднять mem-fraction-static; если слишком мал (меньше 5 ГБ), ждите OOM.
4.2 Radix-кэш и вытеснение
Когда KV-пул заполнен, radix-дерево вытесняет узлы. Политика задаётся --radix-eviction-policy:
| Политика | Кого вытесняет | Когда использовать |
|---|---|---|
lru (по умолчанию) | давно не использованный префикс | общий случай |
lfu | реже всего попадавший в кэш | небольшой набор частых промптов |
slru | сначала probationary-сегмент | защита проверенных префиксов |
priority | префикс запроса с низким приоритетом | вместе с priority scheduling |
4.3 HiCache
RadixAttention по умолчанию живёт в GPU. HiCache добавляет уровни:
- L1 — GPU;
- L2 — host-память;
- L3 — внешнее хранилище (файл, Mooncake, HF3FS, NIXL и др.).
--enable-hierarchical-cache
--hicache-ratio 2 # host-пул в 2 раза больше GPU
--hicache-size 100 # или точный размер в ГБ
--hicache-io-backend kernel
--hicache-storage-backend file # или mooncake, hf3fs, nixl...
L1 и L2 приватны для инстанса; L3 может быть общим для нескольких инстансов. Если host-пул не больше GPU-пула, попадания в L3 могут не уместиться и промпт придётся пересчитывать. Подробности — в документации HiCache.
Tip
Если у вас агент с длинным системным промптом и историей, сначала включите RadixAttention (он включён по умолчанию) и
--schedule-policy lpm. HiCache добавляйте, когда GPU-пула перестаёт хватать, а не «на всякий случай»: он расходует ОЗУ и добавляет I/O.
Посчитай сам. Агент делает 50 шагов. Общий префикс — 24k токенов, новый хвост — 400 токенов. Prefill идёт со скоростью 1500 ток/с, декод — 40 ток/с, ответ — 150 токенов. Сколько времени экономит RadixAttention за всю задачу?
Решение
Без кэша:
prefill = 24 000 / 1500 = 16 с
decode = 150 / 40 = 3,75 с
шаг ≈ 19,75 с; 50 шагов ≈ 988 с ≈ 16,5 мин
С RadixAttention:
prefill = 400 / 1500 ≈ 0,27 с
шаг ≈ 4,02 с; 50 шагов ≈ 201 с ≈ 3,4 мин
Экономия ≈ 787 с ≈ 13 мин, то есть примерно в 5 раз.
Это идеализированный расчёт: часть шагов может не попасть в кэш из-за ветвления или вытеснения. Но порядок величины показывает, почему для агентов кэш префиксов важнее, чем несколько процентов скорости декода.
5. Спекулятивное декодирование и MTP
SGLang поддерживает:
| Метод | Флаг | Комментарий |
|---|---|---|
| EAGLE / EAGLE-3 | --speculative-algorithm EAGLE3 | нужен draft-чекпойнт |
| MTP | --speculative-algorithm NEXTN (алиас EAGLE) | MTP-головы целевой модели |
| STANDALONE | --speculative-algorithm STANDALONE | отдельная draft-модель |
| NGRAM | --speculative-algorithm NGRAM | без модели, CUDA-only |
| UNO | --speculative-algorithm UNO | LoRA-адаптер к целевой модели |
| DFLASH | --speculative-algorithm DFLASH | блок-диффузионный черновик |
Пример EAGLE-3:
python3 -m sglang.launch_server \
--model-path ./models/target \
--speculative-algorithm EAGLE3 \
--speculative-draft-model-path ./models/eagle3-draft \
--speculative-num-steps 3 \
--speculative-eagle-topk 4 \
--speculative-num-draft-tokens 16 \
--mem-fraction-static 0.70
Warning
Спекуляция ест память под draft-модель и KV и может ухудшить пропускную способность на высоком QPS. Начинайте с малых
num-steps/num-draft-tokens, меряйте acceptance и ITL (глава 9). Для MTP не нужен отдельный чекпойнт, но нужна модель с MTP-головами.
6. Структурированный вывод и tool calling
6.1 Грамматики
SGLang поддерживает JSON Schema, regex и EBNF через три бэкенда:
- XGrammar (по умолчанию);
- Outlines;
- llguidance.
--grammar-backend xgrammar
Запрос:
{
"model": "local-model",
"messages": [{"role": "user", "content": "Верни JSON"}],
"response_format": {
"type": "json_schema",
"json_schema": {
"name": "answer",
"schema": {
"type": "object",
"properties": {"answer": {"type": "string"}},
"required": ["answer"]
}
}
}
}
Ограничение гарантирует синтаксис, но не смысл; и обрыв по max_tokens всё равно даёт невалидный JSON. Подробно — глава 11.
6.2 Tool calling
--tool-call-parser auto
--reasoning-parser auto
auto пытается определить парсер по шаблону модели. Если не получается, укажите явно: qwen, llama3, deepseekv3, glm, gpt-oss, kimi_k2, mistral и др. Список зависит от версии.
Если tool calls приходят текстом, а не в tool_calls, почти всегда виноват парсер или шаблон. Проверьте --chat-template / --hf-chat-template-name и документацию парсера. Дизайн инструментов — глава 11.
7. OpenAI-совместимый сервер
Запуск:
python3 -m sglang.launch_server \
--model-path ./models/model \
--host 0.0.0.0 \
--port 30000 \
--api-key secret
Или новый CLI:
sglang serve --model-path ./models/model --host 0.0.0.0 --port 30000
Поддерживаются:
/v1/chat/completions,/v1/completions;/v1/models,/v1/embeddings;/v1/rerank,/v1/score;/v1/messages(Anthropic-совместимый);- native
/generate,/get_model_info,/server_info,/health,/health_generate,/flush_cache.
По умолчанию сервер слушает 127.0.0.1:30000. Для доступа извне — --host 0.0.0.0; для защиты — --api-key.
Note
SGLang исторически силён в native API и frontend-языке, но OpenAI-совместимый слой у него тоже полноценный. Если вы пишете обычное приложение, используйте
/v1/chat/completions; если нужны ветвления и параллельные генерации — frontend-язык.
8. Метрики и наблюдаемость
Включаются флагом --enable-metrics; /metrics отдаёт Prometheus-метрики с префиксом sglang::
| Метрика | Смысл |
|---|---|
sglang:prompt_tokens_total | обработано токенов промпта |
sglang:generation_tokens_total | сгенерировано токенов |
sglang:token_usage | заполнение KV-пула |
sglang:cache_hit_rate | доля попаданий в radix-кэш |
sglang:time_to_first_token_seconds | TTFT |
sglang:e2e_request_latency_seconds | полное время |
sglang:num_running_reqs | запросов в работе |
sglang:num_queue_reqs | запросов в очереди |
sglang:num_retracted_reqs | вытесненных запросов |
Имена метрик — по документации v0.5.23; в своей сборке проверьте curl /metrics.
Дополнительно:
--enable-cache-report— число кэшированных токенов вusage.prompt_tokens_details;--log-requests— логи запросов;- лог сервера —
#running-req,token usage,gen throughput,#queue-req; /server_info— параметры и размеры пулов;- OpenTelemetry (
--enable-trace) — трассировка запросов.
Для замеров используйте sglang.bench_serving / bench_serving (глава 12). Смотрите не только средний tok/s, но и cache_hit_rate, token_usage, num_retracted_reqs.
9. Практика: установка, запуск, ошибки, тюнинг
9.1 Установка
SGLang требует Linux, Python 3.11+ и CUDA 13 для NVIDIA-сборок.
uv venv --python 3.12
source .venv/bin/activate
uv pip install --prerelease=allow sglang
Docker:
docker pull lmsysorg/sglang:latest
docker run --rm --gpus all --ipc=host \
-p 30000:30000 \
-v ~/.cache/huggingface:/root/.cache/huggingface \
-v "$PWD/models:/models" \
lmsysorg/sglang:latest \
sglang serve --model-path /models/model --host 0.0.0.0 --port 30000
Для AMD — отдельная сборка sgl-kernel и ROCm-образ; для Apple — SGLANG_USE_MLX=1 и MLX-зависимости.
9.2 Одна потребительская карта: 16 ГБ, 8B AWQ
Задача: 8B в AWQ (~5,5 ГБ), контекст 32k, несколько одновременных запросов.
python3 -m sglang.launch_server \
--model-path ./models/qwen3-8b-awq \
--context-length 32768 \
--mem-fraction-static 0.82 \
--max-running-requests 8 \
--chunked-prefill-size 4096 \
--schedule-policy lpm \
--enable-metrics \
--enable-cache-report \
--host 0.0.0.0 --port 30000
Что важно:
--quantization awqв команде нет: метод уже записан в конфиге чекпойнта и определяется автоматически. Флаг нужен для онлайн-квантования FP16-модели, а не для готового AWQ.--mem-fraction-static 0.82оставляет около 2,9 ГБ на активации и CUDA graphs; на 16 ГБ это разумная отправная точка.--context-length 32768— максимум; реальный KV-пул может позволить меньше одновременных запросов.--schedule-policy lpmпомогает, если запросы делят префикс; для одиночного чата разницы почти нет.--enable-cache-reportпоказывает, сколько токенов пришло из кэша.
Для MoE 35B-A3B, который не влезает в 16 ГБ, используйте Paged Experts (см. §3.2), если квант поддерживается; иначе — llama.cpp с --n-cpu-moe.
9.3 Сервер с несколькими GPU: 4×48 ГБ, 70B FP8
Задача: 70B FP8, 4 GPU, контекст 32k, до 32 одновременных запросов.
python3 -m sglang.launch_server \
--model-path ./models/70b-fp8 \
--tp-size 4 \
--context-length 32768 \
--mem-fraction-static 0.85 \
--max-running-requests 32 \
--chunked-prefill-size 8192 \
--schedule-policy lpm \
--enable-metrics \
--enable-cache-report \
--host 0.0.0.0 --port 30000
Почему так:
--tp-size 4делит веса и KV между картами;--mem-fraction-static 0.85оставляет запас на активации;--max-running-requests 32ограничивает конкурентность, чтобы не уйти в постоянные retraction;--chunked-prefill-size 8192даёт хороший TTFT на длинных промптах;lpmпомогает агентам и многоходовым диалогам.
Для MoE добавьте --ep-size (expert parallelism) и проверьте поддержку архитектуры. Для очень больших кластеров смотрите PD disaggregation и Model Gateway.
9.4 Типичные ошибки
| Симптом | Вероятная причина | Что делать |
|---|---|---|
| OOM при старте | mem-fraction-static слишком высок, длинный контекст | снизить до 0.75–0.85, уменьшить --context-length |
KV cache pool is full. Retract requests. | мало KV, слишком много запросов | поднять --schedule-conservativeness, снизить --max-running-requests |
Низкий cache_hit_rate | префиксы меняются, fcfs вместо lpm | стабилизировать начало, --schedule-policy lpm |
| Модель печатает спецтокены | неверный chat template | --chat-template, --hf-chat-template-name |
| Tool calls не разбираются | неверный --tool-call-parser | указать парсер явно |
peer access is not supported | несколько GPU без P2P | --enable-p2p-check |
| OOM при захвате CUDA graph | слишком большой batch | --disable-cuda-graph или уменьшить max bs |
| Paged Experts не стартует | неподдерживаемый квант/режим | проверить список в документации, один GPU |
| Apple Silicon не работает | не включён MLX | SGLANG_USE_MLX=1, --disable-cuda-graph |
9.5 Порядок тюнинга
Ориентиры по теории: prefill/decode и потолок памяти — глава 2; размер KV и контекст — глава 6; кэш префиксов — глава 7; батчинг и слоты — глава 8; спекуляция — глава 9; методика замера — глава 12.
- Модель и квант. Проверьте поддержку архитектуры и кванта.
- Контекст.
--context-lengthпод задачу; KV считается по главе 6. - Память.
--mem-fraction-static; смотритеavailable_gpu_memв логе. - Конкурентность.
--max-running-requests,--chunked-prefill-size. - Кэш. RadixAttention включён;
lpmдля агентов;--enable-cache-report. - HiCache. Только когда GPU-пула не хватает; следите за host-памятью.
- Спекуляция. Последней, с замером acceptance.
- Замер.
bench_serving, 3–5 повторов, медиана (глава 12).
Ключевые идеи
- SGLang — frontend-язык плюс runtime; RadixAttention хранит префиксы в дереве и делит KV между запросами.
- Радикс-кэш естественно подходит агентам и многоходовым диалогам;
lpmпланирует запросы с учётом префикса. - HiCache расширяет кэш на host-память и внешнее хранилище; L1/L2 приватны, L3 может быть общим.
- Paged Experts позволяют запустить MoE больше VRAM на одной карте, но имеют узкие ограничения.
- Поддержка: NVIDIA, AMD, Ascend, TPU, XPU, CPU, Jetson, Moore Threads, Apple через MLX.
- Структурированный вывод — XGrammar/Outlines/llguidance; tool calling — через парсеры.
- Слабости — сложность настройки и более узкая матрица моделей/квантов, чем у vLLM.
Проверь себя
- Чем radix-кэш отличается от хеша блоков в vLLM?
- Зачем нужен
--schedule-policy lpmдля агента? - Когда HiCache помогает, а когда только добавляет задержку?
- Почему Paged Experts не поддерживает спекуляцию и multi-GPU?
- Что означает
KV cache pool is full. Retract requests.и как это лечить? - В каком сценарии SGLang проигрывает llama.cpp?
Ответы
- Radix-кэш хранит префиксы в дереве и делит узлы между запросами; хеш блоков в vLLM — плоская таблица блоков, где ключ включает хеш предыдущего блока. Дерево естественнее для ветвления диалога, хеш проще для плоского параллельного батча.
lpm(longest prefix match) сначала планирует запросы, у которых больше общего с уже закэшированным, что уменьшает prefill и повышает попадания.- Помогает, когда GPU-пула не хватает, а префиксы повторяются и host-память быстрая. Вредит, когда попаданий мало, L3 медленный или host-пул меньше GPU-пула: тогда данные перекладываются зря.
- Paged Experts копируют экспертов в слоты на GPU и используют CUDA graphs; спекуляция и multi-GPU требуют другой раскладки памяти и синхронизации, поэтому в v0.5.23 они исключены.
- KV-пул переполнен, и планировщик вытесняет запросы. Лечится уменьшением контекста/конкурентности, повышением
schedule-conservativenessили добавлением GPU. - Когда нужен один пользователь на ноутбуке, максимальная простота, широкий набор экзотического железа или надёжный CPU-MoE-offload без ограничений Paged Experts.
Источники главы
Версии и флаги проверены 8 ноября 2026 по релизу v0.5.23 и документации SGLang.
- SGLang, релиз v0.5.23 — SGLang Project, 02.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, Paged Experts, HiCache, новые модели.
- SGLang, «Server Arguments» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: все флаги, значения по умолчанию.
- SGLang, «Radix Cache Eviction Policies» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: LRU/LFU/SLRU/priority.
- SGLang, «HiCache Best Practices» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: L1/L2/L3 и настройка.
- SGLang, «Speculative Decoding» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: EAGLE, MTP, NGRAM, UNO, DFLASH.
- SGLang, «Structured Outputs» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: XGrammar/Outlines/llguidance.
- SGLang, «Tool Parser» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: парсеры и поддерживаемые модели.
- SGLang, «Production Metrics» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем:
sglang:метрики. - SGLang, «Quantization» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: FP8/FP4/AWQ/GPTQ.
- SGLang, «Paged Experts» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: MoE больше VRAM и ограничения.
- Zheng et al., «SGLang: Efficient Execution of Structured Language Model Programs» — 2023. arXiv:2312.07104. Уровень: продвинутый. Зачем: RadixAttention и frontend-язык.
Движки инференса: сравнение и выбор
Зачем эта глава. Три предыдущие главы разобрали llama.cpp, vLLM и SGLang по отдельности. Теперь — главный практический вопрос: что выбрать под конкретную нагрузку. Ответ не сводится к «самый быстрый движок»: у каждого своя ниша, и часто выигрывает не тот, у кого выше пиковый tok/s, а тот, чья модель памяти и планирования совпадает с вашей задачей.
За 30 секунд
- llama.cpp — один пользователь, разнородное железо, GGUF, CPU/GPU-гибрид и MoE-offload.
- vLLM — много пользователей на NVIDIA/AMD GPU, широкая поддержка моделей и квантов, TP/PP/EP.
- SGLang — агенты и многоходовые диалоги с длинным общим префиксом, RadixAttention, HiCache, Paged Experts.
- Абсолютного победителя нет: сравнивайте на своём трафике по методике главы 12.
1. Три движка в одной таблице
| llama.cpp | vLLM | SGLang | |
|---|---|---|---|
| Ниша | локальный запуск, edge, CPU/GPU-гибрид | серверный GPU-инференс | агенты, structured programs, MoE |
| Стек | C/C++ над ggml | Python + C++/CUDA | Python + C++/CUDA |
| Формат весов | GGUF | HF safetensors | HF safetensors |
| Кванты | k-quants, i-quants, MXFP4/NVFP4, FP8 | FP8, INT8, INT4, AWQ, GPTQ, bnb, GGUF | FP8, FP4, AWQ, GPTQ, INT8, GGUF, MLX |
| Бэкенды | CPU, CUDA, ROCm, Metal, Vulkan, SYCL, CANN, MUSA, OpenCL | CUDA, ROCm, XPU, CPU, Apple через vLLM-Metal | CUDA, ROCm, Ascend, TPU, XPU, CPU, Jetson, Apple через MLX |
| Один пользователь | отлично | нормально, но тяжелее | нормально |
| Много пользователей | ограниченно | отлично | отлично |
| Prefix cache | слот + LCP | хеш блоков | radix-дерево |
| MoE-offload в ОЗУ | да, --n-cpu-moe | только общий --cpu-offload-gb | Paged Experts (узко) |
| Спекуляция | draft, EAGLE-3, DFlash, DSpark, MTP, n-граммы | draft, EAGLE-3, MTP, n-граммы, suffix, DFlash, DSpark | EAGLE, MTP, NGRAM, UNO, DFLASH |
| Structured output | GBNF, JSON Schema | XGrammar/guidance | XGrammar/Outlines/llguidance |
| Tool calling | нативные/generic обработчики | парсеры + strict schema | парсеры + auto |
| OpenAI API | да | да | да |
| Метрики | Prometheus, /slots, логи | Prometheus, per-request | Prometheus, cache report, OTel |
| Multi-GPU | layer/row, tensor экспериментально | TP/PP/EP/DP | TP/DP/EP/PP, PD |
| Сложность | низкая | средняя | средне-высокая |
| Версия на 08.11.2026 | v0.9.0 | v0.33.0 | v0.5.23 |
Note
Таблица — ориентир, а не истина в последней инстанции. Матрицы поддерживаемых моделей, квантов и функций меняются от релиза к релизу; перед выбором проверьте конкретную модель в документации движка.
2. Дерево выбора
flowchart TB
Start["Что за нагрузка?"] --> One{"Один пользователь<br/>или много?"}
One -->|"один, локально"| Local{"Какое железо?"}
Local -->|"NVIDIA / AMD / Apple / CPU"| LC["llama.cpp"]
Local -->|"только NVIDIA, нужен сервер"| V1["vLLM или SGLang"]
One -->|"много пользователей"| Many{"Что важнее?"}
Many -->|"пропускная способность,<br/>широкая матрица моделей"| V["vLLM"]
Many -->|"общий длинный префикс,<br/>агенты, MoE"| S["SGLang"]
Many -->|"не уверен"| Bench["Замерить оба<br/>на своём трафике (глава 12)"]
Start --> Fit{"Модель не влезает<br/>в VRAM?"}
Fit -->|"да, одна карта"| Off["llama.cpp: --n-cpu-moe<br/>или SGLang: Paged Experts"]
Fit -->|"да, несколько GPU"| More["vLLM/SGLang: TP/EP<br/>или более сильный квант"]
Fit -->|"нет"| One
Дерево даёт первый вариант, а не окончательный ответ. Дальше — три проверки: влезает ли модель с нужным контекстом, хватает ли пропускной способности на пике и совпадает ли движок с вашим железом.
3. Когда что выбирать
| Сценарий | Первый выбор | Почему | Ограничения |
|---|---|---|---|
| Один пользователь, ПК с 16–24 ГБ VRAM | llama.cpp | GGUF, гибридный запуск, минимум зависимостей | меньше пропускной способности на многих запросах |
| Один пользователь, Mac | llama.cpp | Metal, объединённая память | нет CUDA-экосистемы |
| Один пользователь, AMD Radeon | llama.cpp | HIP/ROCm, Vulkan | vLLM/SGLang на Radeon сложнее |
| Один пользователь, CPU-only | llama.cpp | лучший CPU-путь и кванты | скорость ограничена ОЗУ |
| Агент с длинным системным промптом | SGLang, затем vLLM | RadixAttention и lpm | сложнее настройка |
| Много параллельных пользователей | vLLM или SGLang | непрерывный батчинг, KV-менеджмент | нужен GPU-сервер |
| MoE 235B, не влезает в одну карту | llama.cpp --n-cpu-moe; SGLang Paged Experts | вычисления на CPU/с подкачкой экспертов | скорость и ограничения квантов |
| 4–8 GPU, 70B+ | vLLM или SGLang | TP/PP/EP, PD disaggregation | сеть и синхронизация |
| Нужна максимальная матрица моделей/квантов | vLLM | самая широкая поддержка | Linux-only |
| Нужен structured output и tool calling | все; SGLang/vLLM удобнее | готовые парсеры и грамматики | проверяйте шаблон модели |
| Нужна минимальная сложность | llama.cpp | один бинарь, один файл | меньше серверных функций |
| Нужен долгий общий кэш на диске | SGLang HiCache | L1/L2/L3 | host-память и I/O |
3.1 Если сомневаетесь
Начните с llama.cpp, если работа идёт на одной машине. Переходите на vLLM или SGLang, когда появляется одно из трёх:
- Очередь. Пользователи ждут, GPU загружен, но пропускной способности не хватает.
- Общий префикс. Агенты или диалоги тратят много времени на prefill одного и того же начала.
- Масштаб. Модель не влезает в одну карту, или нужно несколько GPU.
Если появилась очередь, сначала проверьте, не упираетесь ли вы в KV и закон Литтла (§8.4), а уже потом меняйте движок.
4. Производительность: что действительно отличается
Физика одна для всех: декод упирается в чтение весов и KV, prefill — в вычисления (глава 2). Если модель, квант, контекст и железо одинаковы, потолок декода одного запроса у всех трёх движков близок. Разница появляется в другом:
| Аспект | llama.cpp | vLLM | SGLang |
|---|---|---|---|
| Декод одного запроса | близок к потолку памяти | близок к потолку | близок к потолку |
| Prefill на GPU | хороший | очень хороший | очень хороший |
| Пропускная способность на многих запросах | ниже | высокая | высокая |
| Повторное использование префикса | ограниченное | хорошее | очень хорошее |
| Накладные расходы на маленькой карте | низкие | выше | выше |
| Вытеснение/очередь | проще | развитое | развитое |
| MoE-offload | сильный | слабый | узкий, но быстрый |
Это качественное сравнение, не замер. Числа зависят от модели, кванта, контекста, драйвера и версии. Единственный способ получить цифры для своего случая — прогнать главу 12 на своём трафике.
Warning
Не сравнивайте «tok/s» из разных источников: они почти всегда измерены на разных промптах, контекстах и размере батча. Сравнивайте конфиги на одном наборе запросов, с одинаковыми шаблонами и температурой.
4.1 Почему на одной карте разница мала
При декоде одного запроса все три движка читают веса и KV. Накладные расходы на планировщик, Python, HTTP и сэмплинг — это доли миллисекунды на фоне 20–50 мс шага. Поэтому «vLLM быстрее llama.cpp в 3 раза» на одном запросе — почти всегда ошибка измерения или разные кванты.
Другое дело — много запросов. Здесь vLLM/SGLang выигрывают за счёт непрерывного батчинга, эффективного KV-менеджмента и разделяемого кэша префиксов. Именно поэтому для сервера выбирают их, а не потому, что у них «лучше ядро» на одном токене.
4.2 Почему на длинном префиксе выигрывает SGLang
Агент из 60 шагов с общим префиксом 20k токенов тратит почти всё время на prefill, если кэш не работает (глава 7). RadixAttention уменьшает prefill до хвоста, а lpm дополнительно группирует запросы с общим префиксом. vLLM тоже умеет APC, но хеш блоков менее естественно разделяет ветвящиеся диалоги. llama.cpp умеет кэш на слот, но не разделяет его между многими запросами так же эффективно.
5. Форматы, переносимость и lock-in
| Вопрос | llama.cpp | vLLM | SGLang |
|---|---|---|---|
| Основной формат | GGUF | safetensors | safetensors |
| Конвертация | convert_hf_to_gguf.py, llama-quantize | обычно не нужна | обычно не нужна |
| GGUF | родной | ограниченно | ограниченно |
| Кванты | самые разные, включая i-quants | FP8/INT8/INT4/AWQ/GPTQ | FP8/FP4/AWQ/GPTQ |
| Токенизатор | из GGUF | из HF | из HF |
| Chat template | Jinja из GGUF | Jinja из HF | Jinja из HF |
| Перенос между движками | через конвертацию | обычно без конвертации | обычно без конвертации |
Практическое следствие: выбор движка — это ещё и выбор формата. Если вы квантуете модель в GGUF и настраиваете её под llama.cpp, перенос в vLLM/SGLang потребует конвертации и проверки, что архитектура поддерживается. И наоборот: safetensors-чекпойнт с AWQ может не иметь GGUF-версии.
Tip
Если планируете сравнивать движки, держите один и тот же исходный чекпойнт и один и тот же chat template. Разные кванты и шаблоны — самая частая причина «движок X отвечает хуже».
6. Стоимость эксплуатации
Движок не меняет физику памяти, но меняет утилизацию:
- llama.cpp позволяет запустить модель на уже имеющемся железе, включая CPU и Apple; это часто дешевле, чем покупать GPU.
- vLLM/SGLang требуют GPU-сервера, но дают больше токенов в час на той же карте при многопользовательской нагрузке.
- Paged Experts и MoE-offload могут отсрочить покупку GPU, но добавляют зависимость от ОЗУ и PCIe.
Для оценки «покупать или арендовать» используйте главу «Как выбрать железо»: там есть порог по часам в год и стоимость электричества. Для оценки «хватает ли текущего GPU» — закон Литтла и b* из главы 8.
7. Чек-лист миграции
Если решили перейти с одного движка на другой, проверьте по порядку:
- Модель и квант. Тот же чекпойнт? Если нет — качество может отличаться.
- Токенизатор и шаблон. Тот же chat template? Иначе изменятся и ответы, и tool calls.
- Контекст. Тот же
max_model_len/-c? Иначе часть запросов обрежется. - Сэмплинг. Та же температура, top-p, min-p, seed? Разные дефолты меняют вывод.
- Кэш. Включён ли prefix caching? Какой размер блока/страницы?
- Батч. Сколько одновременных запросов? Какой TTFT/ITL на пике?
- Память. Пик VRAM и ОЗУ под нагрузкой; есть ли запас 1,5–2 ГБ?
- Метрики. Сравните TTFT, ITL, tok/s, долю завершённых, качество на одном наборе задач.
- Ошибки. Проверьте OOM, обрезку контекста, парсинг tool calls.
- Откат. Оставьте старый движок запущенным, пока новый не пройдёт приёмку.
Посчитай сам. Агент делает 40 шагов, средний промпт 18k токенов, хвост 300 токенов, prefill 1200 ток/с, декод 35 ток/с, ответ 200 токенов. Сколько времени экономит prefix cache за задачу? Сравните с выигрышем от ускорения декода в 1,5 раза.
Решение
Без кэша: prefill 18 000 / 1200 = 15 с
decode 200 / 35 ≈ 5,7 с
шаг ≈ 20,7 с; 40 шагов ≈ 828 с ≈ 13,8 мин
С кэшем: prefill 300 / 1200 = 0,25 с
шаг ≈ 5,95 с; 40 шагов ≈ 238 с ≈ 4 мин
Экономия ≈ 590 с ≈ 9,8 мин.
Ускорение декода в 1,5 раза: шаг 0,25 + 3,8 = 4,05 с;
40 шагов ≈ 162 с. Против варианта без кэша это ≈ 666 с,
но против варианта с кэшем и обычным декодом — только ≈ 76 с.
Вывод: кэш префикса убирает основную часть времени; после него ускорять декод всё ещё полезно, но абсолютный выигрыш меньше, потому что задача стала короче. Это типичный пример из главы 7.
8. Итоговая рекомендация
- Дома, на одной машине, с GGUF и ограниченной VRAM — llama.cpp. Он даст лучший баланс простоты, совместимости и гибридного запуска.
- Сервер на NVIDIA/AMD, много пользователей, широкая матрица моделей — vLLM. Это самый предсказуемый выбор для «обычного» GPU-сервинга.
- Агенты, длинные общие префиксы, MoE, structured programs — SGLang. RadixAttention и HiCache дают преимущество именно на таких нагрузках.
- Сомневаетесь — начните с llama.cpp для локальной разработки и прототипа, а для продакшена замерьте vLLM и SGLang на своём трафике.
Note
Все три движка предоставляют OpenAI-совместимый API. Это позволяет менять движок, не переписывая клиента, — но только если вы не зависите от специфичных полей, парсеров и шаблонов. Проверяйте совместимость на своём клиенте.
9. Что здесь не проверено
- Независимых замеров нет. Все сравнения в этой главе качественные; числа производительности нужно получать по методике главы 12 на своём железе и трафике.
- Матрицы поддержки меняются. Списки моделей, квантов, бэкендов и функций в vLLM/SGLang обновляются каждый релиз; таблицы отражают документацию на 8 ноября 2026.
- Заявления авторов. Отдельно отмеченные цифры (например, «до 30× быстрее CPU-offload» для Paged Experts) — самозаявленные; независимой проверки в книге нет.
- Имена метрик. Они сверены с документацией и исходниками соответствующих версий, но не с живым
/metricsкаждого движка. Перед настройкой дашборда сделайте одинcurl /metricsна своей сборке: имена и набор метрик могут отличаться. - Железо и драйверы. Реальная скорость зависит от конкретной карты, драйвера, охлаждения и версии ядра; в книге — порядки величин.
- Цены и доступность. Экономические выводы — в главе «Как выбрать железо»; здесь они не пересчитываются.
Ключевые идеи
- Выбор движка определяется нагрузкой, железом и форматом весов, а не абсолютным «tok/s».
- llama.cpp — локальный и гибридный запуск; vLLM — многопользовательский GPU-сервер; SGLang — общий префикс, агенты и MoE.
- На одном запросе разница между движками невелика; на многих запросах и общем префиксе — решающая.
- Формат весов (GGUF vs safetensors) — часть выбора движка.
- Сравнивайте на одном чекпойнте, шаблоне и наборе задач; иначе получите разницу квантов, а не движков.
- Перед миграцией проверьте контекст, сэмплинг, кэш, батч и метрики.
Проверь себя
- Почему на одном запросе разница между llama.cpp и vLLM часто меньше, чем ожидают?
- В каком сценарии RadixAttention даёт больше выигрыша, чем APC в vLLM?
- Когда стоит выбрать llama.cpp, даже если есть GPU-сервер?
- Почему перенос модели между движками — это не только «поменять команду запуска»?
- Какой движок выбрать для 235B MoE на одной карте 24 ГБ и 256 ГБ ОЗУ?
- Что проверить перед миграцией, чтобы не сравнить разные модели?
Ответы
- На декоде одного запроса все читают те же веса и KV; накладные расходы движка малы по сравнению с шагом. Разница растёт на батче, кэше и планировании.
- Когда много запросов делят длинный префикс и ветвятся (агенты, диалоги): дерево естественно разделяет общие начала, а хеш блоков менее эффективен при ветвлении.
- Когда нужен GGUF, экзотическое железо, CPU/GPU-гибрид, MoE-offload или максимальная простота; либо когда нагрузка последовательная и очередь не возникает.
- Нужно проверить формат, квант, токенизатор, chat template, контекст, сэмплинг, кэш и поддержку архитектуры. Иначе изменится не только скорость, но и качество.
- llama.cpp с
--n-cpu-moe— самый предсказуемый путь; SGLang Paged Experts — если квант и архитектура поддерживаются. vLLM для одной карты здесь не лучший выбор. - Один и тот же чекпойнт, квант, токенизатор, шаблон, температура и набор промптов; иначе разница будет не в движке.
Источники главы
- llama.cpp, релиз v0.9.0 — ggml-org, 04.11.2026. GitHub. Уровень: продвинутый. Зачем: версия и возможности.
- llama.cpp,
tools/server/README.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: флаги, endpoints, метрики. - vLLM, релиз v0.33.0 — vLLM Project, тег 01.11.2026, публикация 02.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, CUDA/ROCm, изменения.
- vLLM v0.33.0,
vllm/config/speculative.py— vLLM Project, 2026. GitHub. Уровень: продвинутый. Зачем:SpeculativeMethodвключаетdflashиdspark. - vLLM, «Optimization and Tuning» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: батчинг, preemption, параллелизм.
- SGLang, релиз v0.5.23 — SGLang Project, 02.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, Paged Experts, HiCache.
- SGLang, «Server Arguments» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: флаги и значения по умолчанию.
- Kwon et al., «PagedAttention» — 2023. arXiv:2309.06180. Уровень: продвинутый. Зачем: теория KV-менеджмента.
- Zheng et al., «SGLang» — 2023. arXiv:2312.07104. Уровень: продвинутый. Зачем: RadixAttention.
Готовые «коробки»: Ollama, LM Studio и Unsloth Studio
Зачем эта глава. До сих пор книга почти всегда требовала собирать конфиг руками: выбрать GGUF, посчитать KV, выставить
-ngl,-c,-np. Большинство людей начинает не с этого, а с приложения: скачал, выбрал модель, нажал «чат». Такие приложения — «коробки» — экономят дни, но прячут ровно те параметры, от которых зависит, поместится ли длинный промпт и не превратится ли агент в тыкву. Здесь — что находится внутри Ollama, LM Studio и Unsloth Studio, что они умеют на ноябрь 2026 года, где их дефолты обманывают и когда пора доставать голый движок.
За 30 секунд
- «Коробка» — это движок + менеджер моделей + HTTP-API + набор дефолтов. Удобство оплачивается контролем: версией движка, размером контекста, KV-квантом и набором флагов.
- Ollama — самый простой путь к OpenAI-совместимому API: llama.cpp (и MLX на Apple), свой реестр, Modelfile. Но контекст по умолчанию — 4k на картах до 24 ГиБ, а KV-квант задаётся глобально.
- LM Studio — GUI и headless-ядро
llmster: llama.cpp + MLX, до четырёх параллельных запросов по умолчанию, спекулятивное декодирование и KV-квант в интерфейсе. Приложение закрытое, но бесплатное и для работы.- Unsloth Studio — не только инференс, но и дообучение: GGUF/MLX, экспорт, API, несколько пользователей. Это бета с AGPL-лицензией на UI и маркетинговыми цифрами «2× быстрее, 70% меньше VRAM» (про обучение).
- Коробки хватает одному человеку или небольшой команде на стандартных GGUF. Для тензорного параллелизма, сотен конкурентных запросов, точного апстрим-коммита и нестандартных квантов нужен голый движок — см. сравнение движков.
Версии и ссылки в этой главе проверены 8 ноября 2026 года. Поведение коробок меняется между сборками быстрее, чем выходит книга; перед повторением команд сверьтесь с --help и release notes своей версии. Глава вставная и не входит в нумерацию: в оглавлении после 12-й сразу идёт она, а затем 13-я.
1. Что такое «коробка» и из чего она состоит
У любой коробки, будь то десктопное приложение или сервер в контейнере, одна и та же слоёная структура:
flowchart TB
UI["GUI, CLI или чат"] --> API["HTTP API<br/>часто OpenAI-совместимый"]
API --> SCH["Планировщик:<br/>загрузка модели, очередь,<br/>слоты, выгрузка"]
SCH --> ENG["Движок:<br/>llama.cpp, MLX, vLLM,<br/>SGLang или свой"]
ENG --> W["Веса:<br/>GGUF, MLX, safetensors"]
SCH --> REG["Реестр и метаданные:<br/>теги, шаблоны чата,<br/>пресеты, лицензии"]
Четыре слоя можно менять по отдельности, но коробка продаёт их как одно целое. Отсюда главный компромисс: вы получаете работающий сервер за минуты, но не выбираете, какой именно коммит llama.cpp внутри, как посчитан KV и что случится, когда промпт длиннее окна.
Что коробка берёт на себя:
- определяет GPU и раскладывает слои;
- скачивает модель из своего реестра или с Hugging Face;
- подставляет шаблон чата и стоп-токены;
- поднимает HTTP-сервер и иногда веб-интерфейс;
- хранит пресеты, историю и настройки;
- обновляет движок вместе с приложением.
Что она обычно скрывает:
- точную версию движка и его отставание от апстрима;
- фактический размер контекста и число слотов;
- тип KV-кэша (FP16,
q8_0,q4_0); - политику выгрузки экспертов MoE в ОЗУ;
- момент, когда промпт обрезается или сдвигается;
- лицензию модели — она почти всегда отдельная от лицензии приложения.
Note
Лицензия приложения не делает модель коммерчески свободной. Ollama и LM Studio распространяются по своим лицензиям, а веса Llama, Gemma, Qwen и других моделей — по своим. Проверяйте карточку конкретной модели, а не название коробки.
1.1 Кто на чём работает (ноябрь 2026)
| Решение | Версия и дата | Движок | Формат поставки |
|---|---|---|---|
| Ollama | v0.40.15, 3 ноября 2026 | llama.cpp; MLX-сборки для Apple | CLI + сервер, GUI-приложение |
| LM Studio | линейка 0.4.x; 0.4.0 — 28 января 2026 | llama.cpp + MLX на Apple Silicon | GUI + headless llmster + CLI lms |
| Unsloth Studio | v0.1.916-beta, 6 ноября 2026 | llama.cpp + Hugging Face; MLX; опционально vLLM/SGLang | Desktop, web UI, Docker |
| Jan | v0.8.8, 28 октября 2026 | llama.cpp + MLX | Desktop + локальный API |
| llamafile | 0.10.6, 15 сентября 2026 | llama.cpp + Cosmopolitan Libc | Один исполняемый файл |
| GPT4All | 3.10.0, 25 февраля 2025 | llama.cpp | Desktop + Python SDK |
| LocalAI | 4.12.1, 23 октября 2026 | llama.cpp, ik_llama.cpp, vLLM, SGLang, Transformers и др. | Сервер, Docker, веб-UI |
Эта таблица — не рейтинг. Разные инструменты решают разные задачи: llamafile — «отправить один файл», LocalAI — «поднять шлюз на команду», Unsloth — «дообучить и тут же проверить».
2. Ollama
2.1 Что внутри
Ollama — Go-сервер, который запускает модели через llama.cpp; на Apple Silicon у него есть и MLX-бэкенд для части моделей (в релизах есть отдельные MLX-сборки и заметки об обновлении MLX). Сверху есть собственный реестр моделей, менеджер загрузки, шаблоны, Modelfile и HTTP-API. Проект под MIT, текущая версия на момент проверки — v0.40.15 (релиз).
Установка:
# Linux / macOS
curl -fsSL https://ollama.com/install.sh | sh
# Windows — установщик OllamaSetup.exe или install.ps1 с ollama.com
ollama run gemma4
Ollama не просто «обёртка над одной командой». Это полноценный локальный сервер с:
- собственным реестром
ollama.com/library; - тегами моделей и квантов (
qwen3:8b-q4_K_M); - Modelfile — рецептом из базовой модели, параметров, шаблона и системного промпта;
- OpenAI-совместимыми
/v1/chat/completions,/v1/responses,/v1/embeddings; - нативным
/api/chatсoptions,keep_aliveи метриками; - автоматической раскладкой по GPU/CPU.
Важно: Ollama не квантует GGUF при импорте. Если у вас safetensors или неудобный квант, сначала готовьте GGUF через llama-quantize, потом импортируйте (документация).
2.2 Модели, теги и Modelfile
Базовый сценарий:
ollama pull qwen3:8b
ollama run qwen3:8b
ollama list
ollama ps
Тег — это не только имя модели, но и квант, и шаблон. Один и тот же qwen3 в разных тегах может иметь разный размер файла, разный шаблон и разные стоп-токены. Поэтому «я запустил qwen3, почему ответы другие» — почти всегда не про модель, а про тег.
Свой рецепт собирается через Modelfile:
FROM qwen3:8b
PARAMETER num_ctx 32768
PARAMETER temperature 0.6
PARAMETER top_p 0.95
SYSTEM Ты помогаешь с кодом. Отвечай по-русски.
ollama create my-qwen -f Modelfile
ollama run my-qwen
Посмотреть, что реально лежит внутри чужого тега, можно так:
ollama show --modelfile qwen3:8b
Это полезнее, чем карточка на сайте: вы увидите TEMPLATE, PARAMETER stop, num_ctx и путь к блобу. Если шаблон чата не совпадает с тем, на котором модель обучали, tool calling и рассуждения ломаются — см. главу 11.
2.3 API: OpenAI-совместимый и нативный
Минимальный запрос к OpenAI-совместимому endpoint:
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "my-qwen",
"messages": [{"role": "user", "content": "Привет!"}]
}'
Нативный API даёт больше контроля над параметрами модели:
curl http://localhost:11434/api/chat -d '{
"model": "my-qwen",
"messages": [{"role": "user", "content": "Привет!"}],
"stream": false,
"options": {"num_ctx": 32768, "temperature": 0.6}
}'
Ollama поддерживает значительную часть OpenAI API, но не всю. На ноябрь 2026 в /v1/chat/completions нет tool_choice, logit_bias, logprobs, user и n; изображения принимаются в base64, но не по URL; reasoning_effort поддержан для моделей с рассуждениями (таблица совместимости). Этого достаточно для большинства чатов и простых агентов, но для строгого продакшн-клиента проверяйте каждое поле.
Tool calling устроен как в OpenAI: вы передаёте tools, получаете tool_calls, возвращаете role: "tool" с результатом. Поддержаны и параллельные вызовы (документация). Это работает, если шаблон модели и парсер Ollama понимают формат; для экзотических моделей проверяйте, что тег действительно объявляет capability tools.
2.4 Контекст: главный дефолт, который надо проверить
Ollama — самый частый источник истории «модель забыла начало промпта». Причина в дефолтном контексте.
Официальная страница Context length на ноябрь 2026 говорит:
| VRAM | Контекст по умолчанию |
|---|---|
| меньше 24 ГиБ | 4k |
| 24–48 ГиБ | 32k |
| 48 ГиБ и больше | 256k |
Это ориентир по VRAM; при чисто CPU-инференсе он не работает, и фактический размер надо смотреть в ollama ps. Для агентов, веб-поиска и кодинг-инструментов документация рекомендует ставить не меньше 64 000 токенов. Это не «рекомендация для красоты»: системный промпт агента, история инструментов и файлы легко дают 20–50k ещё до первого вопроса.
Управлять контекстом можно тремя способами:
# 1. Глобально для сервера
OLLAMA_CONTEXT_LENGTH=64000 ollama serve
# 2. В Modelfile для конкретной модели
# PARAMETER num_ctx 32768
# 3. В нативном API
# "options": {"num_ctx": 32768}
А вот в OpenAI-совместимом API поля для контекста нет. Документация прямо предлагает создать модель с нужным num_ctx через Modelfile и обращаться к ней по имени (OpenAI compatibility). Это неочевидный, но важный момент: клиент, который привык к OpenAI, не может попросить «дай 64k» — это решается только на стороне Ollama.
Проверить фактический контекст и раскладку можно командой:
ollama ps
В выводе есть SIZE, PROCESSOR (100% GPU, 100% CPU, 48%/52% CPU/GPU) и CONTEXT. Именно CONTEXT, а не то, что вы написали в конфиге, определяет, сколько модель реально видит.
Warning
В документации Ollama три разных указания: страница Modelfile —
num_ctxпо умолчанию 2048, FAQ — 4096, а страница Context length — 4k/32k/256k в зависимости от VRAM. Это не повод верить одной из страниц: смотритеCONTEXTвollama psиprompt_eval_countв ответе. Еслиprompt_eval_countзаметно меньше числа токенов, которое вы отправили, — контекст обрезан или сдвинут.
2.5 Параллельные запросы и память
Ollama умеет обслуживать несколько запросов, но дефолт — последовательный:
OLLAMA_NUM_PARALLEL— сколько запросов одна модель обрабатывает одновременно; по умолчанию 1;- при параллельной обработке контекст увеличивается кратно числу запросов: «2K контекста × 4 параллельных = 8K и дополнительная память» (FAQ);
OLLAMA_MAX_LOADED_MODELS— сколько моделей держать в памяти; по умолчанию 3 × число GPU или 3 для CPU;OLLAMA_MAX_QUEUE— длина очереди, по умолчанию 512; при переполнении сервер отвечает 503.
Это не «многопользовательский режим», а именно параллельная обработка запросов к одной модели. Аутентификации, квот и разделения пользователей в Ollama нет. Если нужно выставить сервер в сеть, ставьте reverse proxy с авторизацией и не биндитесь на 0.0.0.0 без необходимости (OLLAMA_HOST).
Память:
- Ollama автоматически решает, сколько слоёв положить на GPU, а сколько оставить в ОЗУ;
ollama psпоказывает фактическое соотношение; - KV-кэш квантуется глобально:
OLLAMA_KV_CACHE_TYPE=f16|q8_0|q4_0, по умолчаниюf16; настройка действует на все модели (FAQ); - Flash Attention включается автоматически, если бэкенд поддерживает; можно форсировать
OLLAMA_FLASH_ATTENTION=1; - отдельной ручки «сколько экспертов MoE оставить на CPU» (
--n-cpu-moe) в Ollama нет. Это одна из причин уходить на llama.cpp, если модель большая и MoE.
Модель выгружается через 5 минут простоя по умолчанию; keep_alive в запросе или OLLAMA_KEEP_ALIVE меняет таймер. Для агента, который ходит в модель каждые полчаса, это означает повторную загрузку и холодный старт; для ноутбука — наоборот, экономию памяти. Кэш промпта при этом живёт по правилам слота и тоже теряется при выгрузке; как это влияет на агентские нагрузки — в главе 7.
2.6 Подводные камни Ollama
- Тихий дефолт 4k. На карте 16 ГБ вы можете месяцами работать с 4k, даже не подозревая, что модель не видит половину инструкции. Поставьте
num_ctxявно и проверьтеollama ps. - Контекст умножается на параллельность.
OLLAMA_NUM_PARALLEL=4иOLLAMA_CONTEXT_LENGTH=32768— это не 32k памяти, а четыре слота по 32k плюс накладные расходы. Считайте по главе 6, а не по названию флага. - KV-квант глобальный. Нельзя одной модели дать
q8_0, а другойf16. Если нужен разный режим — либо разные инстансы, либо llama.cpp. - Имена и кванты — свои.
qwen3:8bиqwen3:8b-q4_K_Mмогут отличаться не только размером. Смотритеollama show --modelfileи размер блоба. - Импорт не квантует. Ollama не делает
llama-quantizeза вас; «загрузил safetensors и стало 4 бита» — не про этот инструмент. - OpenAI-совместимость — подмножество.
tool_choice,logprobs,logit_biasиnотсутствуют. Для агентов, которым нуженtool_choice: required, это блокер. - Облако и телеметрия. Локальные промпты не отправляются, но приложение умеет предлагать облачные модели и веб-поиск. Для полностью локального режима:
OLLAMA_NO_CLOUD=1или"disable_ollama_cloud": trueв~/.ollama/server.json(FAQ, политика). Лицензия самого Ollama — MIT, но лицензии моделей отдельные. - Отставание от апстрима. Ollama обновляет llama.cpp и MLX в своих релизах (например, v0.40.12: «Updated MLX and llama.cpp»), но вы не выбираете коммит и не можете поставить патч отдельно. Новая архитектура может потребовать обновления приложения, а не только нового GGUF.
3. LM Studio
3.1 Что внутри
LM Studio — десктопное приложение с закрытым исходным кодом. Внутри два движка:
- llama.cpp — на Windows, Linux и Apple Silicon; в 0.4.0 движок получил версию «llama.cpp v2.0.0» в нумерации LM Studio;
- MLX — на Apple Silicon, отдельный
mlx-engine.
С 0.4.0 ядро отделено от GUI и поставляется как headless-демон llmster; управление — CLI lms (релиз 0.4.0). Приложение бесплатно для личного и рабочего использования с июля 2025 года (анонс), но остаётся проприетарным: EULA запрещает реверс-инжиниринг, распространение и встраивание не через публичные интерфейсы (условия).
Установка headless-варианта:
# Linux / macOS
curl -fsSL https://lmstudio.ai/install.sh | bash
lms daemon up
lms get qwen/qwen3.6-27b
lms load qwen/qwen3.6-27b --context-length 32768 --gpu max
lms server start
GUI-версия ставится установщиком с lmstudio.ai; CLI lms идёт вместе с ней.
Note
В 2026 году под брендом LM Studio появился отдельный агентский продукт Bionic. Это не то же самое, что классическое приложение LM Studio и
llmster; ниже речь только о последних.
3.2 Модели и пресеты
LM Studio умеет:
- искать и скачивать модели из Hugging Face через встроенный Discover;
- работать с GGUF и MLX;
- импортировать локальные файлы;
- хранить пресеты — именованные наборы системного промпта и параметров сэмплирования;
- задавать per-model defaults — контекст, GPU offload, Flash Attention для каждой модели (per-model defaults);
- публиковать
model.yamlи пресеты в LM Studio Hub.
Для API-сервера важно, что модель можно загрузить заранее (lms load) или по первому запросу (JIT). JIT включён по умолчанию: /v1/models показывает все скачанные модели, а не только загруженные; модель подгружается при первом обращении. Простаивающая JIT-модель выгружается через 60 минут по умолчанию; TTL можно задать в запросе или через lms load --ttl. Auto-evict выгружает предыдущую JIT-модель перед загрузкой новой (TTL).
3.3 API
LM Studio предоставляет:
- OpenAI-совместимые
/v1/chat/completions,/v1/completions,/v1/responses,/v1/embeddings,/v1/models; - Anthropic-совместимый
/v1/messages; - собственный REST
/api/v1с загрузкой/выгрузкой моделей и статистикой; - stateful
/v1/chatсprevious_response_idи поддержкой локальных MCP-серверов; - permission keys — ключи доступа к серверу, которыми можно ограничить клиентов.
Пример:
curl http://localhost:1234/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $LM_API_TOKEN" \
-d '{
"model": "qwen/qwen3.6-27b",
"messages": [{"role": "user", "content": "Привет!"}]
}'
OpenAI-совместимость здесь шире, чем у Ollama: есть tools, structured output, Responses API и Anthropic Messages. Но это всё равно не полный OpenAI: часть полей игнорируется или реализована иначе, а load-time параметры через REST ограничены (context_length, eval_batch_size, flash_attention, num_experts, offload_kv_cache_to_gpu).
3.4 Контекст, параллельность и память
Контекст задаётся при загрузке:
lms load qwen/qwen3.6-27b --context-length 32768
В GUI есть настройка Default Context Length с выбором пользовательского значения или максимума модели. Официальная документация не фиксирует одно число для всех сборок, поэтому не полагайтесь на «по умолчанию же должно быть максимум». Проверяйте фактический context_length в ответе REST (список моделей или конфиг загруженной модели) или в индикаторе контекста. Даже если глобально выбран максимум, per-model профиль может переопределить значение; это одна из самых частых причин «модель не видит файл».
С 0.4.0 LM Studio умеет параллельные запросы через continuous batching:
- Max Concurrent Predictions по умолчанию 4;
- Unified KV Cache включён по умолчанию: буфер не делится жёстко на четыре равные части, запросы могут быть разной длины;
- запросы сверх лимита ставятся в очередь;
- на момент 0.4.0 параллельность была только для llama.cpp; для MLX её обещали позже (документация).
Это важный сдвиг: раньше LM Studio был строго последовательным, и «сервер на 4 пользователя» на нём был невозможен. Теперь — возможен, но с оговорками: четыре параллельных запроса по 32k контекста — это не «бесплатно», а четыре KV-кэша, пусть и в общем буфере.
Память:
- GPU offload — ползунком или
--gpu 0.5|max|off; n_cpu_moe— ползунок для выгрузки экспертов MoE в ОЗУ (появился в 0.4.0);- KV-квант — в GUI и через SDK (
llamaKCacheQuantizationType,llamaVCacheQuantizationType); на практике его включают вместе с Flash Attention и проверяют, что выбранный тип поддерживается бэкендом; offload_kv_cache_to_gpu— можно оставить KV в ОЗУ, если VRAM не хватает;--estimate-onlyпоказывает оценку памяти до загрузки.
3.5 Tool calling, MCP и спекуляция
Tool calling:
- OpenAI-совместимые
toolsв/v1/chat/completions; - MCP-серверы можно подключить в приложении и использовать в чате;
- stateful
/v1/chatумеет вызывать локальные MCP с permission keys; - серверный vs клиентский цикл инструментов зависит от клиента: LM Studio отдаёт
tool_calls, но не обязана исполнять их сама.
Спекулятивное декодирование:
- включается в GUI (Power User / Developer mode) выбором Draft Model;
- черновик должен иметь тот же словарь, что и основная модель;
- ориентиры LM Studio: для 7B — черновик до 1B, для 14B — до 3B, для 32B — до 7B; больше — может стать медленнее;
- выигрыш зависит от промпта: математика и код ускоряются лучше, чем свободная проза;
- черновик ест дополнительную память и вычисления (документация).
Это ровно та ручка, которой нет в Ollama «из коробки» в таком виде: там есть draft_num_predict и автоматический подбор черновика для некоторых моделей, но выбрать произвольную пару main/draft в UI нельзя. Формулы выигрыша, acceptance rate и безубыточный размер черновика — в главе 9.
3.6 Подводные камни LM Studio
- Четыре параллельных запроса по умолчанию. Если вы привыкли к последовательному серверу, после 0.4.0 память может уйти в четыре KV-кэша. Для одного пользователя ставьте
--parallel 1или Max Concurrent Predictions = 1. - Контекст не равен максимуму модели. Проверяйте
context_length; «загрузил 128k-модель» не значит «получил 128k». - KV-квант и параллельность не всегда сочетаются программно. Открытый баг-репорт #2024 (июнь 2026, LM Studio 0.4.16) показывает: CLI умеет
--parallel 1, SDK умеет KV-квант, но один headless-путь не даёт задать и то, и другое; REST не принимает поля KV-кванта. Это баг-репорт, а не официальная документация; на ноябрь 2026 проверяйте свою сборку. - Движок обновляется отдельно.
lms runtime update llama.cppиlms runtime update mlx; версия рантайма — не версия приложения. Записывайте её в отчёт. - MLX и параллельность. На 0.4.0 параллельные запросы были только для llama.cpp; проверьте, доехало ли до MLX в вашей версии.
- Проприетарная лицензия. Бесплатно — не значит open source. Для встраивания в продукт читайте EULA, а не только «free for work».
- Нет многопользовательских аккаунтов. Permission keys — это ключи доступа, а не роли, квоты и изоляция пользователей. Для команды с разными правами нужен LocalAI или прокси сверху.
- Телеметрии нет, но сеть есть. Политика LM Studio говорит: локальные чаты и документы не передаются; приложение ходит в сеть за обновлениями и при поиске/скачивании моделей; облачные функции — только если вы их включили (privacy). Для полностью офлайн-режима скачайте модели заранее и не включайте облако.
4. Unsloth Studio
4.1 Что внутри
Unsloth Studio — открытый no-code интерфейс (web UI и desktop) для дообучения и запуска моделей. Это не только «ещё один чат»: внутри два разных стека.
- Инференс: GGUF через llama.cpp, MLX на Apple, safetensors через Hugging Face; опционально vLLM и SGLang.
- Обучение: PyTorch + ядра Unsloth, LoRA/QLoRA, полное дообучение, GRPO/DPO, обучение vision/audio/embedding-моделей.
- Экспорт: GGUF, safetensors, NVFP4, FP8, LoRA-адаптеры.
- API: OpenAI-совместимый
/v1/chat/completionsи/v1/responses, Anthropic-совместимый/v1/messages.
Версия на момент проверки — v0.1.916-beta (6 ноября 2026), то есть проект всё ещё в бете (changelog, релиз).
Установка:
# macOS / Linux / WSL
curl -fsSL https://unsloth.ai/install.sh | sh
unsloth studio
# или desktop-приложение с unsloth.ai/download
Для API-сценария можно запустить модель одной командой:
# пример из документации Unsloth; точный тег может измениться
unsloth run --model unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
-c 131072 --threads 32
unsloth run поднимает llama-server, печатает URL и API-ключ, а лишние флаги передаёт в llama.cpp (документация).
4.2 Дообучение: что именно умеет
Заявленные возможности на ноябрь 2026:
- 500+ моделей: text, vision, TTS/audio, embedding, decision;
- LoRA, QLoRA, полное дообучение, continued pretraining, GRPO, DPO, FP8;
- multi-GPU обучение (включая FSDP2 в alpha);
- Data Recipes: превращение PDF/CSV/JSON/DOCX в датасет;
- наблюдение за loss, gradient norm, GPU utilization;
- сравнение base и fine-tuned в Model Arena;
- экспорт в GGUF и safetensors для llama.cpp, Ollama, LM Studio, vLLM.
Маркетинговые цифры Unsloth — «2× быстрее и на 70% меньше VRAM без потери точности» — относятся к обучению (ядрам Unsloth), это заявление вендора, а не независимый замер инференса. Для книги важно другое: сам подход (LoRA/QLoRA + оптимизированные ядра) действительно снижает требования к памяти, но конкретный выигрыш зависит от модели, длины последовательности, батча и GPU. Проверяйте на своей задаче по главе 12, а не переносите цифру из баннера.
Практический сценарий:
- Загрузить базовую модель.
- Импортировать датасет или собрать его из документов.
- Выбрать LoRA/QLoRA и пресет.
- Обучить, следя за loss и памятью.
- Сравнить с базой на своих промптах.
- Экспортировать GGUF и запустить в llama.cpp/Ollama/LM Studio.
Это единственная из «коробок» в этой главе, которая закрывает цикл «дообучил → проверил → экспортировал → запустил» без переключения между пятью инструментами.
4.3 Инференс: контекст, слоты, выгрузка
Инференс в Studio — это llama.cpp (и MLX), поэтому модель ведёт себя как в llama.cpp, но с автоматикой:
- Smart auto context: Studio заявляет, что подбирает контекст под доступную память и не грузит лишнего; ручной слайдер контекста при этом остаётся;
- 4 слота llama-server по умолчанию, число настраивается в web UI; при нехватке памяти Studio снижает число слотов (changelog, 29 июля 2026);
- multi-GPU inference и автоматическая выгрузка слоёв/экспертов в ОЗУ;
- можно держать несколько моделей загруженными и переключаться;
- опционально можно включить vLLM или SGLang как движок (с октября 2026);
- поддерживаются кастомные сборки llama.cpp и большинство флагов
llama-server(документация).
«Smart auto context» — удобно, но это ещё один дефолт, который вы не выбирали. Если вы делаете агента с длинным системным промптом, задайте контекст явно (-c 64000 или слайдер) и проверьте фактическое значение в мониторе API. Автоматика хороша, когда она совпадает с вашей задачей; когда не совпадает — вы снова отлаживаете «почему модель забыла инструкцию».
4.4 API, инструменты и многопользовательский режим
API:
POST /v1/chat/completions— OpenAI-совместимый, streaming, tools, vision;POST /v1/responses— OpenAI Responses, без statefulprevious_response_id;POST /v1/messages— Anthropic Messages для Claude Code и подобных клиентов;GET /v1/models,GET /v1/props,POST /v1/embeddings,POST /v1/chat/count_tokens;- API-ключи
sk-unsloth-..., монитор запросов, latency, TTFT, throughput.
Инструменты:
- клиентские tools в формате OpenAI/Anthropic;
- server-side tools: Python, bash, web search — выполняются на сервере и возвращаются как
tool_result; - self-healing tool calling: Unsloth пытается чинить сломанный JSON/разметку; вендор заявляет до +50% точности (примерно вдвое меньше сломанных вызовов), это не независимая проверка;
- sandbox для кода: ограничение доступа к файлам; политика зависит от ОС.
Многопользовательский режим:
- с 17 сентября 2026 есть аккаунты с изоляцией (Settings → Accounts): отдельные пароли, одноразовые коды настройки, разделение работ;
- загруженная модель может шариться между пользователями, если настройки совпадают;
- это не полноценный RBAC с квотами, как в LocalAI, но для небольшой команды уже лучше, чем один общий API-ключ.
4.5 Подводные камни Unsloth Studio
- Бета. Версия 0.1.x, changelog выходит почти каждую неделю; поведение и флаги меняются. Для продакшна фиксируйте версию и тестируйте обновления.
- Обучение и инференс делят GPU. Во время тренировки инференс может быть выгружен или замедлен; планируйте ресурсы, а не запускайте всё сразу.
- AGPL-3.0 на UI. Ядро Unsloth — Apache 2.0, но Studio UI — AGPL-3.0 (FAQ). Если вы встраиваете UI в коммерческий продукт, это важно; для локального использования — нет.
- Автоконтекст — не прозрачен. Он подбирается по памяти, а не по вашей задаче. Для агентов и RAG задавайте контекст руками.
- Вендорские цифры. «2× быстрее» (обучение), «до +50% tool calls», «3× длиннее контекст» — заявления Unsloth. Проверяйте на своих промптах и своей модели.
- Не production-оркестратор. Аккаунты и слоты есть, но по документации на ноябрь 2026 нет распределённого батчинга, квот, OIDC и горизонтального масштабирования, как в LocalAI/vLLM. Для одного сервера и малой команды — да; для сотен пользователей — нет.
- Телеметрия. Unsloth заявляет, что не собирает usage-телеметрию и берёт только минимальную информацию о железе для совместимости (FAQ). Это заявление вендора; для строгих требований проверяйте сетевой трафик и настройки.
5. Остальные: Jan, llamafile, GPT4All, LocalAI
5.1 Jan
Что это. Открытый десктопный клиент (Apache 2.0) с локальным API и MCP. Версия 0.8.8 — 28 октября 2026 (релиз, quickstart).
Движок. llama.cpp, на Apple Silicon — MLX. Движок встроен в приложение и обновляется вместе с ним; отдельной версии llama.cpp для выбора нет (документация).
Установка. Установщик с jan.ai; локальный API включается в Settings → Local API Server, по умолчанию на 127.0.0.1:1337.
Что умеет. Чат, проекты, ассистенты, MCP, локальный OpenAI-совместимый сервер на 127.0.0.1:1337 с опциональным API-ключом, tool calling, grammars/JSON Schema, continuous batching, параллельные последовательности, KV-квант f16/q8_0/q4_0, context shift, prompt cache, настройки RoPE. Для десктопа это неожиданно много ручек llama.cpp.
Ограничения. Один пользователь, нет аккаунтов и квот; на Intel Mac локальный движок не поддерживается с v0.8.0 (в v0.8.5 это явно задокументировано); API-сервер требует заранее выбранную локальную модель. Хороший выбор, если нужен открытый GUI с контролем, а не сервер на команду.
5.2 llamafile
Что это. Один исполняемый файл, внутри — llama.cpp и Cosmopolitan Libc. Версия 0.10.6 — 15 сентября 2026 (репозиторий). Запуск:
# пример из официального quickstart; имя файла может измениться
curl -LO https://huggingface.co/mozilla-ai/llamafile_0.10/resolve/main/Qwen3.5-0.8B-Q8_0.llamafile
chmod +x Qwen3.5-0.8B-Q8_0.llamafile
./Qwen3.5-0.8B-Q8_0.llamafile
Что умеет. CLI, чат, сервер (--server, по умолчанию 127.0.0.1:8080), OpenAI- и Anthropic-совместимые API, --api-key, --jinja, --ctx-size, --tools all для встроенных инструментов, whisperfile для речи. Лицензия Apache 2.0; патчи к llama.cpp/whisper.cpp — MIT (лицензирование).
Ограничения. Это не менеджер моделей: обновлять и раскладывать модели вы будете руками. На Windows исполняемые файлы больше 4 ГБ не запускаются — нужен внешний GGUF и отдельный бинарник. Предсобранные llamafile привязаны к конкретному коммиту llama.cpp, поэтому новые архитектуры могут отставать. Многопользовательского режима нет, только общий --api-key.
Когда брать. Демо, «отправить коллеге один файл», запуск без установки, быстрый стенд на чужой машине. Для постоянного сервера — нет.
5.3 GPT4All
Что это. Десктопное приложение и Python SDK от Nomic, MIT, на llama.cpp. Умеет чат, LocalDocs (RAG по локальным файлам), запуск GGUF, простой API-сервер. Ставится установщиком с gpt4all.io; Python-пакет — pip install gpt4all.
Состояние на ноябрь 2026. Последний релиз — 3.10.0 от 25 февраля 2025 (релиз); с тех пор новых стабильных релизов нет. Проект не «умер» — репозиторий и Python-пакет живут, — но темп разработки несопоставим с Ollama/LM Studio, и поддержка свежих архитектур, tool calling и длинного контекста может отставать.
Когда брать. Если нужен максимально простой офлайн-чат с LocalDocs на старом железе и вы готовы к тому, что новые модели могут не завестись. Для новых проектов — скорее нет.
5.4 LocalAI
Что это. Открытый (MIT) серверный шлюз, а не десктопная коробка. Версия 4.12.1 — 23 октября 2026 (релиз). Умеет OpenAI-, Anthropic- и Open Responses-совместимые API, веб-UI, галерею моделей, агентов, MCP, RAG, изображения, аудио, видео.
Движки. Не один, а набор бэкендов: llama.cpp, ik_llama.cpp, turboquant (llama.cpp с TurboQuant KV), vLLM, SGLang, Transformers, RWKV и другие (документация). Модель описывается YAML; бэкенд можно менять без смены API.
Установка. Быстрее всего Docker: docker run -p 8080:8080 --name local-ai -ti localai/localai:latest; модель ставится из галереи (local-ai models install qwen3-4b) или описывается YAML (quickstart).
Многопользовательский режим. Здесь он настоящий: LOCALAI_AUTH=true включает пользователей, роли admin/user, сессии, GitHub OAuth, OIDC (Keycloak, Google, Okta, Authentik), персональные API-ключи и учёт потребления токенов (Usage Tracking). Есть распределённый режим, P2P-федерация и шардирование моделей (аутентификация).
Когда брать. Нужен один OpenAI-совместимый вход для команды, разные модели/бэкенды, авторизация и учёт. Это уже не «коробка для ноутбука», а сервис; сложнее в установке и требует понимания бэкендов.
6. Сравнительная таблица
6.1 Основные три
| Ollama | LM Studio | Unsloth Studio | |
|---|---|---|---|
| Движок | llama.cpp; MLX на Apple | llama.cpp + MLX на Apple | llama.cpp; MLX; опционально vLLM/SGLang |
| Модели | Свой реестр, теги, GGUF-импорт, Modelfile | Hugging Face, GGUF/MLX, импорт, пресеты | Hugging Face, GGUF/MLX/safetensors, свои и старые GGUF |
| API | OpenAI-подмножество + нативный /api/chat | OpenAI + Anthropic + REST + stateful /v1/chat | OpenAI + Anthropic + Responses + API-ключи |
| Контекст | 4k/32k/256k по VRAM; num_ctx; в OpenAI API не задать | --context-length; Default Context Length; JIT TTL 60 мин | Auto context; -c; 4 слота по умолчанию |
| Параллельность | OLLAMA_NUM_PARALLEL, по умолчанию 1 | Max Concurrent Predictions, по умолчанию 4, unified KV (llama.cpp; MLX — проверяйте) | 4 llama-server слота, настраивается |
| Tool calling | Да, включая параллельные вызовы; нет tool_choice | Да, OpenAI tools + MCP | Да, OpenAI/Anthropic + server-side tools |
| KV-квант | Глобально OLLAMA_KV_CACHE_TYPE | GUI/SDK; обычно с Flash Attention | Флаги llama-server |
| Многопользовательский | Нет; только параллельные запросы | Permission keys, без аккаунтов | Аккаунты с изоляцией, без полноценного RBAC |
| Лицензия | MIT (модели — отдельно) | Проприетарная, бесплатна для работы | Apache 2.0 ядро + AGPL-3.0 UI |
| Когда брать | Быстрый API, один пользователь, стандартные GGUF | Десктоп + headless, спекуляция, 2–5 пользователей | Дообучение + инференс + экспорт |
6.2 Остальные
| Jan | llamafile | GPT4All | LocalAI | |
|---|---|---|---|---|
| Движок | llama.cpp + MLX | llama.cpp + Cosmopolitan | llama.cpp | llama.cpp, ik_llama.cpp, vLLM, SGLang, Transformers |
| Форма | Desktop + API | Один файл | Desktop + Python | Сервер/Docker |
| API | OpenAI на :1337 | OpenAI + Anthropic на :8080 | Простой API-сервер | OpenAI + Anthropic + Responses |
| Контекст/память | Много ручек llama.cpp, KV-квант | Флаги llama.cpp | Ограниченно | YAML + флаги бэкенда |
| Многопользовательский | Нет | Нет (общий ключ) | Нет | Да: роли, OAuth/OIDC, квоты |
| Лицензия | Apache 2.0 | Apache 2.0 | MIT | MIT |
| Когда брать | Открытый GUI с контролем | Демо/перенос одного файла | Старый простой офлайн-чат | Шлюз на команду/сервер |
6.3 Коробка или голый движок
| Критерий | Коробки достаточно | Нужен голый движок |
|---|---|---|
| Пользователей | 1–5 | десятки и больше, с квотами |
| Нагрузка | последовательная или 4 слота | сотни конкурентных запросов |
| Модели | стандартные GGUF/MLX | новая архитектура в день релиза, свои кванты |
| Контекст | до 32–64k на слот | 128k+ с точным KV-бюджетом |
| Тюнинг | контекст, GPU layers, KV-квант | tensor parallel, n-cpu-moe, спекуляция, prefix caching |
| Воспроизводимость | версия приложения | закреплённый коммит движка |
| API | OpenAI-подмножество | полный набор полей, свои парсеры |
| Эксплуатация | ноутбук/одна машина | SLO, мониторинг, балансировка |
7. Подводные камни: что именно ломается
7.1 Контекст: дефолт, который вы не выбирали
Это самая дорогая ошибка главы. У Ollama дефолт — 4k на карте до 24 ГиБ. У LM Studio контекст задаётся настройкой, а не максимумом модели. У Unsloth — «smart auto». У Jan — per-model. У llamafile — --ctx-size, по умолчанию из llama.cpp.
Механика описана в главе 6: KV-кэш растёт линейно с контекстом и числом слотов, а внимание на длинном контексте дорожает. Коробка может незаметно выбрать за вас и то, и другое.
Посчитай сам. Карта 16 ГиБ. Веса 4,5 ГиБ, буферы 1,5 ГиБ, запас 1 ГиБ. KV — 128 КиБ на токен в FP16. Сколько контекста на слот можно дать при 4 параллельных запросах? А если перевести KV в q8_0?
Решение
На KV: 16 − 4,5 − 1,5 − 1 = 9 ГиБ = 9216 МиБ
Токенов всего: 9216 × 1024 / 128 = 73 728
На слот (4): 73 728 / 4 = 18 432 ≈ 18k
q8_0: примерно вдвое меньше байт на токен → ≈ 36k на слот
Дефолт Ollama 4k на такой карте оставляет на KV всего 4 × 4k × 128 КиБ = 2 ГиБ; ещё около 7 ГиБ простаивают. Если поставить 18k на слот, модель увидит в четыре раза больше — при той же карте. Это не «магия флага», а арифметика из главы 6.
Warning
«Тихое обрезание» выглядит по-разному: Ollama может сдвинуть окно или обрезать начало, LM Studio — упереться в
context_length, Unsloth — в auto context. Универсальная проверка одна: сравните число токенов промпта сprompt_eval_count(Ollama),context_length(LM Studio) или «Context used» (Unsloth). Если модель отвечает так, будто не видела системную инструкцию, — почти всегда контекст.
7.2 Имена, кванты и шаблоны
«Модель» в коробке — это не только веса. Это ещё:
- квант (Q4_K_M, Q5_K_M, Q8_0, IQ4_XS, UD-Q4_K_XL);
- шаблон чата и стоп-токены;
- парсер tool calls;
- версия токенизатора.
В реестре Ollama тег может выглядеть как qwen3:8b-q4_K_M, в LM Studio ключ включает квант, в Unsloth — UD-Q4_K_XL, в Jan — имя файла. Один и тот же «Q4» у разных авторов может означать разные типы и разный размер. Сравнивать модели по названию — то же, что сравнивать автомобили по цвету. Типы квантов и их цена по качеству разобраны в главе 4.
Практика:
- смотрите размер файла и тип кванта, а не только имя;
- для Ollama —
ollama show --modelfile, для LM Studio —lms lsиlms ps; - проверяйте, что шаблон чата соответствует модели (глава 11);
- для tool calling прогоняйте свой тест, а не полагайтесь на «supported» в карточке.
Динамические кванты Unsloth (UD-Q4_K_XL и т.п.) — отдельная история: вендор утверждает, что сохраняет важные слои в более высокой точности, но это его методика и его замеры. Проверяйте на своих задачах по главе 12.
7.3 Отставание от апстрима
У коробки всегда есть «свой» движок:
- Ollama обновляет llama.cpp и MLX в релизах, но вы не выбираете коммит; новая архитектура может потребовать обновления приложения.
- LM Studio поставляет рантаймы отдельно (
lms runtime update), но версия — это версия LM Studio, а не тег upstream. В 0.4.0 это «llama.cpp v2.0.0» в их нумерации. - Jan встраивает движок в приложение; отдельной версии нет — обновляете приложение целиком.
- Unsloth тащит llama.cpp, но разрешает кастомные сборки и передачу флагов; это ближе к голому движку.
- llamafile прибит к коммиту llama.cpp в каждом релизе; предсобранные файлы могут отставать.
- LocalAI держит бэкенды отдельными образами; их можно обновлять независимо, но и следить надо за совместимостью.
Что это значит на практике: если модель вышла сегодня и требует нового оператора attention, коробка может её не запустить, даже если GGUF уже лежит. Проверяйте release notes и --help, а не «должно работать».
7.4 Телеметрия, лицензии и данные
- Ollama: MIT; локальные промпты не отправляются; облачные функции отключаются
OLLAMA_NO_CLOUD=1; политика говорит о limited metadata (privacy). - LM Studio: проприетарная; бесплатна для работы; политика утверждает, что телеметрии и трекинга нет, сеть — обновления, поиск/скачивание моделей и облачные функции по желанию (privacy).
- Unsloth: ядро Apache 2.0, UI AGPL-3.0; вендор заявляет отсутствие usage-телеметрии (FAQ).
- Jan: Apache 2.0; локальный режим по умолчанию; облачные провайдеры — по желанию.
- llamafile: Apache 2.0; локальный бинарник, облака нет by design.
- GPT4All: MIT; локальный чат и LocalDocs.
- LocalAI: MIT; self-hosted, данные остаются у вас, если вы сами не настроили внешние бэкенды.
Warning
Лицензия приложения ничего не говорит о модели. Llama 3.x — Community License, Gemma — Gemma Terms, Qwen часто Apache-2.0, но бывают исключения. Коммерческое использование модели проверяйте по её карточке, а не по слову «open source» на сайте коробки.
7.5 Где кончаются ручки
Сводка по состоянию на ноябрь 2026. «Частично» значит «есть в API/UI, но не во всех режимах; проверяйте сборку». Таблица разбита на две, чтобы читалась на телефоне.
Основные три
| Ручка | Ollama | LM Studio | Unsloth |
|---|---|---|---|
| Контекст на модель | num_ctx | --context-length | -c |
| KV-квант | глобально | GUI/SDK; CLI/REST — нет | флаги llama-server |
n-cpu-moe | — | ползунок | флаги |
| Спекуляция | draft_num_predict | Draft Model | llama-server |
| Tensor parallel | — | только layer split | флаги |
| Грамматика/JSON Schema | JSON Schema | structured output | да |
| Многопользовательский | — | ключи | аккаунты |
Остальные
| Ручка | Jan | LocalAI |
|---|---|---|
| Контекст на модель | да | YAML |
| KV-квант | q8_0/q4_0 | cache_type_k/v |
n-cpu-moe | не видно в UI | опции |
| Спекуляция | не видно в UI | частично (vLLM/движок) |
| Tensor parallel | — | llama.cpp/vLLM |
| Грамматика/JSON Schema | GBNF/JSON Schema | constrained grammars |
| Многопользовательский | — | полный RBAC |
Если нужной ручки нет в таблице — это не обязательно приговор: можно поднять рядом llama.cpp и проксировать, но это уже гибрид, а не коробка.
7.6 OpenAI-совместимость — это подмножество
Все коробки говорят «OpenAI-compatible», но набор полей разный:
- Ollama не поддерживает
tool_choice,logprobs,logit_bias,n, URL-изображения; контекст не задаётся через API. - LM Studio поддерживает tools и Responses, но не все load-time параметры через REST; KV-квант — через SDK/GUI.
- Unsloth поддерживает OpenAI и Anthropic, но Responses без
previous_response_id. - llamafile наследует поля llama-server; поведение зависит от вкомпилированного коммита.
- LocalAI поддерживает больше всего, но за счёт сложности и YAML-конфигов.
Проверка простая: возьмите реальный запрос вашего клиента (с tools, JSON Schema, картинкой, tool_choice) и прогоните его. «Работает в чате» не значит «работает в API».
7.7 Бенчмарк коробки
Коробка добавляет свои накладные расходы: планировщик, JIT-загрузку, шаблоны, возможно — сериализацию. Поэтому цифры из llama-bench и из коробки могут расходиться. Это нормально, но сравнивать надо одинаково:
- фиксируйте версию приложения и рантайма;
- прогревайте модель (JIT/TTL);
- смотрите
prompt_eval_count,eval_count, TTFT; - проверяйте пик VRAM, а не только размер файла;
- для длинного контекста мерьте на 8k/32k/64k, а не только на пустом.
Методика — в главе 12. Если разница между коробкой и голым движком меньше 5–10%, это часто шум или разные дефолты, а не «коробка медленная».
8. Когда коробки достаточно, а когда — голый движок
8.1 Коробка достаточна, если...
- у вас один пользователь или небольшая команда (1–5 человек);
- модели — стандартные GGUF/MLX из популярных семейств;
- нагрузка последовательная или до 4 параллельных запросов;
- контекст до 32–64k на слот;
- вам нужны чат, API, tool calling и быстрый старт, а не сотни запросов в секунду;
- вы готовы принять дефолты и проверять их, а не настраивать каждый слой.
Типичные сценарии:
- Ноутбук/десктоп: LM Studio или Jan; Ollama, если нужен API для скриптов.
- Один сервер на команду: Ollama + reverse proxy или LM Studio headless; для аккаунтов — Unsloth/LocalAI.
- Дообучение: Unsloth Studio, затем экспорт GGUF и запуск где угодно.
- Демо/перенос: llamafile.
- Шлюз с разными бэкендами: LocalAI.
8.2 Пора на голый движок, если...
- нужен tensor parallel или pipeline parallel на несколько GPU;
- нужны сотни конкурентных запросов, честный continuous batching и PagedAttention;
- нужен точный контроль KV:
-ctk/-ctv q8_0,--n-cpu-moe,--cache-reuse,--swa-full,--split-mode tensor; - нужна спекуляция с выбором черновика,
γ, acceptance rate и замером; - нужна новая архитектура в день релиза или свой квант;
- нужна воспроизводимость: закреплённый коммит llama.cpp, а не «версия приложения»;
- нужен полный OpenAI API:
logprobs,logit_bias,tool_choice,n; - нужен SLO, мониторинг, балансировка и изоляция пользователей.
Здесь начинаются главы о движках: llama.cpp — для одного-двух GPU и гибридного CPU/GPU; vLLM и SGLang — для серверной пропускной способности. Сравнение и критерии выбора — в общей главе о движках. Коробка и движок — не враги: разумная схема — разрабатывать и отлаживать в коробке, а на нагрузку выносить тот же GGUF в vLLM/SGLang.
8.3 Дерево решений
flowchart TD
A["Нужно дообучение?"] -->|да| B["Unsloth Studio:<br/>обучить, сравнить,<br/>экспортировать GGUF"]
A -->|нет| C{"Сколько пользователей<br/>и запросов?"}
C -->|"1–2"| D{"Нужен GUI?"}
D -->|да| E["LM Studio / Jan"]
D -->|нет| F["Ollama / llama.cpp"]
C -->|"3–10"| G{"Нужны аккаунты,<br/>квоты, RBAC?"}
G -->|да| H["LocalAI / Unsloth"]
G -->|нет| I["LM Studio headless /<br/>Ollama + прокси"]
C -->|"десятки и больше"| J["vLLM / SGLang<br/>(см. сравнение движков)"]
K["Один файл для демо"] --> L["llamafile"]
Выбор между движками и их сравнение — в общей главе о движках; отдельные главы: llama.cpp, vLLM, SGLang.
8.4 Промежуточные варианты
- LocalAI как шлюз: оставляет OpenAI-совместимый вход, но позволяет менять бэкенд (llama.cpp → vLLM/SGLang) без переписывания клиента. Это разумный мост от коробки к движку.
- Unsloth как лаборатория: обучить/экспортировать, а сервировать в vLLM. Не тащите тренировочный UI в продакшн-сервинг.
- Ollama для прототипа, llama.cpp для тюнинга: один и тот же GGUF, но во втором случае вы видите все флаги и версию.
- LM Studio для десктопа, llama-server для сервера: переносите не настройки, а модель и подобранные параметры; проверьте, что шаблон чата совпадает.
9. Практикум: настроить коробку и не обмануть себя
Этот чек-лист работает для любой коробки.
- Зафиксируйте версию. Приложение, рантайм, бэкенд (CUDA/Metal/ROCm/Vulkan), модель и квант. Без этого через неделю вы не поймёте, что изменилось.
- Задайте контекст явно. Не надейтесь на дефолт. Для агента — минимум 32k, лучше 64k, если память позволяет.
- Проверьте фактический контекст. Ollama —
ollama ps(CONTEXT), LM Studio —context_lengthв REST, Unsloth — монитор API. - Посчитайте KV и слоты.
C × k × Nпо главе 6; оставьте 1–2 ГиБ запаса. - Настройте KV-квант.
q8_0обычно почти бесплатен по качеству и экономит память;q4_0— только если очень тесно. - Проверьте tool calling. Один инструмент, параллельный вызов, ошибка в аргументах, повтор. Смотрите, не ломается ли JSON.
- Прогоните длинный промпт. 8k, 32k, 64k. Сравните
prompt_eval_countс ожидаемым. - Замерьте TTFT и tg. На прогретой модели, 3–5 повторов, с пиком VRAM. Методика — глава 12.
- Проверьте выгрузку/повторную загрузку. JIT/TTL,
keep_alive,lms unload,ollama stop. Холодный старт может быть дороже, чем кажется. - Запишите отчёт. Версия, флаги, контекст, KV, слоты, результаты, что не сработало.
Tip
Начните с
q8_0для KV и--parallel 1для одного пользователя. Это два изменения, которые чаще всего дают предсказуемый результат без потери качества. Четыре слота иq4_0включайте только после замера.
Ключевые идеи
- Коробка — это движок, менеджер моделей, API и дефолты в одном флаконе; удобство оплачивается контролем.
- Ollama — самый быстрый путь к API, но 4k контекста на картах до 24 ГиБ и глобальный KV-квант — главные ловушки.
- LM Studio — лучший десктопный компромисс: llama.cpp + MLX, 4 параллельных запроса, спекуляция, KV-квант; но приложение закрытое и не multi-tenant.
- Unsloth Studio — единственная коробка, которая закрывает дообучение, инференс и экспорт; бета, AGPL UI, вендорские цифры.
- Jan — открытый GUI с неожиданно глубокими ручками llama.cpp; llamafile — один файл для демо; GPT4All — скорее наследие; LocalAI — серверный шлюз с настоящим RBAC.
- Контекст, KV-квант, число слотов и версия движка — четыре параметра, которые надо проверять в любой коробке.
- Коробки хватает одному-пяти пользователям на стандартных GGUF; для нагрузки, тензорного параллелизма и точной воспроизводимости — голый llama.cpp/vLLM/SGLang; сравнение — в общей главе о движках.
Проверь себя
- Почему Ollama на карте 16 ГБ может показывать контекст 4k, даже если модель обучена на 128k?
- Вы поставили
OLLAMA_NUM_PARALLEL=4иOLLAMA_CONTEXT_LENGTH=32768. Сколько примерно памяти уйдёт на KV, если KV — 128 КиБ/токен? - Чем
Max Concurrent Predictionsв LM Studio отличается отOLLAMA_NUM_PARALLEL? - Почему «OpenAI-совместимый» API у коробок может не принять ваш запрос с
tool_choice? - В чём разница между лицензией LM Studio и лицензией модели, которую вы в нём запускаете?
- Когда Unsloth Studio достаточно, а когда лучше экспортировать GGUF и уйти в vLLM?
- Почему
q8_0для KV-кэша обычно безопаснее, чемq4_0? - Как проверить, что промпт не был тихо обрезан?
Ответы
- Потому что дефолт зависит от VRAM, а не от возможностей модели: до 24 ГиБ Ollama ставит 4k. Модель «умеет» 128k, но сервер выделил окно 4k. Нужно задать
num_ctxилиOLLAMA_CONTEXT_LENGTHи проверитьollama ps. 4 × 32 768 × 128 КиБ = 16 ГиБтолько на KV, не считая весов и буферов. На 16-гигабайтной карте это не влезет; нужно уменьшать контекст, число слотов или квантовать KV.- Оба задают число параллельных запросов, но LM Studio с 0.4.0 использует continuous batching и unified KV, а Ollama — слоты, где контекст умножается на параллельность. Дефолты тоже разные: у LM Studio 4, у Ollama 1.
- Потому что «совместимость» — подмножество. Ollama, например, не поддерживает
tool_choice; клиент должен либо не отправлять его, либо использовать нативный API/другой сервер. - LM Studio — проприетарное приложение под EULA; модель — отдельный продукт под своей лицензией (Llama Community License, Gemma Terms, Apache 2.0 и т.д.). Бесплатность приложения не меняет права на веса.
- Unsloth достаточно для обучения, сравнения и локального инференса малой команды. Для сотен конкурентных запросов, тензорного параллелизма и SLO — экспорт GGUF и vLLM/SGLang.
q8_0даёт примерно вдвое меньше памяти на токен при небольшой потере точности;q4_0— вчетверо меньше, но деградация заметнее, особенно на длинном контексте и при агрессивном GQA (малом числе KV-голов). См. главу 6.- Сравнить число токенов промпта с
prompt_eval_count(Ollama),context_length/индикатором (LM Studio) или «Context used» (Unsloth); прогнать длинный промпт с маркером в начале и проверить, видит ли его модель.
Источники главы
- Ollama, документация — docs.ollama.com. Context length, FAQ, Modelfile, OpenAI compatibility, tool calling, import. Основные факты о дефолтах и ограничениях.
- Ollama v0.40.15 — GitHub, 3 ноября 2026. Версия и состав релиза.
- Ollama, политика приватности — ollama.com/privacy, март 2026. Локальный режим и облачные функции.
- LM Studio 0.4.0 — блог, 28 января 2026.
llmster, параллельные запросы, unified KV, stateful REST. - LM Studio, Parallel Requests — docs. Max Concurrent Predictions = 4 по умолчанию; MLX позже.
- LM Studio, Headless / TTL — docs, TTL. JIT, TTL 60 минут, auto-evict.
- LM Studio, lms load — docs.
--context-length,--gpu,--ttl,--estimate-only. - LM Studio, Speculative Decoding — docs. Черновик, словарь, ориентиры размеров.
- LM Studio, App Terms / Privacy — terms, privacy. Проприетарная лицензия и отсутствие телеметрии.
- LM Studio, bug #2024 — GitHub, июнь 2026. Ограничения программной настройки KV-кванта и параллельности (пользовательский отчёт).
- Unsloth Studio — документация, chat, API. Возможности, лицензия, API, auto context.
- Unsloth changelog — docs, 6 ноября 2026. 4 слота, аккаунты, vLLM/SGLang, версии.
- Jan — quickstart, репозиторий, движок, API. Версия, лицензия, настройки.
- llamafile — репозиторий, запуск, API. Один файл, сервер, API, ограничения Windows.
- GPT4All 3.10.0 — GitHub, 25 февраля 2025. Последний стабильный релиз.
- LocalAI 4.12.1 — GitHub, 23 октября 2026; quickstart, text generation, auth. Бэкенды, API, RBAC.
13. Выбор модели под железо
Зачем эта глава. «Какая модель лучше?» — неправильный вопрос. Правильный: «какая модель лучше всего решает мою задачу на моём железе при приемлемой скорости и качестве». Здесь — как читать карточки, считать бюджет и не верить маркетингу.
За 30 секунд
- Сначала бюджет памяти (веса + KV + буферы + запас), потом модель.
- Скорость оценивается заранее: пропускная способность ÷ байт активных весов на токен.
- Бенчмарки в карточках самозаявленные и часто не про ваш домен; решает прогон 20–50 своих задач.
- Лицензия, язык, токенизатор и наличие квантов под ваш рантайм — такие же критерии, как качество.
13.1 Сначала бюджет, потом модель
Любая модель должна уложиться в:
вес + KV-кэш + буферы + запас = доступная память
Составляющие:
- вес — по таблице «бит на вес» из главы 4;
- KV — по формуле из главы 6;
- буферы — 0,5–1,5 ГБ в зависимости от батча и бэкенда;
- запас — 1,5–2 ГБ, чтобы не уйти в системную память (глава 3).
Пример: 13B dense в Q4_K_M (около 7,9 ГБ), 40 слоёв, 8 KV-голов, d_head = 128, контекст 16k, KV в q8:
KV = 2 × 40 × 8 × 128 × 1,06 × 16 384 ≈ 1,43 ГБ (1,33 ГиБ)
вес + KV + буферы ≈ 7,9 + 1,4 + 1 ≈ 10,3 ГБ
На карте 12 ГБ это помещается с запасом ~1,7 ГБ — на грани. На 16 ГБ — комфортно, можно поднять контекст до 32k.
Формулы здесь коротко; подробный вывод и единая таблица квантов — в главах 2, 4 и 6.
13.2 Что читать в карточке модели
| Параметр | Зачем |
|---|---|
| Всего параметров | Объём весов и памяти |
| Активных параметров (MoE) | Скорость декода |
| Число слоёв | Размер KV и глубина |
n_kv_heads, head_dim | Точный расчёт KV |
| Контекст обучения | Верхняя граница, но не гарантия качества |
| Тип внимания | Full / GQA / MLA / гибрид / sliding window |
| Токенизатор и языки | Длина текста в токенах, качество языка |
| Лицензия | Можно ли коммерческое использование |
| Форматы квантов | Есть ли GGUF/MLX/AWQ под ваш рантайм |
| Tool calling | Поддержка формата и шаблона |
| Бенчмарки | Что и как измеряли (см. ниже) |
Если в карточке нет конфига или числа KV-голов, придётся лезть в config.json. Это нормально: карточки часто написаны для маркетинга, а не для планирования памяти.
13.3 Dense или MoE
Dense — все параметры активны на каждом токене. Плюсы: предсказуемая скорость, проще квантовать, меньше памяти при том же качестве на простых задачах. Минусы: чтобы получить больше знаний, нужно больше параметров, а значит, больше памяти и медленнее декод.
MoE — хранит много параметров, активирует мало. Плюсы: больше знаний при высокой скорости. Минусы: вся модель должна помещаться в память (или часть — в ОЗУ), сложнее батчинг и квантование, качество на редких доменах может быть неравномерным.
Правило: если память позволяет и нужна скорость на большой модели — MoE. Если память ограничена и задача простая — dense меньшего размера.
13.4 Сколько влезает: ориентиры
Это оценки, а не гарантии: всё зависит от архитектуры, KV, контекста и кванта.
| Память | Что обычно влезает | Ожидаемая скорость |
|---|---|---|
| 8 ГБ | 7–9B dense Q4_K_M, контекст 8k; или 3–4B Q8_0, 16k | 30–50 ток/с |
| 12 ГБ | 13B dense Q4_K_M, 16k (KV в q8_0); или 8B Q8_0, 8k | 25–40 ток/с |
| 16 ГБ | 13B dense Q5_K_M, 32k (KV в q8_0); или 30B MoE Q4_K_M с выгрузкой | 20–45 ток/с |
| 24 ГБ | 30B dense Q4_K_M, 16k (KV в q8_0); или 30B MoE Q4_K_M целиком | dense 25–40 ток/с; MoE — в разы быстрее |
| 48 ГБ | 70B dense Q4_K_M, 16k (KV в q8_0) | 12–18 ток/с |
| 64 ГБ unified | 70B Q4_K_M, 16–32k (KV в q8_0); или 30B Q6_K | 6–12 ток/с (Mac) |
| 128 ГБ unified | 70B Q8_0, 64k (KV в q8_0); или 120B MoE Q4_K_M | 70B Q8_0: 5–8 ток/с; MoE заметно быстрее (Mac) |
Как получены строки: размер весов — по таблице §4.4, KV — по формуле главы 6 для типичной GQA-конфигурации (8 KV-голов по 128), плюс 1 ГБ буферов и запас 1,5–2 ГБ на дискретной карте. Скорость — 50–75% от потолка из главы 2. Числа — порядок величины. Для MoE скорость зависит от того, сколько экспертов в VRAM; для Mac — от пропускной способности объединённой памяти.
13.5 Оценка скорости до загрузки
Оценка — по формуле из главы 2: пропускная способность делится на байты, которые читаются на токен. Для dense берите все параметры, для MoE — активные. Если часть экспертов в ОЗУ, к времени добавляется второе слагаемое — чтение из более медленной памяти.
Пример: 30B MoE, 3B активных, Q4_K_M (1,8 ГБ на токен), половина в ОЗУ, VRAM 600 ГБ/с, ОЗУ 60 ГБ/с:
0,9 / 600 + 0,9 / 60 = 1,5 + 15 = 16,5 мс → ~60 ток/с
Это потолок; по правилу 50–75% из главы 2 реально получится 30–45 ток/с.
Посчитай сам. Карта 24 ГБ, 1 ТБ/с. Кандидаты: плотная 32B в Q4_K_M и MoE 30B-A3B в Q4_K_M, обе целиком в VRAM. Каковы потолки декода и какую скорость ждать на практике?
Решение
32B dense: 32 млрд × 0,6 = 19,2 ГБ на токен → 1000 / 19,2 ≈ 52 ток/с → реально 26–39
30B-A3B MoE: 3 млрд × 0,6 = 1,8 ГБ на токен → 1000 / 1,8 ≈ 555 ток/с — формальный потолок
У MoE потолок по весам настолько высок, что упираться начнут уже другие вещи: attention и KV-кэш, роутинг, накладные расходы на запуск ядер. Поэтому реальная скорость MoE будет заметно ниже 50–75% от 555 — но всё равно в разы выше, чем у плотной 32B. Зато плотная 32B на одинаковой памяти часто качественнее; что важнее, решает ваш набор задач.
13.6 Как читать бенчмарки
Проблемы:
- Самозаявленность. Числа в карточке получены авторами на их промптах и их настройках. Независимой проверки может не быть.
- Контаминация. Тестовые вопросы могли попасть в обучение. Особенно у популярных бенчмарков.
- Разные настройки. Temperature, число попыток, формат ответа, длина рассуждения — всё влияет.
- Насыщение. Когда все модели набирают 90%+, бенчмарк перестаёт различать.
- Не ваш домен. MMLU не измеряет качество русского технического текста или следование JSON-схеме.
- Arena — это предпочтения. Люди выбирают более приятный ответ, а не более правильный.
Что делать:
- смотреть на несколько бенчмарков и на методологию;
- проверять, есть ли независимые прогоны;
- для своей задачи собрать 20–50 реальных примеров и прогнать кандидатов;
- сравнивать при одинаковых настройках и одинаковом кванте;
- смотреть не только качество, но и скорость, память, завершаемость.
13.7 Лицензии
«Открытые веса» не всегда значит «open source».
- Apache 2.0 / MIT — разрешительное использование, включая коммерческое.
- Community licenses (например, у некоторых семейств) могут ограничивать масштаб, использование конкурентами или требовать указания;
- Non-commercial — только для исследований;
- Custom — читать целиком.
Если модель нужна для продукта, лицензия — такой же критерий, как качество. Проверяйте её до того, как влюбитесь в бенчмарки.
13.8 Язык и токенизатор
Для русского текста важны:
- покрытие языка в обучении;
- эффективность токенизатора (сколько токенов на слово);
- наличие русских инструкций и tool calling;
- качество на технических терминах, числах, единицах, ГОСТах.
Модель с большим словарём может тратить меньше токенов на русский, но это не гарантирует качества. Проверяйте на своих текстах: длина в токенах, сохранение чисел и обозначений.
13.9 Контекст: «поддерживает» не значит «использует»
Смотрите:
max_position_embeddings/n_ctx_train— обученный контекст;- поддерживается ли расширение (YaRN, PI) и до какой длины;
- есть ли sliding window или гибридное внимание;
- как модель ведёт себя на «иголке в стоге сена»;
- сколько KV стоит каждый шаг.
Модель с 128k может быть хуже на 64k, чем модель с 32k, если её не обучали на длинных зависимостях. Тестируйте на своей задаче.
13.10 Не только NVIDIA и Apple
Большая часть книги написана про дискретную NVIDIA-карту, потому что это самый распространённый локальный сценарий. Но не единственный:
- CPU-only. Модели 7–9B в Q4 работают, но скорость — единицы токенов в секунду. Для чата это терпимо, для агента — медленно. Главное — пропускная способность ОЗУ и число физических ядер.
- AMD ROCm / Vulkan. llama.cpp поддерживает ROCm и Vulkan; поддержка зависит от карты и версии драйвера. Проверяйте, собран ли бэкенд под вашу архитектуру.
- Intel XPU / iGPU. Возможен через SYCL/Vulkan, но выбор моделей и квантов уже, а производительность ниже.
- Apple Silicon. Объединённая память и Metal; для моделей, которые помещаются, это удобный вариант, но пропускная способность ниже топовых дискретных карт.
Общие формулы памяти и скорости остаются теми же; меняются доступная память, пропускная способность и зрелость бэкенда.
13.11 Русский домен
Для русских технических текстов общие бенчмарки почти бесполезны. Проверяйте:
- длину текста в токенах (токенизатор может быть неэффективен);
- сохранение чисел, единиц и обозначений;
- качество на терминах и аббревиатурах;
- следование JSON-схеме и вызов инструментов;
- галлюцинации на редких фактах.
Соберите 20–50 реальных примеров из своих документов и прогоните кандидатов. Публичные русские лидерборды полезны как ориентир, но не заменяют ваш набор.
13.12 Процесс выбора
flowchart TB
T["Задача и метрика успеха"] --> B["Бюджет памяти:<br/>веса + KV + буферы + запас"]
B --> F{"Плотная модель нужного<br/>размера влезает целиком?"}
F -->|"да"| S["Шорт-лист 3–4 моделей"]
F -->|"нет"| MOE{"Есть MoE с похожим<br/>качеством?"}
MOE -->|"да"| OFF["MoE: целиком или<br/>с выгрузкой экспертов (гл. 5)"]
MOE -->|"нет"| Q["Квант ниже или модель<br/>меньше (гл. 4)"]
OFF --> S
Q --> S
S --> R["Прогон 20–50 своих задач:<br/>качество, скорость, память"]
R --> C["Лучший баланс,<br/>конфиг и отчёт (гл. 12)"]
- Опишите задачу и метрику. Что считается успехом: правильный ответ, валидный JSON, время, стоимость?
- Посчитайте бюджет памяти по формулам.
- Составьте шорт-лист из 3–4 моделей, которые влезают.
- Проверьте доступность квантов и поддержку рантаймом.
- Прогоните на 20–50 реальных примерах. Одинаковые промпты, температура, контекст.
- Сравните качество, скорость, память, завершаемость.
- Выберите не «лучшую», а лучший баланс.
- Запишите конфиг и результаты (глава 12).
Warning
Ориентиры этой главы — для одного слота и типичной GQA-архитектуры. Если вам нужно несколько параллельных пользователей (глава 8) или модель без GQA, пересчитайте KV по формуле главы 6: именно он чаще всего превращает «влезает» в «не влезает».
13.13 Красные флаги в карточке
- Нет лицензии или она «other» без пояснений.
- Нет конфига и числа KV-голов.
- «Превосходит GPT-4» без цифр и методики.
- Бенчмарки только самозаявленные, без независимых прогонов.
- Нет информации о языках и токенизаторе.
- Нет GGUF/MLX, хотя модель заявлена для локального запуска.
- Обещания «работает на 8 ГБ» без указания кванта и контекста.
Ключевые идеи
- Сначала бюджет памяти, потом модель.
- Dense предсказуем, MoE даёт больше знаний за ту же скорость, но требует памяти.
- Скорость можно оценить по пропускной способности и активным параметрам.
- Бенчмарки самозаявленные, контаминированные и часто не про ваш домен.
- Лицензия, язык и поддержка квантов — такие же критерии, как качество.
- Выбирайте по своим 20–50 примерам, а не по лидерборду.
Проверь себя
- Как оценить, поместится ли модель на карту, до скачивания?
- Почему MoE может быть быстрее dense при большем числе параметров?
- Почему MMLU не поможет выбрать модель для русского JSON?
- Чем «open weights» отличается от open source?
- Что делать, если модель заявляет 128k, а вам нужно 64k?
Ответы
- Посчитать вес по параметрам и кванту, KV по формуле, добавить буферы и запас. Сравнить с доступной памятью.
- MoE активирует только часть параметров на токен, поэтому чтение памяти и вычисления меньше, чем у dense с тем же общим числом параметров. Но хранить нужно все параметры.
- MMLU измеряет общие знания на английских вопросах с выбором ответа. Он не проверяет русский технический текст, следование JSON-схеме и вызов инструментов.
- Open weights означает, что веса доступны, но лицензия может ограничивать использование. Open source обычно требует свободного использования, изменения и распространения.
- Проверить, как контекст получен: обучение, YaRN/PI, гибридное внимание. Затем измерить качество и скорость на 64k на своих задачах, а не доверять числу в карточке.
Источники главы
- Hugging Face, LLM Course — huggingface.co/learn/llm-course. Основы моделей, токенизаторов и выбора.
- Mitchell et al., «Model Cards for Model Reporting» (2018) — arXiv:1810.03993. Что должно быть в карточке модели.
- Liang et al., «Holistic Evaluation of Language Models» (2022) — arXiv:2211.09110. Почему один бенчмарк не описывает модель.
- Hendrycks et al., «Measuring Massive Multitask Language Understanding» (2020) — arXiv:2009.03300. MMLU и его ограничения.
- Chiang et al., «Chatbot Arena» (2024) — arXiv:2403.04132. Что измеряют предпочтения людей.
- Miller, «Adding Error Bars to Evals» (2024) — arXiv:2411.00640. Как не переоценить разницу между моделями.
- llama.cpp,
tools/server/README.md— GitHub. Поддержка моделей, квантов и флагов.
Как выбрать железо для локального инференса
Зачем эта глава. Глава 13 отвечает, какая модель влезет в вашу память. Эта глава — о том, на чём её запускать: какие карты, боксы и платформы продаются в ноябре 2026 года, сколько они стоят, что на них реально работает и где начинаются подводные камни. Железо не делает модель умнее. Оно решает три вещи: поместится ли она, с какой скоростью будет отвечать и сколько это будет стоить в рублях, ваттах и децибелах.
За 30 секунд
- Память решает, что запустится. Пропускная способность решает, как быстро пойдёт декод. Софт решает, заработает ли вообще.
- Ноябрь 2026 — плохое время для покупки: кризис памяти поднял цены видеокарт и серверной ОЗУ в 1,5–3 раза выше MSRP. Покупайте под задачу, которая есть сейчас, а не «под будущее».
- Одна карта с 24–32 ГБ часто полезнее двух по 16 ГБ: модель должна помещаться в один пул, а не делиться по PCIe.
- 128 ГБ объединённой памяти — это про модели на 70–120 млрд параметров в Q4 (235B MoE — уже 192–256 ГБ), но декод dense-моделей будет 3–60 ток/с, а не 200. Считайте по формуле из главы 2, а не по маркетингу.
- Если нагрузка меньше ~500 часов в год, аренда GPU почти всегда дешевле покупки. Если больше 2 000 часов в год и данные нельзя выносить — покупка.
1. Три числа, которые решают всё
Любой вариант железа описывается тремя числами.
1. Объём памяти. Сколько весов, KV-кэша и буферов помещается одновременно. Считается по формулам глав 4 и 6:
вес + KV + буферы + запас ≤ доступная память
Для Q4_K_M удобно брать 0,6 ГБ на миллиард параметров. Тогда 8B — около 4,8 ГБ, 14B — 8,4 ГБ, 32B — 19,2 ГБ, 70B — 42 ГБ, 120B MoE — около 72 ГБ, 235B MoE — около 141 ГБ. KV-кэш на длинном контексте добавляет единицы или десятки гигабайт — глава 6.
2. Пропускная способность памяти (ПСП). Сколько гигабайт в секунду можно прочитать. Потолок декода:
ток/с ≈ ПСП ÷ байт активных весов на токен
Для dense это все параметры, для MoE — только активные. Реально получается 50–75 % потолка (глава 2). У 70B dense в Q4_K_M на токен читается ~42 ГБ: карта с 1 ТБ/с даёт потолок ~24 ток/с, реально 12–18.
3. Софт. CUDA, ROCm, SYCL, Metal, Vulkan, MLX. Одна и та же карта может быть отличной в llama.cpp и бесполезной в vLLM. Поэтому «характеристики» — только половина ответа.
Note
Дальше в таблицах я даю потолок и реалистичный диапазон (50–75 % от потолка) для одного слота. Это оценки по формуле, а не замеры. Ваш рантайм, квант и длина контекста дадут другой результат — проверяйте по методике главы 12.
1.1 Почему ноябрь 2026 — особый случай
Рынок перекошен спросом на память: контрактные цены DRAM выросли на 93–98 % в 1 кв. 2026 и ещё на 58–63 % во 2 кв. (Fusion Worldwide, 2026). Следствия:
- RTX 5090: MSRP $1 999 → $4 999–6 919 (BestValueGPU, 12.10.2026; Tech Insider, 05.11.2026).
- RTX PRO 6000: $8 565 → $16 000 (Tom’s Hardware, 2026).
- DGX Spark: $3 999 → $4 699 → $6 950; 64 ГБ — $4 999 (The Register, 02.10.2026; ServeTheHome, 2026).
- RTX 50 Super — не раньше 2027; 5080 24 ГБ может пропустить январь (WCCFtech, 03.11.2026). Ждать бессмысленно.
Warning
Все цены в главе — на 7 ноября 2026 года, если рядом не указана другая дата. Курс ЦБ РФ на 06.11.2026 — 81,79 ₽ за доллар (ЦБ РФ). Долларовые цены — уличные в США и Европе, без налогов; рублёвые — российские магазины и маркетплейсы, часто с серым импортом. Разброс в 1,5–2 раза внутри одной модели — норма. Наличие в РФ нестабильно: DNS и Citilink часто продают «под заказ», Avito — наличием; проверяйте перед покупкой. Там, где надёжного источника не было, написано «не нашёл», а не придуманное число.
1.2 Электричество и шум — часть цены
Стоимость энергии считается так:
₽/год = мощность, Вт × часы в год × тариф / 1000
Московский одноставочный тариф для населения с 1 октября 2026 года — 8,90 ₽/кВт·ч (info-gkh.ru, 2026; Мосэнергосбыт). Возьмём типичные системные 150 Вт сверху к видеокарте:
| Конфигурация | Мощность | 8 ч/день, ₽/год | 24/7, ₽/год |
|---|---|---|---|
| RTX 5090 + ПК | ~725 Вт | ~18 800 | ~56 500 |
| 2×RTX 3090 + ПК | ~850 Вт | ~22 100 | ~66 200 |
| Mac Studio M5 Max | ~150 Вт | ~3 900 | ~11 700 |
| DGX Spark / Strix Halo | ~140 Вт | ~3 600 | ~10 900 |
575 Вт в маленькой комнате — это постоянный источник тепла и звука. Боксы на 140 Вт можно ставить на стол; 4×5090 — только в отдельную комнату.
Рисунок. Память, ПСП и цена устройств: логарифмические оси, размер кружка — уличная цена США. Правый верх — серверные CPU: объём есть, скорости нет; их цены — оценка. Данные — таблицы главы; ПСП/объёмы сверены с AI Infra in Depth (Apache-2.0); цены — ноябрь 2026.
Prefill — отдельная история. У дискретных NVIDIA он быстрый: тысячи ток/с на 8B и сотни на 30–70B. У R9700 — в 2,6–3,4 раза медленнее 5090; у Apple и Strix Halo — ещё медленнее, особенно на длинном промпте; у CPU — десятки–сотни ток/с. Поэтому RAG с длинными документами и агент с большим системным промптом на unified-боксах ощущаются иначе, чем на 5090, даже когда декод у них сопоставим.
2. NVIDIA для потребителя: RTX 50 и остатки RTX 40
Это самый простой путь: CUDA, llama.cpp, vLLM, Ollama, TensorRT-LLM — всё работает. Вопрос только в том, сколько вы готовы заплатить за память и пропускную способность.
| Карта | VRAM | ПСП, ГБ/с | TDP | США, $ | Россия, ₽ | Кому |
|---|---|---|---|---|---|---|
| RTX 5090 | 32 | 1792 | 575 | 4 999–6 919 ↗ | 750–950 тыс. ↗ | 30B dense, 30B-A3B, длинный контекст |
| RTX 5080 | 16 | 960 | 360 | 1 290–1 866 ↗ | 202–210 тыс. ↗ | 14B Q4; 30B MoE с выгрузкой |
| RTX 5070 Ti | 16 | 896 | 300 | 990–1 150 ↗ | ~150 тыс. ↗ | то же, дешевле и медленнее |
| RTX 5070 | 12 | 672 | 250 | 779–909 ↗ | 105–113 тыс. ↗ | 8–9B Q4 с запасом, 14B на грани |
| RTX 5060 Ti 16 | 16 | 448 | 180 | 500–780 ↗ | 80–92 тыс. ↗ | 8–14B Q4, бюджетный вход |
| RTX 5060 8 | 8 | 448 | 145 | 330–380 ↗ | 54–55 тыс. ↗ | только 7–8B Q4, без запаса |
Цены в таблице — на 07.11.2026. MSRP на старте: 5090 — $1 999, 5080 — $999, 5070 Ti — $749, 5070 — $549, 5060 Ti — $429, 5060 — $299. То есть текущие улицы — это +10–250 % к рекомендованной цене; в Европе добавьте НДС, обычно +15–20 %. В России разброс больше: например, RTX 5090 в DNS и «Регарде» идёт за 750–950 тыс. ₽, а на Авито встречаются предложения «под заказ» около 500 тыс. ₽ (3DNews, 02.11.2026). Гарантия и происхождение при такой разнице — не формальность. DNS/Citilink — официальная розница; агрегаторы серого импорта на те же даты дают в 1,5–2 раза ниже (5060 Ti — от ~50 тыс., 5080 — от ~116 тыс., 5070 — от ~60 тыс. ₽), но без гарантии (GPUPrices, 31.10.2026).
2.1 RTX 5090: 32 ГБ и 1,8 ТБ/с, но за них просят как за автомобиль
Спецификация: 21 760 CUDA-ядер, 32 ГБ GDDR7, 512-битная шина, 1792 ГБ/с, 575 Вт, рекомендуемый БП 1000 Вт, длина 304 мм, 2 слота у Founders Edition, 3352 AI TOPS в FP4 с разреженностью (NVIDIA, 2026). NVLink нет — только PCIe 5.0 x16. FP4 есть у 50-й серии, у 40-й — только FP8; для GGUF это почти не важно, для vLLM с FP8/FP4 — важно.
Что реально:
- 8B Q4 (4,8 ГБ) — 190–280; 14B (8,4 ГБ) — 110–160; prefill — тысячи ток/с.
- 32B dense Q4 (19,2 ГБ) — 47–70, с 32k и q8 остаётся ~7–9 ГБ; 30B-A3B MoE — 250–400 (потолок ~996, мешают attention и роутинг).
- 70B dense Q4 (42 ГБ) — не влезает; с выгрузкой слоёв в ОЗУ — 3–8 ток/с.
Плюсы: лучший декод, 32 ГБ, CUDA. Минусы: 2,5–3,5× MSRP, 575 Вт, 12V-2x6, БП 1000 Вт, шум, 2–3 слота.
Warning
RTX 5090D v2 — не «дешёвая 5090». Китайская версия для обхода экспортных ограничений: те же 21 760 CUDA, но 24 ГБ на 384-битной шине, 1344 ГБ/с вместо 1792 и 2375 AI TOPS вместо 3352, плюс встроенное ограничение ИИ-производительности (NVIDIA China, 2026; Guru3D, 15.08.2025). В России её продают за 400–440 тыс. ₽ (Metaratings, 2026). Для 30B dense и 70B-с-выгрузкой она интересна, для честной 5090 — нет: меньше память, ниже ПСП и срезанный ИИ.
2.2 RTX 5080 и 5070 Ti: 16 ГБ — новый минимум
Обе карты дают 16 ГБ, но разную ПСП: 960 ГБ/с у 5080 и 896 ГБ/с у 5070 Ti. Для декода это почти одна лига; разница заметна в prefill и играх. TDP 360 и 300 Вт, длина около 304 мм, 2–3 слота — в компактный корпус такие карты не влезут.
Что реально:
- 8B Q4 — 100–150 (5080) и 93–140 (5070 Ti); 14B Q4 — 57–86 и 53–80, 32k с q8 помещается.
- 32B dense Q4 и 70B — не влезают: 19,2 ГБ весов больше 16 ГБ; 30B MoE Q4 (~18 ГБ) — только с выгрузкой.
16 ГБ — минимум для 14B Q4 с длинным контекстом; 32B dense — нет. Если бюджет позволяет, 24–32 ГБ дают больше возможностей, чем +10 % скорости.
2.3 RTX 5070 и 5060 Ti: где заканчивается комфорт
RTX 5070 (12 ГБ, 672 ГБ/с, 250 Вт) — 8–9B Q4 с 32k комфортно; 14B Q4: 8k ~11,6 ГБ, 16k ~12,3 ГБ (на грани), 32k нет. 32B нет.
RTX 5060 Ti 16 (16 ГБ, 448 ГБ/с, 180 Вт) — 14B Q4 с 32k и 8B 47–70 ток/с; версия 8 ГБ — только 7–8B Q4 на 8k.
RTX 5060 8 — 7–8B Q4, 8k; 16k уже не оставляет запаса.
2.4 RTX 40: дешёвое б/у и никакой гарантии
Серия снята с производства, но на вторичке ещё много карт. Главное отличие от 50-й серии — нет FP4 и нет DLSS 4, но для GGUF это почти не важно; FP8 у Ada есть, CUDA — та же.
Б/у 40-я серия: 4090 24 ГБ (1008 ГБ/с, 450 Вт, $2 496–3 800 ↗, 145–270 тыс. ₽ ↗); 4080/4080 Super 16 ГБ (717–736 ГБ/с, $800–930), 4070 Ti Super 16 (672, $720–800), 4060 Ti 16 (288, цену не нашёл) (SellGPU). 4080/4070 Ti Super проигрывают новой 5060 Ti 16 по гарантии и цене за ГБ.
Посчитай сам. Есть 24 ГБ VRAM и 32B dense в Q4_K_M. Хватит ли контекста 32k, если KV-кэш в q8_0, а на буферы и запас оставить 2,5 ГБ? Конфиг: 48 слоёв, 8 KV-голов, d_head = 128.
Решение
вес: 32 × 0,6 = 19,2 ГБ
KV: 2 × 48 × 8 × 128 × 1,06 × 32 768 ≈ 3,41 ГБ
буферы: 1,0 ГБ
запас: 1,5 ГБ
итого: 19,2 + 3,41 + 1,0 + 1,5 = 25,11 ГБ
Не хватает около 1,1 ГБ. Варианты: контекст 24k (KV ~2,56 ГБ, итого ~24,3 ГБ — всё ещё на грани), KV в q4_0 (около 1,8 ГБ, итого ~23,5 ГБ), квант Q4_K_S или 32 ГБ карта. Вывод: 24 ГБ для 32B Q4 с 32k — мало; 32 ГБ — комфортно. Это ровно тот случай, когда «влезает» и «работает» — разные вещи.
3. Б/у 3090 и профессиональные карты: память без скорости
Когда нужно много памяти, а бюджет не резиновый, есть два пути: вторичка и профессиональные карты.
3.1 RTX 3090 24 ГБ — народный выбор для 30B
3090 — это 24 ГБ GDDR6X, 936 ГБ/с, 350 Вт, 2×8-pin (у Founders Edition — 12-pin), длина около 313 мм, 3 слота. NVLink есть: две карты объединяются в 48 ГБ с пропускной способностью моста 112,5 ГБ/с. Для 2020 года это был флагман; в 2026-м — рабочий инструмент за 115–140 тыс. ₽ на Авито (Авито, 07.11.2026). В США медиана проданных — $1 586 за 14 дней к 04.11.2026 (GPU Sold, 04.11.2026). 3090 стартовала с $1 499, 4090 — с $1 599; сегодняшние б/у цены близки к этим MSRP, что для четырёх-пятилетних карт ненормально.
Что реально:
- 8B Q4 — 98–146; 14B — 56–83; 32B — 24–37 (только 16k; 32k в 24 ГБ не помещается).
- 30B-A3B MoE — 150–250.
- 70B Q4 не влезает; две 3090 по NVLink (48 ГБ) — 16–24.
Плюсы: 24 ГБ, NVLink, CUDA, ремонтопригодность, выбор на вторичке. Минусы: нет FP8/FP4, нагрев памяти 100–110 °C, майнинг, нет гарантии. Проверяйте артефакты, термопрокладки, разъёмы, NVLink-мост.
3.2 Профессиональные RTX PRO: ECC, blower и гарантия
| Карта | VRAM | ПСП, ГБ/с | TDP | США, $ | Что реально |
|---|---|---|---|---|---|
| RTX PRO 4000 | 24 | 672 | 140 | 3 050 ↗ | 32B Q4 только 16k; 14B комфортно; 1 слот |
| RTX PRO 4500 | 32 | 896 | 200 | 5 726 ↗ | 32B Q4 с запасом, 70B нет |
| RTX PRO 5000 | 48 | 1344 | 300 | 7 300 ↗ | 70B Q4 16–24 ток/с; 32B 35–53 |
| RTX PRO 6000 | 96 | 1792 | 600 | 16 000 ↗ | 70B Q4 21–32; 70B Q8 12–18; 120B MoE 150–250 |
| RTX A6000 (б/у) | 48 | 768 | 300 | ~3 750 ↗ | 70B Q4 9–14; без FP8, но 48 ГБ |
| RTX 6000 Ada (б/у) | 48 | 960 | 300 | ~5 225 ↗ | 70B Q4 11–17; FP8, но NVLink нет |
На 48 ГБ 70B Q4 помещается с контекстом около 16k; для 32k нужно 64–96 ГБ. ECC, blower и трёхлетняя гарантия — это +1,5–3× к цене за гигабайт. Российских розничных цен на PRO-карты я не нашёл: они продаются через интеграторов. Версия PRO 5000 на 72 ГБ — $8 999–9 999 (Newegg, 11.2026) и держит 70B Q4 с 32k. У PRO 6000 есть Max-Q на 300 Вт — меньше шума, ниже потолок мощности.
Note
В главе 13 для 48 ГБ стоит 12–18 ток/с. Это тот же расчёт с более консервативным запасом; для PRO 5000 и пары 3090 в таблице 16–24 — потолок 50–75 %, для A6000/6000 Ada — 9–14/11–17 по их ПСП. Для планирования берите 12–18.
Важно про NVLink. В RTX PRO 6000 Blackwell нет NVLink — ни в Workstation, ни в Server Edition; в спецификации Lenovo прямо написано «NVLink support: No» (Lenovo Press, 2026). Две карты по 96 ГБ работают как два отдельных пула на 192 ГБ, общаются по PCIe 5.0 x16. Для layer split это нормально, для tensor parallel — медленнее. У старых A6000 (Ampere) NVLink был; у RTX 6000 Ada и RTX PRO 6000 Blackwell его уже нет. Именно поэтому A6000 до сих пор берут для 2×48 ГБ, а RTX 6000 Ada — уже нет.
Tip
Если нужен именно один пул на 96 ГБ и CUDA — RTX PRO 6000 вне конкуренции. Если нужен 192 ГБ и вы готовы платить за две карты, сначала проверьте, умеет ли ваш рантайм нормально работать с двумя пулами по PCIe. vLLM умеет tensor parallel, llama.cpp — layer split; для второго NVLink не критичен.
4. AMD: 32 ГБ дешевле, но с оговорками
AMD в 2026 — это Radeon AI PRO R9700: 32 ГБ GDDR6, 640 ГБ/с, 300 Вт, 95,7 TFLOPS FP16 (векторных), 1531 TOPS INT4, ECC на Linux, 2 слота, blower. Вентилятор слышно — плата за плотность (AMD, 2026; AI Miracle, 13.10.2026). MSRP $1 299, улица $1 320–1 699 (Newegg, 11.2026).
Что реально (по независимым тестам и формуле):
- 8B Q4 — 67–100; 14B — 38–57; 32B — 17–25 (32k помещается); 70B — нет; 30B-A3B — 150–250.
- Prefill в 2,6–3,4 раза медленнее 5090, декод — примерно в 1,5 раза (Local AI Master, 2026). Для RAG и длинных промптов это чувствуется.
Софт: ROCm 7 на Linux, официальная поддержка R9700 (gfx1201), llama.cpp HIP и Vulkan, vLLM ROCm, Ollama. На Windows — Vulkan/Adrenalin, ROCm ограничен. Проверяйте, собран ли бэкенд под вашу карту и версию драйвера.
RX 9070 XT 16 ГБ — тот же Navi 48, 640 ГБ/с, 304 Вт, MSRP $599, улица $760–919 (BestValueGPU, 11.2026). В России — от 65 тыс. ₽ на Авито (Авито, 07.11.2026) до ~110 тыс. ₽ в рознице (GPUPrices, 30.10.2026). Для 8–14B Q4 — отлично, для 32B мало памяти; ROCm у RDNA4 сырее, чем у R9700.
RX 9060 XT 16 ГБ — 320 ГБ/с, 160 Вт, MSRP $349, улица ~$500; в России 73–89 тыс. ₽ (Citilink, 2026). 8B — 40–60, 14B — 20–30; бюджетно, но ПСП низкая.
| Карта | VRAM | ПСП, ГБ/с | TDP | США, $ | Россия, ₽ | Комментарий |
|---|---|---|---|---|---|---|
| Radeon AI PRO R9700 | 32 | 640 | 300 | 1 320–1 699 ↗ | не нашёл | 32 ГБ, ECC, blower для плотных сборок |
| RX 9070 XT | 16 | 640 | 304 | 760–919 ↗ | 65–110 тыс. ↗ | быстрая 16-гиговая, ROCm хуже |
| RX 9060 XT 16 | 16 | 320 | 160 | ~500 ↗ | 73–89 тыс. ↗ | тихая, но медленная |
Warning
AMD — Linux-first. В Windows проверьте ROCm/Vulkan до покупки: R9700 поддержан официально, 9070 XT — зависит от сборки. CUDA-инструменты (TensorRT-LLM и часть quantization) не заработают.
5. Intel: 24–32 ГБ за небольшие деньги, если готовы к SYCL
Intel Arc Pro — самый недооценённый вариант 2026 года. Карты дают много памяти за деньги, но требуют Linux и терпения.
| Карта | VRAM | ПСП, ГБ/с | TDP | США, $ | Россия, ₽ | Что реально |
|---|---|---|---|---|---|---|
| Arc Pro B50 | 16 | 224 | 70 | ~299 ↗ | не нашёл | 8B Q4, 14B Q4 медленно |
| Arc Pro B60 | 24 | 456 | 200 | 934–1 025 ↗ | 110 300 ↗ | 14B Q4 27–41; 32B Q4 12–18 |
| Arc Pro B70 | 32 | 608 | 230 | 1 932–2 059 ↗ | не нашёл | 32B Q4 16–24; 70B нет |
B60 — 20 Xe, 24 ГБ GDDR6, 456 ГБ/с, 200 Вт, PCIe 5.0 x8, 8-pin, blower, ~267 мм у большинства партнёров. MSRP $599, улица $934–1 025; в РФ 110 300 ₽ (ServerFlow, 07.11.2026). Дороже 3090 б/у при меньшей скорости, но новая, с ECC и 200 Вт.
B70 — 32 Xe, 32 ГБ, 608 ГБ/с, 230 Вт, 22,9 TFLOPS FP32, 367 TOPS INT8 (Intel, 2026). Цена выросла с $949 до $1 900–2 060; 32B — 16–24, 14B — 36–54.
Софт: llama.cpp SYCL, vLLM XPU, Ollama, OpenVINO, PyTorch XPU; на Linux — драйвер xe, GuC и сборка с -DGGML_SYCL=ON. 4×B60 (96 ГБ) в независимом тесте: 82,4 ток/с на Qwen3-Coder-30B-A3B, 119 ток/с на 12 параллельных запросов (130B), 211 Вт в тесте (паспорт 4×200 Вт) (ninabot.ch, 10–11.09.2026). Хорошо для 96 ГБ за ~$3,7 тыс., если хватает PCIe x8.
Note
Intel — не «просто работает»: проверяйте драйвер, GuC, образ llama.cpp/vLLM и кванты; IPEX-LLM меняет статус. Для минимального риска — не первый выбор.
6. Apple: 128–512 ГБ, тихо, но медленно
Apple Silicon — это объединённая память: CPU и GPU видят один пул, веса не копируются по PCIe. Плата за это — пропускная способность ниже, чем у дискретных карт, и отсутствие CUDA.
| Машина | Память | ПСП, ГБ/с | Цена США, $ | Цена РФ, ₽ | Что реально |
|---|---|---|---|---|---|
| Mac mini M6 | 16–32 | 153 / 170 | 899 ↗ | не нашёл | 8B Q4 32–48; 14B 18–27 |
| Mac mini M5 Pro | 24–64 | 307 | 1 699 ↗ | 215–280 тыс. ↗ | 14B 18–27; 32B 8–12 |
| Mac Studio M5 Max | 36–128 | 460 / 614 | 2 499 ↗ | 248–824 тыс. ↗ | 70B/120B — только 64/128 ГБ; 70B Q4 7–11; 120B MoE 60–100 |
| Mac Studio M5 Ultra | 96–512 | 1 200 | 5 499 ↗ | 853 тыс. (96/1 ТБ) ↗ | 70B Q4 14–21; 120B MoE 150–250; 235B MoE — только 256–512 ГБ |
Тот же M5 Max с 128 ГБ — в MacBook Pro 16 за $7 399 (Apple, 2026) — для мобильной работы. Официальные ПСП: M5 Max 36 ГБ — 460 (40-ядерный — 614), M5 Ultra — 1200, M6 — 153/170, M5 Pro — 307 (Apple, Apple, 2026).
Что реально:
- Mac mini M5 Pro 64 ГБ — 32B Q4 8–12 ток/с, 14B 18–27, 8B 32–48. Тихий, 12,7×12,7×5 см, ~100 Вт. Для чата и одного агента — отлично; для 70B — мало памяти или медленно.
- Mac Studio M5 Max 128 ГБ — 70B Q4 7–11 ток/с, 120B MoE Q4 60–100, 32B 16–24. Корпус 19,7×19,7×9,5 см, почти бесшумный. Для 70B это рабочий, но не быстрый вариант; для MoE с малым числом активных — вполне.
- Mac Studio M5 Ultra 96–512 ГБ — 1,2 ТБ/с меняет картину: 70B Q4 14–21, 70B Q8 8–12, 120B MoE 150–250; 235B MoE Q4 (~141 ГБ) влезает только в конфигурации на 256–512 ГБ и идёт там на 35–60 ток/с. Это самый доступный способ держать 235B MoE в одном пуле без сервера. 512 ГБ — для моделей на 400B+ и очень длинного контекста, цена «как автомобиль».
MLX против llama.cpp Metal. MLX лучше использует объединённую память и MXFP4, часто быстрее на prefill; llama.cpp Metal зрелее по моделям и флагам, декод близок к ПСП. Для одного пользователя разница 10–30 % на prefill; для сервера с слотами удобнее llama.cpp.
Warning
Объединённая память — не бесконечная VRAM. macOS резервирует часть пула; лимит поднимается через
sudo sysctl iogpu.wired_limit_mb=<МБ>, но оставьте 8–16 ГБ системе. 128 ГБ при 460–1200 ГБ/с — не 1,8 ТБ/с: на 70B Q4 разница в декоде 1,5–4 раза.
7. NVIDIA DGX Spark: 128 ГБ CUDA на столе
DGX Spark — маленькая коробка на GB10 Grace Blackwell: 20-ядерный ARM (10×Cortex-X925 + 10×Cortex-A725), GPU Blackwell, 128 ГБ LPDDR5X, 273 ГБ/с, 1 PFLOPS FP4 (с разреженностью), TDP 140 Вт, БП 240 Вт, 150×150×50,5 мм, 1,2 кг, шум 29 дБА под нагрузкой и 13 дБА в простое по таблице ECMA-109 (NVIDIA, 2026). Цена — $6 950 за 128 ГБ, $4 999 за 64 ГБ; у партнёров (Acer, ASUS, Dell, Gigabyte, HP, Lenovo, MSI) — $5 660–9 097 (The Register, 02.10.2026; pi3g, 24.09.2026). В России — 860 185 ₽ в NIX на 06.11.2026 (NIX, 06.11.2026).
Что реально:
- 8B Q4 — 28–43; 14B — 16–24; 32B — 7–11.
- 70B Q4 — 3–5 (Q8 — 1,5–2,5); 120B MoE — 30–50.
- 235B MoE Q4 в 128 ГБ не влезает; Q3/IQ3 — на грани, 5–10. Prefill — средне-быстрый CUDA, но не 5090.
Плюсы: 128 ГБ одним пулом, CUDA-стек, тихо, 1,2 кг; до 4 узлов по 200 Гбит/с (шардинг — на фреймворке). Минусы: 273 ГБ/с, ARM, память распаяна, цена выросла; 64 ГБ за $4 999 — плохой выбор.
Note
«1 PFLOPS FP4» — пик для разреженных тензоров; декод упирается в 273 ГБ/с, FP4 помогает prefill/батчингу. Не сравнивайте с 3352 TOPS напрямую.
8. AMD Strix Halo: 128 ГБ по цене видеокарты
Ryzen AI Max+ 395 («Strix Halo») — APU с 16 ядрами Zen 5, Radeon 8060S (40 CU) и 128 ГБ LPDDR5X-8000 на 256-битной шине, 256 ГБ/с, до 126 TOPS (50 NPU), TDP 55–120 Вт, системное потребление мини-ПК 120–140 Вт. Это x86, Windows и Linux, без CUDA.
| Бокс | Память | Цена США, $ | Россия, ₽ | Комментарий |
|---|---|---|---|---|
| Framework Desktop | 128 | 3 449 ↗ | не нашёл | mini-ITX, ремонтопригодный, Linux-first |
| GMKtec EVO-X2 | 128 | 3 649 ↗ | 193–387 тыс. ↗ | самый массовый |
| Beelink GTR9 Pro | 128 | 4 349 ↗ | не нашёл | дороже, больше портов |
| Minisforum MS-S1 Max | 128 | 3 799 ↗ | не нашёл | 2×10GbE, 2U-опция |
Цены в России — от 193 тыс. ₽ на Яндекс Маркете (серый импорт) до 387–414 тыс. ₽ на Wildberries/Ozon. Разброс объясняется происхождением, гарантией и комплектацией; проверяйте, что именно 128 ГБ, а не 64 или 32.
Что реально:
- 8B Q4 — 27–40; 14B — 15–23; 32B — 7–10.
- 70B Q4 — 3–4,5; 120B MoE — 25–45.
- 235B MoE Q4 в 128 ГБ не влезает; Q3/IQ3 — 5–10. Prefill слабее NVIDIA: длинный промпт идёт заметно дольше.
Плюсы: 128 ГБ за 200–400 тыс. ₽ — самая низкая цена за гигабайт; x86/Windows, 4,5 л, ~140 Вт. Минусы: 256 ГБ/с, ROCm на gfx1151 сырее, память распаяна, нет CUDA, шум под нагрузкой.
Tip
Strix Halo — если нужны 128 ГБ и тишина, а 3–4 ток/с на 70B устраивают. Быстрее — Mac Studio Ultra/PRO 6000; CUDA — DGX Spark.
9. CPU-only и серверная память: когда это имеет смысл
CPU-only почти никогда не выигрывает по скорости. Он выигрывает по объёму и цене за гигабайт, если у вас уже есть сервер или нужна пакетная обработка.
| Платформа | Каналов DDR5 | ПСП, ГБ/с | 70B Q4, ток/с | 8B Q4, ток/с | Когда брать |
|---|---|---|---|---|---|
| Десктоп, 2 канала | 2 | 80–100 | 1–1,4 | 8–13 | только 7–14B, офлайн |
| Threadripper TRX50 | 4 | ~205 | 2,5–3,7 | 21–32 | 30B, 70B офлайн, 1–2 GPU |
| Threadripper PRO WRX90 | 8 | ~410 | 5–7 | 43–64 | 70B, 4 GPU, много RAM |
| EPYC 9005 | 12 | 614 | 7–11 | 64–96 | сервер, 768 ГБ+, батчи |
| 2×EPYC 9005 | 24 | 1 228 | 15–22 | 128–192 | большие батчи, NUMA-тюнинг |
Цифры ПСП — теоретические: 12 каналов DDR5-6400 дают 614,4 ГБ/с на сокет (Supermicro, 2026); WRX90 — 8 каналов, около 410 ГБ/с; TRX50 — 4 канала, около 205 ГБ/с (NEMIX, 2026). Реальная ПСП ниже на 10–20 %, а на 70B добавляется NUMA и неоптимальные ядра. Intel Xeon 6 в старших моделях тоже даёт 8–12 каналов DDR5; по ПСП он близок к EPYC, но конкретную платформу, цену и поддержку б/у проверяйте отдельно (Intel, 2026).
Стоимость в 2026 году абсурдна: EPYC 9655P — около £10 999 (Overclockers UK, 2026), 64 ГБ RDIMM — порядка $3 000 (Fusion Worldwide, 2026). 768 ГБ на 12 каналах — $50–60 тыс. только за CPU, память и плату [оценка]; за это — 3–4 RTX PRO 6000 или стойка б/у 3090. Ориентиры для графика: десктоп на 2 каналах — ~$1,5 тыс., WRX90 на 8 каналах — ~$12 тыс. [оценка].
Когда CPU-only оправдан:
- Пакетная обработка: ночью прогнать 10 тысяч документов, скорость не важна.
- Огромный контекст/база: модель на 200B+ в Q4 не влезает ни в одну карту, а 768 ГБ ОЗУ — влезает.
- Сервер уже есть: вы докупаете память, а не всю платформу.
- Юридические ограничения: данные не могут покидать контур, а GPU нет.
Когда нет: интерактивный чат, агент с тулами, несколько пользователей. 70B на 1–2 ток/с — это не работа, а ожидание. И помните про шум: 1U-сервер с 12 каналами памяти и турбинными вентиляторами слышно из соседней комнаты; для дома нужен tower-корпус.
Warning
На двухсокетной системе каждый сокет — свой NUMA-узел; чтение «чужой» памяти почти вдвое снижает ПСП. Закрепляйте потоки (
numactl --cpunodebind) и проверяйте, что модель не размазана.
10. Несколько GPU: 48, 64, 96, 192 ГБ
Несколько карт нужны, когда одна не вмещает модель или когда нужен батчинг. Есть два режима:
- Layer split (llama.cpp
--split-mode layer): слои делятся между картами, каждая считает свои; по PCIe ходят только активации. Требует меньше пропускной способности, но на каждом шаге карты ждут друг друга. - Tensor parallel (vLLM): матрицы слоя делятся между картами, нужен all-reduce на каждом слое. Быстрее на prefill, но требует высокой пропускной способности между картами.
| Конфигурация | Память | ПСП суммарно | Мощность | Цена (оценка) | NVLink | Комментарий |
|---|---|---|---|---|---|---|
| 2×RTX 3090 | 48 | 1 872 | ~700 Вт | 230–280 тыс. ₽ ↗ | да, 112,5 ГБ/с | 70B Q4 16–24; лучший бюджет |
| 2×RTX 5090 | 64 | 3 584 | ~1 150 Вт | 1,5–1,9 млн ₽ [оценка] | нет | 70B Q4 24–40; БП 1600 Вт |
| 4×RTX 5090 | 128 | 7 168 | ~2 300 Вт | 3–3,8 млн ₽ [оценка] | нет | 120B MoE; только отдельная комната |
| 2×RTX PRO 6000 Workstation Edition | 192 | 3 584 | ~1 200 Вт | 2,6–3 млн ₽ [оценка] | нет | 235B MoE Q4 40–60; PCIe only |
| 4×Arc Pro B60 | 96 | 1 824 | ~800 Вт | ~440 тыс. ₽ [оценка] | нет | 30B-A3B 82 ток/с (тест) |
PCIe, питание и шум: 2×5090 — БП 1 600 Вт, 4× — 2,3 кВт и отдельная комната; 4 GPU требуют HEDT/сервер: у Ryzen 9 24 линии → x8/x8, у Threadripper/EPYC — 80–128. Подробнее — §1.2.
- NVLink. У 5090 его нет; у 3090 есть (2-way). У RTX PRO 6000 Blackwell нет. Для tensor parallel на 2×5090 all-reduce пойдёт по PCIe 5.0 x8 (32 ГБ/с в каждую сторону) — это может стать бутылочным горлышком на prefill. Для layer split — терпимо.
Warning
2×16 ГБ ≠ 32 ГБ. Модель на 24 ГБ не всегда делится на две по 12: слой attention или эксперт может не поместиться, а tensor parallel добавляет all-reduce. Если влезает в одну 32-гиговую — она быстрее и проще. Исключение — 2×3090 по NVLink: память объединяется.
11. Облако или покупка: считаем точку безубыточности
Аренда GPU в 2026 году дешевле, чем кажется, а локальное железо — дороже. Формула простая:
часы до безубыточности = цена железа / (аренда в час − электричество в час)
Пример для RTX 5090:
- Покупка: 800 тыс. ₽ (карта + БП + корпус).
- Электричество: ~7 ₽/ч (725 Вт × 8,90 ₽/кВт·ч).
- Аренда 5090: $0,69/ч ≈ 56 ₽/ч в Community Cloud (RunPod, 27.08.2026); Secure Cloud — $1,19/ч ≈ 97 ₽/ч.
- Разница: 49 ₽/ч (Community) или 90 ₽/ч (Secure). Безубыточность: 16 300 ч в Community или 8 900 ч в Secure — ~1,9 года 24/7 или ~1 год 24/7 соответственно; по 8 часов в день это 5,6 и 3 года.
| Вариант | Цена (только GPU/бокс) | Аренда | Часы до безубыточности | Вывод |
|---|---|---|---|---|
| RTX 5090 | 800 тыс. ₽ | 56 ₽/ч (Community) / 97 ₽/ч (Secure) | ~16 300 / ~8 900 | 24/7 — локально; 8 ч/день — облако |
| 2×RTX 3090 | 260 тыс. ₽ | 60 ₽/ч (2×4090, RunPod) | ~5 200 | 24/7 — локально; 8 ч/день — ~1,8 года |
| RTX PRO 6000 96 ГБ | 1,3 млн ₽ | 290 ₽/ч (Selectel) | ~4 700 | 24/7 — локально; иначе аренда |
| Mac Studio M5 Ultra 96 ГБ | 853 тыс. ₽ | 342 ₽/ч (H100, Immers) | ~2 600 | сравнение условное: разные архитектуры |
Россия: Selectel — 2×4090 210 ₽/ч, PRO 6000 290 ₽/ч; HOSTKEY — H100 207 ₽/ч; Immers — H100 342 ₽/ч (Selectel, HOSTKEY, Immers, 2026).
За рубежом: RunPod 5090 — $0,69 Community / $1,19 Secure, 4090 — $0,34, H100 — $1,99–2,89; PRO 6000 — $1,69–2,35 (RunPod, Spheron, 30.10.2026).
Посчитай сам. Вы работаете с 70B Q4 по 8 часов в день, 250 дней в году. Две карты 2×3090 стоят 260 тыс. ₽ (остальной ПК у вас уже есть), электричество — 10 ₽/ч, аренда 2×4090 на RunPod — около 60 ₽/ч (две карты по ~$0,34/ч). Что дешевле за 3 года?
Решение
часы: 8 × 250 × 3 = 6 000 ч
аренда: 6 000 × 60 = 360 000 ₽
локально: 260 000 + 6 000 × 10 = 320 000 ₽
Локально дешевле на ~40 тыс. ₽ за 3 года — но это без учёта амортизации, ремонта, шума и времени на настройку. Если часы упадут до 4 в день, аренда выиграет. Если 24/7 — локально выиграет в разы. Считайте свои часы, а не «кажется, что своё дешевле».
Облако: нет capex, доступ к H100/B200, масштаб, тишина. Минусы: данные наружу, egress, изменчивые цены. Гибрид: локальная 24–32 ГБ для разработки, аренда 96–192 ГБ для больших прогонов.
12. Бюджет → лучший вариант
Цены — российские, ноябрь 2026; они взяты из разделов выше, ссылки и дата проверки — там же (07.11.2026). «Лучший» — не самый быстрый, а лучший баланс памяти, скорости, гарантии и шума.
| Бюджет | Лучший вариант | Почему |
|---|---|---|
| до 50 тыс. ₽ | б/у RTX 3060 12 ГБ ↗; новых карт с 12+ ГБ в этом бюджете не нашёл | 12 ГБ лучше 8 для LLM; гарантии нет |
| 50–100 тыс. ₽ | RTX 5060 Ti 16 ГБ (80–92 тыс.) | 16 ГБ, гарантия, 180 Вт, CUDA |
| 100–200 тыс. ₽ | б/у RTX 3090 24 ГБ (115–140 тыс.) или RX 9070 XT 16 ГБ (65–110 тыс.) | 24 ГБ за деньги 16-гиговой новой; 9070 XT быстрее, но 16 ГБ |
| 200–400 тыс. ₽ | 2×RTX 3090 48 ГБ (230–280 тыс.) или Strix Halo 128 ГБ (193–387 тыс.) | 48 ГБ с NVLink против 128 ГБ без CUDA |
| 400–800 тыс. ₽ | Mac Studio M5 Max 64 ГБ (464 тыс.) или RTX 5090 32 ГБ (750–950 тыс., верхняя граница) | тишина и 64 ГБ против скорости и 32 ГБ |
| 1 млн ₽+ | RTX PRO 6000 96 ГБ (1,3–1,7 млн [оценка]) или Mac Studio M5 Ultra 256 ГБ (точную цену не нашёл; 96 ГБ — 853 тыс.) | один пул 96 ГБ с CUDA против 256 ГБ с 1,2 ТБ/с |
Tip
За 200–300 тыс. ₽ без б/у Strix Halo 128 ГБ — самый универсальный: x86, Windows, 140 Вт. Но 70B на нём — 3–4,5 ток/с; быстрее — 2×3090 (48 ГБ), зато без 120B MoE.
12.1 Цена за гигабайт — грубый, но полезный фильтр
| Устройство | Цена, ₽ | Память, ГБ | ₽/ГБ | Что не учтено |
|---|---|---|---|---|
| Strix Halo 128 ГБ | 300 000 | 128 | ~2 340 | скорость, софт, гарантия |
| Arc Pro B60 | 110 300 | 24 | ~4 600 | скорость, драйверы |
| RTX 3090 б/у | 130 000 | 24 | ~5 420 | гарантия, ремонт, шум |
| Mac Studio M5 Max 128 ГБ | 823 900 | 128 | ~6 440 | CPU, SSD, софт Apple |
| RTX PRO 6000 96 ГБ | 1 310 000 | 96 | ~13 650 | CUDA, ECC, гарантия |
| RTX 5090 32 ГБ | 800 000 | 32 | ~25 000 | скорость, CUDA, но цена |
Цена за гигабайт не говорит о скорости: 3090 и B60 стоят похоже за 24 ГБ, но 3090 читает память вдвое быстрее. И не говорит о софте: Strix Halo дешевле всех за гигабайт, но CUDA на нём нет. Это только первый фильтр, после которого всё равно надо считать декод и смотреть, что поддерживает ваш рантайм.
13. Задача → железо
| Задача | Минимум | Комфорт | Почему |
|---|---|---|---|
| Чат 7–14B | RTX 5060 Ti 16 | RTX 5070 / Mac mini M5 Pro 24 | 16 ГБ хватает на 14B Q4 + 32k; 12 ГБ — на 8–9B |
| Агент 30B MoE | RTX 3090 24 / B60 24 | RTX 5090 32 / R9700 32 | вся модель в VRAM; 24 ГБ — минимум, 32 ГБ — запас на KV |
| 70B dense | 2×3090 48 / RTX PRO 5000 48 | Mac Studio 96 / RTX PRO 6000 96 | 42 ГБ весов + KV; 48 ГБ — только 16k, 96 ГБ — комфорт |
| 100B+ MoE | Strix Halo 128 / DGX Spark 128 | RTX PRO 6000 96 / Mac Studio 128 | 72–110 ГБ весов (120B Q4); 235B MoE Q4 — 192 ГБ+ |
| Длинный контекст 64k+ | RTX 5090 32 | RTX PRO 6000 96 / Mac Studio 128 | KV растёт линейно; q8 KV и запас 2 ГБ |
| Несколько пользователей | RTX PRO 6000 96 + vLLM | 2×PRO 6000 / сервер | батчинг, PagedAttention, изоляция слотов |
| Тишина и мало ватт | Mac mini M5 Pro | Mac Studio / DGX Spark / Strix Halo | 140–150 Вт, 13–29 дБА |
| Бюджет и офлайн | б/у 3090 24 | 2×3090 48 | дешёвая память, CUDA, но шум и нет гарантии |
14. Дерево решений
flowchart TB
A["Задача и бюджет"] --> B{"Сколько памяти<br/>нужно сейчас?"}
B -->|"≤ 16 ГБ"| C["16 ГБ:<br/>5060 Ti / 5070"]
B -->|"24–32 ГБ"| D["24–32 ГБ:<br/>3090 б/у, 5090,<br/>R9700, B60"]
B -->|"48–96 ГБ"| E["48–96 ГБ:<br/>PRO 5000/6000,<br/>2×3090, Mac Studio"]
B -->|"128 ГБ+"| F["128 ГБ+:<br/>Mac Studio, DGX Spark,<br/>Strix Halo"]
C --> G{"Что важнее?"}
D --> G
E --> G
F --> G
G -->|"скорость"| H["NVIDIA + CUDA"]
G -->|"тишина и ватты"| I["Apple / DGX Spark"]
G -->|"цена за ГБ"| J["AMD / Intel / б/у"]
Сначала память — она решает, что запустится; потом приоритет. Если объём неизвестен, вернитесь к главе 13.
15. Красные флаги ноября 2026
- 8 ГБ и «две по 16». Для LLM нужен один пул 16+ ГБ; 8 ГБ — только 7–8B Q4, две 16 не заменяют 32.
- RTX 5090 за $6 900 / 950 тыс. ₽. Это цена дефицита, а не производительности; при нагрузке < 2 000 ч/год — аренда.
- DGX Spark 64 ГБ за $4 999. За +$1 951 — вдвое больше памяти; 64 ГБ — маркетинговый компромисс.
- «1 PFLOPS» / «3352 TOPS» и серверная DDR5. Пики FP4 не про декод; 64 ГБ RDIMM за ~$3 000 — не время собирать CPU-only с нуля.
- Серый импорт и б/у 3090. Разница 30–40 % часто означает «без возврата»; у 3090 проверяйте термопрокладки, память 100–110 °C и тест под нагрузкой.
Ключевые идеи
- Память решает, что запустится; ПСП — как быстро; софт — заработает ли.
- 16 ГБ в 2026 году — минимум для 14B Q4 с длинным контекстом, 24–32 ГБ — комфорт для 30B, 48–96 ГБ — для 70B, 128 ГБ+ — для 100B+ MoE.
- RTX 5090 — самая быстрая потребительская карта, но цена в 2,5–3,5 раза выше MSRP; 5090D v2 — не замена.
- Б/у 3090 24 ГБ — лучший бюджетный вход в 30B; 2×3090 по NVLink — 48 ГБ за разумные деньги.
- AMD R9700 даёт 32 ГБ и ECC, но prefill в 2,6–3,4 раза медленнее 5090; Intel B60/B70 — 24–32 ГБ за небольшие деньги, если готовы к SYCL.
- Apple и Strix Halo — это 128 ГБ и тишина, но 3–21 ток/с на 70B; DGX Spark — 128 ГБ с CUDA и ценой как у подержанной машины.
- Ноябрь 2026 — рынок продавца: покупайте под задачу, не «под будущее»; считайте электричество и точку безубыточности аренды.
Проверь себя
- Почему RTX 5090 с 1,8 ТБ/с не всегда быстрее Mac Studio M5 Ultra с 1,2 ТБ/с?
- Почему две карты по 16 ГБ не заменяют одну на 32 ГБ?
- Что такое объединённая память и почему 128 ГБ в Mac — не то же самое, что 128 ГБ VRAM?
- Когда CPU-only имеет смысл, а когда это потеря времени?
- Как посчитать, что дешевле — купить RTX 5090 за 800 тыс. ₽ или арендовать её по 56–97 ₽/ч?
Ответы
- Важны не только ПСП, но и объём одного пула, prefill и софт. На 70B Q8 или 120B MoE Mac выигрывает объёмом; на модели до 32 ГБ 5090 быстрее.
- Две карты — два пула; tensor parallel добавляет all-reduce, layer split — ожидание. Одна 32-гиговая проще, кроме 2×3090 по NVLink.
- Это общий пул CPU/GPU без копирования по PCIe, но с меньшей ПСП, резервом ОС и без CUDA. 128 ГБ Mac — 460–1200 ГБ/с, не 1,8 ТБ/с.
- Когда важны объём и цена за гигабайт, а не задержка: пакетная обработка, огромный контекст, сервер уже есть, данные нельзя выносить. Для чата 1–2 ток/с — потеря времени.
- Разделите цену железа на разницу «аренда минус электричество»: 800 000 / (56 − 7) ≈ 16 300 ч для Community Cloud и 800 000 / (97 − 7) ≈ 8 900 ч для Secure. По 8 часов в день это 5,6 и 3 года; если нагрузка меньше — аренда, если 24/7 — покупка. Та же формула работает для любой карты.
Источники главы
- NVIDIA GeForce RTX 5090 — Specifications — NVIDIA, 2026. nvidia.com. 32 ГБ GDDR7, 575 Вт, 1000 Вт БП, NVLink нет.
- NVIDIA RTX PRO 6000 Blackwell Workstation Edition — NVIDIA, 2026. nvidia.com. 96 ГБ, 1792 ГБ/с, 600 Вт, 4000 AI TOPS.
- Lenovo Press, RTX PRO 6000 Blackwell Max-Q — Lenovo, 2026. lenovopress.lenovo.com. Прямо указывает «NVLink support: No».
- NVIDIA RTX PRO 5000 Blackwell — NVIDIA, 2026. nvidia.com. 48/72 ГБ, 1344 ГБ/с, 300 Вт.
- NVIDIA DGX Spark — Specifications — NVIDIA, 2026. nvidia.com. 128 ГБ LPDDR5X, 273 ГБ/с, 140 Вт, 1 PFLOPS FP4, 29 дБА.
- AMD Radeon AI PRO R9700 — AMD, 2026. amd.com. 32 ГБ, 640 ГБ/с, 300 Вт, ECC, ROCm.
- Intel Arc Pro B-Series — Intel, 2026. intel.com. B50/B60/B65/B70: 16–32 ГБ, 224–608 ГБ/с, 70–230 Вт.
- Apple Mac Studio (M5 Max/M5 Ultra) — Tech Specs — Apple, 2026. support.apple.com. 36–512 ГБ, 460–1200 ГБ/с.
- Apple Mac mini (M6/M5 Pro) — Tech Specs — Apple, 2026. support.apple.com. 16–64 ГБ, 153–307 ГБ/с.
- AMD EPYC 9005 Series — AMD, 2026. amd.com. 12 каналов DDR5-6400, 614 ГБ/с на сокет.
- AMD Ryzen Threadripper 9000 — AMD, 2026. amd.com. TRX50 — 4 канала, WRX90 — 8 каналов, 80–128 линий PCIe 5.0.
- llama.cpp — Backend/build docs — ggml-org, 2026. GitHub. CUDA, HIP, SYCL, Metal, Vulkan, CPU.
- llama.cpp — SYCL backend — ggml-org, 2026. GitHub. Сборка и запуск на Intel GPU.
- MLX — Apple Machine Learning Research, 2026. GitHub. Фреймворк для Apple Silicon.
- ROCm — System requirements — AMD, 2026. docs.amd.com. Поддержка Radeon AI PRO и RDNA.
- vLLM — Installation — vLLM, 2026. docs.vllm.ai. CUDA, ROCm, XPU.
- Fusion Worldwide, «RDIMM Shortage 2026» — 2026. fusionww.com. Рост цен DRAM и RDIMM.
- Tom’s Hardware, «Nvidia doubles RTX PRO 6000 Blackwell’s MSRP to $16,000» — 2026. tomshardware.com. Динамика цен professional-карт.
- RunPod — RTX 5090 и H100 — 2026. runpod.io, H100. Цены аренды.
- Selectel — GPU-серверы — 2026. selectel.ru. Российские цены аренды.
- HOSTKEY — аренда H100/A100 — 31.08.2026. hostkey.ru. 207 и 153 ₽/ч.
- AI Infra in Depth — hardware dataset — Bojie Li, 2026. GitHub, JSON. Apache-2.0. Сверка ПСП и объёмов 151 устройства; использован для Apple M5/M6, RTX PRO 6000, A6000 и RTX 6000 Ada.
14. Речь и OCR локально
Зачем эта глава. Инференс — это не только текст. Голосовые заметки и сканы документов часто нужны там же, где LLM, и их тоже можно обрабатывать локально. Здесь — коротко о том, как устроены пайплайны и что важно при выборе.
За 30 секунд
- Речь и сканы тоже обрабатываются локально — отдельными, гораздо более лёгкими моделями, чем LLM.
- Для речи: VAD + ASR (Whisper — универсально, GigaAM — сильнее на русском); метрики — WER/CER и RTF.
- Для документов: сначала проверьте текстовый слой PDF, и только если его нет — OCR (Tesseract для простого, PP-OCR/RapidOCR для сложной вёрстки).
- На одной машине разумный дефолт — ASR и OCR на CPU, LLM на GPU.
14.1 Зачем локально
- Приватность. Аудио и сканы не уходят в облако.
- Офлайн. Работает без сети.
- Предсказуемая стоимость. Нет оплаты за минуты и страницы.
- Контроль. Можно выбрать модель под язык и домен.
Цена — качество и время на настройку. Локальные модели догоняют облачные, но не во всём.
14.2 Как устроено распознавание речи
Типичный пайплайн:
аудио → декодирование в WAV 16 кГц моно → VAD → модель ASR → пунктуация/нормализация → текст
- Декодирование. Форматы вроде ogg/opus, mp3, m4a нужно привести к PCM. Это делает ffmpeg или встроенный декодер.
- VAD (voice activity detection) — определение речи и пауз. Помогает резать длинные записи и не гонять тишину.
- ASR (automatic speech recognition) — модель, которая превращает аудио в текст.
- Постобработка — пунктуация, числа, нормализация, разбиение на абзацы.
Для длинных записей аудио режут на окна (например, 30 секунд) с перекрытием, иначе модель теряет контекст или упирается в память.
14.3 Whisper
Whisper (OpenAI, 2022) — encoder-decoder трансформер, обученный на большом многоязычном корпусе. Работает с окнами по 30 секунд, поддерживает определение языка и перевод на английский.
Размеры и вес:
| Модель | ggml f16 (whisper.cpp) | q5_1 (примерно) | Замечание |
|---|---|---|---|
| tiny | ~75 МБ | ~31 МБ | слишком грубо для терминов |
| base | ~142 МБ | ~57 МБ | минимум для связной речи |
| small | ~466 МБ | ~182 МБ | лучше термины, но медленнее |
| medium | ~1,5 ГБ | ~0,54 ГБ | хороший баланс |
| large-v3 | ~3,1 ГБ | ~1,1 ГБ | лучшее качество, больше памяти |
Это размеры f16-моделей в формате whisper.cpp. Исходные .pt-чекпоинты OpenAI и другие конвертации могут занимать больше; ориентируйтесь на файл, который реально скачали.
whisper.cpp — C/C++ порт с поддержкой CPU, CUDA, Metal и квантов. Позволяет запускать Whisper без Python и GPU.
Особенности:
- на тишине и музыке может «галлюцинировать» текст;
- чувствителен к шуму и акценту;
- для русского технического текста качество зависит от размера модели;
- промпт с терминами может помочь, но иногда усиливает галлюцинации.
Warning
Классическая ловушка Whisper — повторяющаяся фраза или текст, похожий на подпись к субтитрам, на месте тишины или музыки. Модель обучалась на слабо размеченных данных из интернета (Radford et al.) и дорисовывает правдоподобный текст там, где речи нет. Лечится VAD перед ASR: на вход модели должны попадать только участки с речью.
14.4 GigaAM и другие русские модели
Для русского языка имеет смысл смотреть специализированные модели. GigaAM (SberDevices) — семейство акустических моделей, обученных self-supervised преимущественно на русской речи; версия v3 показывает лучшее качество на русских бенчмарках, чем Whisper-large-v3, по данным авторов. «Русскость» здесь следует не из названия статьи, а из обучающих данных и приведённых авторами замеров — проверяйте на своих записях.
Варианты:
- CTC — быстрее, проще;
- RNNT — обычно точнее;
- e2e — с пунктуацией и нормализацией на выходе.
Модели небольшие (сотни мегабайт), хорошо работают на CPU. Лицензия MIT у кода и весов — важный плюс для локального использования.
Другие варианты: Vosk (лёгкий, офлайн), NeMo-модели, sherpa-onnx. Выбор зависит от языка, домена и готовности возиться со сборкой.
14.5 Метрики речи
- WER (word error rate) — доля ошибок на уровне слов: замены, вставки, пропуски.
- CER (character error rate) — на уровне символов; полезна для языков с богатой морфологией.
- RTF (real-time factor) — отношение времени обработки к длительности аудио. RTF 0,5 означает, что 70 секунд аудио обрабатываются за 35 секунд.
WER сильно зависит от домена: на чистой студийной речи и на телефонном канале это разные числа. Сравнивайте на своих записях.
Посчитай сам. За неделю накопилось 6 часов записей совещаний. ASR на CPU работает с RTF 0,3. Сколько займёт расшифровка и уложится ли она в ночь с 23:00 до 7:00?
Решение
6 ч × 0,3 = 1,8 ч ≈ 1 ч 48 мин
Укладывается с большим запасом: в восьмичасовое окно поместилось бы 8 / 0,3 ≈ 26 часов записей. Если RTF окажется 1,0 (медленная модель, слабый CPU), 6 часов аудио займут 6 часов — всё ещё влезает, но без запаса на OCR и LLM.
14.6 OCR: текст с картинок и сканов
OCR (optical character recognition) — распознавание текста на изображениях. Типичный пайплайн:
изображение/PDF → предобработка → детекция текстовых блоков → распознавание → структура
- Предобработка: поворот, выравнивание, бинаризация, масштаб (обычно 300 DPI).
- Детекция: найти области с текстом (строки, абзацы, таблицы).
- Распознавание: превратить область в строку.
- Структура: порядок чтения, колонки, таблицы, заголовки.
Tesseract
Классический открытый OCR (Apache 2.0), LSTM-движок, много языков, включая русский. Плюсы: лёгкий, быстрый на CPU, предсказуемый. Минусы: хуже на сложной вёрстке, рукописном тексте и низком качестве сканов.
PP-OCR / RapidOCR
PP-OCR (PaddleOCR) — детектор + распознаватель, обученные на больших данных; хорошо работают на разных языках и вёрстке. RapidOCR — ONNX-порт, который проще запускать без тяжёлых зависимостей.
Плюсы: лучше на сложных страницах, таблицах, многоколоночном тексте. Минусы: тяжелее, медленнее на CPU, больше зависимостей.
Гибридный подход
- Если в PDF есть текстовый слой — извлечь его, OCR не нужен.
- Если слой битый или это скан — рендерить страницы в изображения и запускать OCR.
- Для таблиц и формул — отдельные инструменты или ручная проверка.
Tip
Проверить текстовый слой можно за секунду: выделите текст в PDF-просмотрщике или извлеките его любой утилитой вроде
pdftotext. Если получается осмысленный текст — OCR не нужен. Если пусто или «кракозябры» — это скан или битый слой.
14.7 Пример расчёта
100 страниц сканов.
- Tesseract: ~2–4 с на страницу на 4 ядрах → 3–7 минут.
- PP-OCR/RapidOCR: ~15–25 с на страницу на CPU → 25–42 минуты.
- На GPU: быстрее, но конкурирует с LLM за VRAM.
Если LLM уже занимает 13–14 ГБ из 16, OCR на GPU может не поместиться. Тогда OCR на CPU — разумный дефолт, а GPU — для разовых задач.
14.8 Качество OCR и типичные ошибки
- Числа и единицы: «1,5» может стать «1.5» или «15»; «мм» — «мн».
- Похожие символы:
О/0,l/1,З/3. - Дефисы и переносы: слова разрываются на строке.
- Повороты и перспектива: страница снята под углом.
- Печати и подписи: могут перекрывать текст.
- Таблицы: порядок чтения ломается.
Поэтому OCR почти всегда требует постобработки и проверки, особенно если дальше эти данные идут в LLM.
14.9 VLM: когда нужен не OCR, а понимание картинки
VLM (vision-language model) — модель, которая принимает изображение и текст. В локальном варианте это обычно языковая модель плюс vision-энкодер и проектор; в GGUF они лежат отдельным файлом mmproj.
VLM полезен, когда нужно не просто извлечь текст, а понять вёрстку, найти подпись к рисунку или ответить на вопрос по схеме. Но:
- изображение превращается в токены и занимает контекст;
- vision-энкодер требует дополнительной памяти;
- мелкий текст и таблицы VLM часто читает хуже специализированного OCR.
Практичный гибрид: OCR извлекает текст и координаты, VLM отвечает на вопросы по странице, LLM сводит результат.
14.10 Совмещение с LLM
Типичный локальный пайплайн:
flowchart LR
subgraph CPU ["CPU и ОЗУ"]
A["Аудио"] --> V["VAD"] --> ASR["ASR:<br/>GigaAM / whisper.cpp"]
P["PDF / скан"] --> TL{"Есть<br/>текстовый слой?"}
TL -->|"нет"| OCR["OCR:<br/>Tesseract / RapidOCR"]
end
subgraph GPU ["GPU"]
LLM["LLM"]
end
ASR -->|"транскрипт"| ST[("Промежуточные<br/>результаты на диске")]
OCR -->|"текст"| ST
TL -->|"да: извлечь текст"| ST
ST --> LLM
Что важно:
- Не запускайте тяжёлые модели одновременно на одной GPU, если не считали память.
- Очередь задач помогает не конкурировать за ресурсы.
- Разделяйте CPU и GPU: ASR/OCR на CPU, LLM на GPU — часто лучший баланс.
- Храните промежуточные результаты (транскрипт, OCR-текст), чтобы не пересчитывать.
14.11 Что выбрать
| Задача | Начальный выбор |
|---|---|
| Русская речь, CPU | GigaAM v3 (CTC/RNNT/e2e) |
| Многоязычная речь, CPU | whisper.cpp base/small |
| Многоязычная речь, GPU | whisper.cpp medium/large или faster-whisper |
| Простые сканы, CPU | Tesseract с языковым пакетом |
| Сложная вёрстка, CPU | RapidOCR / PP-OCR |
| PDF с текстовым слоем | извлечение текста без OCR |
Это отправные точки, а не догмы: проверяйте на своих данных.
Ключевые идеи
- Речь и OCR — отдельные пайплайны, но с теми же принципами: модель, препроцессинг, постобработка, метрики.
- Whisper универсален, GigaAM силён на русском; размер модели — компромисс качества и скорости.
- WER/CER и RTF — базовые метрики; сравнивать надо на своём домене.
- OCR для PDF начинается с проверки текстового слоя.
- CPU для ASR/OCR и GPU для LLM — часто лучший баланс на одной машине.
Проверь себя
- Зачем в пайплайне ASR нужен VAD?
- Что означает RTF 0,5?
- Почему WER на телефонной записи выше, чем на студийной?
- Когда OCR не нужен?
- Почему запуск OCR на GPU может быть плохой идеей, если там уже работает LLM?
Ответы
- VAD отделяет речь от тишины и шума, позволяет резать аудио на куски и не тратить время на обработку пустых участков. Он также снижает галлюцинации на тишине.
- Время обработки равно половине длительности аудио: 70 секунд записи обрабатываются примерно за 35 секунд.
- Телефонный канал добавляет шум, сжатие и ограничение полосы частот; модель хуже различает звуки и термины. Домен и качество записи сильно влияют на WER.
- Когда в PDF есть корректный текстовый слой: извлечение текста дешевле и точнее, чем OCR.
- OCR и LLM будут конкурировать за видеопамять. Если LLM занимает почти всю VRAM, OCR может вытеснить её в системную память и резко замедлить обе задачи.
Источники главы
- Radford et al., «Robust Speech Recognition via Large-Scale Weak Supervision» (2022) — arXiv:2212.04356. Оригинальная статья Whisper.
- whisper.cpp — GitHub. C/C++ порт с квантами и бэкендами.
- Kutsakov et al., «GigaAM: Efficient Self-Supervised Learner for Speech Recognition» (2025) — arXiv:2506.01192. Русская ASR-модель; сравнение с Whisper-large-v3.
- Silero VAD — GitHub. Лёгкий детектор речи.
- Tesseract documentation — tesseract-ocr.github.io. Установка, языковые пакеты, ограничения.
- Du et al., «PP-OCR: A Practical Ultra Lightweight OCR System» (2020) — arXiv:2009.09941. Архитектура PP-OCR.
- RapidOCR — GitHub. ONNX-порт для практического запуска.
- PaddleOCR — GitHub. Полный набор инструментов OCR.
Новые эксперименты: большие модели на маленьком железе
Зачем эта глава. В главах 3 и 5 уже было главное: веса можно выгрузить в ОЗУ, а эксперты MoE — считать на CPU. К ноябрю 2026 появился целый слой проектов, которые идут дальше: держат в VRAM только «горячую» часть модели, холодную считают на CPU, редкое читают с SSD и добавляют спекуляцию. Эта глава — карта таких приёмов: что реально работает, сколько стоит и что пробовать первым на 8, 16 и 24 ГБ.
За 30 секунд
- «Запустить больше, чем влезает» — это не один трюк, а три рычага: меньше байт на токен, более быстрый уровень памяти для горячих байт и больше токенов за один проход.
- Главная величина — эффективная пропускная способность: если 90% байт приходят из VRAM, а 10% из ОЗУ, скорость падает не в 30 раз, а примерно в 4.
- Громкие проекты работают, но в узких нишах: Strata — под конкретные Qwen/DeepSeek, AirLLM — скорее «запустить и посмотреть», чем «работать», PowerInfer — только на специально обученных ReLU-моделях.
- Сначала посчитайте рабочее множество (горячие эксперты + KV + буферы). Если оно не влезает в VRAM, выбирайте приём под узкое место, а не самый громкий заголовок.
Три рычага вместо «магии»
Напомню формулу из главы 2: скорость декода примерно равна пропускной способности памяти, делённой на байты, которые читаются на один токен. Все новые приёмы меняют одну из трёх величин:
- Меньше байт. Сильнее квантовать веса, хранить разреженные активации, не читать холодных экспертов.
- Быстрее память для горячей части. Держать часто используемые эксперты в VRAM, остальные — в ОЗУ, совсем редкое — на SSD.
- Больше токенов за проход. Спекулятивное декодирование проверяет несколько токенов за одно чтение весов.
flowchart TB
M["Модель не влезает<br/>в VRAM"] --> A["Меньше байт:<br/>квантование,<br/>разреженность"]
M --> B["Быстрее уровень:<br/>VRAM-кэш,<br/>CPU, SSD"]
M --> C["Больше токенов<br/>за проход:<br/>спекуляция"]
A --> S["Скорость ≈<br/>B_eff ÷<br/>байт на токен"]
B --> S
C --> S
Эффективная пропускная способность
Если модель читает W байт на токен, а доля s_i этих байт приходит из уровня памяти с пропускной способностью B_i, то время на токен:
t ≈ Σ (s_i × W / B_i)
Эффективная пропускная способность:
B_eff = 1 / Σ (s_i / B_i)
Пример: 90% байт из VRAM с 1,8 ТБ/с и 10% из ОЗУ с 60 ГБ/с.
B_eff = 1 / (0,9 / 1800 + 0,1 / 60)
= 1 / (0,0005 + 0,001667)
≈ 461 ГБ/с
То есть скорость падает не в 30 раз (как если бы всё шло из ОЗУ), а примерно в 4 раза. Именно на этом стоит вся идея экспертного кэша: чем выше доля попаданий в VRAM, тем ближе система к нормальной скорости.
При 70% попаданий:
B_eff = 1 / (0,7 / 1800 + 0,3 / 60) ≈ 186 ГБ/с
Это уже в 10 раз меньше VRAM. Отсюда практическое правило: 90% попаданий — это рабочая скорость, 70% — уже «тяжело», а 50% — почти режим ОЗУ.
Note
Это оценка только по памяти. Когда промахи считает CPU, добавляется второй потолок — его вычислительная мощность. Для 6 млрд активных параметров нужно около 12 ГФЛОП на токен; CPU с 100–300 ГФЛОП/с даёт потолок 8–25 ток/с, даже если ОЗУ бесконечно быстрое. Это грубая оценка: реальные ядра и накладные расходы меняют цифру.
Почему это стало возможным в 2026
Три вещи совпали. Во-первых, MoE-модели стали нормой: у большой модели активна малая доля параметров, и её можно считать частями. Во-вторых, кванты вроде IQ2/IQ3 довели большие модели до десятков-сотен гигабайт, которые ещё можно купить в виде ОЗУ и SSD. В-третьих, появились движки, которые рассматривают ПК как иерархию памяти, а не как «видеокарту с довеском».
SSD-стриминг: AirLLM и «LLM in a Flash»
Идея
Самый простой способ запустить модель больше памяти — держать на GPU только один слой, а остальные читать с диска. На каждом токене модель проходит все слои, поэтому с диска читается примерно весь объём весов. Это не «кэш», а именно потоковая подгрузка.
Почему это вообще работает: слой большой модели весит единицы гигабайт и помещается в VRAM, а не вся модель. Почему это медленно: диск в сотни раз медленнее VRAM, и чтение повторяется на каждом токене.
AirLLM
AirLLM — самый известный проект этого класса: github.com/lyogavin/airllm, Apache-2.0, около 41,9 тыс. звёзд на 7 ноября 2026, последний коммит в тот же день. Он разбивает модель на слои, держит на GPU один слой и подгружает следующий, перекрывая загрузку с вычислением. Заявлено: 70B на 4 ГБ VRAM, DeepSeek-V3 671B примерно на 12 ГБ, Kimi K3 2.8T на 3,72 ГБ, Qwen3.8-Flash-Next 125B на 5,95 ГБ (README считает полный объём ~180B вместе с 51B n-gram embedding) (README). Всё это — самозаявленные числа; независимые замеры есть только по скорости, и они ниже.
Что здесь правда: модель действительно запускается на маленькой карте, без квантования и дистилляции. Что здесь не сказано в заголовке: скорость. Независимые замеры дают для 70B порядка 5–35 секунд на токен на нормальном NVMe и ещё медленнее на слабом диске; на 16-гигабайтном Mac Mini Llama 3.1 8B шла около 19,6 секунды на токен, а для 70B прогноз — 2,5–3 минуты на токен (разбор, тест на Mac Mini).
Посчитаем потолок. 70B в FP16 — около 140 ГБ. NVMe на 5 ГБ/с:
140 / 5 = 28 с на токен ≈ 0,036 ток/с
Даже в 4 бита (около 42 ГБ) — 8,4 с на токен, то есть 0,12 ток/с. Это режим «оставить на ночь», а не чат. Именно поэтому AirLLM честно называет себя инструментом для запуска и обучения на маленькой VRAM, а не быстрым сервером.
Warning
«70B на 4 ГБ» не означает «70B работает как обычно». Считайте не только объём, но и байты на токен: при потоковой загрузке с диска это весь размер модели. Если вам нужен интерактивный чат, SSD-стриминг почти всегда проигрывает меньшей модели, которая целиком помещается в память.
«LLM in a Flash»
Работа Apple «LLM in a flash» (Alizadeh et al., 2023) — научная основа этого подхода. Идеи две:
- windowing — переиспользовать недавно активированные нейроны, чтобы не читать их с флеша повторно;
- row-column bundling — читать веса крупными непрерывными кусками, потому что флеш-память любит последовательный доступ.
Результат: модель до 2× больше объёма DRAM, ускорение в 4–5× на CPU и 20–25× на GPU по сравнению с наивной загрузкой. Важно: это не «20× быстрее обычного инференса», а «20× быстрее наивного стриминга». Обычная модель, целиком лежащая в VRAM, всё равно будет быстрее.
Готового продукта Apple не выпустила; идеи разошлись по движкам и статьям. AirLLM — самый доступный их родственник, но без windowing и bundling в том же виде.
Посчитай сам. У вас 70B в 4-битном кванте (42 ГБ), NVMe на 3,5 ГБ/с и 32 ГБ ОЗУ. Модель не помещается в ОЗУ целиком. Оцените потолок, если читать с диска каждый токен, и потолок, если 20 ГБ весов всё же лежат в ОЗУ, а 22 ГБ читаются с диска.
Решение
Всё с диска: 42 / 3,5 = 12 с/токен ≈ 0,083 ток/с
20 ГБ в ОЗУ, 22 ГБ с диска:
ОЗУ: 20 / 60 ≈ 0,33 с
диск: 22 / 3,5 ≈ 6,3 с
итого ≈ 6,6 с/токен ≈ 0,15 ток/с
Выигрыш всего в 1,8 раза: диск всё равно остаётся самым медленным звеном. Даже если 40 ГБ лежат в ОЗУ, а с диска читается только 2 ГБ, потолок — около 0,8 ток/с: 40 / 60 ≈ 0,67 с плюс 2 / 3,5 ≈ 0,57 с. Отсюда правило: для интерактива диск не должен участвовать в каждом токене; SSD-стриминг — режим offline/batch, когда время не важно.
Экспертный кэш: Strata, ktransformers, PowerInfer
Чем MoE отличается от плотной модели
В главе 5 уже объяснено: MoE хранит всех экспертов, но на токен активирует нескольких. Поэтому эксперт можно держать в ОЗУ и считать на CPU, а в VRAM — только те, что нужны чаще всего. Новые движки добавили к этому три вещи:
- адаптивный кэш — какие эксперты «горячие», решается по ходу разговора, а не один раз при загрузке;
- параллельную работу GPU и CPU — пока GPU считает попавшие в кэш эксперты, CPU считает промахи;
- предсказание — следующий токен часто использует похожий набор экспертов, поэтому можно подгрузить их заранее.
Strata: самый громкий проект 2026 года
Что это. Strata — MIT-движок на C++/CUDA/HIP/Metal/SYCL под конкретные большие MoE: Qwen3.8-Flash-Next (125B-A6B; Akita), Qwen3.6-35B-A3B и DeepSeek V4.1-Flash. Проект создан 24 сентября 2026 года; по снимку GitHub API на 7 ноября 2026 у него 41,2 тыс. звёзд, 1059 открытых issue/PR и релиз v0.2.12 (GitHub, релиз). Это очень молодой и очень быстро растущий проект; цифры звёзд здесь — мера внимания, а не зрелости.
Как устроено. У Qwen3.8-Flash-Next 48 слоёв и 24 576 экспертов (512 на слой), на токен выбирается 10 экспертов плюс общий (How it works). Схема:
- VRAM — attention, DeltaNet-миксеры, роутеры, shared experts, выходная голова, MTP-черновик, KV-кэш и кэш горячих экспертов; на 32 ГБ RTX 5090 помещается 10–11,5 тыс. экспертов, почти половина;
- ОЗУ — все 24 576 экспертов, закреплённые в памяти; если нужного эксперта нет в VRAM, его считает CPU прямо в ОЗУ, параллельно с GPU;
- SSD — большая таблица n-gram (Engram) на 28,8 ГБ; на токен читается несколько строк.
У DeepSeek V4.1-Flash та же идея, но другие числа: 40 слоёв, 384 эксперта на слой (6 активных), полная таблица Engram на 203 ГБ (в 4-битном кванте — 111 ГБ). Полные 2-битные наборы (веса + Engram + черновик) весят 239–274 ГБ и требуют 12 ГБ VRAM и 46–64 ГБ ОЗУ (DeepSeek guide).
flowchart TB
SSD["SSD:<br/>n-gram,<br/>холодное"] --> RAM["ОЗУ:<br/>все эксперты"]
RAM --> VRAM["VRAM:<br/>горячие<br/>эксперты"]
VRAM --> GPU["GPU:<br/>attention +<br/>попадания"]
RAM --> CPU["CPU:<br/>промахи"]
GPU --> OUT["выход слоя"]
CPU --> OUT
Что заявлено. Производитель заявляет 1,6–1,8× ускорение от MTP-спекуляции, 2,4–3,2 принятых токена за проход, 90–97% попаданий в кэш экспертов и скорость 4–6 ток/с для DeepSeek V4.1 на RTX 5070 12 ГБ с 64 ГБ ОЗУ, 9–11 ток/с на RTX 3060 с 46 ГБ ОЗУ, 19–21 ток/с на Strix Halo 128 ГБ и 74–77 ток/с на четырёх R9700 (README, MODELS). Всё это — самозаявленные числа. Важно: это README-таблица для 2.00 bpw на Strata 0.2.5 (Strix Halo — 0.2.7); в MODELS.md на Strata 0.2.4 (до Speed choice) те же конфигурации дают ~5, 6–9 и ~31, а с DSpark — 8,2–8,7 и 55–69. Числа расходятся из-за версии и режима.
Что подтверждено. Независимый обзор Fabio Akita на RTX 5090 (32 ГБ), Ryzen 9 7950X3D и 96 ГБ ОЗУ: Qwen3.8-Flash-Next IQ3_S прошла его тест на 91 балл, Tier A, всего на 1,5 балла ниже той же модели на B300, со скоростью около 159 ток/с (AkitaOnRails). В логах действительно было 10–11,5 тыс. экспертов в VRAM и 90–97% попаданий; холодный старт — 35–40 с; при работе занято 88 из 92 ГБ ОЗУ и около 48 ГБ swap. Это не «магия»: на 5090 просто очень быстрая память, а кэш покрывает почти всё.
Есть и независимый пользовательский замер на RTX 5080 16 ГБ и 61,6 ГБ ОЗУ: 90–113 ток/с на Qwen3.8-Flash-Next IQ3_S, но режим --kv-resident оказался на 13–20% медленнее --kv-grow даже при коротком контексте (issue #4815). Это хороший пример того, что даже у работающего движка отдельные флаги могут стоить дороже, чем обещают.
Цена приёма. Strata — не «любая модель на любом ПК». Официально: от 32 ГБ ОЗУ+VRAM вместе для самого сжатого варианта, около 64 ГБ ОЗУ для IQ3_S, 80 ГБ диска, карта от 12 ГБ; на практике для комфортной работы нужны 64–96 ГБ ОЗУ и NVMe. Первый промпт читается целиком: ориентир README — около 60 с на 30 тыс. токенов, на 5090 — 100 тыс. за 16–20 с. По умолчанию сервер обслуживает один запрос за раз; параллельные агенты встают в очередь. Поддержка моделей узкая: Qwen3.8-Flash-Next, Qwen3.6-35B-A3B и DeepSeek V4.1-Flash, а не «any consumer hardware», как в заголовке.
Tip
Если хотите повторить опыт Akita, начните с
strata launch --plan: команда ничего не скачивает и показывает, сколько ОЗУ, VRAM и диска уйдёт. Это дешевле, чем скачать 80 ГБ и узнать, что не хватает 8 ГБ ОЗУ.
ktransformers: серверный CPU-GPU гибрид
Что это. ktransformers — Apache-2.0, около 19,7 тыс. звёзд, последний коммит 6 ноября 2026. Это не «ещё один llama.cpp», а набор оптимизированных CPU-ядер для MoE-экспертов плюс GPU-часть для attention. Проект вырос из работ SJTU/IPADS и теперь поддерживает DeepSeek V4, Kimi K2.5/K2.6, GLM-5.3, MiniMax M3, Qwen3-Next и другие модели.
Идея. Эксперты, которые не помещаются в VRAM, считаются на CPU с использованием AMX (Intel Sapphire Rapids и новее), AVX-512 или AVX2; GPU делает attention и то, что помещается. Ключевое — не гонять веса по PCIe, а считать их там, где они лежат. Это ровно тот же принцип, что в главе 5, но с ядрами, заточенными под серверные CPU.
Что заявлено. Для DeepSeek-V3/R1 671B в Q4_K_M: 14 ГБ VRAM и 382 ГБ DRAM, prefill 54–286 ток/с, декод 8,7–13,7 ток/с; против llama.cpp на той же машине — до 3,03× в декоде и до 27,79× в prefill (туториал). Это агрегат разных версий: 3,03×/9,44× — V0.2, 27,79× — V0.3-preview. Тестировали на двухсокетном Xeon Gold 6454S с 1 ТБ DDR5 — это сервер, а не домашний ПК. Все цифры — самозаявленные.
Что подтверждено. Это замеры команды на их железе; независимых повторений на домашнем железе в открытом виде мало. Важно: «24 ГБ VRAM» в заголовке скрывает 382 ГБ ОЗУ; без серверной памяти и AMX/AVX-512 выигрыш будет скромнее.
Цена. Linux x86-64, Python 3.10–3.12, GPU NVIDIA Ampere/Ada/Hopper (для CUDA-части), много ОЗУ, сложная установка. На обычном десктопе с 64 ГБ ОЗУ 671B не запустить: только меньшие MoE или модели с сильным квантованием. Зато для «домашней лаборатории на старом сервере» это один из самых сильных вариантов.
PowerInfer: горячие и холодные нейроны
Что это. PowerInfer — MIT, около 9,9 тыс. звёзд, последний коммит 11 мая 2026. Идея: активации нейронов в LLM распределены по степенному закону — небольшая часть нейронов («горячие») активна почти всегда, остальные («холодные») зависят от входа. Горячие держим на GPU, холодные считаем на CPU. Это не MoE-эксперты, а отдельные нейроны внутри FFN.
Что заявлено. В среднем 13,20 ток/с и пик 29,08 ток/с на одной RTX 4090 для набора моделей, до 11,69× быстрее llama.cpp; на RTX 2080 Ti с INT4 — до 8× (README, статья). PowerInfer-2 для смартфонов: 11,68 ток/с на TurboSparse-Mixtral-47B, до 22× быстрее аналогов по README (в статье — до 27,8×) (статья). Все эти числа — самозаявленные; независимой проверки в открытом виде я не нашёл.
Что подтверждено и в чём подвох. Проект работает, но только с моделями, у которых ReLU/ReGLU/Squared ReLU и разреженность около 90%: Falcon-40B (ReLU), семейство Llama2 (ReLU), ProSparse, Bamboo. Обычные Llama/Mistral/Qwen с SiLU не поддерживаются. Для 70B авторы дообучали ReLU-вариант всего на 5 млрд токенов, и в FAQ честно сказано, что качество просело. Код предсказателя обучения не выложен; PowerInfer-2 для смартфонов в этом репозитории тоже нет — это отдельная исследовательская работа. То есть «11× быстрее» — это про узкое семейство специально подготовленных моделей, а не про вашу любимую Qwen.
Цена. Конвертация модели, профилирование активаций, потеря качества, отдельный формат GGUF, только Linux/Windows x86 с AVX2 (macOS есть, но без выигрыша). Для повседневного запуска сегодня проще взять MoE и llama.cpp с выгрузкой экспертов.
Что добавляют исследования: MoE-Infinity и ExpertFlow
Два проекта показывают, куда движется предсказание экспертов.
MoE-Infinity (arXiv:2401.14361, код) предлагает кэш экспертов с трассировкой активаций для batch=1 и предзагрузкой по истории. В статье заявлено ускорение per-token latency в 3,1–16,7× по сравнению с vLLM, Ollama, DeepSpeed и BrainStorm на DeepSeek и Mixtral. Это исследовательский прототип, а не готовый продукт; README кода прямо предупреждает, что открытая версия отличается от версии из статьи. Цифры — из статьи, независимой проверки я не нашёл.
ExpertFlow (arXiv:2410.17954) добавляет трансформер-предиктор маршрутизации, планировщик токенов и кэш с исправлением ошибок. В abstract заявлены снижение памяти GPU до 93,72% и ускорение до 10× относительно сильных offload-баз. Это исследование, а не «поставил и поехал»; независимой проверки я не нашёл.
Общий вывод: предсказание экспертов работает, но требует либо обучения предиктора, либо трассировки на вашем трафике. В Strata и ktransformers это уже встроено; в llama.cpp пока есть только кэш --moe-cache-mib без предсказания.
llama.cpp как база
Не стоит забывать, что большая часть этого уже есть в llama.cpp:
--n-cpu-moe N— экспертные FFN первых N слоёв оставить на CPU;--cpu-moe— все эксперты на CPU;--moe-cache-mib N— кэш горячих экспертов в VRAM для тех, что остались на CPU;-ot "\.ffn_.*_exps\.weight=CPU"— точечная выгрузка по шаблону.
В текущей документации --n-cpu-moe — именно «первые N слоёв»; семантику стоит проверить в своей сборке (server README). Этого достаточно, чтобы запустить 30B-A3B на 8–12 ГБ VRAM, но не чтобы получить 90% попаданий на 125B: для этого нужен адаптивный кэш и параллельная работа CPU.
Новое поколение «движков под одну модель»
В 2026 году появился отдельный жанр: движок, заточенный под одну модель, одну видеокарту или одну платформу. Он жертвует универсальностью ради скорости.
| Проект | Звёзды | Лицензия | Ниша | Что заявлено |
|---|---|---|---|---|
| Strata | 41,2 тыс. | MIT | Qwen3.8-Flash-Next, DeepSeek V4.1; NVIDIA/AMD/Intel/Mac | 4–159 ток/с (разные модели и железо) |
| Splash | 2,1 тыс. | Apache-2.0 | Apple Silicon, M3+; Qwen3.8-27B, 35B-A3B, Flash-Next | 95 ток/с Flash-Next Q2_0 на M5 Pro 64 ГБ |
| NInfer | 3,3 тыс. | Apache-2.0 | RTX 5090 и DGX Spark; Qwen3.6/3.8, GLM-5.3 | 101 ГиБ Flash-Next на RTX 5090 с CPU-offload |
| HyperQwen | 2,6 тыс. | Apache-2.0 | Qwen3.8-27B на одной 24-ГБ карте через vLLM | 127 ток/с single, 1 035 ток/с при 64 запросах |
Splash — пример того, как ANE и Metal используются вместе. По README (Splash 1.0): Flash-Next Q2_0 — 95 ток/с на M5 Pro 20-core/64 ГБ; 35B-A3B — 210 и 27B — 74 на M5 Pro 16-core/48 ГБ. Для 27B prefill частично идёт на Neural Engine (README). Числа — самозаявленные, сравнение — с Strata на той же машине.
NInfer — наоборот, только NVIDIA: RTX 5090 (sm_120a) и DGX Spark (sm_121a), выбранные чекпоинты, CUDA Graph, MTP/DFlash2, CPU expert offload. Flash-Next занимает 101 ГиБ в четырёх файлах; без большого объёма ОЗУ и быстрого NVMe не обойтись (README).
HyperQwen не пытается запустить модель больше VRAM: он берёт 27B dense, патчит vLLM, переквантовывает головы и добавляет спекуляцию, чтобы выжать 127 ток/с на RTX 3090 и 150k контекста. Это пример «скорость на слабом железе» без offload, но только для одной модели и одной карты; числа — самозаявленные. В README NInfer заявлен размер (101 ГиБ), а не скорость; независимых замеров Splash, NInfer и HyperQwen я не нашёл.
Warning
У всех четырёх проектов возраст — месяцы, а не годы. Они могут быть быстрее универсальных движков, но у них меньше тестов, уже поддержка железа и больше шансов сломаться после обновления драйвера. Проверяйте на копии модели и не тащите в продакшен без запасного варианта.
Распределённый инференс: exo, llama.cpp RPC, Petals, distributed-llama
Идея простая: если модель не влезает в одну машину, сложите память нескольких. Проблема в том, что сеть — это новая PCIe, и она почти всегда медленнее.
exo
exo — Apache-2.0, около 48,2 тыс. звёзд, активен. Он автоматически находит устройства в локальной сети, строит граф топологии и распределяет слои с учётом ресурсов и задержек. Бэкенд — MLX (Apple Silicon), поэтому основной сценарий — Mac. Заявлено: tensor parallel даёт до 1,8× на двух устройствах и 3,2× на четырёх; RDMA over Thunderbolt 5 снижает задержку между устройствами (README). Заявленные 1,8×/3,2× — самозаявленные; независимый тест ниже.
Независимый тест Jeff Geerling на четырёх Mac Studio M3 Ultra (1,5 ТБ объединённой памяти, около $40 тыс.): Qwen3 235B — около 32 ток/с, Kimi K2 Thinking 1T (32B active) — около 30 ток/с (отчёт). Там же важное наблюдение: llama.cpp RPC на той же сети замедляется при добавлении узлов, а exo ускоряется.
Цена: Mac-кластер стоит как автомобиль; RDMA требует macOS 26.2 и настройки в Recovery; практически работают кластеры до четырёх Mac; стабильность предрелизная (в тесте были падения и отказы загрузки). Плюс история: разработчики exo на время пропадали из публичного доступа (issue #819). Для дома это скорее эксперимент, чем рабочий сервер.
llama.cpp RPC
В llama.cpp есть ggml-rpc-server и флаг --rpc host:port: удалённый хост отдаёт свои CUDA/Metal/CPU устройства, а главный процесс распределяет по ним веса и KV. Документация прямо говорит: это proof-of-concept, функциональность хрупкая и небезопасная, не выставляйте RPC-сервер в открытую сеть (tools/rpc/README.md). Поддерживаются TCP и RDMA (RoCEv2 на Linux, RDMA over Thunderbolt на macOS 26.2+).
Практика: на 10GbE и двух машинах 70B-class может дать 4,9–5,5 ток/с; с MoE-моделью — 21–25 ток/с (замер). На 1GbE и неудачной топологии легко получить 3 ток/с и меньше (обсуждение). Причина: каждый слой ждёт данные по сети, а не только читает быструю память.
Petals
Petals — MIT, около 10,7 тыс. звёзд, но последний коммит — сентябрь 2024. Идея BitTorrent-стиля: разные люди держат разные слои одной модели и соединяются в публичный swarm; можно запускать Llama 3.1 405B, Mixtral 8x22B, BLOOM 176B. Это pipeline-parallel, а не tensor-parallel, поэтому сеть нагружается меньше, но задержка растёт.
Статус: проект фактически не развивается; публичный swarm на health.petals.dev при проверке не ответил. Для чувствительных данных публичный swarm не подходит в принципе: ваши промпты обрабатываются на чужих GPU. Приватный swarm можно поднять самому, но это уже инфраструктурный проект.
distributed-llama
distributed-llama — MIT, около 3,1 тыс. звёзд, активен. Он соединяет домашние устройства в кластер через Ethernet, делит модель по слоям (tensor parallelism) и поддерживает Linux/macOS/Windows, ARM и x86 с AVX2. Ограничения: число узлов — 1, 2, 4, 8… (2^n), максимум равен числу KV-голов; поддерживаются только Q4_0 и F32; на Raspberry Pi и Mac Mini работает, но скорость упирается в сеть. В обсуждениях есть запуск Llama 3.3 70B на четырёх Mac Mini M4 Pro 24 ГБ.
Note
Домашняя сеть 1GbE — это 0,125 ГБ/с, 10GbE — 1,25 ГБ/с, PCIe 5.0 x16 — до 64 ГБ/с. Распределённый инференс имеет смысл, когда модель иначе не влезает, а не когда нужна максимальная скорость. Если модель помещается в одну машину, один быстрый GPU почти всегда выиграет у кластера.
Экстремальное квантование: IQ1/IQ2, BitNet, HQQ, AQLM, QTIP
IQ1/IQ2 в llama.cpp
IQ1_* и IQ2_* — i-quants с кодовыми книгами и решётками, которые позволяют ужать веса до 1,75–2,25 бита на параметр. Именно на них держится запуск DeepSeek V4.1-Flash: 2-битный набор весит 138 ГБ, 2,25-битный — 155 ГБ, плюс 111 ГБ Engram и 8 ГБ черновика (Strata docs). Это уже не «немного сжать», а «уместить большую MoE в домашний ПК».
Цена — качество. По данным ISTA-DASLab (их приводит Strata): 2,0 bpw даёт +15,5% perplexity, +8,6% на коде и +5,3% на агентских задачах; 1,75 bpw — +21% perplexity и +53% на обычной прозе. 2,25 bpw — около +7,7–8,3% perplexity и +2,2–3,5% на коде. Это самозаявленные числа, но порядок величины правдоподобен: ниже 2 бит сильнее всего страдает именно свободный текст, а код и JSON держатся дольше.
Warning
Ниже 3 бит качество зависит от задачи сильнее, чем от модели. Проверяйте не только perplexity, но и свои 20–50 задач: числа, единицы, JSON, вызовы инструментов. Модель может писать гладкий текст и ломать таблицу.
BitNet b1.58 и bitnet.cpp
BitNet b1.58 — не квантование готовой модели, а обучение с нуля с тернарными весами {-1, 0, 1}. Один вес занимает около 1,58 бита; умножения заменяются сложениями, поэтому на CPU это очень выгодно. bitnet.cpp — MIT, около 41,5 тыс. звёзд, последний коммит июль 2026; по данным авторов, даёт 2,37–6,17× на x86 и 1,37–5,07× на ARM, снижает энергию на 55–82% (техотчёт).
Что подтверждено: официальная модель BitNet-b1.58-2B-4T (2,4 млрд параметров, 4 трлн токенов) действительно работает и даёт конкурентное качество для своего размера. Что не подтверждено публично: «100B на одном CPU со скоростью 5–7 ток/с» — это заявление из отчёта; весов 100B-модели в открытом доступе нет. И главное: BitNet нельзя применить к обычной Llama/Qwen постфактум — модель должна быть обучена тернарной.
HQQ
HQQ — Apache-2.0, около 1 тыс. звёзд, последний коммит февраль 2026. Это не рантайм, а быстрый квантователь: 8/4/3/2/1 бит, без калибровочных данных, за минуты. Авторы заявляют около 158 ток/с для Llama-3-8B в 4 битах на RTX 4090 с бэкендом GemLite (README). HQQ удобен, когда надо быстро получить 4-битную модель и прогнать её в Transformers/vLLM; для 1–2 бит лучше HQQ+ с LoRA-адаптерами.
AQLM и QTIP
AQLM — аддитивное квантование с обучаемыми кодовыми книгами, 2–3 бита. Заявлено: Llama-3-70B в 2 битах весит 21,9 ГБ, MMLU падает с 0,79 до 0,75; 1-битная Llama-2-7B даёт perplexity 7,85 на WikiText-2 (README, статья). AQLM требует калибровки и дообучения, зато даёт одно из лучших качеств на 2 битах; есть ядра для GPU и поддержка vLLM.
QTIP — квантизация с решётками (trellis coded quantization), которая позволяет использовать очень высокую размерность вектора и обходит ограничение кодовых книг. На 2 битах авторы показывают state-of-the-art; это прежде всего исследование, а не повседневный инструмент.
| Формат | Бит/вес | Готовность | Когда брать |
|---|---|---|---|
| IQ2/IQ1 (llama.cpp) | 1,75–2,25 | рабочая, но качество падает | большая MoE, мало памяти |
| BitNet b1.58 | 1,58 | только обученные ternary-модели | если есть готовая BitNet-модель |
| HQQ | 1–8 | быстрый квантователь | быстро получить 4 бита |
| AQLM | 2–3 | ядра + vLLM, нужна калибровка | максимум качества на 2 битах |
| QTIP | 2 | исследование | следить, не для продакшена |
Разреженность активаций: Deja Vu, CATS, PowerInfer
Идея: в каждом слое активна не вся матрица, а небольшая часть нейронов или голов. Если предсказать эту часть до вычисления, можно не читать и не считать остальное.
Deja Vu (arXiv:2310.17157, код) предсказывает контекстную разреженность — набор голов attention и нейронов MLP, которые дадут примерно тот же выход. Заявлено ускорение OPT-175B в 2×+ против FasterTransformer и 6×+ против Hugging Face без потери качества. Предсказатель дешёвый, но его надо обучать; разреженные ядра должны реально пропускать работу, иначе выигрыша нет.
CATS (arXiv:2404.08763) заменяет активацию на пороговую и получает 50% разреженности при падении качества на 1–2% без дообучения; по данным авторов, собственное GPU-ядро даёт около 15% реального ускорения генерации на Llama-7B и Mistral-7B. Это меньше, чем обещают заголовки, потому что нерегулярный доступ к памяти съедает часть выигрыша.
PowerInfer — практическая реализация той же идеи для FFN, но с жёстким требованием ReLU-моделей (см. раздел о PowerInfer). Общий вывод: разреженность активаций — реальный рычаг, но он требует модели, предсказателя и специальных ядер; «просто включить» его в llama.cpp нельзя.
Спекуляция и KV: что добавилось в 2026
Спекуляция
Теория — в главе 9; здесь важен 2026-й слой. Крупные MoE-движки стали встраивать черновик в модель:
- MTP-голова Qwen3.8-Flash-Next черновит до 3 токенов; Strata заявляет 2,4–3,2 принятых токена за проход и 1,6–1,8× ускорения;
- DFlash2 используется в Splash и HyperQwen; HyperQwen заявляет 381 ток/с, когда ответ цитирует промпт, и 127 ток/с в обычном режиме;
- DSpark — отдельный маленький черновик для DeepSeek V4.1; по MODELS.md (2.00 bpw, Strata 0.2.4) на RTX 3060 поднимает 6,1–6,7 до 8,2–8,7 ток/с, на четырёх R9700 даёт 55–69 ток/с вместо ~31, а на RTX 5070 с 6-ядерным CPU выигрыша не даёт;
- lookup/ngram — поиск по уже сгенерированному тексту; Strata включает его только там, где принятие окупается: правки кода — 6–11%, обычный текст — без изменений.
Все эти числа — самозаявленные. Независимый эффект обычно ниже: спекуляция помогает на предсказуемом тексте (код, JSON, цитаты) и почти не помогает на свободной прозе.
KV-кэш
KV-кэш — вторая по величине часть памяти после весов, и его тоже можно выгружать и квантовать.
- В llama.cpp
--kv-offloadвключён по умолчанию;--no-kv-offloadоставляет KV в ОЗУ, освобождая VRAM;-ctk/-ctv q8_0сжимает кэш примерно вдвое (server README). - Strata хранит KV в int8, а
--kv-resident Nдержит в VRAM только N ячеек на слой, остальное — в закреплённом ОЗУ; по логам 97% чтений KV всё равно попадают в VRAM. Но независимый замер показал, что--kv-residentможет быть на 13–20% медленнее--kv-growдаже при коротком контексте (issue #4815). - LMCache заявляет 10× по p99 TTFT (13,55 → 1,30 с); средний декод при этом ускоряется примерно в 3,8× (37,47 против 9,81 ток/с). Это vendor-блог, независимой проверки я не нашёл (LMCache).
Главное: KV-кэш помогает длинному контексту, но не делает модель меньше. Если веса не влезают, выгрузка KV даст несколько гигабайт, а не десятки.
NPU, iGPU, WebGPU и телефоны
Ryzen AI NPU: FastFlowLM
FastFlowLM (FLM) — NPU-first рантайм для AMD Ryzen AI (XDNA2: Strix, Strix Halo, Kraken, Gorgon). Около 2 тыс. звёзд, активен, лицензия смешанная: оркестрация MIT, NPU-ядра — проприетарные бинарники, бесплатные для использования (README).
В официальном бенчмарке AMD на Ryzen AI 5 340 (Kraken Point, 64 ГБ): Qwen3.8-27B даёт 2,04–2,70 ток/с декода, prefill 105–113 ток/с, TTFT 9,35 с на 1K и 68,7 с на 8K (бенчмарк). Это самозаявленные числа; независимой проверки я не нашёл. Важный отрезвляющий факт: 27B на NPU работает, но в разы медленнее, чем на видеокарте. NPU выигрывает по энергии и prefill, а не по декоду большой модели.
Apple Neural Engine
ANEMLL — открытый пайплайн конвертации LLM в CoreML для ANE: LLaMA 3.1/3.2 (1B, 8B), Qwen 3 (0.6B, 1.7B), Gemma 3 (270M–4B), DeepSeek R1 Distill 8B. Версия 0.3.5 beta, около 1,7 тыс. звёзд, активен. Ограничения: контекст обычно до 4K, LUT4-квантование заметно снижает качество, MIT заявлен в README, но отдельного LICENSE-файла нет — проверьте перед коммерческим использованием (README).
ANE хорошо работает для небольших моделей и prefill; Splash использует его для prefill 27B. Но это не способ запустить 70B: память общая с CPU/GPU, а конвертация и качество квантования требуют отдельной проверки.
Intel NPU
Intel NPU (AI Boost) поддерживается через OpenVINO GenAI. В препринте 2026 года о pipeline-шардах для Intel AI PC Llama 3.1 8B INT4 на Lunar Lake NPU даёт 3,55 ток/с при одном слоте и 11,46 ток/с при четырёх; это aggregate throughput двухстадийного шарда, §8.6 (arXiv:2608.19147, §8.6). Гибрид «NPU prefill + CPU decode» даёт около 9,3 ток/с (Cascadia). При этом INT8 weight-only модели на NPU в OpenVINO 2026.0 могли падать с access violation — проверяйте версию и формат (issue #35641).
iGPU и объединённая память
AMD Strix Halo (Ryzen AI Max+ 395) — 128 ГБ объединённой памяти и около 256 ГБ/с. Это меньше, чем у RTX 5090 (1,8 ТБ/с), но больше, чем у обычного DDR5. Поэтому большая MoE на нём работает: Strata заявляет 19–21 ток/с для Qwen3.8-Flash-Next на 128 ГБ, а плотная Qwen3.8-27B в Q8 на Strix Halo идёт около 7,7 ток/с при теоретическом потолке 9 (Akita). Это ровно roofline из главы 2: памяти много, но она медленная.
WebGPU: WebLLM
WebLLM — Apache-2.0, около 19,4 тыс. звёзд, активен. Он запускает модель целиком в браузере через WebGPU, с OpenAI-совместимым API. Модели — Llama 3, Phi 3, Gemma, Mistral, Qwen2; на практике это 1–8B в 4 битах, потому что модель должна поместиться в память GPU и не может выгружаться в ОЗУ.
Замер в блоге: Llama 3.1 8B 4-bit на M3 Max — около 41 ток/с, примерно 80% от нативной скорости (tianpan.co). Плюсы: ничего не устанавливать, данные не уходят с машины. Минусы: скачивание 4–5 ГБ, ограничение памятью вкладки, нет 70B и нет нормального агентского контекста.
Телефоны
MLC LLM — Apache-2.0, около 23,3 тыс. звёзд, активен; компилирует модель под Metal/OpenCL/Vulkan и запускает на iOS/Android. По разным замерам, на Snapdragon-устройствах 3–7B модели идут единицы-десятки токенов в секунду; 7B — обычно около 5–15 ток/с в зависимости от памяти и охлаждения. PowerInfer-2 заявляет 11,68 ток/с для 47B на смартфоне, но это специально разреженная TurboSparse-модель и исследовательская работа, а не массовый рантайм.
Таблица: приём → выигрыш → цена → зрелость
Паспорт проектов (снимок на 7 ноября 2026)
Звёзды и даты — по GitHub API; «коммит» — последний push, а не последний релиз. У исследовательских проектов (MoE-Infinity, ExpertFlow, Deja Vu, CATS, QTIP) паспорта нет: это статьи и прототипы, а не готовые продукты.
| Проект | Звёзды | Коммит | Лицензия | Модели | ОС |
|---|---|---|---|---|---|
| Strata | 41,2 тыс. | 07.11.2026 | MIT | Qwen3.8-Flash-Next, Qwen3.6-35B-A3B, DeepSeek V4.1 | Windows, Linux, macOS |
| ktransformers | 19,7 тыс. | 06.11.2026 | Apache-2.0 | DeepSeek V4, Kimi K2.5/2.6, GLM-5.3, MiniMax M3, Qwen3-Next | Linux x86-64 |
| PowerInfer | 9,9 тыс. | 11.05.2026 | MIT | ReLU: Falcon-40B, Llama2, ProSparse, Bamboo | Linux, Windows, macOS (CPU) |
| AirLLM | 41,9 тыс. | 07.11.2026 | Apache-2.0 | почти любые HF-модели (macOS — Llama-style) | Linux, macOS |
| exo | 48,2 тыс. | 06.11.2026 | Apache-2.0 | MLX-модели: Qwen, DeepSeek, Kimi | macOS, Linux |
| Petals | 10,7 тыс. | 07.09.2024 | MIT | Llama 3.1 405B, Mixtral 8x22B, BLOOM 176B | Linux, macOS, WSL |
| bitnet.cpp | 41,5 тыс. | 27.07.2026 | MIT | BitNet b1.58 (2B) | Linux (CPU/GPU), Windows (CPU) |
| llama.cpp | 133,6 тыс. | 07.11.2026 | MIT | GGUF, почти все архитектуры | все |
| MLC LLM | 23,3 тыс. | 30.10.2026 | Apache-2.0 | Llama, Qwen, Gemma, Phi и др. | iOS, Android, WebGPU, desktop |
| WebLLM | 19,4 тыс. | 03.11.2026 | Apache-2.0 | Llama 3, Phi 3, Gemma, Mistral, Qwen2 | браузер (WebGPU) |
| HQQ | 0,96 тыс. | 26.02.2026 | Apache-2.0 | любые HF-модели | CUDA/CPU |
| AQLM | 1,3 тыс. | 26.02.2026 | Apache-2.0 | Llama, Mistral, Mixtral | CUDA/CPU |
| Splash | 2,1 тыс. | 06.11.2026 | Apache-2.0 | Qwen3.8-27B, 35B-A3B, Flash-Next, Ornith, Flint | macOS 26.4+, M3+ |
| NInfer | 3,3 тыс. | 07.11.2026 | Apache-2.0 | Qwen3.6/3.8-27B, 35B-A3B, Flash-Next, GLM-5.3 | Linux, RTX 5090/DGX Spark |
| HyperQwen | 2,6 тыс. | 03.11.2026 | Apache-2.0 | Qwen3.8-27B | Linux, NVIDIA 24 ГБ |
| FastFlowLM | 2,0 тыс. | 07.11.2026 | смешанная | LLaMA, Qwen, Gemma, gpt-oss, Phi, DeepSeek | Windows, Linux (Ryzen AI) |
| ANEMLL | 1,7 тыс. | 31.10.2026 | MIT (в README, без LICENSE) | LLaMA 3.x, Qwen 3, Gemma 3, DeepSeek R1 8B | macOS, iOS |
| distributed-llama | 3,1 тыс. | 07.11.2026 | MIT | Llama 3.x, Qwen 3, Qwen3 MoE | Linux, macOS, Windows |
Релизы, на которые стоит смотреть: Strata v0.2.12 (7 ноября 2026), ktransformers v0.7.0 (17 августа 2026), AirLLM v3.0 (июнь 2026), FastFlowLM 1.0.0 (11 августа 2026), exo 1.0 (декабрь 2025), Splash 1.6.0 (6 ноября 2026), bitnet.cpp 1.0 (октябрь 2024). У NInfer и HyperQwen пока нет версий — они живут в main. У llama.cpp, MLC и WebLLM релизы выходят часто; фиксируйте коммит или тег, а не «последнюю версию».
Сводная таблица приёмов
| Приём | Что даёт | Реалистичный выигрыш | Цена | Зрелость (ноябрь 2026) |
|---|---|---|---|---|
| Выгрузка экспертов в ОЗУ (llama.cpp) | запускает MoE больше VRAM | 2–5× против плотной выгрузки; зависит от доли CPU | скорость, сложность флагов | зрелая |
| Адаптивный кэш экспертов (Strata, KT) | 90–97% попаданий | 3–10× против «всё на CPU» (оценка) | ОЗУ, NVMe, молодой код | ранняя |
| SSD-стриминг (AirLLM) | запускает почти всё | 0,03–0,2 ток/с для 70B | диск, время, конверсия | рабочая, но медленная |
| Предсказание экспертов (MoE-Infinity, ExpertFlow) | меньше промахов | 3–16× latency в статьях | обучение/трассировка | исследовательская |
| IQ1/IQ2 | 1,75–2,25 бита | в 2–3 раза меньше Q4_K_M | качество, особенно проза | рабочая |
| BitNet b1.58 | 1,58 бита, CPU | 2–6× на CPU | нужна ternary-модель | рабочая для 2B |
| HQQ | быстрые 4–2 бита | без калибровки | качество на <3 битах | зрелая как квантователь |
| AQLM | 2–3 бита | лучшее качество на 2 битах | калибровка, экосистема | рабочая |
| Разреженность (Deja Vu, CATS) | меньше FLOPs | 15%–2× | ядра, обучение | исследовательская |
| Спекуляция (MTP, DFlash2) | больше токенов за проход | 1,3–1,8× | память под черновик | зрелая |
| KV offload/квантование | длинный контекст | 2× памяти KV | скорость, качество | зрелая |
| exo / RPC | несколько машин | exo: 1,8–3,2× на 2–4 узлах; RPC часто медленнее | цена, сеть, стабильность | ранняя |
| NPU (FLM, OpenVINO) | энергия, prefill | 2–3 ток/с для 27B; до 11 для 8B | маленькие модели, драйверы | ранняя |
| WebGPU | ноль установки | 40 ток/с для 8B | 8B-потолок | рабочая |
| Телефоны (MLC) | карманный инференс | 5–15 ток/с для 7B | память, тепло | рабочая |
Маршрут: что пробовать первым на 8, 16 и 24 ГБ
8 ГБ VRAM
- Плотная 7–8B в Q4_K_M — база. Ожидайте 20–50 ток/с в зависимости от пропускной способности; контекст 8k.
- 14B в IQ3_XXS/Q3_K_M с частичной выгрузкой — 5–15 ток/с, если 32 ГБ ОЗУ.
- MoE 30B-A3B в Q4 с
--n-cpu-moeна 10–20 слоёв — 10–25 ток/с; это лучший способ получить «умнее» без покупки карты. - Не начинайте с AirLLM/Strata DeepSeek: первый запустится, но будет считаться секундами на токен; второй потребует 46–64 ГБ ОЗУ и 250+ ГБ диска.
16 ГБ VRAM
- 14B в Q4/Q5 целиком — 20–40 ток/с.
- 27B в IQ3/IQ4 с выгрузкой части слоёв — 10–25 ток/с.
- 35B-A3B в Q4 с небольшим
--n-cpu-moe— 20–40 ток/с, если 32–64 ГБ ОЗУ. - Strata Qwen3.8-Flash-Next IQ2_XS — 39 ГБ ОЗУ+VRAM, 64 ГБ ОЗУ желательно; в community-замерах около 48–77 ток/с на 16-ГБ картах. Начните с
--plan. - exo/llama.cpp RPC — только если есть 10GbE и вторая машина; иначе не тратьте время.
24 ГБ VRAM
- 27B dense в Q4/Q5 целиком — 30–60 ток/с.
- 35B-A3B в Q4 целиком — 60–100+ ток/с (зависит от памяти).
- 70B в IQ2/IQ3 — 10–25 ток/с, если влезает целиком; 5–15 ток/с с выгрузкой. Для чата терпимо, для агента на длинном контексте — нет.
- 125B-A6B Q2 через Strata/NInfer/Splash — 50–100 ток/с при 64 ГБ ОЗУ; это лучший «большой» вариант на сегодня.
- DeepSeek V4.1 2-bit — 4–10 ток/с, 46–64 ГБ ОЗУ и NVMe; только если очень нужна именно эта модель.
Tip
Правило выбора: сначала модель, которая влезает целиком; потом MoE с выгрузкой экспертов; потом сильное квантование; и только в конце — SSD-стриминг и распределённый кластер. Каждый следующий шаг добавляет сложность быстрее, чем скорость.
Как экспериментировать безопасно
Эти проекты часто просят curl | sh, sudo, проприетарные бинарники и десятки гигабайт с чужих серверов. Минимальная гигиена:
Изоляция.
- Ставьте в отдельного пользователя, контейнер (Docker/Podman) или VM; не давайте
sudoустановщику, который в этом не нуждается. - Читайте
install.sh/install.ps1до запуска; используйте--plan,--dry-run,--check, если они есть. - Не выставляйте сервер в сеть без API-ключа; по умолчанию —
127.0.0.1. Туннель с--no-api-keyозначает «кто нашёл адрес, тот пользуется вашей моделью». - Для RPC-серверов llama.cpp: только доверенная сеть, никогда не открытый интернет; документация прямо называет их небезопасными.
Контрольные суммы и версии.
- Скачивайте релизы с официального GitHub/Hugging Face, проверяйте
SHA256SUMSили хеш из карточки модели; фиксируйте версию/коммит. - Не берите «оптимизированные» бинарники с форумов и зеркал; если очень надо — прогоните через VirusTotal и запускайте в песочнице без доступа к вашим файлам.
- Проверяйте лицензию: у ANEMLL MIT заявлен в README, но отдельного LICENSE-файла нет; у FastFlowLM NPU-ядра проприетарные; у моделей — свои лицензии. «MIT» на движке не делает модель MIT.
Ресурсы.
- Оставляйте 1,5–2 ГБ VRAM свободными (правило главы 3); следите за пиком, а не за состоянием после загрузки.
- Следите за swap: если система ушла в swap, скорость падает на порядок, а SSD изнашивается. В тесте Akita Strata занимала 48 ГБ swap — это не «норма», это признак нехватки ОЗУ.
- Для SSD-стриминга считайте ресурс записи/чтения и температуру; NVMe под постоянной нагрузкой греется и троттлит.
Измерения.
- Сначала baseline на меньшей модели, потом один приём за раз; иначе не поймёте, что помогло.
- 3–5 прогонов, медиана, одинаковые промпты и версии; записывайте GPU, драйвер, квант, контекст и объём ОЗУ.
- Проверяйте качество на своих задачах: JSON, числа, вызовы инструментов; не только «на глаз».
- Для Strata используйте
strata bench run, для llama.cpp —llama-bench; сохраняйтеresults.jsonи логи.
Приватность.
- Публичный Petals-swarm обрабатывает ваши данные на чужих GPU; для секретов — только приватный swarm или локальный движок.
- Локальный сервер с API-ключом всё равно логирует запросы; проверьте, куда пишутся логи и не попадают ли туда документы.
Что работает, а что — хайп
Работает и стоит пробовать:
- llama.cpp с
--n-cpu-moeи--moe-cache-mib— самый дешёвый способ запустить 30B-A3B на 8–16 ГБ. - ktransformers — если у вас есть серверная память и AMX/AVX-512; для 671B на 14 ГБ VRAM это реальный путь.
- Strata — если ваша модель — Qwen3.8-Flash-Next или DeepSeek V4.1 и у вас 64–96 ГБ ОЗУ; независимый замер на 5090 подтверждает 159 ток/с и 90–97% попаданий.
- exo — если у вас несколько Mac и вы готовы к цене и сырости; 30+ ток/с на 235B–1T в кластере подтверждены независимо.
- IQ2/IQ3 + MoE — главный практический способ получить большую модель на домашнем железе.
- MTP/DFlash2 — реальный, но скромный выигрыш 1,3–1,8× на предсказуемом тексте.
- FastFlowLM/MLC/WebLLM — для маленьких моделей, низкого энергопотребления и демо, а не для 70B.
Хайп или узкая ниша:
- AirLLM — технически честно, но «70B на 4 ГБ» означает секунды-минуты на токен. Для интерактива не подходит.
- PowerInfer — сильная идея, но только ReLU-модели, потеря качества на 70B и нет кода предиктора; как общий движок не работает.
- BitNet — реальные 2–6× на CPU, но только для моделей, обученных ternary; «100B на CPU» пока заявление без весов.
- «Любая модель на любом железе» — маркетинг. У каждого движка есть список моделей, ОС, квантов и минимальный объём памяти.
- NPU — не «бесплатное ускорение»: 27B на NPU идёт 2–3 ток/с; выигрыш в энергии и prefill, а не в декоде.
- Публичный Petals — проект не развивается с 2024 года, а данные уходят на чужие GPU.
Ключевые идеи
- Большая модель на маленьком железе — это иерархия памяти: горячее в VRAM, тёплое в ОЗУ, холодное на SSD.
- Эффективная пропускная способность
B_eff = 1 / Σ(s_i / B_i)объясняет, почему 90% попаданий в кэш дают почти нормальную скорость, а 70% — уже нет. - Экспертный кэш работает, потому что MoE активирует малую часть весов; но CPU должен успеть посчитать промахи, а ОЗУ — вместить всех экспертов.
- SSD-стриминг запускает всё, но платит секундами на токен; это режим batch/эксперимента, не чата.
- Экстремальное квантование ниже 3 бит требует проверки на своих задачах; BitNet — отдельный класс моделей, а не квантование готовой.
- Распределённый инференс упирается в сеть; 1GbE почти всегда хуже одной быстрой карты.
- NPU/ANE/WebGPU хороши для малых моделей и энергии, но не отменяют пропускную способность памяти.
Проверь себя
- Почему при 90% попаданий в кэш экспертов скорость падает не в 30 раз, а примерно в 4?
- Чем SSD-стриминг AirLLM отличается от выгрузки экспертов в ОЗУ и почему он на порядки медленнее?
- Почему ktransformers с 14 ГБ VRAM не запустит DeepSeek 671B на обычном домашнем ПК с 64 ГБ ОЗУ?
- В чём подвох заявления «BitNet: 100B на одном CPU»?
- Почему 27B на NPU может быть медленнее, чем 7B на той же машине, и что это говорит о роли NPU?
- Когда распределённый инференс на двух домашних ПК имеет смысл?
Ответы
- Потому что 90% байт идут из быстрой памяти, и только 10% — из медленной. Эффективная пропускная способность считается как гармоническое среднее:
1 / (0,9/1800 + 0,1/60) ≈ 461 ГБ/с, то есть примерно в 4 раза меньше 1,8 ТБ/с, а не в 30. - AirLLM держит на GPU один слой и на каждом токене читает с диска почти все веса плотной модели (у MoE — активных экспертов); выгрузка экспертов держит всех экспертов в ОЗУ, а на токен читает только активных. Диск в 10–100 раз медленнее ОЗУ, поэтому потоковая загрузка даёт секунды на токен, а выгрузка экспертов — десятки токенов в секунду.
- Потому что 671B в 4 битах — это сотни гигабайт, и ktransformers требует около 382 ГБ ОЗУ (или 1 ТБ на два сокета), плюс серверный CPU с AMX/AVX-512. 64 ГБ ОЗУ физически не хватит для всех экспертов; начнётся swap или чтение с диска.
- В отчёте заявлено 5–7 ток/с для 100B-модели на одном CPU, но публично выложена только 2B-модель. Кроме того, BitNet требует обучения с нуля с тернарными весами, а не квантования готовой Llama/Qwen.
- NPU имеет свою пропускную способность и ограниченный объём памяти; 27B читает больше байт на токен и не помещается в быстрый кэш, поэтому декод упирается в память. NPU помогает с энергией и prefill, но не увеличивает пропускную способность памяти.
- Когда модель не помещается в одну машину, а сеть достаточно быстрая (10GbE/RDMA), и вы готовы платить за электричество, шум и сложность. Если модель помещается в одну карту, одна карта почти всегда быстрее и проще.
Источники главы
- Strata — GitHub, How it works, Models, DeepSeek V4.1, issue #4815. Движок, документация и независимый пользовательский замер.
- Fabio Akita, «Best Open Source LLM: Strata with Qwen 3.8 Flash Next» (2026) — akitaonrails.com. Независимый обзор и замеры на RTX 5090 и Strix Halo.
- Benjamin Marie, «Qwen3.8 Flash Next Review» (2026) — kaitchup.substack.com. Доп. чтение: в лиде — 125B-A6B, 51B n-gram-таблица и 4B MTP; бенчмарки за пейволом.
- ktransformers — GitHub, DeepSeek R1/V3 tutorial. CPU-GPU гибрид, AMX/AVX-512, цифры команды.
- PowerInfer — GitHub, arXiv:2312.12456; PowerInfer-2 — arXiv:2406.06282. Горячие/холодные нейроны и смартфонный вариант.
- AirLLM — GitHub. Послойная загрузка; независимые замеры: dev.to, Mac Mini.
- Alizadeh et al., «LLM in a flash» (2023) — arXiv:2312.11514. Windowing и row-column bundling.
- MoE-Infinity — arXiv:2401.14361, GitHub; ExpertFlow — arXiv:2410.17954. Предсказание и кэш экспертов.
- exo — GitHub; Jeff Geerling, «1.5 TB of VRAM on Mac Studio» (2025) — jeffgeerling.com. Кластер Mac и RDMA.
- llama.cpp RPC — tools/rpc/README.md, обсуждение #9136; llama.cpp server — tools/server/README.md. RPC,
--n-cpu-moe,--moe-cache-mib, KV. - Petals — GitHub; distributed-llama — GitHub. Распределённый инференс на домашних устройствах.
- BitNet b1.58 — arXiv:2402.17764; bitnet.cpp — GitHub, arXiv:2410.16144. Тернарные модели и CPU-ядра.
- HQQ — GitHub; AQLM — GitHub, arXiv:2401.06118; QTIP — arXiv:2406.11235. Экстремальное квантование.
- Deja Vu — arXiv:2310.17157; CATS — arXiv:2404.08763. Разреженность активаций.
- Splash — GitHub; NInfer — GitHub; HyperQwen — GitHub. Движки под одну модель.
- FastFlowLM — GitHub, бенчмарк Qwen3.8; ANEMLL — GitHub. NPU/ANE.
- Intel NPU — arXiv:2608.19147, §8.6, OpenVINO issue #35641, Cascadia. NPU на Lunar Lake: 3,55 → 11,46 ток/с на четырёх слотах.
- WebLLM — GitHub, arXiv:2412.15803; MLC LLM — GitHub. WebGPU и мобильные движки.
- LMCache — блог. Vendor-заявление об offload KV: 10× по p99 TTFT, декод — около 3,8× (не независимая проверка).
15. Куда расти
Зачем эта глава. Книга заканчивается, а инференс — нет. Здесь — карта дальнейшего движения: что читать, что писать руками и как не утонуть в потоке статей.
За 30 секунд
- Вся книга сводится к нескольким формулам: размер весов, KV-кэш, потолок декода, ускорение спекуляции. Числа устаревают, формулы — нет.
- Дальше три пути: системы и serving, ядра GPU, качество моделей и оценка.
- Лучше всего закрепляют знание маленькие проекты своими руками — от tiny GPT до бенчмарк-харнесса.
- Следите за областью через первоисточники и release notes, а не через пресс-релизы.
15.1 Что вы теперь знаете
Кратко, весь путь:
- Модель — это токены, эмбеддинги и стопка слоёв attention + FFN.
- Prefill параллелен и упирается в вычисления; decode последователен и упирается в память.
- Память иерархична: VRAM быстрее ОЗУ, PCIe медленный, диск — для загрузки.
- Квантование уменьшает и память, и трафик; ниже 4 бит нужна проверка качества.
- MoE хранит много, активирует мало; выгрузка экспертов в ОЗУ — рабочий трюк.
- KV-кэш растёт с контекстом; GQA, MLA и линейное внимание его сокращают.
- Кэш промпта убирает prefill из критического пути агента.
- Батчинг повышает пропускную способность; PagedAttention борется с фрагментацией.
- Спекуляция ускоряет декод, если черновик хорошо угадывает.
- Сэмплинг и бюджет рассуждений управляют поведением и временем.
- Tool calling — это шаблон чата плюс парсер плюс грамматика.
- Бенчмарк без методики — самообман.
- Выбор модели начинается с бюджета памяти и своих примеров.
- Речь и OCR — отдельные пайплайны с теми же принципами.
15.2 Направления роста
Системы и инфраструктура
Если нравится «почему быстро/медленно»:
- CMU 11-868 LLM Systems — курс про GPU, serving, распределённый инференс, quantization, paged attention.
- Stanford CS336 — языковое моделирование с нуля: токенизация, архитектура, обучение, масштабирование.
- vLLM / SGLang — читать код и документацию, разбирать, как устроены батчинг и кэш.
- llama.cpp / ggml — читать исходники, особенно квантование, бэкенды (CUDA, Metal) и сервер.
Практика: собрать свой сервер, прогнать нагрузку, найти узкое место, починить.
Ядра и производительность
Если хочется «под капот GPU»:
- CUDA или Triton; начать с матричного умножения и softmax.
- FlashAttention 1/2/3 — прочитать статьи и реализовать упрощённую версию.
- PagedAttention — понять, как блоки KV отображаются на память.
- Roofline — научиться считать, во что упирается конкретный кернел.
Практика: написать attention на Triton, сравнить с PyTorch, посчитать арифметическую интенсивность.
Модели и качество
Если ближе «что модель умеет»:
- Hugging Face LLM Course — практика с моделями и токенизаторами.
- CS224n — NLP и трансформеры.
- Evals — как измерять качество, а не любоваться демо.
- Tool calling и агенты — HF Agents Course, BFCL, свои сценарии.
Практика: собрать набор из 50 реальных задач, прогнать 3 модели, сравнить честно.
Следующий уровень: от одного ПК к кластеру и обучению
Когда одна машина перестаёт быть достаточной, меняются не формулы, а число членов в них: появляются обмен между картами, сеть, отказы, планирование и стоимость. Главный маршрут в эту сторону — книга Bojie Li (Боцзе Ли), «AI Infra in Depth: Quantitative Analysis and System Design» (Apache-2.0; есть русский перевод community edition). Она построена на том же принципе, что и наша: сначала ограничения, потом конструкция.
Карта перехода:
flowchart TB
A["Наша книга:<br/>один ПК, llama.cpp, MLX"] --> B["Их гл. 1–2:<br/>память, roofline,<br/>архитектура модели"]
B --> C["Их гл. 8:<br/>батчинг, KV,<br/>спекуляция, очереди"]
C --> D["Их гл. 6–7:<br/>несколько GPU,<br/>суперузел, сеть"]
D --> E["Их гл. 9–10:<br/>распределённый инференс,<br/>обучение"]
E --> F["Их гл. 11–12:<br/>планирование,<br/>edge-cloud"]
Порядок чтения под локальный опыт:
- Гл. 1–2 — те же веса, KV и roofline, но с формальным выводом и модельными примерами. Сюда стоит заглянуть, если хочется не «формула на салфетке», а полный расчёт по
config.json. - Гл. 8 — прямое продолжение наших глав 8–9: батчинг, страничный KV, кэш префикса, выгрузка, спекуляция, эффективная пропускная способность. Многое из §12.7 выросло отсюда.
- Гл. 6–7 — что происходит, когда карт несколько: tensor/pipeline parallelism, AllReduce, топология, цена обмена. Наши §8.6 и §9.7 — только вход в тему.
- Гл. 9–10 — распределённый инференс и обучение: размещение prefill/decode, ZeRO, checkpoint, отказы. Это уже другой масштаб, но законы Амдала и Литтла те же.
- Гл. 11–12 — планирование ресурсов и edge-cloud: очереди, допуск, стоимость принятой задачи.
Что меняется по сравнению с одним ПК:
- Память делится между картами, и появляется обмен: выигрыш от N карт не равен N, а иногда отрицателен.
- Сеть становится членом формулы: маленькие сообщения упираются в задержку, большие — в полосу.
- Отказы — норма: checkpoint и восстановление входят в проект, а не в «потом».
- Стоимость считается на принятую задачу, а не на токен: очереди, повторы и простой входят в числитель.
- Обучение — отдельная дисциплина: данные, оптимизатор, параллелизм, стабильность. Наша книга её не покрывает; у Bojie Li — глава 10.
Tip
Не начинайте с распределённого обучения. Сначала доведите до предела одну машину по §12.7: посчитайте нижнюю границу, разберите разрыв, убедитесь, что узкое место действительно в железе. Тогда переход на несколько карт будет решением, а не побегом от неизмеренной проблемы.
15.3 Что написать руками
Чтение без практики забывается. Небольшие проекты, которые дают больше всего:
- Tiny GPT — токенизатор, attention, обучение на маленьком корпусе. Karpathy, «Let's build GPT».
- GPT-2 reproduction — загрузка весов, генерация, KV-кэш. Karpathy, «Let's reproduce GPT-2».
- FlashAttention на Triton — упрощённая версия с тайлингом и online softmax.
- Paged KV cache — блоки, таблица страниц, разделение префиксов.
- Квантование — реализовать блочное 4-битное квантование и сравнить ошибку.
- Спекулятивное декодирование — draft + verify, замерить acceptance.
- Бенчмарк-харнесс — повторяемые прогоны, медиана, разброс, VRAM.
- Tool-calling агент — шаблон, схема, валидация, лимиты.
- OCR/ASR пайплайн — от файла до текста, с метриками.
Даже по одному вечеру на проект даёт больше, чем десять обзоров.
15.4 Порядок чтения
Для новичка:
- Karpathy, «Deep Dive into LLMs like ChatGPT» — общая картина.
- Karpathy, «Let's build GPT» — код.
- 3Blue1Brown, серия про трансформеры — визуальная интуиция.
- «The Little Book of Deep Learning» — компактный учебник.
- Эта книга, главы 1–4.
Для среднего уровня:
- «Attention Is All You Need» — первоисточник.
- «Efficiently Scaling Transformer Inference» — память и вычисления.
- FlashAttention 1/2 — IO-aware attention.
- vLLM / PagedAttention — serving.
- Главы 5–9 этой книги.
Для продвинутого:
- CS336 и CMU 11-868 — курсы целиком.
- FlashAttention-3, EAGLE-3, Gated DeltaNet — свежие статьи.
- Код vLLM, SGLang, llama.cpp.
- Свои эксперименты и замеры.
15.5 Как следить за областью
- arXiv — cs.CL, cs.LG, cs.DC; подписка на нужные категории.
- Hugging Face Papers — подборки свежих статей со ссылками на код и модели (бывший адрес Papers with Code теперь перенаправляет сюда).
- Блоги лабораторий — Hugging Face, vLLM, SGLang, llama.cpp.
- Конференции — NeurIPS, ICML, ICLR, MLSys, OSDI/NSDI, ACL.
- GitHub — release notes и discussions дают больше, чем пресс-релизы.
Фильтруйте: не каждая статья с «достигает 2×» проверена на вашем железе. Читайте методологию, а не только abstract.
15.6 Что осталось за рамками
- Обучение и fine-tuning — LoRA, QLoRA, RLHF/DPO; это отдельная книга.
- Мультимодальность — зрение, аудио, видео в одной модели; в книге лишь кратко затронуты VLM (§14.9).
- Распределённый инференс — tensor/pipeline parallelism, disaggregated prefill/decode; в книге — только обзор (§8.6), маршрут дальше — в §15.2.
- Серверная эксплуатация — очереди, автомасштабирование, мониторинг, стоимость.
- Безопасность — prompt injection, утечки, изоляция инструментов; основы — в §11.8.
Каждая тема заслуживает отдельного изучения.
15.7 Честные ограничения
- Железо меняется. Числа из статей устаревают; формулы — нет.
- Бенчмарки не равны качеству. Ваш домен может дать другую картину.
- Вендоры заявляют лучшее. Проверяйте независимо.
- Оптимизации конфликтуют. Спекуляция, кэш экспертов, батчинг и KV-квантование влияют друг на друга.
- Локальный инференс — компромисс. Облако часто быстрее и умнее; локально вы покупаете приватность, контроль и отсутствие счёта за токены.
Tip
Самый полезный следующий шаг — не новая статья, а собственный отчёт по шаблону §12.10 для вашей машины и вашей задачи. Он сразу покажет, какие главы вы поняли, а какие стоит перечитать.
15.8 Финальный чек-лист
- Я могу объяснить разницу prefill и decode и посчитать потолок скорости.
- Я считаю KV-кэш по формуле и знаю, сколько стоит контекст.
- Я понимаю, что означают
Q4_K_M,IQ4_XS,UD. - Я знаю, зачем
--n-cpu-moeи когда он помогает. - Я умею мерить ток/с, VRAM и качество, не обманывая себя.
- Я проверяю модель на своих задачах, а не по лидерборду.
- Я записываю конфиги и отрицательные результаты.
- Я знаю, куда читать дальше.
Ключевые идеи
- Дальше три пути: системы, ядра, качество моделей.
- Чтение без практики забывается; маленькие проекты дают больше.
- Начинайте с общей картины, затем первоисточники, затем код.
- Следите за областью, но фильтруйте маркетинг.
- Локальный инференс — это инженерия компромиссов, а не волшебная кнопка.
Проверь себя
- Какой проект лучше всего проверит понимание KV-кэша?
- Зачем читать исходники llama.cpp или vLLM, если есть документация?
- Почему числа из статей нельзя переносить на своё железо без проверки?
- Что из этой книги не покрывает обучение моделей?
- Какой первый шаг, если вы хотите углубиться в ядра?
Ответы
- Реализовать Paged KV cache или хотя бы кэш с блоками и таблицей страниц, затем сравнить память и скорость с наивным вариантом.
- Документация описывает интерфейс, а исходники — реальное поведение: какие оптимизации включены, как обрабатываются края, где узкие места. Версии и флаги меняются, код — источник истины.
- Разное железо, версии рантайма, кванты, драйверы и нагрузки. Статья даёт метод и порядок величины, а не гарантию для вашей машины.
- Fine-tuning, RLHF/DPO, обучение с нуля и распределённое обучение; мультимодальность и эксплуатация серверов — только обзорно.
- Написать простой CUDA/Triton кернел для матричного умножения или softmax, замерить его и сравнить с библиотечным.
Источники главы
- Andrej Karpathy, «Deep Dive into LLMs like ChatGPT» (2025) — YouTube. Общая картина обучения и инференса.
- Andrej Karpathy, «Intro to Large Language Models» (2023) — YouTube. Доступное введение.
- Andrej Karpathy, «Neural Networks: Zero to Hero» — плейлист. От backprop до GPT.
- nanoGPT — GitHub. Минимальная реализация GPT для экспериментов.
- llm.c — GitHub. Обучение LLM на C/CUDA.
- Stanford CS336 — курс. Языковое моделирование с нуля.
- CMU 11-868 LLM Systems — курс. Системы, serving, GPU.
- MIT 6.5940 TinyML and Efficient Deep Learning — курс. Эффективные модели и квантование.
- Hugging Face Agents Course — курс. Практика агентов и инструментов.
- «The Little Book of Deep Learning» — PDF. Компактное введение в глубокое обучение.
- Bojie Li, «AI Infra in Depth: Quantitative Analysis and System Design» — GitHub, Apache-2.0; русский перевод. Уровень: продвинутый. Зачем: следующий уровень после одного ПК — serving, несколько GPU, сеть, распределённый инференс и обучение; количественный метод тот же.
16. Глоссарий
Короткие определения терминов, которые встречаются в книге. В скобках — глава, где тема разобрана подробнее.
Железо и память
- VRAM — видеопамять, отдельный пул на дискретной видеокарте. Самая быстрая память для весов, но её мало: 8–32 ГБ у потребительских карт, 48–96 ГБ у профессиональных. (Гл. 3)
- ОЗУ (RAM) — системная память. Больше по объёму, но в 5–15 раз медленнее VRAM. (Гл. 3)
- Объединённая память (unified memory) — общий пул для CPU и GPU, как у Apple Silicon, Strix Halo и DGX Spark. Не нужно копировать веса по PCIe, но пропускная способность ниже, чем у топовых дискретных карт. (Гл. 3)
- Strix Halo — APU AMD Ryzen AI Max с 128 ГБ LPDDR5X и iGPU Radeon 8060S; 256 ГБ/с, x86, без CUDA. (Гл. «Как выбрать железо»)
- GB10 / DGX Spark — связка Grace CPU + Blackwell GPU с 128 ГБ когерентной LPDDR5X; 273 ГБ/с, CUDA, 140 Вт. (Гл. «Как выбрать железо»)
- GDDR7 — седьмое поколение графической памяти; в RTX 50-серии даёт 448–1792 ГБ/с в зависимости от шины. (Гл. 3)
- LPDDR5X — энергоэффективная память с высокой плотностью; используется в Apple Silicon, Strix Halo и DGX Spark. (Гл. 3)
- HBM — stack-память с очень высокой пропускной способностью (терабайты в секунду); стоит в серверных GPU, не в потребительских. (Гл. 3)
- TDP — тепловой пакет, Вт. Определяет требования к охлаждению, БП и шуму. (Гл. «Как выбрать железо»)
- NVLink — прямой высокоскоростной мост между GPU. У RTX 3090 и A6000 есть, у RTX 5090, RTX 6000 Ada и RTX PRO 6000 Blackwell — нет. (Гл. «Как выбрать железо»)
- PCIe-линии — сколько карт можно подключить на полной ширине. У Ryzen 9 обычно 24 usable линии, у Threadripper — 80–128, у EPYC — 128. (Гл. «Как выбрать железо»)
- ECC — коррекция ошибок памяти; есть у профессиональных карт. У AMD обычно только в Linux, у NVIDIA работает и в Windows. (Гл. «Как выбрать железо»)
- Blower — турбинный кулер, выдувающий воздух наружу; удобен для плотных многокартных сборок, но шумный. (Гл. «Как выбрать железо»)
- MSRP / уличная цена — рекомендованная цена производителя и реальная цена магазина. В 2026 году расходятся в 1,5–3 раза. (Гл. «Как выбрать железо»)
- PCIe — шина между GPU и системной памятью. 25–60 ГБ/с — в десятки раз медленнее VRAM; гонять по ней веса на каждом токене нельзя. (Гл. 3)
- Пропускная способность (bandwidth) — сколько байт в секунду можно прочитать. Определяет скорость декода. (Гл. 2)
- Задержка (latency) — время до одного ответа памяти. Важна для случайного доступа, но не заменяет пропускную способность. (Гл. 3)
- mmap — отображение файла в память: ОС подгружает страницы по мере обращения. Удобно для старта, опасно для весов, которые считаются на CPU. (Гл. 3)
- sysmem fallback — тихая выгрузка не влезшей VRAM в системную память на Windows. Причина резкого падения скорости без ошибки. (Гл. 3)
- FLOP — одна операция с плавающей точкой.
FLOP/s— производительность железа. (Гл. 2) - Арифметическая интенсивность — отношение FLOP к прочитанным байтам. У декода около
2/b, у prefill —2B/b. (Гл. 2) - Roofline — модель «упирается либо в вычисления, либо в память». Точка перелома
I* = FLOP/s ÷ пропускная способностьзависит только от железа. (Гл. 2)
Модель и архитектура
- Токен — кусок текста, единица работы модели. Не слово. (Гл. 1)
- Токенизатор — алгоритм, который режет текст на токены; чаще всего BPE (byte-pair encoding). (Гл. 1)
- Словарь (vocabulary) — набор всех токенов модели, обычно 32k–256k. (Гл. 1)
- Эмбеддинг — вектор, в который превращается токен; таблица эмбеддингов —
vocab × d_model. (Гл. 1) d_model— ширина вектора на слое.d_head— ширина одной головы attention. (Гл. 1)- Логиты — сырые числа до softmax, по одному на токен словаря. (Гл. 1)
- Softmax — превращает числа в вероятности: экспонента и нормировка на сумму. (Гл. 1, 10)
- Attention — механизм, который смешивает информацию между позициями через Q, K, V. (Гл. 1)
- Q / K / V — Query («что ищу»), Key («что предлагаю»), Value («что передаю»). (Гл. 1)
- Голова (head) — независимое подпространство attention. (Гл. 1)
- Causal mask — запрет смотреть на будущие токены. (Гл. 1)
- FFN — feed-forward network, преобразует каждую позицию отдельно; хранит большую часть знаний. (Гл. 1)
- SwiGLU — вариант FFN с «воротами» и тремя матрицами. (Гл. 1)
- LayerNorm / RMSNorm — виды нормировки; RMSNorm дешевле, без вычитания среднего. (Гл. 1)
- Остаточная связь (residual) —
x + block(x), позволяет сигналу проходить через много слоёв. (Гл. 1) - GQA — grouped-query attention: несколько Q-голов делят одну пару K/V, экономя KV-кэш. (Гл. 6)
- MQA — multi-query attention: одна KV-голова на все Q-головы. (Гл. 6)
- MLA — multi-head latent attention: сжатие K/V в латентный вектор. (Гл. 6)
- RoPE — позиционное кодирование поворотом Q и K; зависит от относительной позиции. (Гл. 6)
- YaRN — способ растянуть контекст через масштабирование частот RoPE и коррекцию attention. (Гл. 6)
- Контекстное окно — максимальная длина последовательности, которую модель обрабатывает за раз. (Гл. 6)
- KV-кэш — сохранённые K и V прошлых токенов; растёт с контекстом. (Гл. 6)
- MoE — mixture of experts: много экспертов, на токен активируется несколько. (Гл. 5)
- Эксперт — отдельный FFN в MoE. Роутер — выбирает экспертов для токена. (Гл. 5)
- Активные параметры — сколько весов читается на токен. Всего параметров — сколько хранится. (Гл. 5)
- Shared expert — эксперт, который работает для всех токенов. (Гл. 5)
- Sliding window attention (скользящее окно) — каждый токен видит только последние
Wтокенов; KV-кэш слоя не превышаетW. (Гл. 6) - Линейное внимание — замена KV-кэша состоянием фиксированного размера; в гибридных моделях чередуется со слоями полного внимания. (Гл. 6)
- Attention sinks — первые токены, на которые приходится непропорционально много внимания; StreamingLLM сохраняет их вместе со скользящим окном. (Гл. 6)
- FlashAttention — вычисление attention блоками без хранения полной матрицы «токен × токен»; экономит память и ускоряет длинный контекст. (Гл. 2)
Форматы и квантование
- safetensors — формат хранения весов без исполняемого кода; часто используется для исходных моделей. (Гл. 4)
- GGUF — контейнер llama.cpp: веса, метаданные, токенизатор, шаблон чата в одном файле. (Гл. 4)
- GGML / ggml — тензорная библиотека, на которой стоит llama.cpp, и одноимённый старый формат файлов; GGUF — его современный преемник. (Гл. 4)
- Квантование — хранение весов меньшим числом бит с масштабами на блок. (Гл. 4)
- bpw (bits per weight) — среднее число бит на вес с учётом служебных данных. (Гл. 4)
- Q4_0 — простое 4-битное блочное квантование, ~4,5 бита на вес. (Гл. 4)
- Q4_K_M — k-quants, смесь типов, ~4,8 бита на вес; универсальный выбор. (Гл. 4)
- IQ4_XS — i-quants, ~4,4–4,5 бита; часто меньше Q4_K_M при близком качестве. (Гл. 4)
- Q8_0 — 8-битное квантование, ~8,5 бита; почти без потерь. (Гл. 4)
- Imatrix — матрица важности весов по активациям; помогает низким битам. (Гл. 4)
- Суперблок — в k-quants группа из 256 весов с подблоками и сжатыми масштабами. (Гл. 4)
- Perplexity — экспонента средней отрицательной лог-вероятности текста; ниже — лучше, сравнивать только на одинаковых условиях. (Гл. 4)
- FP16 / FP8 / FP4 — форматы чисел с плавающей точкой разной точности. FP8/FP4 ускоряют prefill и батчинг на новых GPU, но для GGUF-квантов важнее байты на вес. (Гл. 2, 4)
- MXFP4 — 4-битный формат с общим масштабом на блок; используется в MLX и некоторых серверных движках. (Гл. 4)
Рантаймы и серверы
- llama.cpp — C/C++ движок инференса с GGUF, CPU/GPU-гибридом и сервером. (Гл. 3, 5)
- llama-server — HTTP-сервер из llama.cpp с OpenAI-совместимым API. (Гл. 7, 11)
- vLLM — серверный движок с PagedAttention и непрерывным батчингом. (Гл. 8)
- SGLang — серверный движок с RadixAttention и разделяемым кэшем префиксов. (Гл. 7)
- Ollama / LM Studio / Unsloth Studio — «коробки» для локального запуска: движок, реестр моделей и API в одном приложении; удобны, но меньше контроля над флагами. (Гл. «Готовые коробки»)
- Коробка (boxed solution) — приложение или сервер, который упаковывает движок, менеджер моделей, шаблоны и HTTP-API вместе с набором дефолтов. (Гл. «Готовые коробки»)
- Modelfile — рецепт модели в Ollama:
FROM,PARAMETER,TEMPLATE,SYSTEM,LICENSE. (Гл. «Готовые коробки») - Реестр моделей — встроенный каталог с тегами, квантами и шаблонами (Ollama Library, Hugging Face в LM Studio/Jan). (Гл. «Готовые коробки»)
- JIT-загрузка — загрузка модели по первому запросу, а не заранее; удобна для API, но добавляет холодный старт. (Гл. «Готовые коробки»)
- TTL / auto-evict — выгрузка простаивающей модели по таймеру и вытеснение предыдущей JIT-модели перед загрузкой новой. (Гл. «Готовые коробки»)
- Unified KV cache — общий KV-буфер на несколько параллельных запросов вместо жёсткого деления на равные слоты. (Гл. «Готовые коробки»)
- Пресет — сохранённый набор параметров загрузки и/или сэмплирования для повторного использования. (Гл. «Готовые коробки»)
- OpenAI-совместимый API — подмножество OpenAI API; набор поддержанных полей у разных коробок отличается. (Гл. «Готовые коробки», 11)
- Бэкенд — вычислительная реализация: CUDA, Metal, ROCm, Vulkan, CPU. От неё зависят скорость и поддержка квантов.
- CUDA — платформа NVIDIA; самый зрелый путь для llama.cpp, vLLM, TensorRT-LLM и Ollama. (Гл. «Как выбрать железо»)
- ROCm — открытая платформа AMD для GPU-вычислений; на Linux поддерживает Radeon AI PRO, на Windows ограничена. (Гл. «Как выбрать железо»)
- SYCL / oneAPI — модель параллельного программирования Intel; через неё llama.cpp и vLLM работают на Arc. (Гл. «Как выбрать железо»)
- Metal — графический API Apple; бэкенд llama.cpp для Mac. (Гл. «Как выбрать железо»)
- MLX — фреймворк Apple для Apple Silicon; хорошо использует объединённую память, но не является заменой CUDA-стека. (Гл. «Как выбрать железо»)
--load-mode— режим загрузки модели:auto,none,mmap,mlock,dio. Для CPU-экспертов обычно нуженnone. (Гл. 3)- Слот (
-np) — независимый контекст на сервере; каждый добавляет KV-кэш. (Гл. 8) -ngl— сколько слоёв модели держать на GPU. (Гл. 5)--n-cpu-moe— сколько слоёв экспертов MoE оставить в ОЗУ и считать на CPU. (Гл. 5)-b/-ub— логический и физический размер батча;-ubускоряет prefill и увеличивает буфер в VRAM. (Гл. 8)- Tensor / pipeline parallelism — деление матриц слоя или самих слоёв между несколькими GPU. (Гл. 8)
- Disaggregated prefill/decode — prefill и decode на разных пулах GPU. (Гл. 8)
- mmproj — отдельный GGUF-файл с vision-энкодером и проектором для VLM. (Гл. 14)
- Prompt cache — переиспользование KV для общего префикса запросов. (Гл. 7)
- PagedAttention — хранение KV блоками с таблицей страниц; меньше фрагментации. (Гл. 8)
- Непрерывный батчинг — новые запросы занимают освободившиеся слоты на каждом шаге. (Гл. 8)
- RadixAttention — кэш префиксов в radix-дереве; общие начала делят KV между запросами. (Гл. «Движки инференса»)
- HiCache — трёхуровневый кэш SGLang: GPU, host-память, внешнее хранилище. (Гл. «Движки инференса»)
- Paged Experts — выгрузка экспертов MoE в pinned host-память с копированием нужных на GPU; вычисления остаются на GPU. (Гл. «Движки инференса»)
- Chunked prefill — длинный промпт режется на куски и подмешивается к декоду, чтобы не блокировать очередь. (Гл. 8, «Движки инференса»)
- Preemption — вытеснение запроса при нехватке KV; в vLLM V1 по умолчанию с пересчётом. (Гл. «Движки инференса»)
- CUDA graphs — запись последовательности ядер и запуск её одним вызовом; ускоряет декод, но занимает память. (Гл. «Движки инференса»)
- Expert parallelism (EP) — распределение экспертов MoE между GPU. (Гл. «Движки инференса»)
- Data parallelism (DP) — несколько копий модели для пропускной способности. (Гл. «Движки инференса»)
- KV offload — вынос KV-кэша в host-память или на диск; расширяет контекст, но добавляет задержку. (Гл. «Движки инференса»)
- Unified KV — единый пул KV на все слоты llama.cpp вместо отдельного кэша на слот. (Гл. «Движки инференса»)
- Context checkpoint — сохранённое состояние контекста слота для быстрого возврата к ветке диалога. (Гл. «Движки инференса»)
- Tool parser — серверный разбор текста модели в
tool_calls. (Гл. 11, «Движки инференса») - Grammar backend — движок ограниченной генерации: XGrammar, Outlines, llguidance. (Гл. 11, «Движки инференса»)
Генерация и управление
- Prefill — параллельная обработка промпта, упирается в вычисления. (Гл. 2)
- Decode — последовательная генерация по одному токену, упирается в память. (Гл. 2)
- pp — токенов промпта в секунду. tg — токенов генерации в секунду. (Гл. 2)
- TTFT — время до первого токена. ITL — время между токенами. (Гл. 2, 12)
- Throughput — токенов в секунду на весь сервер. Latency — задержка одного запроса. (Гл. 8)
- Сэмплинг — выбор токена из распределения. (Гл. 10)
- Temperature — резкость распределения; 0 — жадный выбор. (Гл. 10)
- Top-k / top-p / min-p — способы обрезать маловероятный хвост. (Гл. 10)
- Greedy — всегда выбирать самый вероятный токен. (Гл. 10)
- Seed — зерно генератора случайных чисел; помогает воспроизводимости, но не гарантирует побитового совпадения. (Гл. 10)
- Бюджет рассуждений — ограничение на скрытые токены «размышления». (Гл. 10)
- Спекулятивное декодирование — черновик предлагает несколько токенов, целевая модель проверяет их за один проход. (Гл. 9)
- Черновик (draft) — модель или голова, предлагающая токены. (Гл. 9)
- Acceptance rate (
α) — доля принятых токенов черновика. (Гл. 9) γ— длина черновика: сколько токенов он предлагает за один цикл. (Гл. 9)- Rejection sampling — схема проверки черновика при
T > 0, сохраняющая распределение целевой модели. (Гл. 9) - MTP — multi-token prediction, дополнительные головы целевой модели. (Гл. 9)
- Medusa / EAGLE — семейства методов спекуляции с несколькими головами или признаками. В llama.cpp реализован EAGLE-3, но не Medusa/EAGLE-1/2. (Гл. 9)
- Chat template — правило превращения ролей и инструментов в текст для модели. (Гл. 11)
- Tool calling — текстовая разметка вызова инструмента плюс парсер на сервере. (Гл. 11)
- Грамматика / GBNF — ограничение допустимых токенов на каждом шаге. (Гл. 11)
- Constrained decoding (ограниченное декодирование) — генерация с маской: недопустимые по грамматике токены получают нулевую вероятность. (Гл. 11)
- Prompt injection — вредоносная инструкция внутри данных (документа, результата инструмента), которую модель принимает за команду. (Гл. 11)
- JSON Schema — описание структуры JSON, которое можно превратить в грамматику. (Гл. 11)
Большие модели на маленьком железе
- Рабочее множество (working set) — байты, которые реально читаются на один токен: активные эксперты, KV-кэш и буферы. Не то же самое, что размер файла модели. (Гл. «Большие модели на маленьком железе»)
- Эффективная пропускная способность (
B_eff) —1 / Σ(s_i / B_i), гдеs_i— доля байт с уровня памятиi. Объясняет, почему 90% попаданий в VRAM дают почти нормальную скорость, а 70% — уже нет. (Там же) - Экспертный кэш — горячие эксперты MoE в VRAM; остальные лежат в ОЗУ и считаются на CPU. (Там же; гл. 5)
- Горячие и холодные эксперты — часто и редко используемые эксперты. Адаптивный кэш определяет их по ходу работы. (Там же)
- Предсказание экспертов — загрузка экспертов заранее по истории маршрутизации или обученному предиктору. (Там же)
- Послойная загрузка (SSD-стриминг) — на GPU держится один слой, остальные читаются с диска на каждом токене. (Там же)
- Одномодельный движок — движок, оптимизированный под одну модель/карту/платформу; выигрывает в скорости, проигрывает в универсальности. (Там же)
- RPC-инференс — удалённые устройства отдают свои GPU/CPU через
ggml-rpc-server; сеть становится узким местом. (Там же) - Тернарные веса — веса {-1, 0, 1}; BitNet b1.58 требует обучения с нуля, а не квантования готовой модели. (Там же)
- AQLM — аддитивное квантование с обучаемыми кодовыми книгами, 2–3 бита; нужна калибровка. (Там же)
- HQQ — быстрое квантование без калибровочных данных, 1–8 бит; удобно для 4 бит. (Там же)
- QTIP — квантование с решётками (trellis), исследовательский метод для 2 бит. (Там же)
- Контекстная разреженность — зависящий от входа набор голов/нейронов, которые можно не считать; требует предсказателя и sparse-ядер. (Там же)
- NPU — нейронный ускоритель в SoC (AMD XDNA2, Intel AI Boost, Apple ANE). Экономит энергию и ускоряет prefill, но не заменяет пропускную способность памяти. (Там же)
- ANE — Apple Neural Engine; запускается через CoreML/ANEMLL, хорошо для небольших моделей и prefill. (Там же)
- WebGPU — браузерный API для вычислений на GPU; WebLLM запускает модель целиком в памяти вкладки. (Там же)
- Engram / n-gram таблица — огромная таблица n-gram-эмбеддингов, которую большие MoE читают с SSD по несколько строк на токен. (Там же)
- DFlash2 / DSpark — семейства маленьких черновиков для спекулятивного декодирования; DFlash2 используется в Splash/HyperQwen, DSpark — в Strata для DeepSeek. (Там же; гл. 9)
- KV offload — хранение KV-кэша в ОЗУ вместо VRAM; освобождает память, но замедляет длинный контекст. (Там же; гл. 6)
Задачи и метрики
- ASR — автоматическое распознавание речи. OCR — распознавание текста на изображениях. (Гл. 14)
- WER / CER — доля ошибок на уровне слов / символов. (Гл. 14)
- RTF — отношение времени обработки к длительности аудио. (Гл. 14)
- RAG — retrieval-augmented generation: поиск внешних фрагментов и вставка их в промпт. (Гл. 7)
- VAD — voice activity detection, выделение участков с речью перед ASR. (Гл. 14)
- VLM — vision-language model, модель с обработкой изображений. (Гл. 14)
- Recall / precision — полнота и точность; в проверке документов важны обе. (Гл. 12)
- Медиана и разброс — устойчивое «типичное» значение замера и мера его шума (стандартное отклонение, интерквартильный размах). (Гл. 12)
- Доверительный интервал — диапазон, в котором с заданной уверенностью лежит истинное значение метрики; на 5 прогонах он очень широкий. (Гл. 12)
- ГиБ / ГБ — гибибайт (2³⁰ байт) и гигабайт (10⁹ байт); 1 ГиБ ≈ 1,074 ГБ. (Соглашения в README)
- Нижняя граница (lower bound) — время, быстрее которого шаг физически невозможен при данных вычислениях и чтении; не прогноз, а предел. (Гл. 2, 12)
- MBU — нижняя граница по чтению, делённая на измеренное время шага:
T_память / T_измеренная. MFU — то же по вычислениям:T_вычисления / T_измеренная. (Гл. 12) - Эффективная пропускная способность — число правильных и вовремя завершённых задач в секунду; в отличие от throughput завершений, учитывает качество и SLO. (Гл. 8, 12)
- Закон Литтла —
N = λ × T: число запросов в системе равно интенсивности поступления, умноженной на время пребывания. (Гл. 8) b*— батч, при котором чтение KV догоняет чтение весов:b* = W / (C × k); минимальный целый — округлением вверх; дальше батч почти не снижает байты на токен. (Гл. 8)E[N]— ожидаемое число выходных токенов за раунд спекуляции, включая бонусный:(1 − α^(γ+1)) / (1 − α). (Гл. 9)- Безубыточный черновик — максимальная стоимость черновика, при которой спекуляция ещё ускоряет:
T_draft < (E[N] − 1) × T_plain. (Гл. 9)
Приложение. Частые заблуждения
Зачем это приложение. Почти все ошибки в локальном инференсе — не в математике, а в постановке вопроса: считают гигабайты вместо гибибайтов, проверяют только веса, меряют скорость на пустом контексте и верят одному прогону. Здесь собраны типовые способы обмануть себя, с проверкой и правилом, как считать на самом деле.
За 30 секунд
- Сначала проверьте, что всё помещается и в одних ли единицах вы считаете.
- Потом посчитайте нижнюю границу и сравните с ней измерение, а не с прошлой версией конфига.
- Меняйте одно условие за раз и повторяйте замер; разница меньше 3–5% на домашнем железе — обычно шум.
- Любое «стало быстрее» проверяйте на времени задачи и качестве, а не только на ток/с.
Как пользоваться
Найдите свой симптом в указателе, прочитайте запись и проверьте число. Записи сгруппированы по темам, а не по важности.
Каждая запись устроена одинаково:
- Как думают — формулировка, которую легко принять за правду;
- Почему неверно — что именно упущено;
- Как правильно — формула, расчёт или эксперимент;
- Глава книги — где тема разобрана подробнее.
Ссылки вида «Боцзе Ли, гл. 1, §1.3.2» указывают на главу и раздел книги Bojie Li «AI Infra in Depth» (русский перевод community edition сохраняет нумерацию). Оттуда взяты идеи и классификация; текст пересказан и пересчитан под один компьютер, llama.cpp и MLX. Подробнее об атрибуции — в файле NOTICE в корне репозитория.
Note
Это не список «плохих практик» вообще, а каталог для самопроверки. Если симптом не совпал, начните с порядка анализа в шпаргалке: память → нижняя граница → измерение → разложение → одна гипотеза.
Указатель по симптомам
«Не влезло, хотя считал»
- «24 ГБ — это 24 ГиБ»
- «Веса поместились — значит, поместится и контекст»
- «После prefill всё помещалось, а к концу генерации — нет»
- «Купил память побольше — генерация станет быстрее»
- «Объединённая память Mac — это unlimited VRAM»
- «Выгрузка в ОЗУ всегда убивает скорость»
- «mmap ускоряет загрузку — значит, ускорит и генерацию»
- «Квантованный KV-кэш всегда безопасен»
«Генерация не ускорилась после…»
- «Скорость решает TFLOPS»
- «Удвоил TFLOPS — удвоил скорость декода»
- «У модели больше параметров — значит, она медленнее на токен»
- «Квант поменьше — всегда быстрее»
- «Поставил больше слотов — стало быстрее»
- «Включил спекуляцию — она всегда ускоряет»
- «Черновик подлиннее — выигрыш больше»
- «Взял черновик побыстрее — стало быстрее»
- «Сократил KV вчетверо — attention ускорился вчетверо»
«Бенчмарк показал X, а в жизни Y»
- «Скорость на пустом контексте — это скорость в работе»
- «В спецификации 400 ГБ/с — столько и получу»
- «Один прогон достаточно»
- «Синтетический повтор показывает реальный прирост»
- «N-граммы на повторяющемся промпте — честный замер»
- «Сравнили на одинаковом числе входных токенов — сравнение честное»
«Стало быстрее, но задача — нет»
- «Батч ускоряет каждый запрос»
- «Высокий ток/с — значит, ответ приходит быстро»
- «Ускорили декод — ускорили задачу»
- «Меньшая модель — всегда быстрее решает задачу»
- «Стало на 30% быстрее — оптимизация удалась»
- «MBU вырос с батчем — значит, чтение ускорилось»
- «GPU загружен на 40% — проблема в GPU»
- «Perplexity не выросла — качество не изменилось»
«Очередь и сервер»
- «Средней мощности хватает — очередь не вырастет»
- «Пропускная способность выросла — сервис стал лучше»
- «Чем больше слотов, тем лучше»
«Качество и квант»
- «Q4 — это ровно 4 бита»
- «Q4 у всех одинаковый»
- «Спекуляция улучшает качество»
Память и единицы
«24 ГБ — это 24 ГиБ»
Как думают. В спецификации карты написано 24 ГБ, значит, под модель есть 24 гибибайта. Модель на 21 ГБ «влезет с запасом 3 ГБ».
Почему неверно. Производитель пишет десятичные гигабайты (10⁹ байт), а операционная система, nvidia-smi и менеджер памяти часто показывают гибибайты (2³⁰ байт). Карта 24 ГБ — это 22,35 ГиБ, а не 24: 1,65 ГиБ уже нет. Если вычитать размер файла в ГБ из ёмкости в ГиБ и называть результат гибибайтами, ошибка накапливается: 16 ГБ (карта) − 4,2 ГБ = 11,8 «ГиБ», хотя реально 10,99 ГиБ — разница 0,8 ГиБ. На больших числах: 141 107 412 992 байт — это 141,11 ГБ и 131,42 ГиБ, разница 9,7 ГБ.
Как правильно. Переводите всё в байты или в ГиБ до сложения:
1 ГиБ = 1,073 741 824 байт ≈ 1,074 ГБ
24 ГБ = 22,35 ГиБ
16 ГБ = 14,90 ГиБ
12 ГБ = 11,18 ГиБ
4,2 ГБ = 3,91 ГиБ
Файл GGUF обычно показан в десятичных ГБ, а nvidia-smi — в МиБ/ГиБ. Не вычитайте одно из другого, не приведя к одной единице. Предельный случай: 141 107 412 992 байт — это 141,11 ГБ и 131,42 ГиБ; ошибка в 9,7 ГБ не видна, пока модель не перестанет помещаться.
Глава книги. Гл. 3, §3.1 и §3.7; Боцзе Ли, гл. 1, §1.2.3.
«Веса поместились — значит, поместится и контекст»
Как думают. Файл модели 7,9 ГБ, карта 12 ГБ — осталось 4 ГБ, контекст точно влезет.
Почему неверно. Кроме весов нужны KV-кэш на все слоты, вычислительные буферы, буферы батча и запас 1,5–2 ГБ, чтобы не уйти в системную память. KV растёт линейно с контекстом и умножается на число одновременных запросов.
Как правильно. Считайте бюджет целиком и в одних единицах:
вес + KV × слоты + буферы + запас ≤ доступная память
Пример: 13B в Q4_K_M (7,9 ГБ = 7,36 ГиБ), карта 12 ГБ (11,18 ГиБ), KV 128 КиБ на токен, буферы 0,75 ГиБ, запас 1,5 ГиБ.
8k: 7,36 + 1,00 + 0,75 + 1,50 = 10,61 ГиБ — помещается, запас 0,57 ГиБ
32k: 7,36 + 4,00 + 0,75 + 1,50 = 13,61 ГиБ — не помещается
То есть выбор не «влезет или нет», а «какой контекст и сколько слотов». Для 12-гигабайтной карты 32k на этой модели — уже другая карта или KV в q8_0.
Глава книги. Гл. 6, §6.2; гл. 13, §13.1; Боцзе Ли, гл. 1, §1.3.1 и гл. 8, §8.1.2.
«После prefill всё помещалось, а к концу генерации — нет»
Как думают. Запрос приняли, промпт обработали, память ещё есть — значит, до конца ответа хватит.
Почему неверно. KV-кэш растёт с каждым сгенерированным токеном. Ёмкость нужно проверять не после prefill, а в конце самого длинного ответа. Если резервировать только под промпт, к концу генерации начнутся вытеснения, повторный prefill или падение.
Как правильно. Резервируйте KV сразу на вход + максимальный выход − 1 токен, округляя до блока. В llama.cpp -c — это общий контекст, включая сгенерированные токены; в vLLM пул KV должен вмещать полную длину. Проверяйте пик под нагрузкой, а не сразу после загрузки.
Глава книги. Гл. 8, §8.3; гл. 12, §12.5; Боцзе Ли, гл. 8, §8.1.2.
«Купил память побольше — генерация станет быстрее»
Как думают. Версия Mac с 512 ГБ дороже и «мощнее», значит, декод будет быстрее версии с 256 ГБ.
Почему неверно. Ёмкость определяет, что поместится, а скорость декода — пропускная способность памяти. У двух конфигураций одного чипа она может быть одинаковой. В формуле R / β ёмкости нет: R — прочитанные байты, β — пропускная способность.
Как правильно. Смотрите в спецификации не объём, а ГБ/с. Больше памяти покупают ради большей модели, длинного контекста или нескольких слотов — не ради ток/с. Если модель уже помещается и пропускная способность та же, скорость не изменится.
Глава книги. Гл. 2, §2.4; гл. 3, §3.5; Боцзе Ли, гл. 4, §4.6.3.
«Объединённая память Mac — это unlimited VRAM»
Как думают. На Mac с 64 ГБ объединённой памяти можно загрузить 60 ГБ весов: память же общая.
Почему неверно. Часть памяти занята ОС, приложениями и проводником, а GPU-доступная доля ограничена настройками и политикой драйвера. Кроме того, пропускная способность делится между CPU и GPU. «Объединённая» не значит «бесплатная» и не значит «быстрая».
Как правильно. Оставляйте запас 8–12 ГБ на систему и считайте доступной не весь объём, а разумную долю. Проверьте, сколько реально резервирует Metal и сколько остаётся под KV. Для 96 ГБ в примере Боцзе Ли доступно около 81,4 ГиБ после вычета 8 ГиБ; разница между двумя квантами в 2,16 ГиБ решает, поместится ли ещё один контекст 8k.
Глава книги. Гл. 3, §3.5; Боцзе Ли, гл. 8, §8.4.1.
«Выгрузка в ОЗУ всегда убивает скорость»
Как думают. Если веса не в VRAM, их придётся гонять по PCIe на каждом токене — это в десятки раз медленнее, поэтому выгрузка бессмысленна.
Почему неверно. Есть два разных способа: гонять веса по PCIe и считать их на GPU или считать выгруженную часть на CPU прямо в ОЗУ. Второй быстрее, если ОЗУ быстрее PCIe, а для MoE выгружаются только активные эксперты. Именно так работает --n-cpu-moe: по шине идут активации размером с d_model, а не матрицы весов.
Как правильно. Сравните два времени для выгружаемого объёма S:
передача по PCIe: S / 25 ГБ/с
счёт на CPU: S / 60 ГБ/с
Для 8 ГБ это 320 мс против 133 мс — счёт на CPU примерно в 2,4 раза быстрее передачи. Но CPU слабее GPU по вычислениям, поэтому выигрыш есть не всегда: для prefill и для маленьких моделей выгрузка может проиграть. Меряйте на своей машине.
Глава книги. Гл. 3, §3.2; гл. 5, §5.5; Боцзе Ли, гл. 8, §8.4.3.
«mmap ускоряет загрузку — значит, ускорит и генерацию»
Как думают. mmap не читает файл целиком, модель стартует мгновенно, значит, это лучший режим и для работы.
Почему неверно. Для весов на GPU разница почти нулевая: они всё равно копируются в VRAM. Для весов, которые считаются на CPU, mmap означает подкачку страниц по мере обращения. Если рабочий набор не помещается в page cache, каждый токен ждёт диск, и prefill падает в разы.
Как правильно. Для постоянно работающего сервера загружайте модель в память явно: --load-mode none (в старых сборках — --no-mmap), при необходимости --mlock. Симптом обратного: свободная ОЗУ почти нулевая, диск активно читается, prefill в разы ниже расчёта. Тогда сначала проверьте режим загрузки, а не покупайте новую карту.
Глава книги. Гл. 3, §3.3; гл. 12, §12.2; Боцзе Ли, гл. 8, §8.4.1.
«Квантованный KV-кэш всегда безопасен»
Как думают. KV в q8_0 или q4_0 экономит память, а на качество почти не влияет — можно включать всем.
Почему неверно. Квантование KV меняет значения K и V, которые участвуют в attention на каждом шаге. Ошибка накапливается с длиной контекста и особенно заметна на структурированном выводе: JSON, вызовы инструментов, длинные таблицы. q8_0 обычно безопасен, q4_0 — уже эксперимент. При этом одинаковое число правильных ответов не означает одинаковые ответы: модель может ошибаться в других задачах.
Как правильно. Включайте KV-квантование только после прогона своих задач. Сравнивайте не только perplexity, но и долю валидного JSON, точность полей, завершаемость вызовов. Если качество просело, верните FP16 или q8_0 и уменьшите контекст/слоты.
Глава книги. Гл. 6, §6.8; Боцзе Ли, гл. 8, §8.4.4.
Скорость и roofline
«Скорость решает TFLOPS»
Как думают. У карты 50 TFLOP/s, у модели 7B — значит, она должна выдавать тысячи токенов в секунду. Чем больше TFLOP/s, тем быстрее.
Почему неверно. Декод упирается не в вычисления, а в чтение весов. На один токен приходится около 2N FLOP, но N × b байт чтения. При Q4_K_M арифметическая интенсивность I ≈ 2/0,6 ≈ 3,3 FLOP/байт, а точка перелома у карты с 50 TFLOP/s и 400 ГБ/с — I* = 125 FLOP/байт. До перелома — в 38 раз. Вычислительные блоки ждут память.
Как правильно. Считайте потолок по памяти:
ток/с ≤ пропускная способность / байт активных весов на токен
7B в Q4_K_M: 400 / 4,2 ≈ 95 ток/с теоретически, 50–70 реально. TFLOPS пригодятся для prefill, но не для интерактивного декода.
Глава книги. Гл. 2, §2.3; Боцзе Ли, предисловие (пять упускаемых ограничений) и гл. 1, §1.3.2.
«Удвоил TFLOPS — удвоил скорость декода»
Как думают. Новая карта вдвое мощнее по матрицам, значит, генерация станет вдвое быстрее.
Почему неверно. Время шага — максимум из времени вычислений и времени чтения, а не их сумма и не только вычисления. Для 7B Q4 на карте 50 TFLOP/s вычисления занимают около 0,28 мс, чтение 4,2 ГБ при 400 ГБ/с — 10,5 мс. Удвоение TFLOP/s сокращает 0,28 до 0,14 мс, то есть меньше 1,5% шага.
Как правильно. Сначала определите, что доминирует, и ускоряйте именно это. Если доминирует чтение, помогают меньший квант, больший батч (для throughput) или более быстрая память; TFLOP/s почти не помогают. Закон Амдала: выигрыш ограничен долей ускоряемой части.
Глава книги. Гл. 2, §2.3; Боцзе Ли, гл. 1, §1.3.2.
«У модели больше параметров — значит, она медленнее на токен»
Как думают. 35B всегда медленнее 8B, потому что параметров больше.
Почему неверно. У MoE на токен читаются только активные эксперты. 35B-A3B хранит 35B, но активирует около 3B: на токен читается ~1,8 ГБ в Q4_K_M против ~21 ГБ у плотной 35B — в 12 раз меньше. Поэтому MoE может быть быстрее плотной модели того же размера, хотя занимает столько же памяти.
Как правильно. Для скорости смотрите на активные параметры и на то, сколько разных экспертов вовлекается в батч. Для памяти — на все параметры. Это две разные величины, и обе нужны.
Глава книги. Гл. 5, §5.3; гл. 13, §13.3; Боцзе Ли, гл. 2, §2.4.2.
«Квант поменьше — всегда быстрее»
Как думают. Q2_K вдвое меньше Q4_K_M по битам, значит, декод вдвое быстрее.
Почему неверно. Реальный формат — не только биты данных: у k-quants есть масштабы и суперблоки, у Q2_K метаданные занимают около 24% объёма. Плюс распаковка перед умножением и эффективность конкретного ядра. Выигрыш меньше отношения битов, а на CPU может почти исчезнуть. И качество падает не линейно: на Q2 модель может стать заметно хуже на ваших задачах.
Как правильно. Сравнивайте размер файла и измеренную скорость, а не заявленные биты. Для Q2_K против Q4_K_M отношение данных около 4,8 / 2,6 ≈ 1,85, но с метаданными и накладными расходами реальный выигрыш обычно 1,2–1,6×. Если качество важно, Q4_K_M или IQ4_XS — более безопасная точка.
Глава книги. Гл. 4, §4.4; Боцзе Ли, гл. 8, §8.4.1.
«Средняя скорость по раундам — это среднее время на токен»
Как думают. Один раунд занял 1,5 мс и дал 1 токен, другой — 1,5 мс и 5 токенов. Среднее время на токен (1,5 + 1,5) / 2 = 1,5 мс.
Почему неверно. Раунды разные по числу токенов. Среднее по раундам даёт время раунда, а не токена. Правильно делить суммарное время на суммарное число токенов: 3 мс / 6 = 0,5 мс на токен. Разница в три раза.
Как правильно. Для любого агрегата:
среднее время на токен = сумма времени всех раундов / сумма токенов всех раундов
То же для запросов: суммируйте время и токены, а не усредняйте отношения. Иначе спекуляция и батчинг будут выглядеть хуже или лучше, чем есть.
Глава книги. Гл. 9, §9.8; Боцзе Ли, гл. 8, §8.5.2.
«Скорость на пустом контексте — это скорость в работе»
Как думают. llama-bench на -d 0 показал 40 ток/с, значит, так и будет на реальном промпте.
Почему неверно. На длинном контексте добавляется чтение KV и вычисление attention. Для 7B Q4 с KV 128 КиБ на токен нижняя граница шага растёт с 10,5 мс на пустом контексте до 13,2 мс на 8k и 21,2 мс на 32k при 400 ГБ/с. Плюс падает эффективность доступа. Скорость на глубине 32k может быть вдвое ниже, чем на нуле.
Как правильно. Меряйте на нескольких глубинах: 0, 8k, 16k, 32k — и берите ту, которая похожа на вашу нагрузку. В llama-bench это -d 0,8192,16384,32768; в серверных логах смотрите длину обработанного промпта.
Глава книги. Гл. 2, §2.6; гл. 12, §12.2; Боцзе Ли, гл. 8, §8.1.1.
«В спецификации 400 ГБ/с — столько и получу»
Как думают. Пиковая пропускная способность памяти указана в характеристиках, значит, декод упрётся ровно в неё.
Почему неверно. Пик — маркетинговое значение для идеального шаблона доступа. Реальные ядра читают блоками, с неполной загрузкой каналов, конкурируют с attention и служебными операциями. Достижимая пропускная способность обычно 60–80% пика, а скорость декода — 50–75% от потолка по памяти.
Как правильно. Берите не паспортные, а измеренные 70–80% и ещё раз умножьте на 0,7–0,8 на накладные расходы. Если нужна точность — измерьте копированием большого буфера или сравните с llama-bench на вашей модели.
Глава книги. Гл. 2, §2.4; Боцзе Ли, гл. 1, §1.3.3–1.3.4.
«Сократил KV вчетверо — attention ускорился вчетверо»
Как думают. GQA уменьшает KV-кэш в четыре раза, значит, и внимание станет в четыре раза быстрее.
Почему неверно. GQA сокращает объём хранения и чтения K/V, но каждая Q-голова по-прежнему считает оценки внимания. Вычисления attention зависят от числа Q-голов и длины контекста, а не только от размера KV. MLA меняет и ширину состояния, и место повышающей проекции. На коротком контексте attention вообще не главное — доминирует чтение весов.
Как правильно. Считать отдельно: байты KV на токен (память и чтение) и FLOPs attention (вычисления). Если доминирует чтение KV, помогает GQA/MLA, окно или сжатие; если вычисления — число Q-голов и длина. Это разные рычаги.
Глава книги. Гл. 6, §6.3–6.4; Боцзе Ли, гл. 2, §2.3.1.
Батчинг, задержка и очередь
«Батч ускоряет каждый запрос»
Как думают. Собрали 8 запросов в батч — каждый поедет в 8 раз быстрее, ведь веса читаются один раз.
Почему неверно. Батч повышает суммарную пропускную способность, но не уменьшает время шага отдельного запроса. В примере Боцзе Ли батч 8 даёт 816 ток/с против 116 у одного, но время между токенами растёт с 8,6 до 9,8 мс, а TTFT — из-за ожидания набора батча. Каждый запрос ждёт соседей.
Как правильно. Разделяйте метрики: throughput (ток/с на сервер) и latency (TTFT, ITL одного запроса). Для интерактивного чата важна задержка, для пакетной обработки — пропускная способность. Не включайте батч «для скорости», если пользователь ждёт первый токен.
Глава книги. Гл. 8, §8.1; Боцзе Ли, гл. 1, §1.3.2 и гл. 8, §8.2.1.
«Высокий ток/с — значит, ответ приходит быстро»
Как думают. Сервер выдаёт 40 ток/с, ответ на 500 токенов придёт за 12,5 секунды.
Почему неверно. Это верно только для декода после первого токена. Полное время — TTFT + ITL × (N − 1). Если промпт 8000 токенов обрабатывается со скоростью 1000 ток/с, TTFT ≈ 8 с, и ответ на 500 токенов займёт около 20,5 с, а не 12,5. Воспринимаемая скорость — 24 ток/с, хотя декод идёт на 40.
Как правильно. Считайте TTFT и ITL отдельно, а полное время — как сумму. Для длинных промптов и агентов TTFT часто важнее ток/с; для длинных ответов — ITL. Одна цифра «ток/с» не описывает сервис.
Глава книги. Гл. 2, §2.8; гл. 8, §8.1; Боцзе Ли, предисловие и гл. 8, §8.1.3.
«Ускорили декод — ускорили задачу»
Как думают. Генерация стала в четыре раза быстрее, значит, задача выполнится в четыре раза быстрее.
Почему неверно. Задача состоит из prefill, декода, вызовов инструментов, ожидания и повторов. Если декод занимал половину времени, ускорение в 4 раза даёт общее ускорение 1 / (0,5 + 0,5/4) = 1,6×, а не 4×. Если декод — только 20%, выигрыш 1,18×. Закон Амдала.
Как правильно. Сначала измерьте доли этапов на реальной задаче, потом считайте предел:
S = 1 / ((1 − f) + f / s)
где f — доля ускоряемого этапа, s — его локальное ускорение. Оптимизируйте критический путь, а не самый удобный этап.
Глава книги. Гл. 12, §12.7; Боцзе Ли, гл. 8, §8.6.3.
«Меньшая модель — всегда быстрее решает задачу»
Как думают. 3B быстрее 30B, значит, и документ она обработает быстрее.
Почему неверно. Меньшая модель может чаще ошибаться, требовать больше шагов, повторов и проверок. Время до принятого результата включает неудачные попытки. Быстрый, но неправильный первый ответ может удлинить задачу.
Как правильно. Сравнивайте время и стоимость на принятую задачу, а не на токен:
время на успех = суммарное время всех попыток / число успешных задач
Плюс доля завершённых и качество. Модель, которая решает 19 из 20 задач за 10 с, лучше модели, которая решает 12 из 20 за 5 с.
Глава книги. Гл. 13, §13.12; гл. 12, §12.6; Боцзе Ли, гл. 3, §3.2.
«Стало на 30% быстрее — оптимизация удалась»
Как думают. Новая версия на 30% быстрее старой, значит, мы близки к пределу.
Почему неверно. Без нижней границы неизвестно, 30% — это много или мало. Если предел 10 мс, а было 30, стало 21 — вы всё ещё в три раза хуже предела, и 30% могли прийти из одной накладной расходной части, которую можно убрать целиком. Если предел 20, а было 21, стало 16 — вы уже у предела, и дальнейшие 30% невозможны.
Как правильно. Сначала посчитайте нижнюю границу для тех же условий, потом считайте MBU = граница / измерение. 30% имеют смысл только вместе с этой парой. И проверяйте, не ускорился ли только удобный этап.
Глава книги. Гл. 12, §12.7; Боцзе Ли, предисловие и гл. 1, §1.3.4.
«MBU вырос с батчем — значит, чтение ускорилось»
Как думают. Эффективность памяти выросла с 33% до 65%, значит, память стала читать быстрее.
Почему неверно. MBU — отношение нижней границы к измеренному времени. С ростом батча постоянная часть раунда (запуск ядер, планирование, синхронизация) делится на большее число байтов, и отношение растёт, хотя чтение каждого байта не ускорилось. Абсолютное время шага при этом увеличивается.
Как правильно. Смотрите на абсолютные миллисекунды и байты, а не только на отношение. Если при росте батча время шага почти не меняется, а MBU растёт — вы распределяете фиксированные накладные расходы, а не ускоряете память. Лечится это CUDA Graph/планированием, а не «более быстрой памятью».
Глава книги. Гл. 12, §12.7; Боцзе Ли, гл. 8, §8.6.3.
«GPU загружен на 40% — проблема в GPU»
Как думают. nvidia-smi показывает 40% загрузки, значит, карта слабая или драйвер плохой.
Почему неверно. Низкая загрузка часто означает, что GPU ждёт: хост не успевает отправлять ядра, данные идут по PCIe, очередь пуста, или часть работы считается на CPU. Утилизация — не диагноз, а симптом. Те же 40% могут быть у совершенно разных задач с разными причинами.
Как правильно. Смотрите на временную шкалу: есть ли разрывы между ядрами, сколько времени занимает запуск, совпадает ли рост задержки с prefill другого запроса, не заполнен ли пул KV. Считайте MBU/MFU и сравнивайте с границей. Утилизация нужна только как первый признак, что что-то не так.
Глава книги. Гл. 12, §12.5; Боцзе Ли, гл. 1, §1.3.4 и гл. 5, §5.6.
«Средней мощности хватает — очередь не вырастет»
Как думают. Средняя нагрузка 8 запросов/с, сервер держит 10 — запас 20%, очередь не появится.
Почему неверно. Очередь определяется не средним, а всплесками и временем пребывания. Если запросы приходят пачками, даже при средней загрузке 80% очередь может расти. Закон Литтла: N = λ × T; при λ = 8 и T = 12 с в системе уже 96 запросов, и каждому нужно место под KV. Средняя мощность не переносится из спокойной минуты в пиковую.
Как правильно. Считайте загрузку по окнам, а не по среднему; проверяйте λ × T и память под всех одновременно живущих; держите запас по мощности заметно ниже 1 (часто 0,6–0,8), а не «ровно хватает». При всплесках помогает допуск, отмена и ограничение приёма.
Глава книги. Гл. 8, §8.4; Боцзе Ли, гл. 3, пример 3-1 и гл. 8, §8.6.1.
«Пропускная способность выросла — сервис стал лучше»
Как думают. Сервер стал завершать 2,4 запроса/с вместо 1,2 — значит, пользователи стали получать ответы лучше.
Почему неверно. Завершение не равно пригодному ответу. Часть ответов неправильная, часть не уложилась в срок, часть — повторы. Если принять больше запросов, чем сервер успевает качественно обслужить, эффективная пропускная способность падает: в примере Боцзе Ли рост поступления с 4 до 16 запросов/с поднял завершения с 2,33 до 2,38, а эффективную пропускную способность снизил с 1,02 до 0,60 запроса/с.
Как правильно. Считайте эффективную пропускную способность:
R_good = число правильных и вовремя завершённых задач / время наблюдения
И только потом сравнивайте конфиги. Рост завершений без качества и SLO — не улучшение.
Глава книги. Гл. 12, §12.6; Боцзе Ли, гл. 8, §8.6.2.
«Чем больше слотов, тем лучше»
Как думают. Поставлю -np 8, сервер будет обслуживать восемь пользователей одновременно, и всем станет быстрее.
Почему неверно. Каждый слот — свой KV-кэш. При 32k и 128 КиБ на токен это 4 ГиБ на слот; восемь слотов — 32 ГиБ только под KV, плюс веса. Если пользователей меньше, лишние слоты просто занимают память и могут вытеснить модель. А при одном пользователе параллелизм не даёт ничего.
Как правильно. Считайте слоты × KV на токен × контекст и сравнивайте с бюджетом. Для одного пользователя — -np 1. Для нескольких — столько слотов, сколько реально приходит одновременно, с запасом по памяти. Проверяйте, не делится ли общий -c между слотами в вашей сборке.
Глава книги. Гл. 8, §8.3; Боцзе Ли, гл. 8, §8.1.2 и §8.3.1.
Квантование и качество
«Q4 — это ровно 4 бита»
Как думают. Q4_K_M — четырёхбитный квант, значит, 7B-модель весит 7 × 4 / 8 = 3,5 ГБ.
Почему неверно. «Q4» — название семейства, а не точное число бит. У Q4_K_M среднее около 4,8 бита на вес: часть тензоров хранится в 4 битах, часть — в 5–6, плюс масштабы блоков и сжатые масштабы суперблоков. Для 7B это около 4,2 ГБ, а не 3,5 — на 20% больше идеальных четырёх бит.
Как правильно. Берите размер готового файла или считайте по bpw:
байт ≈ параметры × bpw / 8
7B × 4,8 / 8 = 4,2 ГБ
Идеальные 4 бита (3,5 ГБ) — только нижняя граница, которой в GGUF почти не бывает. Для памяти и скорости важна реальная bpw, а не цифра в названии.
Глава книги. Гл. 4, §4.3–4.4; Боцзе Ли, гл. 8, §8.4.1.
«Q4 у всех одинаковый»
Как думают. Любой файл с «Q4» в названии даст одинаковый размер, скорость и качество.
Почему неверно. Q4_0, Q4_K_S, Q4_K_M, IQ4_XS и динамические UD- кванты — разные форматы с разным числом бит, разными метаданными и разной обработкой важных тензоров. Размер файла может отличаться на 5–10%, а качество на конкретных задачах — заметно. Imatrix меняет распределение ошибки, а не только размер.
Как правильно. Сравнивайте конкретный файл: имя, bpw, размер в байтах, хеш. Проверяйте на своих задачах, а не по названию. Для одного и того же размера предпочитайте формат, который лучше проходит ваш набор, а не самый популярный.
Глава книги. Гл. 4, §4.4–4.6; Боцзе Ли, гл. 8, §8.4.1.
«Perplexity не выросла — качество не изменилось»
Как думают. У кванта та же perplexity, что у FP16, значит, можно не проверять задачи.
Почему неверно. Perplexity — средняя по тексту; она может не заметить редкие, но важные ошибки: сломанный JSON, перепутанные поля, пропущенную скобку, неверный вызов инструмента. В примере Боцзе Ли два конфига дали одинаковое число правильных ответов, но ошибались в разных задачах. Для агента это критично.
Как правильно. Проверяйте метрики задачи: долю валидного JSON, точность извлечения, завершаемость tool calling, число шагов. Perplexity оставьте как быстрый фильтр, а решение принимайте по 20–50 своим задачам.
Глава книги. Гл. 4, §4.5; Боцзе Ли, гл. 8, §8.4.4.
Спекулятивное декодирование
«Спекуляция всегда ускоряет»
Как думают. Черновик предлагает токены, целевая модель проверяет их за один проход — значит, генерация всегда быстрее.
Почему неверно. Выигрыш зависит от acceptance rate α и стоимости черновика. Если черновик угадывает редко или стоит дорого, вы платите за него и за проверку, но получаете мало. При α = 0,5, γ = 4, стоимости черновика d = 0,3 шага целевой модели ускорение 1,94 / (1 + 1,2) ≈ 0,88 — то есть замедление.
Как правильно. Считайте ожидаемое число токенов за раунд и условие окупаемости:
E[N] = 1 + α + α² + ... + α^γ = (1 − α^(γ+1)) / (1 − α)
speedup ≈ E[N] / (1 + γ × d)
окупается, если d < (E[N] − 1) / γ
Для α = 0,5, γ = 4: E[N] ≈ 1,94, d < 0,234. Если черновик дороже 23,4% шага — он не окупается. Меряйте α на своём трафике.
Глава книги. Гл. 9, §9.3; Боцзе Ли, гл. 8, §8.5.2.
«Черновик подлиннее — выигрыш больше»
Как думают. Если γ = 4 даёт ускорение, то γ = 8 даст вдвое больше.
Почему неверно. Каждый дополнительный токен черновика стоит времени и проверки, а принимается всё реже: вклад падает как α^γ. После оптимума кривая идёт вниз. При α = 0,6, d = 0,1 ускорение для γ = 2, 3, 4 равно примерно 1,63, 1,67, 1,65 — оптимум около 3, и разница мала.
Как правильно. Удлинять черновик, пока прирост токенов оправдывает прирост времени:
ΔT / ΔN < T / N
То есть дополнительный токен должен стоить меньше среднего тока. На структурированном выводе оптимум выше, на свободной прозе — ниже. Подбирайте по α, а не по «больше = лучше».
Глава книги. Гл. 9, §9.4; Боцзе Ли, гл. 8, §8.5.4.
«Взял черновик побыстрее — стало быстрее»
Как думают. Черновик стал генерировать быстрее, значит, и общая скорость выросла.
Почему неверно. Важна не скорость черновика сама по себе, а число токенов, которое он приносит за раунд. Более быстрый черновик может хуже угадывать: раунд короче, но E[N] меньше, и на токен выходит дороже. В примере Боцзе Ли параллельный черновик за 3,57 мс приносит 3 токена за раунд и 9,9 мс на токен, а последовательный за 14,28 мс — 13,5 мс на токен. Но если параллельный черновик приносит только 2 токена, он даёт 14,9 мс на токен и проигрывает последовательному.
Как правильно. Сравнивайте время на выходной токен:
T_token ≈ T_round / E[N]
где T_round включает черновик и проверку. Черновик выгоден, если уменьшает T_round / E[N], а не если быстрее работает сам.
Глава книги. Гл. 9, §9.6; Боцзе Ли, гл. 8, §8.5.3.
«N-граммы на повторяющемся промпте — честный замер»
Как думают. N-граммный черновик на тесте с одним и тем же промптом даёт acceptance 0,95 и ускорение 3× — отличный результат.
Почему неверно. На повторяющемся тексте n-граммы почти всегда попадают, потому что последовательность уже встречалась. На новом тексте acceptance падает до 0,3–0,6, а иногда ниже. Вы измерили кэш и повтор, а не метод.
Как правильно. Тестируйте на отложенных реальных запросах, которые не встречались в промпте. Отдельно измеряйте холодный и горячий кэш. Если хочется синтетики, генерируйте разные тексты, а не гоняйте один и тот же.
Глава книги. Гл. 9, §9.8; гл. 12, §12.7; Боцзе Ли, гл. 8, §8.5.3.
«Спекуляция улучшает качество»
Как думают. Целевая модель проверяет больше токенов, значит, ответ станет точнее.
Почему неверно. Спекуляция сохраняет распределение целевой модели: при T = 0 ответ тот же (с точностью до порядка вычислений), при T > 0 — та же статистика. Она не добавляет знаний и не исправляет ошибки модели. Это ускорение, а не улучшение.
Как правильно. Оценивайте спекуляцию по скорости и acceptance, а качество проверяйте отдельно — оно не должно измениться. Если ответы стали «лучше», это шум или другой сэмплинг, а не заслуга метода.
Глава книги. Гл. 9, §9.1–9.2; Боцзе Ли, гл. 8, §8.5.1.
Измерения
«Один прогон достаточно»
Как думают. Первый замер показал 41 ток/с, второй конфиг — 43, значит, второй лучше.
Почему неверно. На потребительском железе разброс легко достигает 10–20%: троттлинг, фон, кэш, разная длина ответов. Разница 5% меньше шума. Один прогон не отличает эффект от случайности.
Как правильно. Минимум 3–5 повторов, медиана и разброс; сравнивайте на одних и тех же промптах; для двух конфигов лучше чередовать запуски и считать медиану парной разницы. Эффект меньше 3–5% на домашнем железе считайте недоказанным.
Глава книги. Гл. 12, §12.4 и §12.12; Боцзе Ли, гл. 1, §1.3.3.
«Синтетический повтор показывает реальный прирост»
Как думают. Прогнал один и тот же промпт десять раз, получил красивый график — можно переносить на продакшн.
Почему неверно. Повтор прогревает кэш промпта, n-граммный пул и страницы памяти. В жизни запросы разные, префиксы меняются, а кэш может не попасть. Синтетика годится для сравнения конфигов на одинаковых условиях, но не для предсказания времени задачи.
Как правильно. Держите два набора: синтетический (для контроля переменных) и реальный (для решения). Отдельно измеряйте холодный и горячий кэш. Решение принимайте по реальному набору, а синтетику используйте, чтобы понять причину.
Глава книги. Гл. 12, §12.1 и §12.7; Боцзе Ли, гл. 8, §8.3.3.
«Сравнили на одинаковом числе входных токенов — сравнение честное»
Как думают. Дали двум моделям по 4000 входных токенов, значит, условия одинаковые.
Почему неверно. У разных моделей разные токенизаторы: один и тот же текст может дать 3500 и 4500 токенов. Одинаковое число токенов — не одинаковый объём работы и не одинаковый смысл. Сравнение по токенам годится для ресурсов, но не для качества.
Как правильно. Фиксируйте один и тот же текст задачи и критерий приёмки, а ресурсы считайте на принятый результат. Сравнивайте время, стоимость и качество на задачу, а не на токен.
Глава книги. Гл. 13, §13.2; Боцзе Ли, гл. 2, §2.6.3.
Посчитай сам
Задача 1. Карта 16 ГБ, модель 13B в Q4_K_M (7,9 ГБ), KV 128 КиБ на токен, буферы 0,75 ГБ, запас 1,5 ГБ. Поместится ли контекст 16k в одном слоте? А 32k?
Решение
16 ГБ = 14,90 ГиБ; 7,9 ГБ = 7,36 ГиБ
16k KV: 16 384 × 128 КиБ = 2 ГиБ
итого 16k: 7,36 + 2,00 + 0,70 + 1,40 ≈ 11,46 ГиБ — помещается с запасом ~3,4 ГиБ
32k KV: 4 ГиБ → 7,36 + 4,00 + 0,70 + 1,40 ≈ 13,46 ГиБ — помещается, запас ~1,4 ГиБ
На 16 ГБ оба варианта влезают, но 32k оставляет меньше запаса. Если добавить второй слот, 32k уже не поместится: 7,36 + 8 + 0,7 + 1,4 = 17,46 ГиБ.
Задача 2. Модель 8B в Q4_K_M (около 4,2 ГБ активных весов), KV 128 КиБ на токен, пропускная способность 400 ГБ/с. При каком батче чтение KV сравняется с чтением весов на контексте 8k? А на 32k?
Решение
8k: L × k = 8192 × 128 КиБ = 1 ГиБ ≈ 1,074 ГБ
b* = 4,2 / 1,074 ≈ 3,9 → 4 запроса
32k: L × k = 4 ГиБ ≈ 4,295 ГБ
b* = 4,2 / 4,295 ≈ 0,98 → уже при одном запросе KV читается больше весов
На 8k батч до 4 запросов ещё снижает байты на токен; дальше выигрыш почти исчезает. На 32k батч не помогает по памяти: каждый запрос приносит свой KV, и чтение KV сразу доминирует. Это верхняя оценка «по байтам»; реальная точка зависит от attention и раскладки.
Задача 3. Черновик γ = 4, acceptance α = 0,7, шаг целевой модели 28 мс, черновик стоит 5 мс на токен. Окупается ли спекуляция? Каков бюджет на черновик?
Решение
E[N] = (1 − 0,7^5) / 0,3 = (1 − 0,168) / 0,3 ≈ 2,77
раунд = 28 + 4 × 5 = 48 мс
на токен = 48 / 2,77 ≈ 17,3 мс против 28 мс → ускорение ≈ 1,62×
бюджет на весь черновик = (2,77 − 1) × 28 ≈ 49,6 мс
бюджет на токен черновика = 49,6 / 4 ≈ 12,4 мс
Черновик за 5 мс на токен окупается с большим запасом. Если он подорожает до 13 мс на токен, спекуляция перестанет помогать.
Ключевые идеи
- Сначала единицы и бюджет памяти: вес + KV на все слоты + буферы + запас.
- Скорость декода считайте по пропускной способности памяти, а не по TFLOPS.
- Батч повышает throughput, но не ускоряет отдельный запрос; выгода кончается, когда чтение KV догоняет чтение весов.
- Спекуляция окупается только при достаточном acceptance и дешёвом черновике.
- Любое «быстрее» проверяйте против нижней границы, на реальных задачах и с повторами.
Источники
- Bojie Li, «AI Infra in Depth: Quantitative Analysis and System Design» — GitHub, Apache-2.0. Главы 1–8: оценки памяти, roofline, батчинг, KV, спекуляция и измерение.
- Русский перевод community edition — GitHub, Apache-2.0. Та же нумерация глав и разделов; использован для сверки терминов.
- Скилл «Designing AI Infra» — GitHub, Apache-2.0. Каталог заблуждений и плейбук диагностики сервинга, переработанные здесь под локальный масштаб.
Приложение. Порядок анализа: шпаргалка
Зачем это приложение. Когда генерация медленная, хочется сразу крутить флаги. Правильный порядок другой: сначала проверить, что всё помещается, потом посчитать нижнюю границу, затем измерить и только после этого искать причину. Эта страница — короткий маршрут по книге на один экран.
За 30 секунд
- Сначала память, потом время: если не помещается, считать скорость бессмысленно.
- Любое измерение сравнивайте с нижней границей, а не с прошлой версией конфига.
- Разложите время на очередь, prefill, decode и число шагов — и лечите тот отрезок, который вырос.
- Меняйте одно условие за раз; иначе не узнаете, что помогло.
Порядок анализа
flowchart TB
A["0. Задача и SLO:<br/>что считается успехом?"] --> B["1. Память:<br/>вес + KV + буферы + запас<br/>≤ доступная память?"]
B -->|"нет"| B1["Уменьшить модель, контекст,<br/>слоты или квант"]
B -->|"да"| C["2. Нижняя граница:<br/>max(вычисления, чтение)<br/>на тех же условиях"]
C --> D["3. Измерение:<br/>TTFT, ITL, полное время,<br/>пик VRAM, качество"]
D --> E["4. Разложение:<br/>какой отрезок вырос —<br/>очередь, prefill, decode,<br/>число шагов, вне модели?"]
E --> F["5. Одна гипотеза —<br/>одно изменённое условие"]
F --> G{"Эффект больше шума<br/>и качество не упало?"}
G -->|"да"| H["Новая базовая линия"]
G -->|"нет"| I["Отрицательный результат<br/>тоже в отчёт"]
H --> C
I --> C
| Шаг | Вопрос | Что считать | Что обычно забывают | Глава |
|---|---|---|---|---|
| 0 | Что считается успехом? | TTFT, ITL, полное время, доля правильных и завершённых, бюджет | throughput без SLO и качества ничего не говорит о пригодности | 12 |
| 1 | Помещается ли? | вес + KV × слоты + буферы + запас ≤ память, всё в одних единицах | KV на конец генерации, а не после prefill; ГБ против ГиБ; запас 1,5–2 ГБ | 3, 6, 13 |
| 2 | Быстрее чего нельзя? | T ≥ max(2N_active × B / Π, (W + b × C × k) / β) | чтение KV вдобавок к весам; пик не той точности; достижимая, а не паспортная пропускная способность | 2, 8 |
| 3 | Насколько далеко от предела? | MBU = T_lower / T_measured, MFU = T_compute / T_measured | одинаковые определения метрик; один прогон; холодный и горячий кэш | 12 |
| 4 | Какой отрезок вырос? | очередь + prefill + ITL × шаги + время вне модели | очередь при неизменном ITL; заполненный пул KV; вставка чужого prefill; инструменты и сеть | 8, 12 |
| 5 | Что менять? | одна гипотеза, один параметр, чередующиеся пары, медиана разницы | несколько изменённых условий сразу; сравнение «медиана против медианы» вместо парной разницы | 12 |
Warning
Нижняя граница — не прогноз и не обещание скорости. Это время, быстрее которого шаг физически невозможен. Реальное время всегда больше; задача анализа — объяснить, насколько и почему, а не «догнать предел».
Пять ограничений, которые упускают
Это те же пять пунктов, на которых чаще всего ломаются оценки, но пересказанные для одной машины (Боцзе Ли, предисловие; см. sources.md):
- Учли только веса. На каждом шаге attention читает KV всех токенов контекста. На 8k это может быть 1 ГиБ, на 32k — 4 ГиБ; при больших батчах чтение KV сравнивается с весами.
- Посчитали время, но не проверили ёмкость. Веса, KV всех слотов, буферы и запас должны поместиться вместе, и в конце генерации, а не только после загрузки.
- Взяли пиковые FLOP/s. Если память не успевает подавать данные, вычисления ждут. Время — максимум из вычислений и чтения; для декода почти всегда чтение.
- Разделили работу на N и решили, что время уменьшится в N раз. При выгрузке в ОЗУ и нескольких GPU появляется канал: PCIe, NVLink или сеть. Его время не делится на N и может стать критическим путём.
- Получили высокий throughput и забыли задержку. Батч повышает ток/с на сервер, но каждый запрос ждёт очередь и соседей. Пропускную способность и TTFT/ITL указывают вместе.
Рычаг под доминирующий член
| Доминирует | Помогает | Не помогает | Глава |
|---|---|---|---|
| Чтение весов (декод, батч 1) | меньше байт (квант), больше пропускная способность, батч до b* | больше TFLOPS, больше ёмкости | 2, 4 |
| Чтение KV (длинный контекст, много слотов) | GQA/MLA, окно, сжатие KV, общий префикс | батч: KV каждого запроса читается отдельно | 6, 8 |
| Вычисления (prefill, большой батч) | больше FLOP/s нужной точности, меньше токенов, блочный prefill | больше пропускной способности памяти | 2, 8 |
| Очередь | загрузка ниже 1, допуск, отмена, ограничение приёма | рост средней мощности без учёта всплесков | 8 |
| Запуск ядер и хост | CUDA Graph, меньше синхронизаций, крупнее батч | более быстрая карта | 8, 12 |
| Выгрузка в ОЗУ/PCIe | считать на CPU, меньше выгруженных слоёв, быстрее канал | больше VRAM без изменения раскладки | 3, 5 |
Вопрос → формула → глава
| Вопрос | Формула | Глава |
|---|---|---|
| Сколько весит модель? | байт ≈ N × bpw / 8; Q4_K_M — около 4,8 бита | 4 |
| Сколько места под KV? | KV = 2 × L_full × n_kv_heads × d_head × C × bytes | 6 |
| Влезет ли всё? | W + KV × слоты + буферы + запас ≤ M | 13 |
| Потолок декода? | ток/с ≤ β / W_active | 2 |
| Нижняя граница шага? | T ≥ max(2N_active × B / Π, (W + b × C × k) / β), B = b для декода, B = P для prefill | 2, 8 |
| Когда батч перестаёт помогать? | b* = W / (C × k); минимальный целый — округлением вверх; дальше чтение KV догоняет веса | 8 |
| TTFT? | TTFT ≈ очередь + prefill + один шаг decode | 2 |
| Полное время ответа? | T = TTFT + Σ ITL | 2 |
| Сколько запросов в системе? | N = λ × T (закон Литтла) | 8 |
| Сколько токенов даёт спекуляция? | E[N] = (1 − α^(γ+1)) / (1 − α) | 9 |
| Окупается ли черновик? | E[N] > 1 + γ × d, или d < (E[N] − 1) / γ | 9 |
| Ускорение задачи? | S = 1 / ((1 − f) + f / s) | 12 |
| Эффективная пропускная способность? | R_good = правильные и вовремя / время | 12 |
| Насколько мы далеки от предела? | MBU = T_lower / T_measured | 12 |
Пример на салфетке
Дано: плотная 8B в Q4_K_M (W = 4,2 ГБ), контекст 8k, KV k = 128 КиБ/токен, карта β = 400 ГБ/с, измерено 32 ток/с.
KV на 8k: 8192 × 128 КиБ = 1 ГиБ ≈ 1,074 ГБ
нижняя граница: (4,2 + 1,074) / 400 = 13,2 мс
измерено: 1000 / 32 = 31,25 мс
MBU: 13,2 / 31,25 ≈ 0,42
разрыв: 31,25 − 13,2 ≈ 18 мс
18 мс почти не зависят от объёма — похоже на накладные расходы шага (запуск ядер, хост, синхронизация), но это гипотеза, а не доказательство. Проверка одним условием: включить CUDA Graph или Metal-граф и посмотреть, уменьшится ли разрыв. Если да — причина в запуске; если нет — искать очередь, кэш экспертов или выгрузку. Второе условие — поднять контекст до 32k: нижняя граница вырастет на 3 × 1,074 / 400 ≈ 8,1 мс. Если измерение выросло примерно на столько же, виновато чтение KV; если почти не выросло — разрыв фиксированный.
Чек-лист перед выводом
- Все единицы приведены к байтам или ГиБ.
- Посчитан KV на все слоты и на конец генерации.
- Нижняя граница посчитана для той же модели, кванта, контекста и батча.
- Понятно, какой отрезок вырос: очередь, prefill, ITL, число шагов или время вне модели.
- Изменено одно условие; замеров 3–5; есть медиана и разброс.
- Проверено качество, а не только ток/с.
- Записан отрицательный результат и версия рантайма.
Источники
- Bojie Li, «AI Infra in Depth» — GitHub, Apache-2.0: порядок анализа, пять упускаемых ограничений, нижняя граница и разложение разрыва.
- Русский перевод community edition — GitHub, Apache-2.0.
- Скилл «Designing AI Infra» — GitHub, Apache-2.0: шпаргалка и плейбук
diagnose-serving, адаптированные под локальный сервер.
Источники
Аннотированная библиография книги. Ссылки проверены на момент написания: для статей — через arXiv, для курсов и документации — через HTTP-доступ, для видео — через YouTube oEmbed (название и канал). Где источник самозаявленный (карточка модели, блог вендора, документация проекта), это указано.
Уровни:
- новичок — можно читать без специальной подготовки;
- средний — нужно понимать трансформеры и базовую математику;
- продвинутый — нужны системы, CUDA или глубокое знание архитектур.
Курсы
- Stanford CS336: Language Modeling from Scratch — Stanford, 2024–2026. stanford-cs336.github.io. Уровень: продвинутый. Зачем: полный путь от токенизации и трансформера до обучения и масштабирования; задания заставляют писать код, а не только читать.
- Stanford CS224n: Natural Language Processing with Deep Learning — Stanford, 2024–2025. web.stanford.edu/class/cs224n. Уровень: средний. Зачем: классический курс по NLP и трансформерам; полезен для понимания attention и эмбеддингов.
- CMU 11-868: Large Language Model Systems — Lei Li, CMU, Fall 2026. llmsystem.github.io. Уровень: продвинутый. Зачем: GPU-программирование, kernels, serving, quantization, paged attention; ближе всего к теме этой книги.
- MIT 6.5940: TinyML and Efficient Deep Learning Computing — Song Han, MIT, Fall 2024. hanlab.mit.edu. Уровень: продвинутый. Зачем: эффективные модели, квантование, pruning, ускорение inference.
- Hugging Face LLM Course — Hugging Face, постоянно обновляется. huggingface.co/learn/llm-course. Уровень: новичок. Зачем: практическое введение в модели, токенизаторы и fine-tuning.
- Hugging Face Agents Course — Hugging Face, 2025. huggingface.co/learn/agents-course. Уровень: средний. Зачем: практика агентов, инструментов и оркестрации.
Книги
- Dive into Deep Learning — Aston Zhang, Zachary Lipton, Mu Li, Alex Smola, 2023. d2l.ai. Уровень: новичок–средний. Зачем: бесплатный учебник с кодом; главы про attention и трансформеры хорошо дополняют главу 1.
- Speech and Language Processing (3-е изд., черновик) — Daniel Jurafsky, James Martin, 2024–2026. web.stanford.edu/~jurafsky/slp3. Уровень: средний. Зачем: фундаментальный учебник по NLP; разделы про языковые модели и decoding.
- Deep Learning — Ian Goodfellow, Yoshua Bengio, Aaron Courville, 2016. deeplearningbook.org. Уровень: средний–продвинутый. Зачем: база по нейросетям, оптимизации и представлениям; местами устарела, но фундамент хороший.
- The Little Book of Deep Learning — François Fleuret, 2023. PDF. Уровень: новичок. Зачем: короткое и плотное введение; хороший «освежитель» перед курсом.
- Build a Large Language Model (From Scratch) — Sebastian Raschka, Manning, 2024. manning.com. Уровень: средний. Зачем: пошаговая реализация GPT; связывает теорию с кодом.
- Hands-On Large Language Models — Jay Alammar, Maarten Grootendorst, O'Reilly, 2024. O'Reilly. Уровень: новичок–средний. Зачем: визуальное введение в LLM и практические примеры; страница может требовать подписки.
- AI Engineering — Chip Huyen, O'Reilly, 2025. huyenchip.com/books. Уровень: средний. Зачем: как строить приложения на моделях: оценка, RAG, агенты, эксплуатация.
- Designing Machine Learning Systems — Chip Huyen, O'Reilly, 2022. huyenchip.com/books. Уровень: средний. Зачем: системное мышление про данные, деплой и мониторинг; полезно для серверной части.
- «AI Infra in Depth: Quantitative Analysis and System Design» — Bojie Li (Боцзе Ли), 2026, Apache-2.0. GitHub. Уровень: продвинутый. Зачем: следующий уровень после одного ПК — количественные оценки памяти и roofline, батчинг и KV, несколько GPU и сеть, распределённый инференс, обучение. Из неё адаптированы §12.7, приложения о заблуждениях и порядке анализа, метрики TTFT/ITL, закон Литтла,
b*,E[N]и безубыточный черновик. - «AI-инфраструктура изнутри» — русский перевод community edition, организатор @ilkruglov, Apache-2.0. GitHub. Уровень: продвинутый. Зачем: тот же текст с сохранённой нумерацией глав и разделов; использован для сверки терминов и цитат. Неофициальное издание сообщества, не замена авторской редактуре.
- «Designing AI Infra» (скилл) — @ilkruglov, Apache-2.0. GitHub. Уровень: продвинутый. Зачем: каталог заблуждений, шпаргалка порядка анализа и плейбук диагностики сервинга; послужили основой для приложений и §12.7, пересказаны и пересчитаны под локальный масштаб.
Архитектура и основы
- «Attention Is All You Need» — Vaswani et al., 2017. arXiv:1706.03762. Уровень: средний. Зачем: первоисточник трансформера; читать после главы 1.
- «The Transformer Family Version 2.0» — Lilian Weng, 2023. lilianweng.github.io. Уровень: средний. Зачем: обзор вариантов attention, нормализаций и позиционных кодировок.
- «Attention? Attention!» — Lilian Weng, 2018. lilianweng.github.io. Уровень: новичок–средний. Зачем: интуиция attention до погружения в формулы.
- «Transformers, the tech behind LLMs» (Deep Learning, глава 5) — 3Blue1Brown, 2024. YouTube. Уровень: новичок. Зачем: визуальное объяснение архитектуры.
- «Attention in transformers, step-by-step» (глава 6) — 3Blue1Brown, 2024. YouTube. Уровень: новичок. Зачем: пошаговая визуализация attention.
- «Let's build GPT: from scratch, in code, spelled out» — Andrej Karpathy, 2023. YouTube. Уровень: средний. Зачем: лучший переход от формул к коду.
- «Let's reproduce GPT-2 (124M)» — Andrej Karpathy, 2024. YouTube. Уровень: средний–продвинутый. Зачем: обучение и генерация реальной модели, оптимизации.
- «Deep Dive into LLMs like ChatGPT» — Andrej Karpathy, 2025. YouTube. Уровень: новичок–средний. Зачем: общая картина обучения и инференса без кода.
- «Intro to Large Language Models» — Andrej Karpathy, 2023. YouTube. Уровень: новичок. Зачем: короткое введение в LLM.
- «Neural Networks: Zero to Hero» — Andrej Karpathy, 2022–2024. плейлист. Уровень: новичок–средний. Зачем: от backprop до GPT, последовательно.
- «Coding LLaMA 2 from scratch in PyTorch» — Umar Jamil, 2023. YouTube. Уровень: средний. Зачем: KV-кэш, RoPE, GQA и сэмплинг в коде.
- «Flash Attention derived and coded from first principles with Triton» — Umar Jamil, 2024. YouTube. Уровень: продвинутый. Зачем: IO-aware attention и Triton-кернел шаг за шагом.
- nanoGPT — Andrej Karpathy, 2022–2024. GitHub. Уровень: средний. Зачем: минимальная кодовая база для экспериментов с GPT.
- llm.c — Andrej Karpathy, 2024. GitHub. Уровень: продвинутый. Зачем: обучение LLM на C/CUDA; полезно для понимания низкого уровня.
Производительность, память, roofline
- «Efficiently Scaling Transformer Inference» — Pope et al., 2022. arXiv:2211.05102. Уровень: продвинутый. Зачем: формальный анализ памяти, вычислений и батчинга.
- «Making Deep Learning Go Brrrr From First Principles» — Horace He, 2022. horace.io. Уровень: средний. Зачем: compute-bound vs memory-bound на пальцах.
- «Transformer Inference Arithmetic» — kipply, 2022. kipp.ly. Уровень: средний–продвинутый. Зачем: детальные расчёты FLOPs, байт и задержек.
- «LLM Inference Performance Engineering: Best Practices» — Databricks, 2023. блог. Уровень: средний. Зачем: метрики TTFT/ITL и практика продакшена.
- «What Every Programmer Should Know About Memory» — Ulrich Drepper, 2007. PDF. Уровень: продвинутый. Зачем: классика про кэши, задержки и пропускную способность.
- «LLM in a flash» — Alizadeh et al., 2023. arXiv:2312.11514. Уровень: продвинутый. Зачем: выгрузка весов на флеш-память и цена чтения с диска.
- NVIDIA H100 — NVIDIA. nvidia.com. Уровень: справка. Зачем: пример спецификации HBM (3,35 ТБ/с у SXM).
- GeForce RTX 5090 — NVIDIA. nvidia.com. Уровень: справка. Зачем: пример потребительской карты; точную пропускную способность смотрите в спецификации.
- Mac Studio — Technical Specifications — Apple, 2026. apple.com. Уровень: справка. Зачем: пропускная способность объединённой памяти M5 Max/Ultra (460–614 ГБ/с и до 1,2 ТБ/с).
Квантование
- «GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers» — Frantar et al., 2022. arXiv:2210.17323. Уровень: продвинутый. Зачем: пост-тренировочное квантование с компенсацией ошибки.
- «AWQ: Activation-aware Weight Quantization» — Lin et al., 2023. arXiv:2306.00978. Уровень: продвинутый. Зачем: защита важных каналов по активациям.
- «SmoothQuant» — Xiao et al., 2022. arXiv:2211.10438. Уровень: продвинутый. Зачем: перенос сложности квантования с активаций на веса.
- «LLM.int8()» — Dettmers et al., 2022. arXiv:2208.07339. Уровень: продвинутый. Зачем: 8-битное умножение с обработкой выбросов.
- «The case for 4-bit precision: k-bit Inference Scaling Laws» — Dettmers, Zettlemoyer, 2022. arXiv:2212.09720. Уровень: средний–продвинутый. Зачем: эмпирика о том, когда 4 бита достаточны.
- llama.cpp PR #1684, «k-quants» — ggml-org, 2023. GitHub. Уровень: продвинутый. Зачем: исходное обсуждение k-quants.
- llama.cpp PR #4861, «Importance Matrix calculation» — ggml-org, 2024. GitHub. Уровень: продвинутый. Зачем: как работает imatrix.
- llama.cpp,
tools/quantize/README.md— ggml-org. GitHub. Уровень: средний. Зачем: практические команды квантования. - llama.cpp Discussion #5063, «Even more quantization types?» — ggml-org, 2023. GitHub. Уровень: продвинутый. Зачем: эволюция типов и компромиссы.
- «Unsloth Dynamic GGUFs» — Unsloth. docs.unsloth.ai. Уровень: средний. Зачем: динамические кванты; заявления авторов, не независимая проверка.
- «Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA» — Hugging Face, 2023. блог. Уровень: новичок–средний. Зачем: доступное введение в 4-битное квантование.
- Transformers quantization overview — Hugging Face. docs. Уровень: средний. Зачем: карта форматов и библиотек.
MoE
- «Switch Transformers» — Fedus, Zoph, Shazeer, 2021. arXiv:2101.03961. Уровень: продвинутый. Зачем: top-1 роутинг и балансировка.
- «Mixtral of Experts» — Jiang et al., 2024. arXiv:2401.04088. Уровень: средний. Зачем: популярная MoE и её поведение.
- «DeepSeekMoE» — Dai et al., 2024. arXiv:2401.06066. Уровень: продвинутый. Зачем: fine-grained эксперты и shared experts.
- «Mixture of Experts Explained» — Hugging Face, 2022. блог. Уровень: новичок–средний. Зачем: лучшее визуальное введение в MoE.
- «Performant local mixture-of-experts CPU inference with GPU acceleration in llama.cpp» — Doctor-Shotgun, Hugging Face, 2024. блог. Уровень: средний. Зачем: схема «attention на GPU, эксперты в RAM».
- «DeepSeek-V3 Technical Report» — DeepSeek-AI, 2024. arXiv:2412.19437. Уровень: продвинутый. Зачем: большая MoE, shared experts, MTP.
KV-кэш, контекст, позиционные кодировки
- «RoFormer: Enhanced Transformer with Rotary Position Embedding» — Su et al., 2021. arXiv:2104.09864. Уровень: продвинутый. Зачем: первоисточник RoPE.
- «YaRN: Efficient Context Window Extension» — Peng et al., 2023. arXiv:2309.00071. Уровень: продвинутый. Зачем: расширение контекста.
- «Extending Context Window via Positional Interpolation» — Chen et al., 2023. arXiv:2306.15595. Уровень: продвинутый. Зачем: простой способ растянуть позиции.
- «Train Short, Test Long: ALiBi» — Press, Smith, Lewis, 2021. arXiv:2108.12409. Уровень: продвинутый. Зачем: альтернатива RoPE с линейным штрафом.
- «GQA» — Ainslie et al., 2023. arXiv:2305.13245. Уровень: продвинутый. Зачем: групповые KV-головы.
- «Fast Transformer Decoding: One Write-Head is All You Need» — Shazeer, 2019. arXiv:1911.02150. Уровень: продвинутый. Зачем: MQA.
- «DeepSeek-V2» — DeepSeek-AI, 2024. arXiv:2405.04434. Уровень: продвинутый. Зачем: MLA и сжатие KV.
- «Gated Delta Networks: Improving Mamba2 with Delta Rule» — Yang, Kautz, Hatamizadeh, 2024. arXiv:2412.06464. Уровень: продвинутый. Зачем: гибридное линейное внимание; в тексте книги — Gated DeltaNet.
- «Transformers are RNNs» — Katharopoulos et al., 2020. arXiv:2006.16236. Уровень: продвинутый. Зачем: линейное внимание.
- «Mamba» — Gu, Dao, 2023. arXiv:2312.00752. Уровень: продвинутый. Зачем: state-space модели.
- «H2O: Heavy-Hitter Oracle» — Zhang et al., 2023. arXiv:2306.14048. Уровень: продвинутый. Зачем: вытеснение неважных токенов из KV.
- «Efficient Streaming Language Models with Attention Sinks» — Xiao et al., 2023. arXiv:2309.17453. Уровень: продвинутый. Зачем: StreamingLLM и attention sinks.
- «KIVI» — Liu et al., 2024. arXiv:2402.02750. Уровень: продвинутый. Зачем: 2-битное квантование KV.
- «SnapKV» — Li et al., 2024. arXiv:2404.14469. Уровень: продвинутый. Зачем: выбор важных позиций.
- «A Survey on KV Cache Management» — Li et al., 2024. arXiv:2412.19442. Уровень: продвинутый. Зачем: карта методов сжатия и управления KV.
Serving, кэш, батчинг
- «Prompt Cache: Modular Attention Reuse» — Gim et al., 2023. arXiv:2311.04934. Уровень: продвинутый. Зачем: переиспользование частей промпта.
- «SGLang: Efficient Execution of Structured Language Model Programs» — Zheng et al., 2023. arXiv:2312.07104. Уровень: продвинутый. Зачем: RadixAttention и разделяемый кэш.
- «PagedAttention / vLLM» — Kwon et al., 2023. arXiv:2309.06180. Уровень: продвинутый. Зачем: управление KV блоками.
- vLLM blog, «Easy, Fast, and Cheap LLM Serving» — vLLM, 2023. blog.vllm.ai. Уровень: средний. Зачем: доступное объяснение PagedAttention.
- vLLM, «Automatic Prefix Caching» — vLLM. docs.vllm.ai. Уровень: средний. Зачем: как устроен кэш префиксов в vLLM.
- vLLM, «Paged Attention» design doc — vLLM. docs.vllm.ai. Уровень: продвинутый. Зачем: детали реализации.
- «Orca: A Distributed Serving System» — Yu et al., OSDI 2022. USENIX. Уровень: продвинутый. Зачем: итеративный батчинг.
- «How continuous batching enables 23x throughput» — Anyscale, 2022. блог. Уровень: средний. Зачем: наглядный разбор continuous batching.
- llama.cpp Discussion #10260 — ggml-org, 2024. GitHub. Уровень: средний. Зачем: разница
-bи-ub. - llama.cpp,
tools/server/README.md— ggml-org. GitHub. Уровень: средний. Зачем: флаги сервера, KV, MoE, tools,--n-cpu-moe,--moe-cache-mib, KV offload и квантование KV. - llama.cpp,
docs/speculative.md— ggml-org. GitHub. Уровень: средний. Зачем: типы спекуляции и флаги. - llama.cpp PR #22673, «MTP Support» — ggml-org, 2026. GitHub. Уровень: продвинутый. Зачем: поддержка MTP-голов.
- llama.cpp,
tools/llama-bench/README.md— ggml-org. GitHub. Уровень: средний. Зачем: методика микробенчмарка. - GGUF specification — ggml-org. GitHub. Уровень: продвинутый. Зачем: формат файла модели.
- ggml — ggml-org. GitHub. Уровень: продвинутый. Зачем: тензорная библиотека под llama.cpp.
- llama.cpp Discussion #4167 — ggml-org. GitHub. Уровень: средний. Зачем: примеры замеров на Apple Silicon.
- llama.cpp,
docs/function-calling.md— ggml-org. GitHub. Уровень: средний. Зачем:--jinja,tool_choice, параллельные вызовы. - llama.cpp,
grammars/README.md— ggml-org. GitHub. Уровень: средний. Зачем: синтаксис GBNF. - vLLM, «Tool Calling» — vLLM. docs.vllm.ai. Уровень: средний. Зачем: strict schema и
tool_choice.
Движки инференса (ноябрь 2026)
Версии и флаги проверены 8 ноября 2026 по релизам и официальной документации. Матрицы моделей, квантов и функций меняются между релизами; сверяйте --help и документацию своей версии.
- llama.cpp, релиз v0.9.0 — ggml-org, 04.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, ggml 0.29.0, FP8 E4M3, unified KV, список бэкендов.
- llama.cpp,
docs/development/token_generation_performance_tips.md— ggml-org, 2026. GitHub. Уровень: средний. Зачем: потоки CPU и проверка offload. - vLLM, релиз v0.33.0 — vLLM Project, тег 01.11.2026, публикация 02.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, PyTorch 2.14, CUDA 13.0, ROCm 10.0, изменения.
- vLLM v0.33.0,
vllm/config/speculative.py— vLLM Project, 2026. GitHub. Уровень: продвинутый. Зачем:SpeculativeMethodвключаетdflashиdspark. - vLLM, «Security: API key authentication limitations» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: какие маршруты не защищает
--api-key. - vLLM, «Optimization and Tuning» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: chunked prefill, preemption, TP/PP/EP/DP.
- vLLM, «Conserving Memory» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: OOM и способы экономии.
- vLLM, «Speculative Decoding» — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: методы,
--speculative-config, MTP. - vLLM, «Structured Outputs» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: XGrammar/guidance и
response_format. - vLLM, «Production Metrics» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем: метрики Prometheus.
- vLLM, «Per-Request Metrics» — vLLM, 2026. docs.vllm.ai. Уровень: средний. Зачем:
--enable-per-request-metrics. - vLLM, «Quantization» — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: форматы и поддержка железа.
- vLLM, «Quantized KV Cache» — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: FP8 KV и калибровка.
- SGLang, релиз v0.5.23 — SGLang Project, 02.11.2026. GitHub. Уровень: продвинутый. Зачем: версия, Paged Experts, HiCache, новые модели.
- SGLang, «Server Arguments» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: флаги и значения по умолчанию.
- SGLang, «Radix Cache Eviction Policies» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: LRU/LFU/SLRU/priority.
- SGLang, «HiCache Best Practices» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: L1/L2/L3 и настройка.
- SGLang, «Speculative Decoding» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: EAGLE, MTP, NGRAM, UNO, DFLASH.
- SGLang, «Structured Outputs» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: XGrammar/Outlines/llguidance.
- SGLang, «Tool Parser» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: парсеры и поддерживаемые модели.
- SGLang, «Production Metrics» — SGLang, 2026. docs.sglang.io. Уровень: средний. Зачем: метрики
sglang:. - SGLang, «Quantization» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: FP8/FP4/AWQ/GPTQ.
- SGLang, «Paged Experts» (v0.5.23 и main) — SGLang, 2026. v0.5.23, main. Уровень: продвинутый. Зачем: MoE больше VRAM и ограничения; в v0.5.23
--paged-experts-num-residentобязателен, в main по умолчаниюauto. - SGLang, «Quantized KV Cache» — SGLang, 2026. docs.sglang.io. Уровень: продвинутый. Зачем: FP8/FP4 KV.
Спекулятивное декодирование
- «Fast Inference from Transformers via Speculative Decoding» — Leviathan, Kalman, Matias, 2022. arXiv:2211.17192. Уровень: продвинутый. Зачем: формализация и анализ.
- «Accelerating Large Language Model Decoding with Speculative Sampling» — Chen et al., 2023. arXiv:2302.01318. Уровень: продвинутый. Зачем: схема с сохранением распределения.
- «Medusa» — Cai et al., 2024. arXiv:2401.10774. Уровень: продвинутый. Зачем: множественные головы и дерево.
- «EAGLE» — Li et al., 2024. arXiv:2401.15077. Уровень: продвинутый. Зачем: черновик на признаках.
- «EAGLE-2» — Li et al., 2024. arXiv:2406.16858. Уровень: продвинутый. Зачем: динамическое дерево.
- «EAGLE-3» — Li et al., 2025. arXiv:2503.01840. Уровень: продвинутый. Зачем: обучение с test-time scaling.
Сэмплинг и рассуждение
- «The Curious Case of Neural Text Degeneration» — Holtzman et al., 2019. arXiv:1904.09751. Уровень: средний. Зачем: nucleus sampling.
- «Hierarchical Neural Story Generation» — Fan, Lewis, Dauphin, 2018. arXiv:1805.04833. Уровень: средний. Зачем: top-k sampling.
- «Turning Up the Heat: Min-p Sampling» — Nguyen et al., 2024. arXiv:2407.01082. Уровень: средний. Зачем: адаптивная обрезка.
- «Chain-of-Thought Prompting» — Wei et al., 2022. arXiv:2201.11903. Уровень: средний. Зачем: почему промежуточные рассуждения помогают.
- «Self-Consistency Improves Chain of Thought Reasoning» — Wang et al., 2022. arXiv:2203.11171. Уровень: средний. Зачем: несколько траекторий и голосование.
- «s1: Simple test-time scaling» — Muennighoff et al., 2025. arXiv:2501.19393. Уровень: продвинутый. Зачем: бюджетное управление рассуждением.
- «DeepSeek-R1» — DeepSeek-AI, 2025. arXiv:2501.12948. Уровень: продвинутый. Зачем: рассуждающая модель и RL.
Инструменты и структурированный вывод
- «Gorilla: Large Language Model Connected with Massive APIs» — Patil et al., 2023. arXiv:2305.15334. Уровень: средний. Зачем: обучение вызову API.
- «Toolformer» — Schick et al., 2023. arXiv:2302.04761. Уровень: средний. Зачем: модель учится вызывать инструменты.
- «Efficient Guided Generation for Large Language Models» — Willard, Louf, 2023. arXiv:2307.09702. Уровень: продвинутый. Зачем: Outlines и маскирование логитов.
- «XGrammar» — Dong et al., 2024. arXiv:2411.15100. Уровень: продвинутый. Зачем: быстрая структурированная генерация.
- Berkeley Function Calling Leaderboard — UC Berkeley. gorilla.cs.berkeley.edu. Уровень: средний. Зачем: публичный бенчмарк tool calling.
Оценка моделей и бенчмарки
- «Model Cards for Model Reporting» — Mitchell et al., 2018. arXiv:1810.03993. Уровень: новичок–средний. Зачем: что должно быть в карточке модели.
- «Holistic Evaluation of Language Models» — Liang et al., 2022. arXiv:2211.09110. Уровень: средний. Зачем: почему один бенчмарк не описывает модель.
- «Measuring Massive Multitask Language Understanding» — Hendrycks et al., 2020. arXiv:2009.03300. Уровень: средний. Зачем: MMLU и его ограничения.
- «Chatbot Arena» — Chiang et al., 2024. arXiv:2403.04132. Уровень: средний. Зачем: что измеряют предпочтения людей.
- «Adding Error Bars to Evals» — Evan Miller, 2024. arXiv:2411.00640. Уровень: средний. Зачем: статистика для оценок.
- MLPerf Inference — MLCommons. mlcommons.org. Уровень: продвинутый. Зачем: пример строгой методологии бенчмарка.
Речь и OCR
- «Robust Speech Recognition via Large-Scale Weak Supervision» — Radford et al., 2022. arXiv:2212.04356. Уровень: продвинутый. Зачем: оригинальная статья Whisper.
- whisper.cpp — ggml-org. GitHub. Уровень: средний. Зачем: локальный запуск Whisper без Python.
- «GigaAM: Efficient Self-Supervised Learner for Speech Recognition» — Kutsakov et al., 2025. arXiv:2506.01192. Уровень: продвинутый. Зачем: ASR-модель, обученная преимущественно на русской речи по данным авторов, и сравнение с Whisper-large-v3.
- Silero VAD — Silero. GitHub. Уровень: средний. Зачем: лёгкий детектор речи.
- Tesseract documentation — Tesseract OCR. tesseract-ocr.github.io. Уровень: новичок. Зачем: установка и языковые пакеты.
- «PP-OCR: A Practical Ultra Lightweight OCR System» — Du et al., 2020. arXiv:2009.09941. Уровень: продвинутый. Зачем: архитектура PP-OCR.
- RapidOCR — RapidAI. GitHub. Уровень: средний. Зачем: ONNX-порт для практического запуска.
- PaddleOCR — PaddlePaddle. GitHub. Уровень: средний. Зачем: полный инструментарий OCR.
Большие модели на маленьком железе (2026)
- Strata — Niko1221, 2026. GitHub, How it works, Models, DeepSeek V4.1. Уровень: продвинутый. Зачем: устройство экспертного кэша, требования к памяти и самозаявленные замеры; MIT, но проект очень молодой.
- «Best Open Source LLM: Strata with Qwen 3.8 Flash Next» — Fabio Akita, 2026. akitaonrails.com. Уровень: средний. Зачем: независимый обзор и замеры на RTX 5090 и Strix Halo; 159 ток/с, 90–97% попаданий, цена в ОЗУ и swap.
- Strata issue #4815 — пользовательский замер на RTX 5080 16 ГБ. GitHub. Уровень: продвинутый. Зачем: пример независимой проверки флага
--kv-residentи его реальной цены. - «Qwen3.8 Flash Next Review: Benchmarks, Architecture, Memory Requirements, and Local Inference» — Benjamin Marie, 2026. kaitchup.substack.com. Уровень: средний. Зачем: 125B-A6B, 51B n-gram-таблица и 4B MTP-модуль; лид доступен, бенчмарки и расчёты памяти — за пейволом.
- KTransformers — kvcache-ai, 2024–2026. GitHub, DeepSeek R1/V3 tutorial. Уровень: продвинутый. Зачем: CPU-GPU гибрид, AMX/AVX-512, цифры для 671B на 14 ГБ VRAM и 382 ГБ DRAM.
- «PowerInfer: Fast Large Language Model Serving with a Consumer-grade GPU» — Song et al., 2023. arXiv:2312.12456, GitHub. Уровень: продвинутый. Зачем: горячие и холодные нейроны; важно ограничение — только ReLU-модели.
- «PowerInfer-2: Fast Large Language Model Inference on a Smartphone» — Xue et al., 2024. arXiv:2406.06282. Уровень: продвинутый. Зачем: нейронные кластеры и смартфонный инференс; исследовательская работа, не массовый рантайм.
- AirLLM — lyogavin, 2023–2026. GitHub. Уровень: средний. Зачем: послойная загрузка и честная цена в скорости; заявления «70B на 4 ГБ» требуют независимой проверки.
- «LLM in a flash: Efficient Large Language Model Inference with Limited Memory» — Alizadeh et al., 2023. arXiv:2312.11514. Уровень: продвинутый. Зачем: windowing, row-column bundling и потолок SSD-стриминга.
- «MoE-Infinity: Efficient MoE Inference on Personal Machines with Sparsity-Aware Expert Cache» — Xue et al., 2024. arXiv:2401.14361, GitHub. Уровень: продвинутый. Зачем: кэш экспертов и предзагрузка для batch=1; открытый код, по README, отличается от версии из статьи.
- «ExpertFlow: Efficient Mixture-of-Experts Inference via Predictive Expert Caching and Token Scheduling» — 2024. arXiv:2410.17954. Уровень: продвинутый. Зачем: предсказание маршрутизации, до 93,72% экономии памяти GPU и до 10× в abstract.
- exo — exo labs, 2024–2026. GitHub. Уровень: средний. Зачем: домашний кластер Mac, tensor parallel и RDMA over Thunderbolt.
- «1.5 TB of VRAM on Mac Studio — RDMA over Thunderbolt 5» — Jeff Geerling, 2025. jeffgeerling.com. Уровень: средний. Зачем: независимые замеры exo на четырёх Mac Studio и сравнение с llama.cpp RPC.
- llama.cpp,
tools/rpc/README.md— ggml-org. GitHub. Уровень: продвинутый. Зачем: RPC-бэкенд, TCP/RDMA и предупреждение о небезопасности. - Petals — bigscience-workshop, 2022–2024. GitHub. Уровень: средний. Зачем: BitTorrent-подобный распределённый инференс; проект не развивается с 2024 года.
- distributed-llama — b4rtaz, 2023–2026. GitHub. Уровень: средний. Зачем: кластер из домашних устройств, tensor parallelism, ограничения Q4_0 и 2^n узлов.
- «The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits» — Ma et al., 2024. arXiv:2402.17764. Уровень: продвинутый. Зачем: тернарные веса и обучение с нуля; не путать с пост-тренировочным квантованием.
- bitnet.cpp — Microsoft, 2024–2026. GitHub, arXiv:2410.16144. Уровень: продвинутый. Зачем: CPU/GPU-ядра для BitNet b1.58, ускорения и энергия; 100B-модель пока не выложена.
- HQQ — dropbox, 2023–2026. GitHub. Уровень: средний. Зачем: быстрое квантование без калибровки, 1–8 бит; 4-битный пример на 4090.
- AQLM — Vahe1994, 2024–2026. GitHub, arXiv:2401.06118. Уровень: продвинутый. Зачем: аддитивное квантование на 2–3 бита и качество Llama-3-70B.
- «QTIP: Quantization with Trellises and Incoherence Processing» — 2024. arXiv:2406.11235. Уровень: продвинутый. Зачем: trellis-квантование и SOTA на 2 битах; исследование.
- «Deja Vu: Contextual Sparsity for Efficient LLMs at Inference Time» — Liu et al., 2023. arXiv:2310.17157, GitHub. Уровень: продвинутый. Зачем: контекстная разреженность и предсказатель.
- «CATS: Contextually-Aware Thresholding for Sparsity in Large Language Models» — 2024. arXiv:2404.08763. Уровень: продвинутый. Зачем: 50% разреженности при 1–2% потери и ~15% реального ускорения.
- Splash — incoai, 2026. GitHub. Уровень: средний. Зачем: Apple Silicon, DFlash2, Metal и ANE; самозаявленные замеры на M5 Pro.
- NInfer — Neroued, 2026. GitHub. Уровень: продвинутый. Зачем: RTX 5090/DGX Spark, CPU expert offload и 101 ГиБ Flash-Next.
- HyperQwen — syv-ai, 2026. GitHub. Уровень: продвинутый. Зачем: vLLM-патчи и спекуляция для 27B на одной 24-ГБ карте.
- FastFlowLM — ROCm/AMD, 2025–2026. GitHub, бенчмарк Qwen3.8. Уровень: средний. Зачем: NPU-first рантайм для Ryzen AI; официальный бенчмарк AMD — 2–3 ток/с для 27B.
- ANEMLL — Anemll, 2025–2026. GitHub. Уровень: продвинутый. Зачем: конвертация LLM в CoreML для Apple Neural Engine; MIT заявлен в README, отдельного LICENSE-файла нет.
- «Pre-Compiled Pipeline Shards for Distributed LLM Inference on Intel AI PC Fleets» — 2026. arXiv:2608.19147, OpenVINO issue #35641, Cascadia. Уровень: продвинутый. Зачем: §8.6 — Llama 3.1 8B INT4 на Lunar Lake NPU, 3,55 → 11,46 ток/с на четырёх слотах; плюс ограничения OpenVINO.
- WebLLM — MLC AI, 2023–2026. GitHub, arXiv:2412.15803. Уровень: средний. Зачем: WebGPU-инференс в браузере и его потолок по размеру модели.
- MLC LLM — MLC AI, 2023–2026. GitHub. Уровень: средний. Зачем: универсальный компилятор/рантайм для iOS, Android, WebGPU и настольных GPU.
- LMCache, «New Architecture Boosts MoE Inference Performance by 10×» — 2026. блог. Уровень: продвинутый. Зачем: vendor-заявление об offload KV; 10× — по p99 TTFT, декод — около 3,8×, независимой проверки нет.
Коробочные решения (ноябрь 2026)
- Ollama — документация — Ollama, 2026. docs.ollama.com. Уровень: новичок–средний. Зачем: контекст по VRAM, Modelfile, OpenAI-совместимость, tool calling, импорт GGUF, параллельные запросы. Основной источник для главы о коробках.
- Ollama v0.40.15 — Ollama, 3 ноября 2026. GitHub. Уровень: справка. Зачем: актуальная версия, MLX-сборки, изменения llama.cpp/MLX.
- Ollama — политика приватности — Ollama, март 2026. ollama.com/privacy. Уровень: справка. Зачем: что уходит в облако, а что остаётся локально;
OLLAMA_NO_CLOUD. - LM Studio 0.4.0 — LM Studio, 28 января 2026. блог. Уровень: новичок–средний. Зачем:
llmster, параллельные запросы, unified KV, stateful REST, permission keys. - LM Studio — Parallel Requests — LM Studio, 2026. docs. Уровень: средний. Зачем: Max Concurrent Predictions = 4 по умолчанию; ограничение для MLX на момент 0.4.0.
- LM Studio — Headless / TTL — LM Studio, 2026. headless, TTL. Уровень: средний. Зачем: JIT, TTL 60 минут, auto-evict, запуск без GUI.
- LM Studio — lms load — LM Studio, 2026. docs. Уровень: новичок–средний. Зачем:
--context-length,--gpu,--ttl,--estimate-only. - LM Studio — Speculative Decoding — LM Studio, 2026. docs. Уровень: средний. Зачем: черновик, общий словарь, ориентиры размеров, зависимость от промпта.
- LM Studio — App Terms / Privacy — LM Studio, 2025–2026. terms, privacy. Уровень: справка. Зачем: проприетарная лицензия, бесплатность для работы, отсутствие телеметрии.
- LM Studio, bug #2024 — LM Studio bug tracker, июнь 2026. GitHub. Уровень: продвинутый. Зачем: ограничения программной настройки KV-кванта и параллельности; пользовательский отчёт, не официальная документация.
- Unsloth Studio — Unsloth, 2026. документация, chat, API. Уровень: новичок–средний. Зачем: инференс GGUF/MLX, дообучение, экспорт, API, лицензия, auto context.
- Unsloth changelog — Unsloth, 6 ноября 2026. docs. Уровень: средний. Зачем: 4 слота, многопользовательские аккаунты, vLLM/SGLang, версии и изменения.
- Jan — Menlo Research, 2026. quickstart, репозиторий, движок, API. Уровень: новичок–средний. Зачем: llama.cpp/MLX, настройки KV и слотов, локальный API, лицензия.
- llamafile — Mozilla.ai, 2026. репозиторий, запуск, API. Уровень: новичок–средний. Зачем: один файл, сервер, OpenAI/Anthropic API, ограничение Windows 4 ГБ.
- GPT4All 3.10.0 — Nomic, 25 февраля 2025. GitHub. Уровень: новичок. Зачем: последний стабильный релиз; показывает темп проекта.
- LocalAI 4.12.1 — LocalAI, 23 октября 2026. GitHub. Уровень: средний. Зачем: актуальная версия серверного шлюза.
- LocalAI — quickstart / text generation / auth — LocalAI, 2026. quickstart, text generation, auth. Уровень: средний–продвинутый. Зачем: бэкенды llama.cpp/ik/vLLM/SGLang, OpenAI/Anthropic/Responses, роли и OIDC.
Блоги и практика
- Tim Dettmers, «The Best GPUs for Deep Learning in 2023» — 2023. timdettmers.com. Уровень: средний. Зачем: как выбирать GPU под нагрузку и память.
- Chip Huyen, «Building A Generative AI Platform» — 2024. huyenchip.com. Уровень: средний. Зачем: архитектура приложений вокруг моделей.
Железо и цены (ноябрь 2026)
Цены проверены 7 ноября 2026 года; курс ЦБ РФ — 81,79 ₽ за доллар. Уличные цены меняются ежедневно, поэтому числа в главе — ориентиры, а не обещание магазина. Где надёжного источника не было, в главе стоит «не нашёл».
- NVIDIA GeForce RTX 5090 — Specifications — NVIDIA, 2026. nvidia.com. Уровень: справка. Зачем: 32 ГБ GDDR7, 575 Вт, 1000 Вт БП, NVLink нет, 3352 AI TOPS.
- NVIDIA RTX PRO 6000 Blackwell Workstation Edition — NVIDIA, 2026. nvidia.com. Уровень: справка. Зачем: 96 ГБ, 1792 ГБ/с, 600 Вт, 4000 AI TOPS.
- NVIDIA RTX PRO 5000 Blackwell — NVIDIA, 2026. nvidia.com. Уровень: справка. Зачем: 48/72 ГБ, 1344 ГБ/с, 300 Вт.
- NVIDIA DGX Spark — Specifications — NVIDIA, 2026. nvidia.com. Уровень: справка. Зачем: GB10, 128 ГБ LPDDR5X, 273 ГБ/с, 140 Вт, 1 PFLOPS FP4, 29 дБА.
- Lenovo Press, ThinkSystem RTX PRO 6000 Blackwell Max-Q — Lenovo, 2026. lenovopress.lenovo.com. Уровень: справка. Зачем: прямо указывает «NVLink support: No» — полезно против рекламных обещаний.
- Guru3D, «GeForce RTX 5090 D v2 Officially Released» — 15.08.2025. guru3d.com. Уровень: справка. Зачем: 24 ГБ, 1344 ГБ/с, 2375 TOPS, 575 Вт — замена битой ссылке.
- AMD Radeon AI PRO R9700 — AMD, 2026. amd.com. Уровень: справка. Зачем: 32 ГБ, 640 ГБ/с, 300 Вт, ECC, 95,7 TFLOPS FP16, ROCm.
- Intel Arc Pro B-Series — Intel, 2026. intel.com. Уровень: справка. Зачем: B50/B60/B65/B70 — 16–32 ГБ, 224–608 ГБ/с, 70–230 Вт.
- Apple Mac Studio (M5 Max/M5 Ultra) — Tech Specs — Apple, 2026. support.apple.com. Уровень: справка. Зачем: 36–512 ГБ, 460–1200 ГБ/с.
- Apple Mac mini (M6/M5 Pro) — Tech Specs — Apple, 2026. support.apple.com. Уровень: справка. Зачем: 16–64 ГБ, 153–307 ГБ/с.
- AMD EPYC 9005 Series — AMD, 2026. amd.com. Уровень: справка. Зачем: 12 каналов DDR5-6400, 614 ГБ/с на сокет.
- AMD Ryzen Threadripper 9000 — AMD, 2026. amd.com. Уровень: справка. Зачем: TRX50 — 4 канала, WRX90 — 8 каналов, 80–128 линий PCIe 5.0.
- Tom’s Hardware, «Nvidia doubles RTX PRO 6000 Blackwell’s MSRP to $16,000» — 2026. tomshardware.com. Уровень: средний. Зачем: как кризис памяти удвоил цену профессиональной карты.
- BestValueGPU, RTX 5090 price history — 12.10.2026. bestvaluegpu.com. Уровень: справка. Зачем: уличная цена $4 999 и история.
- Tech Insider / Tom’s Hardware, RTX 5090 price tracking — 05.11.2026. tech-insider.org. Уровень: справка. Зачем: верхняя граница $6 919 и дефицит.
- GPU Sold, RTX 3090 used price — 04.11.2026. gpusold.com. Уровень: справка. Зачем: медиана проданных $1 586 за 14 дней.
- PCPrice.Watch, RTX 4090 used price — 04.11.2026. pcprice.watch. Уровень: справка. Зачем: медиана $2 496 и разброс.
- Silicon Comps, RTX 4090 / A6000 / RTX 6000 Ada — 03.11.2026. siliconcomps.com. Уровень: справка. Зачем: ориентиры цен на б/у 24–48 ГБ.
- AI Miracle, «Radeon AI PRO R9700: 32GB for $1,299» — 13.10.2026. aimiracle.ai. Уровень: средний. Зачем: цена, ROCm, ограничения.
- Local AI Master, Radeon AI Pro R9700 for local AI — 2026. localaimaster.com. Уровень: средний. Зачем: prefill в 2,6–3,4 раза медленнее 5090, декод ~1,5 раза.
- ninabot.ch, «Intel Arc Pro B60 for LLM inference: four cards» — 10–11.09.2026. ninabot.ch. Уровень: продвинутый. Зачем: 4×B60 96 ГБ, 82,4 ток/с на 30B-A3B, 211 Вт.
- Framework Desktop Mainboard — Framework, 2026. frame.work. Уровень: справка. Зачем: Strix Halo 128 ГБ, цены и конфигурации.
- ComputingForGeeks, «Best Ryzen AI Max+ 395 Mini PC» — 2026. computingforgeeks.com. Уровень: справка. Зачем: сравнение боксов и цен.
- The Register, «Nvidia debuts $4,999 DGX Spark with half the RAM» — 02.10.2026. theregister.com. Уровень: средний. Зачем: рост цены DGX Spark до $6 950 и 64-гиговая версия.
- NIX, NVIDIA DGX Spark 128 ГБ — 06.11.2026. nix.ru. Уровень: справка. Зачем: российская цена 860 185 ₽.
- DNS, видеокарты RTX 5080 — 07.11.2026. dns-shop.ru. Уровень: справка. Зачем: российские цены 202–210 тыс. ₽.
- DNS, видеокарты RTX 5070 Ti — 07.11.2026. dns-shop.ru. Уровень: справка. Зачем: цена около 150 тыс. ₽.
- DNS, видеокарты RTX 5070 — 07.11.2026. dns-shop.ru. Уровень: справка. Зачем: цены 105–113 тыс. ₽.
- DNS, видеокарты RTX 5060 Ti 16 ГБ — 07.11.2026. dns-shop.ru. Уровень: справка. Зачем: цены 80–88 тыс. ₽.
- Metaratings, «Сколько стоит в России собрать игровой ПК» — 2026. cybersport.metaratings.ru. Уровень: справка. Зачем: RTX 5090 750–950 тыс. ₽, 5090D v2 400–440 тыс. ₽.
- 3DNews, «RTX 5090 продаются в России от 350 тыс. рублей» — 02.11.2026. 3dnews.ru. Уровень: справка. Зачем: разброс и серый импорт.
- Citilink, видеокарты AMD Radeon — 07.11.2026. citilink.ru. Уровень: справка. Зачем: RX 9060 XT 73–89 тыс. ₽.
- ServerFlow, Intel Arc Pro B60 24 ГБ — 07.11.2026. serverflow.ru. Уровень: справка. Зачем: российская цена 110 300 ₽.
- Авито, RTX 3090 — 07.11.2026. avito.ru. Уровень: справка. Зачем: б/у 115–140 тыс. ₽.
- Авито, RTX 4090 — 07.11.2026. avito.ru. Уровень: справка. Зачем: б/у 145–270 тыс. ₽.
- Apple-store.net.ru, Mac mini — 07.11.2026. apple-store.net.ru. Уровень: справка. Зачем: Mac mini M5 Pro 215–280 тыс. ₽.
- Megabait, Mac Studio — 07.11.2026. megabait.net. Уровень: справка. Зачем: Mac Studio M5 Max 36–128 ГБ, цены.
- RunPod — RTX 4090 — 2026. runpod.io. Уровень: справка. Зачем: аренда 4090 около $0,34/ч; использована для сравнения с 2×3090.
- Selectel, GPU-серверы — 2026. selectel.ru. Уровень: справка. Зачем: 2×4090 210 ₽/ч, RTX PRO 6000 290 ₽/ч.
- HOSTKEY, аренда H100/A100 — 31.08.2026. hostkey.ru. Уровень: справка. Зачем: H100 207 ₽/ч, A100 153 ₽/ч.
- Fusion Worldwide, «RDIMM Shortage 2026» — 2026. fusionww.com. Уровень: средний. Зачем: рост цен DRAM и RDIMM, причина подорожания железа.
- ЦБ РФ, курс доллара на 06.11.2026 — 06.11.2026. myfin.by. Уровень: справка. Зачем: 81,79 ₽/$ для пересчёта.
- Тарифы на электроэнергию в Москве — 2026. info-gkh.ru. Уровень: справка. Зачем: 8,90 ₽/кВт·ч с 1 октября 2026.
- llama.cpp — Backend/build docs — ggml-org, 2026. GitHub. Уровень: средний. Зачем: CUDA, HIP, SYCL, Metal, Vulkan, CPU.
- llama.cpp — SYCL backend — ggml-org, 2026. GitHub. Уровень: продвинутый. Зачем: сборка и запуск на Intel GPU.
- MLX — Apple Machine Learning Research, 2026. GitHub. Уровень: средний. Зачем: фреймворк для Apple Silicon.
- ROCm — System requirements — AMD, 2026. docs.amd.com. Уровень: продвинутый. Зачем: поддержка Radeon AI PRO и RDNA.
- vLLM — Installation — vLLM, 2026. docs.vllm.ai. Уровень: продвинутый. Зачем: CUDA, ROCm, XPU.
- AI Infra in Depth — hardware dataset — Bojie Li, 2026. GitHub, JSON. Уровень: справка. Зачем: 151 устройство с объёмами и ПСП; Apache-2.0, использован для сверки Apple M5/M6, RTX PRO 6000, A6000 и RTX 6000 Ada.
Ограничения проверки
- Самозаявленные числа. Бенчмарки моделей, скорость в карточках и заявления вендоров не проверялись независимо. В книге они либо не используются как факты, либо помечены.
- Молодые проекты 2026. У Strata, Splash, NInfer и HyperQwen возраст — месяцы, а не годы; их числа и флаги могут меняться быстрее, чем выходит книга. В тексте это помечено.
- Версии рантаймов. Флаги llama.cpp и поведение сервера меняются между сборками. Сверяйте
--helpсвоей версии и документацию. - Железо. Точные значения пропускной способности и объёма памяти зависят от конкретной модели карты, драйвера и охлаждения. В книге — порядки величин.
- Даты. Для некоторых постов и документации точная дата не указана; приведён год или «постоянно обновляется».
- Языковые модели. Русскоязычные бенчмарки (MERA, ruBFCL и др.) существуют, но независимых сравнений на технических документах мало; в книге нет утверждений, которые опирались бы на такие неполные данные.
- O'Reilly. Страницы книг могут требовать подписки; метаданные (автор, год, название) проверены по каталогу.