Обучение с учетом квантизации: руководство по улучшению локального инференса Gemma 4

Что такое квантизация?

Квантизация — техника сжатия модели, снижающая точность весов.

Большие языковые модели обычно хранятся в высокоточных форматах, таких как BF16 или FP16, которые сохраняют качество, но требуют много памяти. Квантизация переводит веса в низкоразрядные форматы, например 8‑бит или 4‑бит, чтобы модель использовала меньше VRAM и легче запускалась локально. По данным Hugging Face, 8‑битная квантизация примерно вдвое сокращает потребление памяти, а 4‑битная — ещё сильнее.

Компромисс в том, что более низкая точность иногда может снижать качество вывода, особенно если модель не оптимизировали под квантизацию. Проще говоря, BF16 и FP16 обычно дают лучшее качество, но требуют больше памяти; 8‑битные модели меньше и обычно сохраняют высокое качество, а 4‑битные — значительно компактнее, но могут терять в точности или стабильности.

Для локального инференса этот компромисс часто оправдан, поскольку позволяет запускать более крупные модели на потребительских GPU без дорогого датацентрового оборудования.

Что такое обучение с учетом квантизации?

Quantization-Aware Training (QAT) — это методика, при которой модель обучают или дообучают с имитацией поведения низкой точности. Это помогает модели сохранять стабильность после квантизации и может повысить качество локального инференса при низкой разрядности.

Чем QAT отличается?

Обычный подход — посттренировочная квантизация — сжимает модель после завершения обучения. Это просто и практично, но модель может потерять часть качества, поскольку её не обучали работать с низкоточными весами.

Согласно документации Google AI Edge, посттренировочная квантизация — это этап конверсии, который может уменьшить размер модели и улучшить задержки, обычно с незначительной потерей точности. Однако итоговое качество всё же зависит от модели и уровня квантизации.

Обучение с учетом квантизации (QAT) предлагает иной подход. Вместо квантизации только после обучения, QAT имитирует низкую точность во время обучения или дообучения. Это помогает модели научиться сохранять стабильность при последующей конверсии в более компактный формат и минимизирует потерю качества при сжатии.

Именно поэтому Gemma 4 QAT полезна для локального ИИ. Она создавалась с учётом квантизации, поэтому способна лучше сохранять качество исходной модели при меньшем потреблении памяти. Для пользователей, запускающих модели на потребительских GPU, это может означать лучшую стабильность на низких битах, меньший объём VRAM и более практичный локальный инференс.

Шаг 1. Установите зависимости и соберите llama.cpp

Прежде чем скачивать модели, подготовим локальное окружение. Это руководство тестировалось на машине с GPU NVIDIA RTX 4090 и 24 ГБ VRAM. В качестве среды инференса используем llama.cpp, формат модели — GGUF, а файлы модели — с квантизацией UD-Q4_K_XL

Тестовая конфигурация:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Среда выполнения: llama.cpp
• Формат модели: GGUF
• Квантизация: UD-Q4_K_XL

Мы сравним следующие две модели Unsloth в формате GGUF:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

Сначала проверьте доступность GPU.

nvidia-smi

Далее установите системные пакеты, необходимые для сборки llama.cpp.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Клонируйте официальный репозиторий llama.cpp.

git clone https://github.com/ggml-org/llama.cpp

Теперь соберите llama.cpp с поддержкой CUDA. Это позволит запускать слои модели на GPU, а не только на CPU.

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Скомпилируйте необходимые бинарные файлы.

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

После завершения сборки основной бинарник, который нам понадобится, — это llama-server. Он позволяет запускать модель GGUF локально и предоставляет совместимую с OpenAI конечную точку API, к которой можно обращаться с помощью curl. 

Шаг 2. Скачайте модели Gemma 4 12B без QAT и с QAT

Теперь, когда llama.cpp готова, мы можем скачать обе версии Gemma 4 12B с Hugging Face. Загрузим обычную модель, дообученную на инструкциях, и версию QAT в формате GGUF.

Сначала установите CLI Hugging Face Hub с поддержкой ускоренных загрузок.

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Включите высокопроизводительные загрузки Xet.

export HF_XET_HIGH_PERFORMANCE=1

Скачайте обычную модель Gemma 4 12B (instruction) в формате GGUF.

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Затем скачайте версию QAT в том же формате квантизации.

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Флаги --include гарантируют, что мы загрузим только файлы, нужные для этого руководства, а не весь репозиторий. Здесь мы скачиваем файлы модели GGUF UD-Q4_K_XL и файлы mmproj-BF16, используемые пакетом модели. 

После завершения загрузки убедитесь, что обе папки с моделями существуют.

ls models

Ожидаемый вывод:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUF

Теперь обе модели — без QAT и с QAT — доступны локально, и мы можем начать обслуживать их с помощью llama-server.

Шаг 3. Запустите модель без QAT в llama-server

Начнём с запуска обычной модели Gemma 4 12B (instruction). Это даст нам базовый ориентир, с которым мы позже сравним версию QAT при тех же настройках.

Запустите модель без QAT с помощью llama-server.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Это запускает локальный сервер, совместимый с OpenAI, по адресу http://localhost:8001.

Откройте другой терминал и отправьте запрос на локальный сервер.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

В этой команде мы используем локальную конечную точку /v1/chat/completions, совместимую с форматом API OpenAI. Промпт просит модель объяснить обучение с учетом квантизации, а max_tokens установлен в 512, чтобы обе версии модели тестировались с одинаковой длиной ответа. 

В нашем тесте на RTX 4090 модель без QAT показала следующие результаты по времени:

• Токены запроса: 40
• Токены ответа: 512
• Скорость обработки запроса: 510.22 токенов/с
• Скорость генерации: 94.65 токенов/с
• Общее время: 5.516 с

Использование памяти GPU:

9247 MiB / 24564 MiB

Это даёт нам базовую производительность обычной Gemma 4 12B. На следующем шаге мы запустим версию QAT с той же конфигурацией и сравним результаты.

Шаг 4. Запустите и протестируйте модель QAT

Теперь запустим версию Gemma 4 12B с QAT, используя те же настройки llama-server. Обязательно остановите предыдущий сервер без QAT перед запуском этого, поскольку обе команды используют один и тот же порт.

Запустите модель QAT.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Это запускает модель QAT на той же локальной конечной точке, совместимой с OpenAI: http://localhost:8001.

Теперь отправьте тот же тестовый промпт модели QAT.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

В нашем тесте на RTX 4090 модель QAT показала следующие результаты по времени:

1. Токены запроса: 40
2. Токены ответа: 512
3. Скорость обработки запроса: 593.93 токенов/с
4. Скорость генерации: 101.65 токенов/с
5. Общее время: 5.114 с

Использование памяти GPU:

8627 MiB / 24564 MiB

Вы также можете скопировать URL локального сервера (http://localhost:8001) и вставить его в браузер:

Откроется встроенный веб‑интерфейс llama.cpp — простой интерфейс в духе ChatGPT для тестирования локальной модели. Вы можете общаться с моделью QAT прямо в браузере, экспериментировать с промптами и использовать её как ежедневного локального помощника. 

Сравнение результатов: QAT vs без QAT

Протестировав обе модели с одинаковым промптом и настройками сервера, мы можем напрямую сравнить их производительность на RTX 4090.

В этом прогоне модель QAT оказалась и быстрее, и легче, чем обычная без QAT. Она использовала на 620 MiB меньше VRAM, сократив потребление памяти примерно на 6,7%. Для локального инференса это важно: каждый мегабайт сэкономленной VRAM помогает при запуске больших моделей на потребительских GPU.

Модель QAT также генерировала токены быстрее — прирост с 94.65 токенов/с до 101.65 токенов/с. Это примерно 7,4% прироста скорости генерации, что сократило время выполнения с 5,516 до 5,114 секунды.

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

Итоги

Google проделывает впечатляющую работу для сообщества локального ИИ. С такими моделями, как Gemma 4, и техниками вроде QAT мечта о запуске мощных моделей локально, полностью офлайн и даже на потребительском «железе», становится реальностью. 

Наиболее интересно то, что речь не только об уменьшении размера модели. С QAT мы не просто идём на компромисс в качестве, чтобы модель «влезла». Мы получаем модели, изначально рассчитанные на работу в низкоразрядных форматах, что улучшает общий опыт локального ИИ. В этом тесте версия QAT была быстрее, легче и удобнее в использовании, чем вариант без QAT.

Теперь я с интересом жду тестирования версии модели с MTP, которая может ещё больше повысить скорость — возможно, в 2 раза. Это упростит перенос большей части рабочего процесса на локальный ИИ. Я мог бы запускать модель локально, подключать её к таким инструментам, как OpenCode, и начинать редактировать файлы проекта напрямую с помощью приватного локального ассистента.

Новая волна локального ИИ меняет наше представление об использовании ИИ‑систем. Задачи, ранее требовавшие крупных облачных инфраструктур, особенно мультимодальные сценарии с текстом, изображениями и видео, постепенно становятся возможными на локальных машинах. Для разработчиков, исследователей и создателей, которым важны приватность, скорость и контроль, это очень перспективное направление.