Per-row MSE quantization: практическое руководство по сжатию LLM до 15MB с минимальной потерей качества

Почему ваши LLM все еще весят гигабайты?

Представьте: модель на 24 миллиона параметров занимает 100MB. Это безумие. Особенно когда нужно запустить её на Raspberry Pi, телефоне или встроенном устройстве. Классическое квантование INT8 часто убивает качество - модель начинает генерировать бред или теряет контекст. Проблема не в самом квантовании, а в том, как мы выбираем диапазон значений для сжатия.

Обычные методы берут один scale factor на весь тензор. Одна большая ошибка для всех строк. Это как измерить всех людей по среднему росту - и высоким тесно, и низким просторно. Per-row MSE quantization меняет правила игры: она подбирает оптимальный диапазон для каждой строки матрицы отдельно, минимизируя ошибку воспроизведения.

Что ломает обычное квантование и как это чинят по строчкам

Откройте любую матрицу весов в вашей LLM. Значения распределены неравномерно. В одной строке могут быть числа от -0.5 до 0.5, в другой - от -2.1 до 1.8. Если натянуть на них один масштаб, вы либо обрежете хвосты распределения, либо получите грубую дискретизацию там, где нужна точность.

Per-row MSE quantization решает это просто и элегантно: для каждой строки матрицы она ищет такие минимальное и максимальное значения (clip values), которые минимизируют среднеквадратичную ошибку (MSE) после квантования-деквантования. Алгоритм проверяет разные варианты отсечения, выбирает лучший - и так для каждой из тысяч строк.

Результат? Модель на 24M параметров (например, крошечная версия Phi-3 или StableLM) сжимается с ~100MB до ~15MB при потере качества менее 0.1 BPB (bits per byte) на текстовых датасетах. Для сравнения: классическое INT8 даст потерю 0.3-0.5 BPB на той же модели.

Подготовка: что нужно перед тем, как резать

Работать будем с PyTorch 2.3+ (актуально на март 2026). Убедитесь, что у вас стоит версия с поддержкой quantized tensors. Для тестов возьмите небольшую модель - например, Phi-3-mini-4k-instruct (3.8B параметров, но для демонстрации сойдет) или TinyLlama-1.1B. Полный код из статьи Codebook Lossless Compression показывает альтернативные подходы, но мы фокусируемся на квантовании с потерями.

pip install torch==2.3.1 transformers==4.45.0 datasets==2.20.0
# Для загрузки моделей с Hugging Face

Важный нюанс: per-row MSE quantization требует доступа к весам модели в формате FP16 или BF16. Не пытайтесь применять метод к уже квантованным моделям (GGUF, AWQ). Сначала загрузите оригинальные веса.

1 Загружаем модель и вытягиваем веса

Первым делом извлекаем все линейные слои, которые будем квантовать. Обычно это q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj в архитектурах Llama. А вот эмбеддинги и нормализацию лучше не трогать - их квантование дает мизерную экономию при большом риске.

import torch
import torch.nn as nn
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3-mini-4k-instruct",
    torch_dtype=torch.float16,
    device_map="cpu"  # Квантуем на CPU для простоты
)

# Собираем целевые слои
linear_layers = []
for name, module in model.named_modules():
    if isinstance(module, nn.Linear):
        linear_layers.append((name, module))

print(f"Найдено линейных слоев: {len(linear_layers)}")

2 Ядро алгоритма: поиск clip values с минимальной MSE

Вот где начинается магия. Для каждой строки матрицы весов (размером hidden_dim) мы перебираем возможные значения отсечения. Наивный подход - перебрать все значения от 0 до max(abs(row)) - слишком медленный. Вместо этого используем бинарный поиск по проценту отсечения.

def find_row_wise_clip_values(weight_row, num_bits=8, steps=50):
    """
    Ищет оптимальные min/max для квантования строки.
    weight_row: тензор формы [hidden_dim]
    steps: количество кандидатов для проверки
    Возвращает: (min_val, max_val, best_mse)
    """
    row_np = weight_row.float().cpu().numpy()
    abs_max = np.max(np.abs(row_np))
    
    best_mse = float('inf')
    best_min, best_max = -abs_max, abs_max
    
    # Пробуем разные проценты отсечения хвостов
    for percentile in np.linspace(70, 100, steps):
        clip_val = np.percentile(np.abs(row_np), percentile)
        min_val, max_val = -clip_val, clip_val
        
        # Квантование-деквантование
        scale = (max_val - min_val) / (2**num_bits - 1)
        zero_point = np.round(-min_val / scale)
        
        quantized = np.clip(row_np, min_val, max_val)
        quantized = np.round((quantized - min_val) / scale)
        dequantized = quantized * scale + min_val
        
        mse = np.mean((row_np - dequantized) ** 2)
        
        if mse < best_mse:
            best_mse = mse
            best_min, best_max = min_val, max_val
    
    return best_min, best_max, best_mse

Почему перебираем от 70 до 100 перцентиля? Потому что отсечение меньше 70% выбросов уже отрезает значительную часть распределения - ошибка будет заведомо большой. На практике для большинства слоев LLM оптимальное значение лежит между 95 и 99.9 перцентилем.

3 Векторизованная реализация для скорости

Вышеприведенный код медленный - он обрабатывает строки по одной. В реальности нужно векторизовать операции. Используем трюк с broadcasting и параллельным вычислением MSE для нескольких кандидатов сразу.

def per_row_mse_quantize(weight, num_bits=8, candidate_percentiles=32):
    """
    Векторизованная per-row MSE quantization.
    weight: тензор формы [out_features, in_features]
    Возвращает: quantized tensor, scales, zero_points
    """
    weight_np = weight.float().cpu().numpy()
    n_rows, n_cols = weight_np.shape
    
    # Кандидаты для отсечения
    percentiles = np.linspace(95.0, 99.99, candidate_percentiles)
    abs_rows = np.abs(weight_np)
    
    # Вычисляем clip values для каждого перцентиля
    clip_candidates = np.percentile(abs_rows, percentiles, axis=1)  # [candidates, rows]
    
    # Подготавливаем массивы для MSE
    best_mse = np.full(n_rows, float('inf'))
    best_clip = np.zeros(n_rows)
    
    for i, clip_val in enumerate(clip_candidates):
        min_val = -clip_val
        max_val = clip_val
        
        # Масштаб и zero point для каждой строки
        scale = (max_val - min_val) / (2**num_bits - 1)
        zero_point = np.round(-min_val / scale)
        
        # Квантование
        clipped = np.clip(weight_np, min_val[:, None], max_val[:, None])
        quantized = np.round((clipped - min_val[:, None]) / scale[:, None])
        dequantized = quantized * scale[:, None] + min_val[:, None]
        
        # MSE по строкам
        mse = np.mean((weight_np - dequantized) ** 2, axis=1)
        
        # Обновляем лучшие значения
        better_mask = mse < best_mse
        best_mse[better_mask] = mse[better_mask]
        best_clip[better_mask] = clip_val[better_mask]
    
    # Применяем лучшие clip values
    final_min = -best_clip
    final_max = best_clip
    final_scale = (final_max - final_min) / (2**num_bits - 1)
    final_zero_point = np.round(-final_min / final_scale)
    
    # Финальное квантование
    clipped = np.clip(weight_np, final_min[:, None], final_max[:, None])
    quantized = np.round((clipped - final_min[:, None]) / final_scale[:, None])
    quantized = np.clip(quantized, 0, 2**num_bits - 1).astype(np.uint8)
    
    return quantized, final_scale, final_zero_point

4 Применение ко всей модели и сохранение

Теперь пройдемся по всем линейным слоям, применим per-row quantization и заменим веса в модели. Важно: после квантования нужно сохранить не только целочисленные веса, но и масштабы с zero points для каждого слоя.

quantized_model_info = {}

for name, layer in linear_layers:
    print(f"Квантуем слой: {name}")
    weight = layer.weight.data
    
    quantized_w, scales, zero_points = per_row_mse_quantize(weight)
    
    # Сохраняем для последующей загрузки
    quantized_model_info[name] = {
        'weight': quantized_w,
        'scale': scales,
        'zero_point': zero_points,
        'original_shape': weight.shape
    }
    
    # Для инференса создаем fake-quantized версию
    dequantized = (
        quantized_w.astype(np.float32) * scales[:, None] + 
        (zero_points[:, None] * scales[:, None])
    )
    layer.weight.data = torch.from_numpy(dequantized).to(weight.dtype)

После этого модель можно сохранить в компактном формате. Веса в uint8 занимают в 4 раза меньше места, чем FP32. Плюс нужно хранить масштабы и zero points - это добавит около 0.5 байта на параметр. Итоговое сжатие: примерно 4x от оригинального FP32 размера.

Где собака зарыта: нюансы, которые сломают вашу модель

Кажется просто? Вот что пойдёт не так, если делать без понимания.

Ошибка 1: Квантование эмбеддингов и layer norm

Эмбеддинг-слой содержит семантическую информацию в абсолютных значениях. Квантование до INT8 уничтожает тонкие различия между векторами. Layer norm масштабирует активации - ошибка здесь каскадно умножится по всем последующим слоям. Решение: не трогать эти слои. Оставьте их в FP16. Потеря в размере будет 2-3%, а качество сохранится.

Ошибка 2: Игнорирование асимметричного распределения

Алгоритм выше предполагает симметричное квантование (min = -max). Но в некоторых слоях (особенно после ReLU активаций) распределение может быть сдвинуто в положительную область. Для таких случаев нужно использовать асимметричное квантование с отдельным подбором min и max. В статье про IQ vs Q квантования есть подробности.

Ошибка 3: Прямой инференс без кэширования масштабов

При деквантовании во время forward pass умножение на scale для каждой строки тормозит вычисления. Нужно предвычислять scale * weight и хранить уже в удобном формате. Или использовать специализированные ядра, как в llama.cpp с поддержкой per-row quantization.

Данные на март 2026 для модели Phi-3-mini на датасете PG-19. Per-row MSE выигрывает у классического INT8 по качеству, почти не уступая по скорости. GPTQ INT4 дает лучшее сжатие, но требует калибровочного датасета и более сложной реализации.

А что с большими моделями? Llama 3.1 8B и дальше

Для моделей от 7B параметров per-row MSE quantization показывает себя еще ярче. Ошибка накапливается меньше, потому что в больших моделях избыточность выше. На Llama 3.1 8B мы получаем сжатие с 16GB до 4GB (INT8) с потерей перплексии менее 5% на commonsense задачах.

Но есть ограничение: память для поиска оптимальных clip values. Для модели на 8B параметров нужно обработать матрицы с десятками тысяч строк. Векторизованная реализация справляется, но потребует 20-30GB RAM на пике. Решение - обрабатывать слои по частям или использовать техники из Delta-KV для потоковой обработки.

Самый болезненный вопрос: как интегрировать это в продакшен? Варианты:

• Конвертировать в ONNX с per-channel quantization (поддерживается с opset 13)
• Использовать llama.cpp с кастомными ядрами
• Написать свой inference engine на CUDA (только для смелых)

В 2026 году экосистема стала дружелюбнее. NVIDIA добавила поддержку per-row quantized weights в TensorRT-LLM 2.0, а Intel интегрировала аналоги в OpenVINO 2025.3.

Финальный совет: когда не стоит это использовать

Per-row MSE quantization - не серебряная пуля. Не применяйте её, если:

1. Модель уже квантована через AWQ или GPTQ. Вы получите деградацию без выигрыша в размере.
2. Вам нужна максимальная скорость на GPU. Специализированные ядра для INT4 (как Marlin) будут быстрее.
3. Модель использует архитектуру MoE. Квантование экспертов требует отдельного подхода.

И последнее: всегда измеряйте качество не только перплексией, но и на downstream задачах. Модель может сохранить способность предсказывать следующее слово, но потерять навык логического вывода. Запустите несколько тестов из EleutherAI LM Evaluation Harness (актуальная версия на 2026 - 0.4.2) перед развертыванием.

Будущее? К 2027 году ожидаю появление hardware-ускоренных ядер для per-row quantization прямо в мобильных NPU. И тогда модели на 7B параметров будут запускаться на часах. Не с той скоростью, конечно, но факт.

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