QAD от NVIDIA: Почему 4-битное квантование теперь работает и как применить его на практике

Тот самый момент, когда 4 бита перестали быть шуткой

Помните, как в 2023-2024 все смеялись над попытками 4-битного квантования? Модели превращались в овощи, качество падало на 20-30%, а инженеры разводили руками. NVIDIA тоже смеялась - до февраля 2025 года. Потом они выпустили QAD (Quantization-Aware Distillation), и смех закончился.

QAD - это не просто очередной формат квантования. Это принципиально другой подход, который решает главную проблему низкобитных форматов: информационный коллапс. Когда вы сжимаете 16-битные веса в 4 бита традиционными методами, вы теряете не просто точность - вы теряете структуру распределения. Модель не просто ошибается чаще, она начинает ошибаться системно, предсказуемо неправильно.

Почему старый QAT провалился с 4 битами

Давайте разберемся, почему Quantization-Aware Training (QAT) не справлялся с 4-битным квантованием. Проблема в градиентах - точнее, в их отсутствии.

Традиционный QAT использует псевдоквантование во время обучения: вперед проходит квантованный тензор, назад - градиенты по исходным значениям. Работает прекрасно для 8 бит. Но когда вы пытаетесь впихнуть 65 тысяч возможных значений (16 бит) в 16 значений (4 бита), градиенты становятся шумом. Модель не понимает, куда двигаться.

Представьте, что вы пытаетесь научиться играть в дартс, но вместо мишени видите размытое пятно. Вы кидаете дротики наугад. Иногда попадаете. Чаще - нет. QAT с 4 битами - это именно такая ситуация.

NVFP4: E2M1 - формат, который имеет смысл

До QAD существовали две основные категории 4-битных форматов:

• INT4 - равномерное квантование, 16 целых значений
• FP4 - плавающая точка, но с кучей вариантов: E2M1, E3M0, E1M2

NVIDIA стандартизировала формат E2M1: 2 бита на экспоненту, 1 бит на мантиссу, 1 бит на знак. Звучит безумно? Да. Но работает.

Ключевое преимущество E2M1 - асимметричная точность. Малые значения (около нуля) квантуются с шагом 0.125. Большие значения - с большим шагом. Это идеально для распределения весов в LLM, где большинство значений группируется около нуля, но есть важные выбросы.

Distillation вместо Training: гениально просто

QAD не пытается обучать 4-битную модель с нуля. Вместо этого используется дистилляция знаний из полной 16-битной модели (учителя) в 4-битную (ученика).

Процесс выглядит так:

1. Берем предобученную модель (например, Qwen3-72B или Llama 4 405B)
2. Запускаем её на датасете и собираем логиты (выходы перед softmax)
3. Инициализируем 4-битную версию с тем же архитектурой
4. Обучаем 4-битную модель предсказывать логиты учителя, а не ground truth

Звучит тривиально? Возможно. Но есть нюанс: учитель работает в полной точности, ученик - в 4-битной с псевдоквантованием. Градиенты идут по полным весам ученика, но forward pass всегда квантованный.

Цифры, которые заставят вас поверить

NVIDIA опубликовала результаты на AIME25 (AI Model Efficiency benchmark). Если вы не знакомы с этим бенчмарком, рекомендую посмотреть сравнение в полном гайде по квантованию в vLLM.

Результаты QAD vs традиционные методы:

• Qwen3-72B: QAD (NVFP4) - 84.2% accuracy, GPTQ (INT4) - 79.1%, AWQ (INT4) - 80.3%
• Потеря качества: всего 2.1% против 7-9% у традиционных методов
• Память: 36 ГБ против 144 ГБ у полной версии (4x сжатие)
• Скорость inference на Blackwell: 1.8x быстрее INT4

Самое интересное - результаты на маленьких моделях. Gemma 3 1B с QAD показывает всего 0.8% потери на commonsense задачах. Для сравнения, обычное INT4 квантование давало 3-4% потерь. Если вы работали с квантованием QAT-моделей без imatrix, вы понимаете, насколько это впечатляет.

Практика: запускаем QAD на своей инфраструктуре

Теория - это хорошо, но давайте перейдем к практике. Вот пошаговый план развертывания QAD модели.

1 Подготовка окружения

Первое, что нужно понять: QAD требует специфичных версий библиотек. Не пытайтесь использовать старые версии - не сработает.

# Устанавливаем TensorRT-LLM с поддержкой QAD
pip install tensorrt-llm==1.5.2 --extra-index-url https://pypi.nvidia.com

# Обязательно обновляем PyTorch
pip install torch==2.5.1 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# NVIDIA AMMO для квантования
pip install nvidia-ammo==0.9.2

Проверяем, что CUDA 12.4 установлена. QAD не работает на CUDA 11.x. Если у вас старая карта без поддержки CUDA 12.4, можете попробовать эмуляцию, но performance будет значительно хуже.

2 Конвертация существующей модели

Допустим, у вас есть Qwen3-32B в формате Hugging Face. Вы хотите получить её 4-битную версию с QAD.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from nvidia.ammo import quantization

# Загружаем исходную модель
model_name = "Qwen/Qwen3-32B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Подготавливаем калибровочный датасет
# NVIDIA рекомендует 512-1024 примеров
calibration_data = [
    "Explain quantum computing in simple terms.",
    "Write a Python function to reverse a string.",
    # ... добавить релевантные вашей задаче примеры
]

# Конфигурация QAD
qad_config = {
    "quant_cfg": {
        "*.weight": {"num_bits": 4, "axis": 0, "type": "fp4"},
    },
    "algorithm": "qad",
    "format": "nvfp4",  # Используем NVFP4 вместо обычного FP4
    "calibration_samples": 512,
    "distillation_steps": 2000,
    "learning_rate": 2e-5,
}

# Запускаем QAD
quantized_model = quantization.quantize(
    model=model,
    tokenizer=tokenizer,
    quantization_config=qad_config,
    calibration_data=calibration_data
)

Процесс займет 2-6 часов в зависимости от размера модели и GPU. Для 32B модели на RTX 5090 ожидайте около 3 часов. На Blackwell B200 - около 45 минут.

3 Экспорт в TensorRT-LLM

После квантования нужно экспортировать модель в формат, который понимает TensorRT-LLM.

from tensorrt_llm import quantize_mode

# Конвертируем в TensorRT-LLM формат
trtllm_config = {
    "quantization": {
        "quant_algo": "fp4",
        "kv_cache_quant_algo": "fp8",
        "use_quant_kv_cache": True,
    },
    "build_config": {
        "max_batch_size": 8,
        "max_input_len": 4096,
        "max_output_len": 2048,
        "plugin_config": {
            "use_gpt_attention_plugin": True,
            "use_gemm_plugin": True,
        }
    }
}

# Экспортируем модель
trtllm_model = quantize_mode.export_to_trtllm(
    quantized_model,
    tokenizer,
    config=trtllm_config,
    output_dir="./qwen3-32b-qad-fp4"
)

Типичные ошибки и как их избежать

Я видел десятки попыток внедрить QAD. Вот самые частые ошибки:

Ошибка 1: Недостаточно калибровочных данных

Люди берут 10-20 примеров и удивляются, почему качество упало на 15%. QAD требует репрезентативного датасета. Минимум - 512 примеров. Идеально - 1024. Примеры должны покрывать типичные сценарии использования модели.

Ошибка 2: Смешивание форматов

NVFP4 (E2M1) ≠ FP4 (E3M0) ≠ обычное 4-битное квантование. Если вы настроили pipeline под один формат, а используете другой - получите либо ошибку, либо катастрофическую потерю качества.

Ошибка 3: Игнорирование активаций

QAD квантует только веса. Активации остаются в FP8 или BF16. Если вы попытаетесь квантовать активации в INT8 или ниже - производительность упадет. TensorRT-LLM 1.5+ автоматически выбирает оптимальный формат активаций.

Когда QAD не работает (и что делать)

QAD - не серебряная пуля. Есть случаи, когда он проигрывает традиционным методам:

• Очень маленькие модели (<1B параметров): Overhead дистилляции съедает все преимущества. Лучше использовать обычное квантование или специализированные методы для edge-устройств.
• Мультимодальные модели: Vision-encoder плохо переносит 4-битное квантование даже с QAD. Для таких случаев лучше комбинировать: текстовую часть - QAD, vision - INT8.
• Устаревшее железо: На картах до Ampere (RTX 3000 серии) нет аппаратной поддержки FP4. Эмуляция работает в 5-10 раз медленнее.

Что делать в этих случаях? Рассматривать гибридные подходы. Например, использовать техники распределения модели по нескольким GPU с частичным квантованием.

Blackwell и будущее 4-битных вычислений

Архитектура Blackwell (2025) изменила правила игры. В ней есть отдельные ядра для FP4 вычислений с пропускной способностью 2x против INT4. Это не маркетинг - это физика.

На Blackwell B200:

• FP4 матричные операции: 2 PFLOPS против 1 PFLOPS для INT4
• Энергопотребление: на 40% ниже при той же производительности
• Память: пропускная способность HBM3e позволяет обслуживать 4-битные модели без bottleneck

Но есть подвох. Blackwell оптимизирован для NVFP4 (E2M1). Если вы используете другой 4-битный формат - вы не получите ускорения 2x. Максимум - 1.2-1.3x.

Стоит ли переходить с INT4 на NVFP4 сегодня?

Зависит от вашего стека:

• Да, если: у вас Hopper (H100) или Blackwell (B200/B100), вы используете TensorRT-LLM 1.5+, и качество критично
• Нет, если: у вас Ampere (A100) или старше, вы используете vLLM с GPTQ/AWQ, и вас устраивает текущее качество
• Подождите, если: вы только начинаете внедрять квантование. Сначала освоите базовые методы квантования, потом перейдете к QAD

Мой совет: начните с пилотного проекта. Возьмите одну модель среднего размера (7-13B), сравните INT4, FP4 и NVFP4 с QAD. Измерьте не только точность на бенчмарках, но и latency, throughput, память в реальных сценариях.

Что будет дальше? Прогноз на 2026-2027

QAD - только начало. Вот что я ожидаю в ближайшие 1-2 года:

1. Смешанная точность с адаптивным квантованием: разные слои будут использовать разную битность (4/8/16) в зависимости от чувствительности
2. Аппаратная поддержка 2-битных форматов: NVIDIA уже экспериментирует с E1M1. К концу 2026 можем увидеть первые прототипы
3. QAD для специализированных моделей: кодогенерация, мультимодальные, reinforcement learning - у каждого свои требования к квантованию
4. Стандартизация форматов: Сейчас каждый производитель GPU продвигает свой формат. К 2027 должен появиться отраслевой стандарт

Самое интересное - это возможность запускать модели размером с GPT-5 (ожидаемые 1-10 триллионов параметров) на кластере из нескольких Blackwell. С QAD и NVFP4 это становится финансово осуществимо для компаний среднего размера, а не только для Google и OpenAI.

Если в 2024 году 4-битное квантование было хаком для энтузиастов, то в 2026 это production-ready технология. Сложная, требующая глубокого понимания, но дающая реальное преимущество. Время бояться 4 бит прошло. Время использовать их - сейчас.