Квантование LLM с нуля: инструкция по запуску 80B модели на ноутбуке без потери качества

80 миллиардов параметров в вашем ноутбуке: фантастика или реальность?

Вы скачали Qwen-3-Coder-Next-80B. Ваш ноутбук с 32 ГБ ОЗУ и RTX 4070 смотрит на вас с немым укором. Оригинальные веса в формате BF16 занимают около 160 ГБ. Они не просто не помещаются в память – они даже на SSD не влезут, если у вас не игровой монстр. Стандартный совет – арендовать инстанс в облаке за $20 в час. Но зачем платить, если можно сжать?

Квантование: не магия, а математика (но почти магия)

Забудьте про FP16 или BF32. Веса нейросети – это числа с плавающей запятой. Они живут в определенном диапазоне. Идея квантования проста: мы берем этот диапазон, делим его на отрезки и присваиваем каждому отрезку целое число. Вместо 16 бит на вес – используем 8, 4 или даже 3. Память сокращается в 2, 4 или 5 раз. Скорость инференса часто растет.

Но есть нюанс. А точнее, два: потеря информации и сложность вычислений. Когда ты сжимаешь вес из 16 бит в 4, ты теряешь детализацию. Для одних слоев это почти безболезненно (например, embedding-слои). Для других (attention механизмы) – критично. В 2026 году мы научились это компенсировать.

Если вы думаете, что все это слишком сложно для ноутбука, вы правы. Напрямую. Но мы будем использовать облако только на этапе квантования – самом ресурсоемком. А квантированные веса уже скачаем на ноутбук и запустим. Общая стоимость – меньше $5 на облачных вычислениях (если использовать spot-инстансы).

1 Подготовка: что нужно перед началом

Не берите первую попавшуюся модель. Убедитесь, что у нее есть поддержка в инструментах квантования на 2026 год. Qwen-3-Coder-Next-80B – отличный кандидат: современная архитектура, отличные показатели на кодогенерации, и для нее есть готовые рецепты квантования в vLLM и AutoGPTQ.

Что вам понадобится:

• Облачный инстанс с GPU (минимум 1x A100 80GB или 2x RTX 4090). Нужен только на 2-4 часа. Используйте spot-инстансы, чтобы сэкономить 70%. Я предпочитаю Lambda Labs или RunPod за их простую настройку.
• Ваш ноутбук с 32+ ГБ ОЗУ и GPU с 8+ ГБ VRAM (RTX 4070, 4080, 4090). Без GPU будет медленно, но возможно через CPU с GGUF.
• Базовые знания Linux и умение работать в терминале. Если вы до сих пор копируете команды из чата без понимания – этот гайд не для вас.

Мы выберем GPTQ. Почему? Потому что баланс скорости квантования, размера и качества в 2026 году для моделей >70B параметров почти идеален. AWQ чуть лучше, но квантуется в 1.5 раза дольше. А время облачного инстанса – деньги.

2 Шаг на облако: квантование GPTQ за 3 часа

Зайдите в ваш облачный провайдер. Создайте инстанс с Ubuntu 24.04 LTS, GPU A100 80GB. Установите CUDA 12.6 (актуально на март 2026) и необходимые драйверы.

Первое, что делают все и что ломает половину процессов – пытаются установить библиотеки через pip без виртуального окружения. Не делайте так.

# КАК НЕ НАДО ДЕЛАТЬ
pip install torch auto-gptq
# Вы получите конфликт версий, и скрипт квантования упадет с ошибкой о missing symbols

Вот правильный путь:

# Создаем чистую среду
python -m venv gptq_env
source gptq_env/bin/activate

# Ставим PyTorch с совместимостью под CUDA 12.6
pip install torch==2.4.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

# Ставим AutoGPTQ последней версии (на март 2026 это 0.8.1)
pip install auto-gptq==0.8.1

# Дополнительно для работы с моделями Hugging Face
pip install transformers==4.42.0 accelerate huggingface-hub

Теперь скачаем исходную модель. Не пытайтесь качать на инстанс через браузер – используйте CLI.

# Логинимся в Hugging Face (нужен токен с правами чтения)
huggingface-cli login

# Клонируем репозиторий модели
git lfs install
git clone https://huggingface.co/Qwen/Qwen-3-Coder-Next-80B

Модель займет около 160 ГБ. Убедитесь, что на инстансе достаточно места (возьмите диск на 500 ГБ).

Создадим скрипт квантования. Здесь важно правильно подобрать калибровочный датасет. Для кодогенеративной модели берите датасет с кодом, например, `the-stack-smol`.

# quantize_gptq.py
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer
import torch

model_path = "./Qwen-3-Coder-Next-80B"
quant_path = "./Qwen-3-Coder-Next-80B-GPTQ-INT4"

# Конфигурация квантования: 4 бита, группа размером 128
quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=True,  # Активационно-зависимое квантование - ВКЛЮЧАЕМ
    damp_percent=0.01,
    sym=False,
    true_sequential=True
)

# Загружаем модель и токенизатор
print("Loading model...")
tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=True)
model = AutoGPTQForCausalLM.from_pretrained(
    model_path,
    quantize_config,
    device_map="auto",
    torch_dtype=torch.float16,
    trust_remote_code=True
)

# Готовим калибровочные данные (возьмем 128 примеров)
# В реальности используйте датасет, но для примера сгенерируем
calib_data = []
def print_progress(module_name, progress):
    print(f"{module_name}: {progress:.2%}")

# Запускаем квантование
print("Quantization started...")
model.quantize(
    calib_data,  # Здесь должен быть ваш датасет
    use_triton=False,  # Triton не поддерживается для моделей >70B на данный момент
    batch_size=1,
    workers=1,
    progress_callback=print_progress
)

# Сохраняем квантированную модель
print("Saving quantized model...")
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)
print(f"Done! Model saved to {quant_path}")

Запустите скрипт. Это займет 2-3 часа на A100. Потребление памяти GPU будет около 70 ГБ. Не пугайтесь – это нормально.

3 Загрузка на ноутбук и первый запуск

После квантования у вас будет папка с моделью размером около 40 ГБ. Сожмите ее в архив и скачайте на ноутбук через rsync или SCP.

# На облачном инстансе
tar -czf qwen-80b-gptq.tar.gz Qwen-3-Coder-Next-80B-GPTQ-INT4/

# На ноутбуке (замените IP)
scp -r user@:~/qwen-80b-gptq.tar.gz ./
tar -xzf qwen-80b-gptq.tar.gz

Теперь запуск. Не используйте трансформеры напрямую – они съедят всю память. Используйте vLLM 0.5.6+ с поддержкой GPTQ.

pip install vllm==0.5.6

# run_model.py
from vllm import LLM, SamplingParams

# Указываем путь к квантированной модели
model_path = "./Qwen-3-Coder-Next-80B-GPTQ-INT4"

# Инициализируем движок vLLM с настройками под ноутбук
llm = LLM(
    model=model_path,
    quantization="gptq",  # Указываем тип квантования
    gpu_memory_utilization=0.85,  # Не жадничаем, оставляем память под систему
    max_model_len=8192,  # Контекстное окно, можно уменьшить, если мало памяти
    enforce_eager=True,  # Для избежания проблем с графами на потребительских GPU
    trust_remote_code=True
)

sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=512)

# Запрос на генерацию кода
prompt = """Write a Python function to calculate the Fibonacci sequence up to n terms.
The function should be efficient and use memoization.
"""

outputs = llm.generate([prompt], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

Запустите скрипт. Первый запуск займет минуту-две – vLLM компилирует ядра под ваше железо. Затем вы увидите, как модель генерирует код. Потребление VRAM на RTX 4090: около 18 ГБ. ОЗУ: около 25 ГБ. Это влезет в ноутбук с 32 ГБ ОЗУ и 24 ГБ VRAM.

Подводные камни, которые тонут не все

В теории все гладко. На практике вы столкнетесь с этим:

• Out of Memory (OOM) при запуске. Даже с квантированной моделью. Причина: vLLM по умолчанию резервирует память под максимальный контекст. Решение: уменьшите `max_model_len` до 4096 или даже 2048. Да, контекст будет короче, но модель запустится.
• Медленная генерация. Первый токен выходит за 2 секунды, остальные – быстрее. Это норма для больших моделей на consumer-GPU. Ускорить можно через speculative decoding, но для этого нужна маленькая модель-помощник. Не усложняйте на первом этапе.
• Модель генерирует не код, а описание кода. Проблема в промпте или калибровочном датасете. Попробуйте готовые квантизации от сообщества – их калибровали на кодогенеративных задачах.
• Ошибки CUDA. Драйверы. Всегда драйверы. Убедитесь, что у вас CUDA 12.6+ и драйвер NVIDIA 560+. Обновите через официальный сайт, не через репозиторий дистрибутива.

Самая частая ошибка – попытка квантовать ниже INT4 для моделей >70B. Прочитайте опыт с Qwen3.5-122B. Там четко показано: при переходе на INT3 качество падает на 15-20%, и модель начинает путать синтаксис. Оно того не стоит.

А если нет мощной видеокарты? CPU-спаситель GGUF

Ваш ноутбук имеет 64 ГБ ОЗУ и встроенную графику? Тогда путь через GGUF. Суть: модель разбивается на слои, часть загружается в RAM, часть – в VRAM (если есть). Квантование Q4_K_M – оптимально.

Инструкция простая:

# Установите llama.cpp последней версии (на март 2026 это версия 4000+)
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j4

# Конвертируем исходную модель в GGUF формат (делается на облаке)
python convert-hf-to-gguf.py Qwen-3-Coder-Next-80B --outtype q4_k_m

# Квантуем
./quantize qwen-3-coder-next-80b.gguf qwen-3-coder-next-80b-q4_k_m.gguf q4_k_m

Получится файл ~45 ГБ. Скачайте его на ноутбук и запускайте через llama.cpp с флагом `-ngl 20` (20 слоев на GPU, остальные на CPU). Скорость: 1-2 токена в секунду. Медленно, но работает. Для отладки кода – приемлемо.

Что дальше? Баланс на грани

Вы запустили 80B модель на ноутбуке. Теперь что? Не ждите чудес скорости. Генерация 100 строк кода займет минуту. Но это локально. Без интернета. Без платных API. Без ограничений.

Следующий шаг – оптимизация под ваши задачи. Настройка подавления повторений, система промптов, возможно, fine-tuning адаптеров (LoRA) на квантированной модели. Но это тема для отдельного разговора.

Главный урок 2026 года: квантование перестало быть черной магией. Это стандартный инструмент инженера. Выбирайте правильный метод (GPTQ для скорости, AWQ для качества), не экономьте на калибровочных данных и не бойтесь облачных затрат на этапе сжатия. Один раз квантовали – пользуетесь месяцами.

Вопросы, которые вы зададите (и ответы)

Можно ли квантовать модель сразу на ноутбуке?

Нет. Для 80B модели процесс квантования требует >80 ГБ GPU памяти. Даже на RTX 4090 с 24 ГБ этого недостаточно. Используйте облако.

GPTQ или AWQ – что лучше для кода?

AWQ дает чуть лучшее качество на code generation benchmarks (на 1-3%). Но разница заметна только на синтетических тестах. Для реальных задач берите GPTQ – больше поддержки, быстрее квантование.

Почему у меня скорость генерации 0.5 токена в секунду?

Вы запускаете модель через CPU (GGUF) или у вас включена медленная память в BIOS. Проверьте, что llama.cpp использует `-ngl` для переноса слоев на GPU. Для GPTQ убедитесь, что в vLLM `enforce_eager=False` (но это может сломать запуск на некоторых GPU).

Модель после квантования «забыла» как отвечать на русском. Это нормально?

Нет. Значит, калибровочный датасет состоял только из английских текстов. При квантовании всегда включайте мультиязычные данные, если хотите сохранить способности модели.

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