# Квантизация моделей

> Сжатие нейросетей переводом весов и активаций в числа пониженной точности (8, 4 бита и меньше) ради экономии памяти и ускорения инференса.

Источник: https://llmdocs.ru/wiki/quantization/ · обновлено 2026-11-09 · лицензия CC BY-SA 4.0

- **Цель**: меньше памяти, выше скорость, ниже стоимость инференса
- **Форматы чисел**: FP16, BF16, FP8, INT8, INT4, NF4
- **Подходы**: после обучения (PTQ), с учётом квантизации при обучении (QAT)
- **Методы для LLM**: GPTQ, AWQ, bitsandbytes, k-квантизация GGUF
- **Инструменты**: llama.cpp, bitsandbytes, AutoGPTQ, TensorRT, ONNX Runtime
**Квантизация** (англ. *quantization*) — способ сжатия [нейросетей](https://llmdocs.ru/wiki/neural-network.md), при котором веса, а иногда и промежуточные значения (активации), хранятся и обрабатываются в числах пониженной точности: вместо 16 или 32 бит на число — 8, 4 или даже меньше. Модель становится в несколько раз меньше и быстрее при умеренной потере качества. Благодаря квантизации [большие языковые модели](https://llmdocs.ru/wiki/llm.md) запускаются на одной видеокарте, ноутбуке или телефоне.[1]

## Зачем

Размер модели в памяти ≈ число параметров × байт на параметр:

| Точность | Байт на параметр | Модель 8 млрд параметров | Модель 70 млрд |
|---|---|---|---|
| FP32 | 4 | ~32 ГБ | ~280 ГБ |
| BF16 / FP16 | 2 | ~16 ГБ | ~140 ГБ |
| INT8 / FP8 | 1 | ~8 ГБ | ~70 ГБ |
| 4 бита | ~0,5 | ~4,5 ГБ | ~40 ГБ |

При генерации текста скорость LLM ограничена в основном пропускной способностью памяти: на каждый токен нужно прочитать все веса. Поэтому сжатие весов вдвое почти вдвое ускоряет генерацию — помимо того, что модель вообще помещается в [видеопамять](https://llmdocs.ru/wiki/gpu-cuda.md).

## Как это работает

Диапазон вещественных значений отображается на небольшое множество целых чисел с помощью **масштаба** (scale) и, возможно, **сдвига** (zero point):

$$q = \mathrm{round}(x / s) + z, \qquad \hat{x} = s \cdot (q - z)$$

Чем мельче группы, для которых подбирается свой масштаб (по тензору, по каналу, по блокам из 32–128 значений), тем точнее приближение и тем больше накладных расходов на хранение масштабов. Главная трудность — **выбросы**: в трансформерах отдельные признаки принимают значения в сотни раз больше остальных, и общий масштаб «съедает» точность для всех прочих.[2]

## Подходы

- **Квантизация после обучения** (PTQ, post-training quantization) — модель квантуется готовой, обычно с небольшим калибровочным набором данных. Быстро и дёшево — основной вариант для LLM.
- **Обучение с учётом квантизации** (QAT, quantization-aware training) — округление имитируется во время обучения, и модель адаптируется к нему. Точнее, но требует ресурсов обучения; применяется для мобильных моделей и при агрессивном сжатии.
- **Динамическая** и **статическая** квантизация активаций — масштабы вычисляются на лету или заранее.[6]

## Методы для LLM

- **LLM.int8()** (bitsandbytes) — 8-битное умножение с выделением выбросов в 16-битную часть.[2]
- **GPTQ** — послойная квантизация до 3–4 бит с компенсацией ошибки на основе приближённой информации второго порядка.[3]
- **AWQ** — защищает около 1% «важных» весов, выбранных по величине активаций.[4]
- **NF4 и QLoRA** — 4-битный формат, приспособленный к нормальному распределению весов; позволяет дообучать квантованную модель адаптерами LoRA (см. [Fine-tuning и LoRA](https://llmdocs.ru/wiki/fine-tuning-lora.md)).[5]
- **k-квантизация в [GGUF](https://llmdocs.ru/wiki/gguf.md)** — семейство форматов llama.cpp (`Q4_K_M`, `Q5_K_M`, `Q8_0` и др.) со смешанной точностью разных слоёв; стандарт для локального запуска.[7]
- **FP8 и FP4** — аппаратная поддержка на новых GPU позволяет и обучать, и обслуживать модели в 8-битных и 4-битных форматах с плавающей точкой.

```bash
# llama.cpp: квантизовать модель до 4 бит
llama-quantize model-f16.gguf model-Q4_K_M.gguf Q4_K_M
```

```python
# Transformers + bitsandbytes: загрузить модель сразу в 4 битах
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
cfg = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-8B", quantization_config=cfg)
```

## Качество

Практическое правило для LLM: 8 бит почти неотличимы от исходной модели, 5–6 бит — потери едва заметны, 4 бита — разумный компромисс, ниже 3 бит качество падает заметно. Крупная модель в 4 битах обычно лучше маленькой модели той же памяти в 16 битах. Сильнее всего страдают точные задачи — математика, код, длинный контекст, — поэтому квантованную модель стоит проверять на своих задачах (см. [Оценка LLM (evals)](https://llmdocs.ru/wiki/llm-evals.md)). Квантуют также KV-кэш, чтобы вместить более длинное [контекстное окно](https://llmdocs.ru/wiki/context-window.md).

## См. также

- [GGUF](https://llmdocs.ru/wiki/gguf.md)
- [Локальный запуск LLM (llama.cpp, Ollama)](https://llmdocs.ru/wiki/local-llm.md)
- [GPU и CUDA](https://llmdocs.ru/wiki/gpu-cuda.md)
- [Fine-tuning и LoRA](https://llmdocs.ru/wiki/fine-tuning-lora.md)
- [Сервинг моделей](https://llmdocs.ru/wiki/model-serving.md)

## Источники

1. [Hugging Face — Quantization overview](https://huggingface.co/docs/transformers/main/en/quantization/overview)
2. [Dettmers et al. — LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale (2022)](https://arxiv.org/abs/2208.07339)
3. [Frantar et al. — GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers (2022)](https://arxiv.org/abs/2210.17323)
4. [Lin et al. — AWQ: Activation-aware Weight Quantization (2023)](https://arxiv.org/abs/2306.00978)
5. [Dettmers et al. — QLoRA: Efficient Finetuning of Quantized LLMs (2023)](https://arxiv.org/abs/2305.14314)
6. [PyTorch — Quantization (torchao)](https://pytorch.org/ao/stable/index.html)
7. [llama.cpp — quantize tool](https://github.com/ggml-org/llama.cpp/tree/master/tools/quantize)