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

Если совсем простым языком говорить, это как сжатие в JPEG для фотографий с незначительной потерей точности. Размер файла уменьшается в разы, цена — потеря микроскопических деталей, которые глаз не заметит.

1. Зачем понадобилось квантование

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

По умолчанию современные модели сохраняются в формате FP16 (16-битные числа с плавающей точкой). Это означает, что каждый параметр занимает 2 байта памяти.

Замечание 1. Что это значит на практике? Модель Llama-3 8B (8 миллиардов параметров) будет занимать: 8 млрд × 2 байта = 16 ГБ. Таким образом, чтобы запустить такую небольшую модель, понадобится минимум 16+ ГБ оперативной памяти, если это работает на CPU.

Как работает квантование: оно берет эти точные 16-битные числа и «округляет» до 8-битных (INT8) или 4-битных (INT4) целых чисел. То есть в первом случае сжатие происходит в 2 раза (до 8 ГБ), а во втором — в 4 раза (до 4 ГБ). Этого вполне достаточно для CPU с RAM 16 ГБ.

Важно: Многие ошибочно полагают, что квантование — это какой-то динамический процесс. На самом деле это не так. Квантование — это разовая операция, она превращает обычную модель в квантованную.

2. Практический пример расчета

Шаг 1. Допустим, мы квантуем следующие веса:
w = [-1.0, -0.6, 0.2, 0.8] — пусть они заданы в формате с плавающей точкой (FP32 или FP16).

Шаг 2. Хотим квантовать в 4 бита (INT4).
То есть у нас есть интервал значений [0; 15] — по сути, нам надо уместить точность в этот интервал.
Находим размах = [min; max] или [-1.0; 0.8].
range = x_max - x_min = 0.8 - (-1.0) = 1.8

Шаг 3. Считаем шаг квантования:
scale = range / (2^4 - 1) = 1.8 / 15 = 0.12

Вычисляем zero_point (целочисленное смещение, соответствующее реальному нулю):
zero_point = round(-x_min / scale) = round(-(-1.0) / 0.12) = round(8.33) = 8

Шаг 4. Квантование (через zero_point):
w_01 = round(-1.0 / 0.12) + 8 = round(-8.33) + 8 = -8 + 8 = 0
w_02 = round(-0.6 / 0.12) + 8 = round(-5.0) + 8 = -5 + 8 = 3
w_03 = round(0.2 / 0.12) + 8 = round(1.67) + 8 = 2 + 8 = 10
w_04 = round(0.8 / 0.12) + 8 = round(6.67) + 8 = 7 + 8 = 15
[-1.0, -0.6, 0.2, 0.8] -> [0, 3, 10, 15]

Шаг 5. Обратное восстановление (деквантование):
w_approx_01 = (0 - 8) × 0.12 = -8 × 0.12 = -0.96 (Исходно было -1.0, ошибка: +0.04)
w_approx_02 = (3 - 8) × 0.12 = -5 × 0.12 = -0.60 ✓ (точное совпадение)
w_approx_03 = (10 - 8) × 0.12 = 2 × 0.12 = 0.24 (Исходно было 0.2, ошибка: +0.04)
w_approx_04 = (15 - 8) × 0.12 = 7 × 0.12 = 0.84 (Исходно было 0.8, ошибка: +0.04)

Этот алгоритм называется асимметричное линейное квантование (Affine Quantization) и является базовым для понимания алгоритма квантования.

Как это работает на практике во время инференса? Происходит ли обратное восстановление на каждом шаге?

Служебная информация (scale и zero_point) хранится внутри файла модели (или в метаданных рядом с ней). Когда движок инференса (например, llama.cpp) загружает модель, он читает веса, которые упакованы в INT4 (квантованы). Во время инференса все тяжелые вычисления в «кишках» (матричные умножения) идут напрямую с этими квантованными целыми числами (INT4 × INT8), что экономит память и дает огромную скорость. При этом на каждом слое (и для каждой группы весов внутри слоя) движок берет результаты целочисленных вычислений и сразу же умножает их на соответствующий scale, чтобы перевести результат обратно в привычные числа с плавающей точкой (FP32/FP16) для передачи на следующий слой.

Важно: На практике часто веса разбивают на группы, например по 32, 64, 128 или 256 значений. Для каждой группы считают свой scale. Это нужно потому, что разные группы весов могут иметь разные диапазоны.

3. Насколько сильно теряется качество?

Казалось бы, при потере точности должно падать и качество модели. Но на практике 4-битное квантование (Q4) практически неотличимо от оригинала для обычного пользователя (https://arxiv.org/abs/2306.00978).

Почему так происходит? Оказалось, что не все параметры (веса) в нейросети одинаково важны.

1. ~90% весов — это «шум», фоновые знания. Их можно грубо округлить, и модель этого даже не заметит.
2. ~10% весов — это «VIP-нейроны» (salient weights). Они критически важны для логики, грамматики и фактологии. Если округлить их грубо, модель сломается.

Важно: Современные алгоритмы квантования (например, AWQ или GGUF с микшированием) работают умно: они находят эти VIP-веса и оставляют их в высоком разрешении (например, в 8 или 16 бит), а всё остальное сжимают до 4 бит. Это называется квантованием с учетом важности.

Когда НЕ СТОИТ (или опасно) использовать:

• Сложный кодинг, математика и многошаговая логика, где нужно выстроить длинную цепочку рассуждений.
• Полноценное обучение (Full Fine-Tuning): если планируется обучать модель с нуля или делать глубокое дообучение.
• Исследования и честные бенчмарки (тут очевидно).
• Медицина, юриспруденция и финансы, где «галлюцинация» или микро-ошибка из-за округления весов может привести к судебным искам или потере денег.

4. Популярные форматы квантования (В чем разница?)

Если выделить форматы квантования, которые де-факто покрывают ~80% всех реальных сценариев использования (от локальных машин до корпоративного продакшена), то список сужается до двух-трех основных игроков (информация актуальна на 2026 год). Остальные можно смело упоминать вскользь как нишевые или устаревающие (EXL2, HQQ, старый GGML и др.).
(https://www.local-llm.net/learn/quantization-explained/?spm=a2ty_o01.29997173.0.0.61cc55fbMmOyly)

GGUF (джи-джи-ю-эф)

Расшифровывается как GPT-Generated Unified Format (единый формат, сгенерированный или созданный для GPT). Это стандарт экосистемы llama.cpp. На нем работают Ollama, LM Studio, Llamafile и большинство локальных инструментов.

• Абсолютный лидер для CPU и локального использования.
• Используется в популярных оболочках: Ollama, LM Studio, Llamafile и др.
• Главная фишка: в отличие от равномерного сжатия, современные методы GGUF (K-quants) анализируют важность каждого слоя. Критически важным слоям (например, механизму внимания) выделяется больше бит, а менее важным — меньше, что дает лучший баланс качества и размера. Кроме того, GGUF упаковывает веса модели, токенизатор и все метаданные в один единственный файл, избавляя от необходимости хранить рядом кучу конфигов.
• Расшифровка суффикса: Q[число][метод][размер].
  • Q (Quantization) — квантование.
  • Число (2, 3, 4, 5, 6, 8) — среднее количество бит на один вес модели (чем меньше число, тем сильнее сжатие и меньше файл, но ниже качество).
  • Метод:
  • K (K-quants) — использует смешанную точность: важным слоям модели даёт больше бит, менее важным — меньше. Это лучший баланс качества и размера.
  • _0 или _1 — старые равномерные методы (все веса сжимаются одинаково, сейчас используются реже, кроме Q8_0 для почти полного сохранения качества).
  • Размер (применяется только к методу K):
  • S (Small) — минимальный размер, качество немного проседает.
  • M (Medium) — золотая середина (например, Q4_K_M — самый популярный и рекомендуемый формат).
  • L (Large) — больший размер файла, качество максимально приближено к оригиналу для данного числа бит.

AWQ (Ок)

Расшифровывается как Activation-aware Weight Quantization (Квантование весов с учетом активаций). Это современный де-факто стандарт для эффективного и быстрого запуска моделей на видеокартах (GPU) как в продакшене, так и у продвинутых локальных пользователей.

• Абсолютный лидер для GPU и локального использования (не поддерживает эффективный запуск на CPU).
• Используется в продакшен-инструментах: vLLM, TensorRT-LLM, SGLang, AutoAWQ и современных версиях Hugging Face transformers.
• Главная фишка (защита "VIP-весов"): исследования показали, что лишь ~10% весов модели вызывают сильные "всплески" активаций и критически важны для качества. AWQ находит эти веса и защищает их от ошибок сжатия (масштабирует их), в то время как остальные 90% сжимаются агрессивно.
• Расшифровка суффикса/маркировки: в отличие от GGUF, у AWQ нет сложной системы суффиксов, так как он почти всегда используется в одном варианте. Маркируется просто как awq или w4a16 (4 бита на веса, 16 бит на активации). В названиях файлов на Hugging Face обычно выглядит как ...-AWQ или ...-4bit-AWQ.

GPTQ (джи-пи-ти-кью)

Расшифровывается как Generative Pre-trained Transformer Quantization (Квантование генеративных предобученных трансформеров). Это «старый надёжный» стандарт квантования для видеокарт NVIDIA. Долгое время был единственным нормальным способом сжать модель для GPU, пока его не потеснил AWQ, но он до сих пор массово встречается на Hugging Face.

• Только для видеокарт NVIDIA (GPU): не умеет работать на CPU. Требует CUDA.
• Используется в проверенных инструментах: AutoGPTQ, ExLlamaV2, vLLM, TGI, Hugging Face transformers (через AutoGPTQForCausalLM).
• Главная фишка (компенсация ошибок): квантует модель слой за слоем, используя калибровочный датасет. Для каждого слоя вычисляет матрицу Гессе (вторые производные) и «перераспределяет» ошибку квантования на соседние веса — так называемая компенсация ошибок. Это даёт хорошее качество при 4 битах.
• Расшифровка суффикса/маркировки: в названиях обычно выглядит как ...-GPTQ-4bit или ...-gptq-int4. Ключевые параметры, на которые стоит смотреть:
  • 4bit / 8bit — количество бит на вес (чаще всего 4).
  • group_size (128, 64, 32) — размер группы весов, к которым применяется общий масштаб. Чем меньше группа, тем лучше качество, но больше файл. Стандарт — group_size=128.
  • desc_act=True/False — упорядочивает активации по убыванию перед квантованием. При True качество чуть выше, но загрузка модели идёт дольше.
  • Пример: Llama-2-7B-GPTQ-4bit-g128 = 4 бита, группа 128, стандартное качество.

Выводы

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

2. Механика инференса. Все тяжелые вычисления (матричные умножения) идут напрямую с квантованными целыми числами (INT4 × INT8), что экономит память и дает огромную скорость, а на выходном слое сразу же умножает их на соответствующий scale для декодирования результата в (FP32/FP16) и передачи на следующий слой.

3. Правило 90/10. На практике только 10 % параметров LLM являются крайне важными и от них зависит качество модели. Взяв это открытие на вооружение - инженерами были разработаны "умные" алгоритмы и форматы квантования для cpu (gguf) и gpu (awq, gptq) которые находят эти умные параметры и агрессивно их не квантуют, остальные 90 % квантуют по группам (gguf) или целиком (awq).

4. Когда нельзя квантовать? когда нельзя терять точности и нет уверенности, где лежат эти 10 % критически важные параметры - это процесс обучения. Когда модель используется в очень сложных или экономически значимых инференсах.