Вопрос «какой квант 30B влезет в 12 гигабайт» задают примерно раз в неделю, и ответ обычно звучит так: «Q4, наверное, влезет, но лучше Q3». Откуда берётся «наверное» — понятно: считать лень, а проверить не на чем. GPU у человека нет, поэтому он берёт чужой ответ с форума, где автор тоже взял его с форума.
Мне это надоело настолько, что я написал калькулятор, который не гадает, а считает байты. Не «примерно 18 гигов», а 17.30 ГиБ плюс 20 МиБ метаданных GGUF, потому что блок Q4_K_M — это 144 байта на 256 весов, и из этой дроби всё выводится в столбик.
И сразу главное, чтобы не было разочарования. GPU у меня нет, весов Qwen3 у меня нет, модель я не запускал ни разу. Всё, что ниже — арифметика памяти. Ни одного числа tok/s в этом тексте нет и быть не может. Что это даёт: если у тебя 12 ГиБ и ты собираешься поставить Qwen3-30B-A3B, ты узнаешь заранее, сколько слоёв уедет на GPU, сколько останется в RAM и с каким -ngl идти. Что это не даёт: ответа на вопрос «а быстро ли оно будет». Быстрота зависит от CPU, шины, батча и версии бэкенда, и на этой машине не наблюдается вовсе.
Модель: откуда берутся 30.53 млрд
Qwen3-30B-A3B — MoE: 48 слоёв, 128 экспертов, 8 активных на токен, GQA 32:4, head_dim 128, d_model 2048, словарь 151936. Перечисление тензоров по этим параметрам даёт 30.53 млрд весов и 3.35 млрд активных — совпадает с карточкой модели, где написано 30.5B и ~3.3B. Совпадение я использую как проверку: если бы мой пересчёт архитектуры разошёлся с карточкой, дальше считать было бы бессмысленно.
Важно, что это заявленные числа, а не измеренные. Я их не взвешивал, я их взял из описания и пересчитал формулой. Разница принципиальная и дальше встречается ещё не раз.
bpp — не 4.5, и это первое, на чём ловятся
Все думают, что Q4 — это 4 бита на вес, то есть ровно 4.0 bpp. Нет. Внутри блока кроме самих весов лежат скейлы и минимумы, и они съедают заметную долю. Считается это одной формулой на все кванты:
bpp = block_bytes * 8 / block
Q4_K суперблок 256: 2 d + 2 dmin + 12 scales + 128 qs (4 бита) = 144 → 4.5000
Q4_K_M смесь: attn_v и ffn_down на 24 слоях из 48 и output — в Q6_K,
остальное в Q4_K → средневзвешенно 4.87Отсюда два числа, которые надо держать в голове. Чистый блок Q4_K — это ровно 4.5 bpp, красиво и бесполезно. Реальный файл Q4_K_M — 4.87 bpp, потому что «M» в названии означает смесь, и в ней часть матриц (внимание на value, ffn_down, выходной слой) идёт в шестом разряде. Оба числа в коде посчитаны, а не вписаны, и тест падает, если они разойдутся.
Проверка, которая меня убедила: посчитанные размеры файлов сходятся с опубликованными GGUF в пределах 4.5%. Q4_K_M — 18.57 ГБ, Q8_0 — 32.50 ГБ, Q2_K — 11.31 ГБ. Разница в эти проценты — метаданные, токенизатор и разная точность округления по тензорам, а не ошибка раскладки.
квант bpp ГиБ ГБ
F16 16.01 56.91 61.11
Q8_0 8.52 30.27 32.50
Q6_K 6.58 23.38 25.11
Q5_K_M 5.70 20.25 21.74
Q5_K_S 5.53 19.65 21.10
Q4_K_M 4.87 17.30 18.57
IQ4_XS 4.29 15.25 16.38
Q3_K_M 3.80 13.52 14.52
Q2_K 2.96 10.53 11.31ГиБ и ГБ в одной таблице не для красоты. 18.57 ГБ и 17.30 ГиБ — это один и тот же файл, и ровно на этой разнице люди покупают «16 гигабайт» и удивляются, что модель не влезла.
KV-кэш: вторая половина счёта, о которой забывают
Веса — это только половина. Вторая — кэш внимания, и он растёт линейно по контексту, чего веса не делают. Формула простая:
2 · n_layers · n_kv_heads · head_dim · ctx · байт
2 · 48 · 4 · 128 · ctx · 2 Б = 98304 Б на токенДвойка — потому что хранятся и ключи, и значения. Четыре KV-головы вместо 32 — это GQA, и вот здесь она даёт очень много: MHA той же формы потребовал бы в 8 раз больше памяти. Тот же кэш в q8_0 сжимается почти вдвое, экономия 46.9% на любом контексте, потому что блок 32 значения + 2 байта скейла — это 1.0625 байта на значение вместо двух.
ctx f16 ГиБ q8_0 ГиБ экономия
4096 0.38 0.20 46.9%
8192 0.75 0.40 46.9%
32768 3.00 1.59 46.9%На 8192 контексте кэш — это 0.75 ГиБ, мелочь. На 32768 — уже 3.00 ГиБ, то есть четверть всего бюджета 12-гиговой карты. Именно поэтому «у меня Q4 влезает на 8k» и «у меня Q4 не влезает на 32k» — оба утверждения верны и не противоречат друг другу.
Бюджет: почему не 12
Двенадцать гигабайт — это не двенадцать гигабайт доступной VRAM. Рабочий стол, браузер и драйвер держат своё, и на моей машине это 0.90 ГиБ. Плюс CUDA-контекст, который бэкенд выделяет под себя — 0.20 ГиБ. Остаётся 10.90.
бюджет: 12.00 − 0.90 (дисплей) − 0.20 (CUDA-контекст) = 10.90 ГиБ0.90 — это не «настройка», это факт рабочего стола: у тебя с двумя мониторами и открытым браузером будет больше, с выключенным композитором — меньше. Число параметризовано, подставь своё.
Дальше планировщик раскладывает: слои идут на GPU по одному, пока не кончится бюджет, остальные остаются в системной памяти. Вот что выходит на 8192 контексте с f16-кэшем:
квант bpp файл ГиБ KV ГиБ буф. ГиБ сл. GPU занято остаток
F16 16.01 56.91 0.75 0.23 9/48 10.82 0.08
Q8_0 8.52 30.27 0.75 0.29 16/48 10.42 0.48
Q6_K 6.58 23.38 0.75 0.33 21/48 10.67 0.23
Q5_K_M 5.70 20.25 0.75 0.35 24/48 10.62 0.28
Q5_K_S 5.53 19.65 0.75 0.36 25/48 10.75 0.15
Q4_K_M 4.87 17.30 0.75 0.38 28/48 10.62 0.28
IQ4_XS 4.29 15.25 0.75 0.42 32/48 10.81 0.09
Q3_K_M 3.80 13.52 0.75 0.45 36/48 10.80 0.10
Q2_K 2.96 10.53 0.75 0.52 45/48 10.70 0.20Ни один квант не влезает целиком. Даже Q2_K даёт 45 слоёв из 48 — потому что даже у него веса весят 10.53 ГиБ, а бюджета 10.90, и на кэш с буферами уже не остаётся. Вот это и есть честный ответ на исходный вопрос: 30B-класс в 12 гигабайт целиком не влезает ни в каком кванте. Влезает частично, и дальше вопрос только в том, сколько слоёв уедет на карту.
Буферы вычислений — единственная оценка в этой таблице. 0.16 ГиБ плюс 8 МиБ на слой, диапазон ±30%, и я это помечаю везде: в CLI, в таблице, в README, на схеме. Всё остальное — байты по блокам квантов и формула кэша, то есть точная арифметика.
И отдельно про MoE. У моделей с экспертами есть --n-cpu-moe, который выносит экспертные матрицы в RAM, оставляя на GPU внимание и роутер. В плане 1 этот параметр стоит в нуле, потому что я считал честный частичный оффлоад по слоям. Если у тебя быстрая память и медленный PCIe — вариант с --n-cpu-moe может оказаться быстрее, но я его не считал и не мерил, и выдумывать тут нечего.
Два плана, чтобы было видно разницу
Первый: Q4_K_M, контекст 8192. 28 слоёв на GPU, веса на карте 9.80 ГиБ, по 358 МиБ на слой, кэш на карте 0.44, буферы 0.38, занято 10.62, остаток 0.28. В системной памяти остаётся 7.81 ГиБ — веса CPU-слоёв плюс их кэш.
llama.cpp: -ngl 28 -c 8192 -ctk f16 -ctv f16Второй: Q5_K_S, контекст 32768. 22 слоя, веса на карте 8.80 ГиБ (по 409 МиБ), кэш на карте 1.38 из 3.00, буферы 0.34, занято 10.51, остаток 0.39. В RAM — 12.48 ГиБ.
llama.cpp: -ngl 22 -c 32768 -ctk f16 -ctv f16Смотри, что произошло: контекст вырос вчетверо, квант стал тяжелее, и на карту влезло на шесть слоёв меньше. Это не «плохой конфиг», это трейд-офф, и его лучше увидеть числом до запуска, а не после.
Оба конфига в архиве — текст, а не прогон. Я их не запускал. Команды синтаксически соответствуют текущему llama.cpp, но конкретная сборка может ругаться на -fa off или на -ub, и проверять это должен ты на своей машине.
Что здесь измерено, а что нет
Измерено на железе — ничего. Ни GPU, ни весов на этой машине нет, ни одного прогона модели не было. Посчитано: байты весов по блокам квантов, байты KV-кэша, число слоёв, которые влезают в бюджет, остаток. Проверено 95 тестами: bpp монотонны по квантам и совпадают с опубликованными размерами файлов, KV линеен по контексту и по числу KV-голов, GQA ровно в четыре раза меньше MHA по числу голов, планировщик не уходит в минус и не выдумывает несуществующие слои.
И отдельно: тест test_no_command_prints_a_speed падает, если рядом со словом tok/s появится число. Это не шутка и не поза. Я один раз поймал себя на том, что хочу вписать «примерно 8 tok/s на 12 гигабайтах, судя по отзывам» — и остановил, потому что это ровно то враньё, из-за которого чужие гайды бесполезны. В архиве скорость не упоминается ни разу, кроме строки «скорость в tok/s не измерялась».
Что ещё не проверено и важнее тестов: я не знаю, насколько реальная производительность совпадёт с этими планами. Оценка буферов ±30% может оказаться оптимистичной на конкретной карте, драйвер может съесть не 0.90, а 1.4 ГиБ, а Flash Attention в разных версиях llama.cpp меняет потребление заметно. Всё это выясняется одним запуском на живой машине, и такого запуска у меня не было.
Запуск
python -m vram plan --quant Q4_K_M --vram 12 --ctx 8192
python -m vram table --vram 12 --ctx 8192
python -m vram kv --ctx 4096 8192 32768
python -m vram quants
python -m pytest tests -q # 95 passed
python make_transcript.py # пересобрать transcript.txtЗависимостей нет вообще: стандартная библиотека и всё. Если хочешь посчитать под свою карту — подставь --vram и вычти из него свой рабочий стол. Если под другую модель — в vram/model.py лежит описание архитектуры, и его достаточно поменять в одном месте.
Структура
vram/model.py архитектура: слои, эксперты, GQA, словарь; пересчёт в число весов
vram/quant.py блочные раскладки, bpp, размеры файлов, смесь Q4_K_M
vram/kvcache.py формула KV, сжатие q8_0, зависимость от числа KV-голов
vram/plan.py бюджет, раскладка по слоям, остаток, конфиг llama.cpp
vram/cli.py plan / table / kv
tests/ 95 тестов
transcript.txt полный вывод прогонаВ архиве всё это плюс README и схема, на которой видно, как полоса бюджета нарезается на веса, кэш, буферы и остаток. Если забирать из темы одну мысль — пусть это будет «Q4_K_M это 4.87, а не 4.5» и «кэш на 32k стоит три гигабайта». С этими двумя числами ты сам посчитаешь любую карту за минуту и перестанешь спрашивать на форумах.