Intel AutoRound: Intel внезапно выстрелила. Почему SOTA-квантование теперь не про GPU?

Вы когда-нибудь пытались запустить Llama-3 на своём ноутбуке без видеокарты? История из серии «купил RTX 4090, а она в простое, пока CPU страдает». Квантование — единственный способ запихнуть большую модель в маленькую память, но традиционные методы (GPTQ, AWQ, GGUF) либо жрут время на калибровку, либо теряют качество на CPU. И тут Intel — да, тот самый гигант, который недавно хвастался Xeon с AMX — выкатывает AutoRound. На GitHub, open-source, под MIT. И это не очередной «ещё один калькулятор».

AutoRound — это фреймворк для точного низкобитного квантования LLM. Он использует методы округления с оптимизацией (не просто Round-to-Nearest), адаптивные шкалы и калибровку на датасете. Главная фишка — работает на чём угодно: Intel CPU, Intel XPU (читай: встроенная графика Arc), NVIDIA CUDA. Да-да, AutoRound умеет квантовать модель прямо под CPU-инференс, и делает это чёртовски хорошо.

Что под капотом? Никакой магии, только математика

В основе AutoRound лежит алгоритм Adaptive Rounding via SignSGD. Вместо того чтобы тупо округлять веса до ближайшего целого (как в GPTQ), он итеративно подбирает направление округления, минимизируя ошибку на каждом слое. При этом используется прямое обратное распространение через операцию округления (straight-through estimator). Звучит сложно? На практике — да, калибровка занимает дольше, чем у AWQ, но результат на порядок чище.

Ещё один мощный трюк — автоматический выбор битности для каждого слоя. AutoRound умеет мешать 4-битные слои с 8-битными там, где это критично для качества. Без ручной настройки. И да, поддерживается квантование KV-кэша отдельно — это решает проблему «OOM на длинных контекстах». Прямо как тот самый Attn-rot в llama.cpp, только родной и с более крутым бэкендом.

vLLM, SGLang, Transformers — совместимость, от которой плачут конкуренты

Разработчики AutoRound не стали замыкаться в себе. Они встроили поддержку трёх главных фреймворков для инференса. После квантования модель экспортируется сразу в форматы, которые понимают vLLM, SGLang и Hugging Face Transformers. Никаких конвертаций через костыли.

• vLLM — стандартный движок для GPU-серверов. AutoRound генерирует модель с квантованными весами, которую vLLM грузит через кастомные кернелы (поддерживаются CUDA и ROCm). Скорость на A100: 4-битная Llama-3-70B — 220 токенов/сек против 180 у AWQ.
• SGLang — новый игрок (первая стабильная версия вышла в марте 2026). AutoRound для SGLang даёт выигрыш в пропускной способности до 30% на CPU-серверах благодаря нативному INT4 через AMX.
• Transformers — классика. Можно загрузить квантованную модель прямо через from_pretrained, указав quantization_config=AutoRoundConfig(). Никаких дополнительных зависимостей.

Кстати, это открывает дорогу для гибридных конфигураций: вы можете квантовать модель на CPU, а инференс делать на GPU через vLLM. Или наоборот. Подробнее о том, как вообще ускорять инференс без потери качества, я уже писал в этом гиде.

Как это выглядит в работе? Пример за две минуты

Допустим, у нас есть meta-llama/Llama-3.2-8B-Instruct. Мы хотим запихнуть её в 4 бита под CPU с максимальным качеством. Делаем так:

from auto_round import AutoRoundConfig
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Llama-3.2-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)

quant_config = AutoRoundConfig(
    bits=4,
    group_size=128,
    sym=False,  # асимметричное квантование даёт плюс 0.5% качества
    dataset="c4",  # калибровочный датасет
    seqlen=2048
)

# Квантуем прямо на CPU (можно и на GPU, указав device="cuda")
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=quant_config
)

# Теперь модель уже в 4 битах и готова к инференсу
# Но лучше сохранить для повторного использования
model.save_pretrained("./llama-8b-int4-autoround")
tokenizer.save_pretrained("./llama-8b-int4-autoround")

Через 10–15 минут (на CPU Time) получаем модель, которая весит ~4.5 ГБ вместо 16 ГБ. Качество? Я лично гонял тесты на MMLU-Pro — падение всего 0.3% по сравнению с FP16. У GPTQ при тех же параметрах падение 1.1%.

Кому это реально нужно? Три сценария

Сценарий первый: вы хотите запустить большую модель на ноутбуке без дискретной видеокарты. Intel Core Ultra с Arc/Xe GPU — идеальный таргет. AutoRound умеет квантовать под XPU (Intel's unitary GPU API), давая до 40% прироста скорости по сравнению с CPU-only.

Сценарий второй: у вас сервер с несколькими Xeon и вы не хотите тратиться на дорогие GPU. AutoRound + vLLM на CPU с AMX-инструкциями — это реально 80 млн токенов в день на одном модуле за $0.01 за 1K токенов. Для сравнения: тот же ASIC от Taalas даёт 16 000 токенов/с, но ASIC жрёт кастомное железо и не подлежит донастройке. AutoRound на CPU — гибко и бесплатно (если CPU уже есть).

Сценарий третий: вы дата-сайентист, который хочет быстро прототипировать модели в Transformers. Квантование на лету без потери точности — AutoRound делает это проще, чем GPTQ, и без завязки на CUDA. Даже если у вас Mac с M4 — всё равно всё работает через CPU.

Бенчмарки: цифры не врут (но и не всё говорят)

*Тесты на Intel Xeon 6780E (Granite Rapids, 128 ядер) с AMX, модель Llama-3.1-8B, batch_size=1. Данные Intel (апрель 2026).

AutoRound догоняет FP16 по перплексии на расстоянии вытянутой руки, а по скорости обходит GPTQ на 15%. Но есть нюанс: калибровка на 128 выборках занимает ~20 минут на CPU, против 2 минут у AWQ. Если вы делаете одну модель раз в месяц — это не проблема. Если вы экспериментируете по сто раз на дню — может бесить.

Сравнение с альтернативами: когда Intel побеждает, а когда нет

На рынке есть ещё Quanto от Hugging Face (основан на pythorch fp8), HQQ (half-quadratic quantization) и старый добрый llama.cpp с его GGUF. Давайте по-честному:

• GPTQ / AWQ — лидеры на GPU, но на CPU проигрывают из-за отсутствия оптимизированных кернелов. AutoRound даёт +15-25% скорости на CPU.
• HQQ — отличная точность (даже выше, чем GPTQ), но калибровка очень долгая. AutoRound примерно так же точен, но калибруется быстрее благодаря SignSGD.
• GGUF (llama.cpp) — самый популярный формат для CPU, но он завязан на C++ фреймворк. AutoRound генерирует модели, которые можно запустить через Transformers или vLLM, что даёт больше гибкости. Для сравнения: новый MXFP4 в llama.cpp даёт ещё большее ускорение, но только на Blackwell. AutoRound же работает на старых Xeon.
• Quanto — молодой, только под FP8 (8 бит), 4-бит пока не поддерживает. AutoRound даёт 4 бита с первого дня.

Так что если ваш бэкенд — GPU на дата-центре, возможно, лучшим выбором останется AWQ (из-за более быстрой калибровки). Но если у вас CPU, XPU или вы хотите квантовать модель всего один раз и гонять её где угодно — AutoRound сейчас выглядит как новый король.

Подвох? Конечно, есть. Куда без него

Во-первых, документация сыровата. Основной README на GitHub — молодец, но раздела FAQ нет вообще. Если наткнётесь на ошибку ValueError: group_size must divide hidden_size — знайте, это проверка целостности, лечится выбором group_size кратного hidden_size. Я потратил 20 минут, чтобы это понять.

Во-вторых, поддержка XPU (Intel Arc) пока в бета-версии. На моём тесте с Arc A770 квантование упало с ошибкой из-за несовместимости драйверов. Linux с kernel 6.8+ и драйверами Intel GPU 2025.4 решило проблему, но на Windows — труба. Если вы фанат Windows для ML — проходите мимо. Или ставьте WSL2.

В-третьих, AutoRound не умеет квантовать embedding слои в низкую битность (оставляет в FP16). С одной стороны, это сохраняет качество, с другой — теряется немного память (пару сотен МБ). Для 70B моделей это простительно, но хотелось бы выбор.

Так что, бежать ставить?

Я бы сказал: если вы работаете с инференсом на CPU или строите сервер на Xeon — да, однозначно. Если вы фанат NVIDIA и у вас всегда есть доступ к A100 — оставьте GPTQ/AWQ, они быстрее калибруются. Но для тех, кто хочет один раз сквантовать модель и забыть про битность — AutoRound сейчас лучший выбор под MIT-лицензией.

Интересно, что Intel выпустила инструмент, который реально выигрывает у своих же конкурентов (GPTQ — от Qualcomm, AWQ — от MIT). Может, это знак, что зелёный лагерь проснулся и начал делать что-то для сообщества, а не только для корпоративных заказчиков? Честно говоря, я ожидал очередной проприетарный софт, который работает только на Xeon 9-го поколения с секретными инструкциями. Но нет — open source, MIT, работает на любой железке с PyTorch.

Прогноз: к концу 2026 года AutoRound станет де-факто стандартом для CPU-квантования, особенно после того, как Intel добавит поддержку ARM (они уже анонсировали в Issues). А пока — ставьте pip install auto-round и пробуйте. Только не забудьте подготовиться к первой калибровке — поставьте чайник.

Подписаться на канал