Вопрос «Что такое GQA: как головы внимания делят ключи и значения» касается устройства внимания. GQA (grouped-query attention) — схема, при которой запросные головы разбиты на группы, и каждая группа читает один общий набор ключей и значений. В документации IBM формулировка такая: grouped query attention — более общая и гибкая форма multi-query attention, которая делит query-головы на несколько групп, где каждая группа использует свой набор ключей и значений. Разберём устройство по шагам.
Query, key, value и головы
Механика внимания начинается с трёх проекций. Входной вектор токена умножается на три матрицы весов и даёт три тензора: запросы (query), ключи (key) и значения (value). Каждый тензор разбит на головы — независимые подпространства, в которых внимание считается параллельно. Голова — это срез размерности head_dim внутри общей размерности модели.
В классическом multi-head attention (MHA) число query-голов равно числу key-голов и value-голов. Каждая query-голова читает собственные K и V. При генерации текста модель хранит K и V всех предыдущих токенов в KV-кэше, чтобы не пересчитывать их заново на каждом шаге. Размер этого кэша растёт линейно с длиной контекста и числом KV-голов.
Разделение query-голов и KV-голов — ключевая точка, где появляется экономия. Запросных голов может быть много: они задают выразительность внимания. KV-голов может быть меньше: они задают объём хранимых данных. В статье на arxiv.org (работа GQA, 2305.13245v3) сказано, что grouped-query attention делит query-головы на G групп, каждая из которых использует одну key-голову и одну value-голову. Это определение задаёт всю дальнейшую арифметику.
Практический смысл: вы читаете конфигурацию модели и видите два числа — сколько query-голов и сколько KV-голов. Их отношение и есть размер группы. Дальше это отношение превращается в объём памяти под кэш.
Группы GQA
Группа — это набор query-голов, которые совместно используют одну пару K/V. Если у модели 8 query-голов и 2 KV-головы, то головы делятся на 2 группы по 4 головы. Первая группа читает K0 и V0, вторая — K1 и V1. Внутри группы все запросы считают внимание к одним и тем же ключам, но со своими весами.
Число групп равно числу KV-голов. Это тождество удобно для чтения конфигураций: встретив параметр num_key_value_heads, вы сразу знаете число групп. Параметр num_attention_heads задаёт число query-голов. Их частное — размер группы.
В обзоре Себастьяна Рашки на sebastianraschka.com описан тот же механизм: набор query-голов сохраняется, key- и value-голов становится меньше, поэтому несколько query-голов читают одну и ту же пару K/V. Это уменьшает размер KV-кэша и объём кэшированных данных, которые нужно прочитать при авторегрессионной генерации.
Группировка фиксирована на этапе конфигурации модели. Она задаётся архитектурой и весами, которые обучили или адаптировали под эту схему. Во время инференса вы не перегруппировываете головы на лету: вы читаете уже заданное соответствие.
Крайние случаи: MHA и MQA
Две границы задают всю шкалу. В документации IBM указано: GQA с числом KV-групп, равным числу голов внимания, эквивалентен стандартному MHA; GQA с одной KV-группой эквивалентен MQA. То есть MHA и multi-query attention — это крайние точки одного параметра.
| Схема | Query-голов | KV-голов | Групп | Что читает каждая query-голова |
|---|---|---|---|---|
| MHA | 8 | 8 | 8 | собственную пару K/V |
| GQA | 8 | 2 | 2 | одну из двух общих пар K/V |
| MQA | 8 | 1 | 1 | единственную общую пару K/V |
Таблица показывает, что переход между схемами — это изменение одного числа. MHA даёт максимум KV-голов и максимум памяти под кэш. MQA даёт минимум KV-голов и минимум памяти. GQA занимает промежуточное положение и настраивается под задачу.
Отсюда практический вывод для чтения конфигураций: если num_key_value_heads равно num_attention_heads, перед вами MHA. Если это число равно единице, перед вами MQA. Промежуточные значения — GQA.
Полная схема группировки
Схема собирается из трёх форм тензоров. Для учебной конфигурации возьмём один слой, batch 1, три сохранённых токена, восемь query-голов, две KV-головы, размер головы 4. Формы: Q[1, 8, 3, 4], K[1, 2, 3, 4], V[1, 2, 3, 4]. Здесь задано учебное соглашение осей; порядок размерностей в конкретном API зависит от реализации.
Соответствие голов задаётся так: Q0, Q1, Q2, Q3 используют K0 и V0; Q4, Q5, Q6, Q7 используют K1 и V1. Каждая группа содержит четыре query-головы и одну пару K/V. Для каждого токена сохраняются две KV-головы, каждая по четыре числа K и четыре числа V.
Порядок чтения конфигурации:
- Найдите число query-голов (
num_attention_heads). - Найдите число KV-голов (
num_key_value_heads). - Проверьте делимость: число query-голов делится на число KV-голов без остатка.
- Вычислите размер группы как частное.
- Уточните в реализации соответствие индексов query- и KV-голов; в нашем учебном примере группы идут подряд.
Документация PyTorch для scaled_dot_product_attention приводит два условия для GQA: number_of_heads_query % number_of_heads_key_value == 0 и number_of_heads_key == number_of_heads_value. Там же указано, что GQA в этой функции — экспериментальная возможность. Проверка делимости — первый шаг, который отсекает некорректные конфигурации.
Ручной расчёт KV-кэша
Формула из обзора на sebastianraschka.com: cache bytes = 2 x KV heads x head dimension x bytes per element. Множитель 2 покрывает и ключи, и значения. Дальше формула умножается на число сохранённых токенов и размер batch.
Соберём учебный пример. Условия: один слой, batch 1, три сохранённых токена, восемь query-голов, две KV-головы, размер головы 4, два байта на элемент. Считаем только K и V, без padding и служебных буферов.
GQA: 2 (K/V) * 1 (batch) * 3 (tokens) * 2 (KV heads) * 4 (head_dim) * 2 (bytes) = 96 байт
MHA: 2 (K/V) * 1 (batch) * 3 (tokens) * 8 (KV heads) * 4 (head_dim) * 2 (bytes) = 384 байта
MQA: 2 (K/V) * 1 (batch) * 3 (tokens) * 1 (KV head) * 4 (head_dim) * 2 (bytes) = 48 байт
Экономия GQA против этого MHA равна четырём разам, и только в этой части кэша. Расчёт использует заданные учебные входы; реальное потребление памяти продукта здесь не измерялось. Проверьте каждый множитель под свою конфигурацию: число слоёв, batch, длину последовательности, размер головы и тип данных.
Какие расходы остались
Арифметика выше покрывает одну статью расходов. Query-проекции остаются в полном объёме: число query-голов не изменилось. Веса модели, активации, промежуточные буферы и служебные расходы GPU в расчёт не входят. Сокращение KV-кэша в четыре раза не означает сокращения общего потребления памяти в четыре раза.
В обзоре на sebastianraschka.com отмечено: GQA по-прежнему выполняет полное внимание по сохранённой последовательности. Он не сокращает контекст, не делает матрицу внимания разреженной и не убирает зависимость полного внимания от длины последовательности. Экономия идёт по объёму хранимых и читаемых K/V.
Работа на arxiv.org формулирует мотивацию так: статья сосредоточена на снижении накладных расходов пропускной способности памяти при загрузке ключей и значений. Это ограничивает область применимости вывода: выигрыш проявляется там, где узким местом становится чтение кэша.
Качество и задержка из этой арифметики не выводятся. Уменьшение числа KV-голов меняет то, какие ключи видит группа запросов, и влияние на качество оценивается отдельно, обучением или адаптацией.
Когда важна реальная конфигурация
Реальная конфигурация важна при выборе модели под ограничение памяти и при переносе весов. В документации IBM описан процесс uptraining: модели, предобученные со стандартным MHA, адаптируются к GQA через дообучение. В работе на arxiv.org описан способ конвертации: при переносе multi-head чекпоинта в GQA-чекпоинт каждая групповая key- и value-голова строится усреднением исходных голов внутри группы.
Отсюда практическое правило: заменить чекпоинт MHA на GQA простой правкой конфигурации нельзя без поддержки архитектуры и соответствующей адаптации весов. Числа голов должны быть согласованы с тем, как модель обучалась.
Для реализации есть сторонние решения. В README проекта fkodom/grouped-query-attention-pytorch указано, что это неофициальная реализация GQA на PyTorch, и там же приведён прототип необученной encoder-decoder модели, использующей GQA. Такой код удобен для изучения форм тензоров и группировки.
Проверка перед запуском:
- Сверьте
num_attention_headsиnum_key_value_headsв конфигурации модели. - Убедитесь, что первое делится на второе без остатка.
- Проверьте, что число key-голов равно числу value-голов.
- Уточните по документации конкретной реализации порядок осей тензоров.
- Оцените объём KV-кэша по формуле под свои batch, длину и тип данных.
Частые вопросы
Что такое grouped query attention простыми словами?
Это схема внимания, где несколько запросных голов совместно используют одну пару ключей и значений. Головы делятся на группы, число групп равно числу KV-голов. Внутри группы запросы считают внимание к общим ключам со своими весами. Это снижает объём KV-кэша по сравнению с MHA.
Чем GQA отличается от MHA и MQA?
MHA даёт каждой query-голове собственную пару K/V, MQA оставляет одну общую пару на все головы. GQA занимает промежуточное положение: группы запросов читают общие пары K/V. В документации IBM указано, что GQA с числом KV-групп, равным числу голов, эквивалентен MHA, а с одной группой — MQA.
Как посчитать размер KV-кэша для GQA?
Формула: два умножить на число KV-голов, на размер головы и на число байт на элемент. Затем умножьте на число сохранённых токенов, размер batch и число учитываемых слоёв. В нашем примере один слой, batch 1, две KV-головы, три токена, размер головы 4 и два байта на элемент дают 96 байт.
Можно ли заменить MHA-чекпоинт на GQA?
Простая правка конфигурации недостаточна. В работе на arxiv.org описан перенос через усреднение исходных голов внутри группы, а в документации IBM — адаптация через дообучение. Нужна поддержка архитектуры и согласованные веса.
Какие условия проверяет PyTorch для GQA?
Документация scaled_dot_product_attention приводит два условия: число query-голов делится на число KV-голов без остатка, и число key-голов равно числу value-голов. Там же GQA отмечен как экспериментальная возможность. Проверяйте эти условия перед запуском.
