GGUF vs GPTQ vs AWQ: сравнение форматов квантизации для инференса?

Краткий тезис

Квантизация нейросетей — это метод сжатия модели для уменьшения объёма памяти и ускорения вычислений, часто с минимальной потерей качества. GGUF, GPTQ и AWQ — три популярных формата квантованных моделей, каждый со своими сильными сторонами. GGUF ориентирован на CPU и гибридный инференс (особенно на Mac), GPTQ — на GPU с хорошим соотношением скорость/качество, а AWQ — на GPU с наилучшим сохранением качества за счёт защиты важных весов. Выбор формата зависит от целевого железа, требуемой скорости и допустимого падения точности.

1. Что такое квантизация моделей

Квантизация — это процесс приведения весов и/или активаций нейронной сети из формата с плавающей запятой (обычно FP32 или FP16) в целочисленные форматы с меньшей разрядностью, такие как INT8, INT4 или даже 2–3 бита. Цель — уменьшить размер модели в памяти (например, с 7 ГБ для FP16 до 2–3 ГБ для 4‑бит) и ускорить вычисления за счёт более быстрых целочисленных операций на современном железе.

Основные термины:

• Веса — параметры модели, которые хранят обученную информацию.
• Активации — промежуточные значения, вычисляемые во время инференса (выходы слоёв).
• Loss / точность — метрика качества модели (например, perplexity). Квантизация может приводить к небольшому loss’у.

Различают квантизацию только весов (weight‑only) и квантизацию весов + активаций (weight‑quantization|activation quantization). В форматах GGUF, GPTQ, AWQ квантизуются преимущественно веса; активации остаются во FP16.

2. Зачем квантизация для инференса

Основные сценарии:

• Экономия памяти видеокарты: 4‑битная модель LLaMA‑7B занимает ~4 ГБ вместо 14 ГБ в FP16 → можно запускать на consumer GPU.
• Ускорение: меньший объём данных для загрузки из VRAM в вычислительные блоки, плюс специализированные ядра (INT4 tensor cores на NVIDIA).
• Запуск на CPU / Edge: квантизация до 4–8 бит позволяет запускать модели на устройствах с ограниченной памятью (Raspberry Pi, ноутбук без GPU), где FP16 не помещается.
• Снижение энергопотребления на мобильных устройствах.

Для агентных RAG‑систем квантизация критична: агенты часто выполняют множество вызовов LLM, и каждый миллисекунда на счету — меньшая модель быстрее отвечает, потребляет меньше ресурсов, что особенно важно для локальных развёртываний.

3. GGUF (llama.cpp)

GGUF — формат квантования, разработанный для библиотеки llama.cpp. Ориентирован в первую очередь на CPU и гибридные сценарии (часть слоёв на GPU через offloading). Поддерживает множество уровней квантизации от 2 до 8 бит, обозначаемых как q2_K, q3_K, q4_K_M, q5_1, q8_0 и т.д. Буквы _K означают использование k‑means кластеризации для оптимизации.

Ключевые особенности:

• CPU‑first: оптимизирован для работы на процессорах, использует AVX2, ARM Neon, другие SIMD‑инструкции.
• GPU‑offloading: часть слоёв может быть перенесена на GPU, но основная логика расчёта — на CPU.
• Не требует калибровочного датасета — квантование производится на основе распределения весов без дополнительных данных (stateless quantization).
• Широкая поддержка моделей: LLaMA, Mistral, Falcon, Phi, Qwen и многие другие.
• Формат файла включает метаданные (токенизатор, архитектура) — один файл содержит всё необходимое для инференса.
• Качество: среднее по сравнению с GPTQ/AWQ при сопоставимой битности, особенно на 4 бита.

Пример уровня q4_K_M — 4‑битная смешанная точность (большинство весов — 4 бита, некоторые — 6 бит). Рекомендуется для баланса скорости и качества на CPU.

4. GPTQ

GPTQ (Generative Pre‑Trained Transformer Quantization) — метод пост‑тренировочной квантизации, который использует калибровочный датасет (обычно 128–1024 примеров из обучающих данных) для минимизации ошибки квантизации. Работает только на GPU (хотя есть CPU‑версии, но медленнее). Поддерживает 2, 3, 4, 8 бит, но чаще всего используется 4 бита с group size = 128 или 32.

Ключевые особенности:

• Групповое квантование: веса делятся на группы (обычно 128 или 32 элемента), для каждой группы свои параметры масштаба и нуля.
• Симметричное и асимметричное квантование (влияет на распределение значений).
• Точная калибровка — модель прогоняет через себя калибровочные данные и находит оптимальные масштабы.
• Качество: обычно чуть ниже AWQ, но выше GGUF при 4 битах.
• Инструменты: AutoGPTQ (Hugging Face integration), ExLlama, vLLM (поддержка GPTQ через Marlin kernel).

Популярный group size = 128 даёт хороший баланс между качеством и скоростью; group size = 32 улучшает качество, но увеличивает размер файла и замедляет инференс.

5. AWQ

AWQ (Activation‑aware Weight Quantization) — метод, который определяет «важные» веса (salient weights) на основе распределения активаций. Идея: ~1% весов, которые имеют наибольшее влияние на активации (по абсолютной величине), остаются в FP16, а остальные квантизуются до 4 бит. Это позволяет сохранить качество близким к FP16, при этом модель занимает почти столько же места, сколько полная 4‑битная.

Особенности:

• GPU‑only (оптимизирован для CUDA‑ядер, например, через Marlin или TensorRT‑LLM).
• Требует калибровочный датасет (как и GPTQ), но меньшего объёма (128–256 примеров часто достаточно).
• Сохраняет ~1% весов в FP16 — эти веса критически важны для качества.
• Лучшее качество среди форматов при 4 битах, часто превосходит GPTQ на 0.5–1% perplexity.
• Скорость: на GPU AWQ сопоставима с GPTQ, а благодаря Marlin‑ядрам может быть даже быстрее.
• Инструменты: AutoAWQ, vLLM (родная поддержка AWQ), TensorRT‑LLM.

6. Сравнительная таблица

7. Другие форматы квантизации

Кроме трёх основных, существуют и другие форматы:

• Bitsandbytes (Hugging Face): 8‑битная (LLM.int8()) и 4‑битная (NF4) квантизация с нулевым смещением. Хороша для прототипирования, но медленнее специальных форматов.
• HQQ (Half‑Quadratic Quantization): современный метод, не требует калибровки и даёт качество, сопоставимое с AWQ. Работает на GPU и CPU.
• AQLM (Additive Quantization of Language Models): метод на основе аддитивного квантования, пока экспериментальный.
• QuIP (Quantization with Incoherence Processing): теоретически обоснованный метод, даёт качество выше GPTQ, но менее распространён.

Выбор зависит от экосистемы: если вы уже используете vLLM, AWQ — лучший вариант; для локального инференса на ноутбуке — GGUF; для быстрого тестирования — Bitsandbytes.

8. Как выбрать формат

Рекомендации по сценариям:

• Сервер на GPU (V100, A100, 3090/4090): используйте AWQ (лучшее качество и скорость через vLLM). Если нет поддержки AWQ — GPTQ с group size=128.
• Локальный инференс на Mac (Apple Silicon): GGUF (Metal acceleration в llama.cpp) — единственный полноценный вариант.
• CPU / Edge (Raspberry Pi, старый ноутбук): GGUF с уровнем q4_K_M или q5_1.
• Гибрид (CPU+GPU): GGUF с offloading нескольких слоёв на GPU.
• Прототипирование и эксперименты: Bitsandbytes 4‑bit (быстро загрузить модель через Hugging Face).

Важный нюанс: форматы не взаимозаменяемы — вы не сможете загрузить GGUF в vLLM для GPU. Выбор определяется инструментом инференса.

9. Влияние квантизации на качество

Качество измеряется обычно через perplexity на тестовом корпусе (например, wikitext) или на бенчмарках (MMLU, HellaSwag). Для 4‑битной квантизации:

• GGUF (q4_K_M) теряет ~0.5–1 ppl по сравнению с FP16.
• GPTQ (group=128) теряет ~0.2–0.5 ppl.
• AWQ теряет ~0.1–0.3 ppl (иногда прирост на некоторых задачах за счёт FP16‑весов).

Для генеративных задач (чат, суммаризация) разница в 0.5 ppl может быть незаметна, но для точных задач (кодинг, математика) может быть критична. Рекомендуется профилировать свою задачу.

10. Практика: как конвертировать и запускать

Конвертация

• GGUF — через convert.py из llama.cpp, затем квантование через quantize (доступно много уровней).
• GPTQ — через AutoGPTQ или optimum с калибровочным датасетом.
• AWQ — через AutoAWQ (код аналогичен GPTQ, но использует awq метод).

Инференс

# GPTQ с AutoGPTQ
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("model_id", device_map="auto")

# AWQ с vLLM (быстрее)
from vllm import LLM
llm = LLM(model="model_id", quantization="AWQ")

# GGUF с llama.cpp (через Python bindings)
from llama_cpp import Llama
llm = Llama(model_path="model.gguf", n_ctx=2048)

Пет-проект для закрепления

Задача: Сравнить реальную производительность и качество трёх форматов на модели LLaMA‑3‑8B.

Инструменты:

• Python, Hugging Face Hub, AutoGPTQ, AutoAWQ, llama.cpp.
• Библиотеки: transformers, vllm, llama-cpp-python, datasets (wikitext).
• Железо: желательно GPU (RTX 3090/4090) + CPU тест.

Шаги:

1. Загрузите оригинальную модель в FP16 (meta-llama/Meta-Llama-3-8B).
2. Квантуйте в GGUF (q4_K_M), GPTQ (group=128), AWQ (4 бит).
3. Запустите инференс (генерация 100 токенов) на CPU (для GGUF) и GPU (для GPTQ/AWQ), замерьте latency.
4. Вычислите perplexity на 1000 примерах из wikitext для каждого формата.
5. Сохраните результаты в таблицу и визуализируйте: размер файла, скорость генерации, ppl.

Ожидаемый результат: Подтверждение, что AWQ даёт наименьший ppl (ближе всего к FP16), GGUF — медленнее всего на GPU, но работает на CPU. Размер файлов ~одинаков для 4 бит.

Связь с другими вопросами

Навигация

• Предыдущий: 442
• Следующий: 444
• Индекс: 00. Индекс разборов