Квантизация моделей: как запустить большую LLM на слабом GPU

Llama 3.1 70B в полном формате (FP16) занимает 140 ГБ видеопамяти — это две видеокарты A100 80 ГБ стоимостью $30 000. Квантизация позволяет запустить ту же модель на одной RTX 4090 за 150 000 ₽ с потерей качества всего 1–3%. В этом гиде разберём, как это работает и как применить на практике.

Что такое квантизация

Квантизация — это уменьшение точности числовых значений в нейросети. Каждый параметр (вес) модели хранится как число с плавающей точкой. Чем меньше бит на число — тем меньше занимает модель.

Формат	Бит на параметр	Размер 7B модели	Размер 70B модели	Потеря качества
FP32 (полный)	32	28 ГБ	280 ГБ	0% (эталон)
FP16 / BF16	16	14 ГБ	140 ГБ	~0%
INT8 (Q8_0)	8	7.5 ГБ	75 ГБ	0.1–0.5%
Q6_K	6.5	5.5 ГБ	55 ГБ	0.2–0.8%
Q5_K_M	5.5	5 ГБ	48 ГБ	0.5–1.5%
Q4_K_M	4.8	4.5 ГБ	40 ГБ	1–2%
Q3_K_M	3.9	3.5 ГБ	33 ГБ	2–5%
Q2_K	2.6	2.5 ГБ	25 ГБ	5–15% (не рекомендуется)

Форматы квантизации

GGUF (llama.cpp)

Самый популярный формат для локального запуска. Создан проектом llama.cpp. Поддерживается Ollama, LM Studio, и напрямую llama.cpp.

Варианты GGUF-квантизации (от лучшего качества к наименьшему размеру):

• Q8_0 — почти без потерь, но большой размер. Для тех, кому хватает VRAM.
• Q6_K — отличный баланс. Рекомендуется, если помещается.
• Q5_K_M — хороший компромисс. Минимальные потери для большинства задач.
• Q4_K_M — «золотой стандарт». Оптимальный баланс качества и размера. Если не знаете, что выбрать — берите Q4_K_M.
• Q3_K_M — для ситуаций, когда не хватает 2–3 ГБ. Заметная деградация на сложных задачах.
• Q2_K — крайний случай. Качество падает значительно.

GPTQ

Метод квантизации, оптимизированный для GPU (NVIDIA). Работает через библиотеку AutoGPTQ. Быстрый inference, но менее гибкий, чем GGUF.

AWQ (Activation-Aware Weight Quantization)

Улучшенный GPTQ: учитывает важность каждого веса при квантизации. Обычно даёт лучшее качество при том же уровне сжатия.

Сравнение форматов

Формат	Платформа	CPU	GPU NVIDIA	GPU AMD	Apple Silicon
GGUF	llama.cpp / Ollama	Да	Да	Да	Да (Metal)
GPTQ	AutoGPTQ / vLLM	Нет	Да (CUDA)	Частично	Нет
AWQ	AutoAWQ / vLLM	Нет	Да (CUDA)	Частично	Нет

Бенчмарки: качество vs размер

Тестирование Llama 3.2 8B на бенчмарке MMLU (5-shot):

Квантизация	Размер	MMLU	Потеря	Скорость (RTX 4090)
FP16 (эталон)	16.1 ГБ	73.0	—	55 tok/s
Q8_0	8.5 ГБ	72.8	-0.3%	85 tok/s
Q6_K	6.6 ГБ	72.5	-0.7%	95 tok/s
Q5_K_M	5.7 ГБ	72.1	-1.2%	100 tok/s
Q4_K_M	4.9 ГБ	71.5	-2.1%	110 tok/s
Q3_K_M	4.0 ГБ	69.8	-4.4%	115 tok/s
Q2_K	3.2 ГБ	64.2	-12.1%	120 tok/s

Важное наблюдение: квантизация ускоряет inference! Меньше данных на загрузку из памяти → быстрее генерация. Q4_K_M на RTX 4090 генерирует на 100% быстрее, чем FP16.

Как квантизовать модель

Через llama.cpp (GGUF)

# 1. Клонируем llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
pip install -r requirements.txt

# 2. Скачиваем модель с Hugging Face
# (нужен huggingface-cli)
pip install huggingface_hub
huggingface-cli download meta-llama/Llama-3.2-8B   --local-dir models/llama-3.2-8b

# 3. Конвертируем в GGUF (FP16)
python convert_hf_to_gguf.py models/llama-3.2-8b   --outfile models/llama-3.2-8b-f16.gguf

# 4. Квантизуем
./build/bin/llama-quantize   models/llama-3.2-8b-f16.gguf   models/llama-3.2-8b-q4_k_m.gguf   Q4_K_M

# Другие варианты: Q8_0, Q6_K, Q5_K_M, Q3_K_M, Q2_K

Через AutoGPTQ (Python)

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

model_name = "meta-llama/Llama-3.2-8B"
output_dir = "./llama-3.2-8b-gptq-4bit"

tokenizer = AutoTokenizer.from_pretrained(model_name)
quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=True,
)

model = AutoGPTQForCausalLM.from_pretrained(
    model_name, quantize_config=quantize_config
)

# Калибровочные данные (чем лучше — тем лучше результат)
examples = [
    tokenizer("Пример текста для калибровки модели...",
              return_tensors="pt")
    for _ in range(128)
]

model.quantize(examples)
model.save_quantized(output_dir)
tokenizer.save_pretrained(output_dir)

Практические рекомендации

7B модель на 8 ГБ VRAM (RTX 3060/4060)

• Оптимально: Q4_K_M (4.9 ГБ) — остаётся 3 ГБ на контекст
• Максимальный контекст: Q3_K_M (4.0 ГБ) — больше места для KV-кэша
• Рекомендация: Q4_K_M с контекстом 4096–8192 токенов

13B модель на 12 ГБ VRAM (RTX 3060 12 ГБ)

• Оптимально: Q4_K_M (8 ГБ) — помещается с комфортом
• Если нужен длинный контекст: Q3_K_M (6.5 ГБ)

70B модель на 24 ГБ VRAM (RTX 4090)

• Q4_K_M (40 ГБ) — не помещается! Нужна частичная выгрузка на CPU
• Q3_K_M (33 ГБ) — тоже не помещается полностью
• Решение: частичная загрузка (GPU offloading) — 35 из 80 слоёв на GPU, остальное на CPU

# llama.cpp: частичная выгрузка (35 слоёв на GPU из 80)
./build/bin/llama-cli   -m models/llama-3.1-70b-q4_k_m.gguf   -ngl 35   -p "Ваш промпт"   -n 512

# Ollama: автоматически определяет, сколько слоёв помещается
ollama run llama3.1:70b-q4_K_M

Где скачать готовые квантизованные модели

Не обязательно квантизовать самому. На Hugging Face есть готовые GGUF-версии всех популярных моделей. Главный поставщик — TheBloke (для старых моделей) и bartowski (для новых).

# Скачать готовую модель
huggingface-cli download bartowski/Meta-Llama-3.1-70B-Instruct-GGUF   --include "Meta-Llama-3.1-70B-Instruct-Q4_K_M.gguf"   --local-dir models/

# Или через Ollama (скачает автоматически)
ollama pull llama3.1:70b

FAQ

Можно ли квантизовать без потерь?

Q8_0 (INT8) теряет менее 0.5% качества — практически неотличимо от оригинала. Для большинства задач Q4_K_M (потеря ~2%) тоже незаметна в реальном использовании.

Какую квантизацию выбрать по умолчанию?

Q4_K_M — лучший баланс. Если VRAM много — Q6_K. Если мало — Q3_K_M. Ниже Q3 не рекомендуется.

GGUF или GPTQ?

GGUF — если вы используете Ollama, LM Studio или llama.cpp (98% случаев). GPTQ/AWQ — если вы развёртываете через vLLM или TGI на NVIDIA-серверах.

Можно ли дообучить квантизованную модель?

Для fine-tuning обычно используют полную (FP16) модель, а квантизуют результат. Но QLoRA позволяет fine-tuning прямо на квантизованной модели — экономя 75% VRAM.