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

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). При генерации нового токена:

  1. считаются его Q, K, V;
  2. K и V дописываются в кэш;
  3. 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 в FP16KV в q8_0
8k1 ГиБ0,5 ГиБ
32k4 ГиБ2,1 ГиБ
128k16 ГиБ8,5 ГиБ

Даже у 8B-модели контекст 128k съедает больше памяти, чем веса в Q4.

Пример 2: плотная 70B-модель

80 слоёв, 8 KV-голов, d_head = 128, FP16:

2 × 80 × 8 × 128 × 2 = 327 680 байт = 320 КиБ на токен
КонтекстKV в FP16KV в q8_0
8k2,5 ГиБ1,3 ГиБ
32k10 ГиБ5,3 ГиБ
128k40 ГиБ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 Практические правила

  1. Считайте KV до покупки железа. Формула выше и конфиг модели дают ответ за минуту.
  2. Начинайте с контекста, который нужен задаче, а не с максимума модели. 32k часто достаточно; 128k — отдельный проект.
  3. Квантуйте KV в q8_0, если не хватает памяти; q4 — только с проверкой.
  4. Следите за числом слотов. Каждый параллельный слот — свой KV-кэш.
  5. Проверяйте скорость на глубине контекста, а не на пустом промпте: attention дорожает с длиной.
  6. Не путайте «поддерживает» и «эффективно использует»: тест на иголку в стоге сена и реальные задачи важнее числа в карточке.

Ключевые идеи

  • KV-кэш хранит K и V прошлых токенов; без него генерация была бы квадратично дорогой.
  • Размер KV = 2 × слои × KV-головы × d_head × контекст × байт.
  • GQA/MQA уменьшают число KV-голов; MLA сжимает кэш в латент; линейное внимание заменяет его фиксированным состоянием.
  • KV можно квантовать, но q4 рискован для структурированного вывода.
  • Длинный контекст стоит памяти, времени prefill и качества; расширение через RoPE/YaRN — компромисс.

Проверь себя

  1. Почему KV-кэш растёт линейно с контекстом, а вычисление attention на каждом шаге — тоже линейно, хотя наивный пересчёт был бы квадратичным?
  2. У модели 48 слоёв, 8 KV-голов, d_head = 128, FP16. Сколько KV на 16k токенов?
  3. Как GQA влияет на размер кэша и почему это не бесплатно?
  4. Зачем нужны attention sinks в StreamingLLM?
  5. Модель заявляет 128k контекста. Почему не стоит сразу ставить -c 131072?

Ответы

  1. Кэш хранит по вектору на токен, поэтому его размер линеен по длине. На каждом новом токене attention сравнивает его со всеми предыдущими — это линейно по длине, а не квадратично. Квадратичной была бы полная пересборка всех пар на каждом шаге.
  2. 2 × 48 × 8 × 128 × 2 = 196 608 байт = 192 КиБ на токен; 16 384 × 192 КиБ = 3 ГиБ.
  3. GQA уменьшает число KV-голов, поэтому кэш меньше в n_heads / n_kv_heads раз. Но меньшее число KV-голов ограничивает разнообразие представлений; качество может немного снизиться, особенно на задачах, требующих точного сопоставления.
  4. Первые токены часто получают непропорционально большое внимание и служат «стоком» для softmax. Если их выбросить, распределение attention ломается. Поэтому их сохраняют вместе со скользящим окном.
  5. Потому что память под 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.