Вопрос «какая видеокарта нужна под модель N миллиардов параметров» обычно получает ответ «возьмите побольше». Но это можно посчитать на салфетке, и считать нужно не только веса модели. На практике память чаще кончается не из-за весов, а из-за KV-кэша, когда к сервису приходит десяток пользователей с длинным контекстом. Ниже — две формулы, таблица для популярных моделей и разбор трёх типовых сценариев.
Все цифры получены из опубликованных конфигураций моделей (число слоёв, голов внимания, размер головы) и проверяются калькулятором. Это оценка снизу: реальные движки добавляют свои накладные расходы, о них — в конце.
Формула 1: веса модели
Память под веса = число параметров × байт на параметр.
|
Точность |
Байт на параметр |
|---|---|
|
FP16 / BF16 |
2 |
|
FP8 / INT8 |
1 |
|
INT4 (AWQ, GPTQ, GGUF Q4) |
≈ 0,55–0,6 |
У 4-битного квантования не ровно 0,5 байта: к весам добавляются масштабы и нулевые точки групп, а часть слоёв (эмбеддинги, иногда выходной слой) часто остаётся в 16 битах. Для оценки берём 0,56.
|
Модель |
Параметров |
FP16 |
INT8 |
INT4 |
|---|---|---|---|---|
|
Llama 3.1 8B |
8,0 млрд |
16,1 ГБ |
8,0 ГБ |
≈ 4,5 ГБ |
|
Qwen2.5 32B |
32,8 млрд |
65,6 ГБ |
32,8 ГБ |
≈ 18,4 ГБ |
|
Llama 3.1 70B |
70,6 млрд |
141 ГБ |
70,6 ГБ |
≈ 39,5 ГБ |
Отсюда первый вывод: 70B в FP16 не помещается даже в одну H100 на 80 ГБ, а в INT4 — помещается в одну карту на 48 ГБ. Но только веса.
Формула 2: KV-кэш
При генерации модель хранит для каждого уже обработанного токена ключи и значения внимания на каждом слое. Это и есть KV-кэш. На один токен:
KV на токен = 2 × число слоёв × число KV-голов × размер головы × байт на элемент
Двойка — потому что хранятся и ключи, и значения. Ключевой множитель — число KV-голов. Современные модели используют grouped-query attention (GQA): у них голов запросов много, а голов ключей и значений — мало, обычно 8. Это в разы уменьшает кэш.
|
Модель |
Слоёв |
KV-голов |
Размер головы |
KV на токен, FP16 |
|---|---|---|---|---|
|
Llama 3.1 8B |
32 |
8 |
128 |
128 КиБ |
|
Qwen2.5 32B |
64 |
8 |
128 |
256 КиБ |
|
Llama 3.1 70B |
80 |
8 |
128 |
320 КиБ |
|
Llama 2 7B (без GQA) |
32 |
32 |
128 |
512 КиБ |
Пример расчёта для Llama 3.1 70B: 2 × 80 × 8 × 128 × 2 байта = 327 680 байт = 320 КиБ на токен.
Последняя строка для сравнения: у старой Llama 2 7B без GQA кэш на токен вчетверо больше, чем у Llama 3.1 8B, хотя модель меньше.
Сколько кэша на один диалог
Умножаем на длину контекста:
|
Модель |
8K токенов |
32K |
128K |
|---|---|---|---|
|
Llama 3.1 8B |
1 ГиБ |
4 ГиБ |
16 ГиБ |
|
Qwen2.5 32B |
2 ГиБ |
8 ГиБ |
32 ГиБ |
|
Llama 3.1 70B |
2,5 ГиБ |
10 ГиБ |
40 ГиБ |
Один пользователь с полным контекстом 128K на 70B занимает 40 ГиБ — столько же, сколько сама модель в INT4. Это тот момент, когда «модель же влезла» перестаёт работать.
Итоговая формула
Память ≈ веса + KV на токен × контекст × число одновременных запросов + накладные расходы
Накладные расходы: CUDA-контекст (сотни мегабайт на карту), активации, буферы движка. vLLM по умолчанию забирает 90% памяти карты (параметр gpu_memory_utilization) и всё, что осталось после весов, отдаёт под кэш. Поэтому на практике вопрос звучит так: сколько одновременных диалогов нужной длины поместится в остаток.
Три сценария
1. Внутренний ассистент на Llama 3.1 8B, 50 пользователей, контекст 8K. Веса в FP16 — 16 ГБ. Кэш: 50 × 1 ГиБ = 50 ГиБ. Итого около 66 ГБ плюс накладные. Одна карта на 80 ГБ справится, на 48 ГБ придётся резать либо число одновременных запросов, либо контекст. Важная оговорка: 50 пользователей в чате — это не 50 одновременных генераций. Реально одновременно работает меньше, и движок с постраничным кэшем (PagedAttention в vLLM) выделяет память по факту, а не под максимальный контекст каждого.
2. Llama 3.1 70B в INT4, 20 одновременных запросов по 8K. Веса — около 40 ГБ. Кэш в FP16: 20 × 2,5 ГиБ = 50 ГиБ. Итого около 90 ГБ — в одну H100 на 80 ГБ не входит. Варианты: две карты по 48 ГБ с тензорным параллелизмом или кэш в FP8, который делит 50 ГиБ пополам. Тогда 40 + 25 = 65 ГБ — в 80 ГБ помещается с запасом под накладные.
3. Llama 3.1 70B, длинные документы по 128K. Только кэш одного такого запроса — 40 ГиБ. Для нескольких одновременных нужны либо 2–4 карты по 80 ГБ, либо FP8-кэш, либо честное признание: столько контекста не нужно, и документы лучше резать на части и искать по ним (RAG).
Что уменьшает память и чем за это платят
-
Квантование весов в INT4 — минус ~70% к FP16. Плата — небольшая потеря качества, сильнее заметная на малых моделях и в задачах с точными фактами и кодом.
-
FP8-кэш — вдвое меньше KV-кэша. Поддерживается в vLLM и TensorRT-LLM. Аппаратная поддержка FP8 есть у Ada Lovelace и Hopper, на старших поколениях проверяйте, что ваш движок и версия это умеют.
-
Тензорный параллелизм — веса и кэш делятся между картами. Плата — обмен данными между картами на каждом слое. С NVLink это почти бесплатно, через PCIe на больших моделях ощутимо.
-
Меньший контекст. Самый дешёвый способ. Если 95% запросов укладываются в 8K, ставить лимит 128K ради редких случаев — дорогое решение.
Ориентиры по картам
|
Видеопамять |
Примеры карт |
Что помещается с разумным запасом |
|---|---|---|
|
24 ГБ |
RTX 3090, RTX 4090, RTX A5000 |
8B в FP16 с несколькими диалогами; 32B в INT4 на короткий контекст |
|
32 ГБ |
Tesla V100 32GB |
8B с запасом; 32B в INT4 |
|
48 ГБ |
RTX A6000, L40S |
32B в INT4 с запасом; 70B в INT4 на один-два коротких диалога |
|
80 ГБ |
A100 80GB, H100 |
70B в INT4 с десятком диалогов по 8K; 32B в FP16 |
|
141 ГБ |
H200 |
70B в INT8 с запасом под кэш |
Отдельно про старшие поколения: Tesla V100 (архитектура Volta) не поддерживает BF16 и FP8, и часть оптимизированных ядер для квантования в популярных движках требует архитектуру Turing или новее. Прежде чем строить расчёт на такой карте, проверьте в документации движка, какие режимы на ней работают.
Как проверить расчёт у себя
-
Возьмите config.json модели и найдите num_hidden_layers, num_key_value_heads и head_dim (или hidden_size, делённый на num_attention_heads).
-
Посчитайте KV на токен по формуле выше.
-
Запустите vLLM и посмотрите в логе строку о размере KV-кэша и максимальной параллельности для заданной длины контекста — движок считает то же самое и печатает результат при старте.
-
Под нагрузкой смотрите nvidia-smi и метрики движка: если запросы уходят в очередь при свободной вычислительной мощности, упираетесь в память под кэш.
Итог
Память под LLM — это веса плюс кэш, и кэш растёт линейно с длиной контекста и числом одновременных запросов. Для небольших моделей и коротких диалогов хватает одной карты на 24–48 ГБ. Для 70B с десятком пользователей нужна либо карта на 80 ГБ с FP8-кэшем, либо две карты. Для длинного контекста считайте кэш до покупки железа, а не после.
Автор: tsKirill


