Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Приложение. Частые заблуждения

Зачем это приложение. Почти все ошибки в локальном инференсе — не в математике, а в постановке вопроса: считают гигабайты вместо гибибайтов, проверяют только веса, меряют скорость на пустом контексте и верят одному прогону. Здесь собраны типовые способы обмануть себя, с проверкой и правилом, как считать на самом деле.

За 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. Каталог заблуждений и плейбук диагностики сервинга, переработанные здесь под локальный масштаб.