дорожка · 18.10.2026 · сжатие весов

Как большая модель помещается в ноутбук: сжатие весов

Открытые модели выкладывают в десятках вариантов одного и того же файла: Q8_0, Q4_K_M, AWQ, FP8. Все они — одна модель, у которой по-разному огрублены числа внутри. От этого выбора зависит, влезет ли модель в твою память, как быстро она будет отвечать и где начнёт ошибаться. Здесь разберём, почему модель вообще не помещается, что делает с числами сжатие (квантование), как читать названия файлов, как выбрать вариант под своё железо и как проверить, что сжатие не испортило именно твою задачу.

Все дорожки — /put. Прошлая — когда модели нужно «подумать» перед ответом.

1 Почему модель не влезает: веса, байты и память

Зачем это в работе. Прежде чем скачивать модель, запускать её у себя или выбирать облачную видеокарту, нужно за минуту прикинуть, сколько памяти она займёт и почему будет отвечать быстро или медленно. Без этого расчёта ты либо качаешь файл, который не запустится, либо покупаешь железо, которое упрётся не в ту часть. Эта же арифметика объясняет новости про память HBM на серверных ускорителях и про модели, которые работают прямо на телефоне.

Модель внутри — это огромный набор чисел, которые подобрали при обучении. Каждое такое число называют весом (weight) или параметром. Цифра в названии модели — это их количество: «8B» значит восемь миллиардов параметров (B — billion, миллиард), «70B» — семьдесят миллиардов. Когда модель отвечает, программа умножает числа твоего текста на эти веса слой за слоем. Ничего другого, кроме этих чисел и программы, которая их перемножает, у модели нет.

Каждый вес где-то хранится, и важно, сколько байт он занимает. При обучении обычно используют 16-битные дробные числа (форматы FP16 и BF16): это 2 байта на вес. Отсюда простая формула: память под веса = число параметров × байт на параметр. Модель на 8 миллиардов параметров в 16 битах — это 8 × 2 = 16 гигабайт только под веса. Модель на 70 миллиардов — 140 гигабайт. Это не замер, а умножение, и его стоит делать в уме при каждом выборе.

Но веса — не всё. Пока модель читает твой запрос, она для каждого уже прочитанного токена запоминает промежуточные числа, чтобы не пересчитывать их на каждом новом шаге. Это хранилище называют кэшем ключей и значений (KV cache). Оно растёт прямо пропорционально длине текста: вдвое длиннее разговор — вдвое больше кэш. Поэтому одна и та же модель может спокойно работать с короткими вопросами и не влезть в память, когда ты положишь в запрос длинный документ. Про само окно контекста было на отдельной дорожке; здесь важно, что окно стоит памяти.

Теперь про скорость. Чтобы написать один новый токен, обычной модели нужно пройти через все свои веса, то есть прочитать из памяти все 16 гигабайт. На следующий токен — ещё раз. Поэтому скорость генерации чаще ограничена не тем, как быстро процессор умножает, а тем, как быстро память отдаёт числа. Это называют пропускной способностью памяти (memory bandwidth), её меряют в гигабайтах в секунду. Отсюда главный практический вывод всей дорожки: если веса стали вдвое меньше, их вдвое быстрее читать, и модель на том же железе обычно отвечает заметно быстрее. Отличие от модели со смесью экспертов (mixture of experts, MoE): там на каждый токен работает только часть весов, поэтому читать нужно меньше, но держать в памяти всё равно приходится все веса.

Подробный пример. Посчитаем три размера одной модели на 8 миллиардов параметров и сравним с ноутбуком, где 16 гигабайт оперативной памяти. В 16 битах веса занимают 16 ГБ: не влезает, потому что системе и программам тоже нужна память. В 8 битах (1 байт на вес) — 8 ГБ. В 4 битах — около 4,5 ГБ: половина байта на вес плюс небольшие служебные числа, о которых пойдёт речь на второй ступени. Для модели на 70 миллиардов те же три варианта дают 140, 70 и около 40 ГБ: на таком ноутбуке её не запустить ни в каком виде. Повтори этот расчёт для любой модели, которую видишь в новостях, просто умножая число параметров на байты.

def weights_gb(params_billion: float, bits: float) -> float:
    """Только веса: число параметров × байт на параметр."""
    return params_billion * bits / 8

for params in (8, 70):
    for bits in (16, 8, 4.5):
        print(f"{params}B в {bits} битах: {weights_gb(params, bits):6.1f} ГБ")

Число 4,5 вместо 4 — не опечатка: в четырёхбитных форматах рядом с весами хранятся ещё масштабы, и средний расход получается чуть больше четырёх бит на вес. Точное значение для конкретного файла видно по его размеру на диске.

Где обычно ошибаются.

  • Смотрят только на размер файла и забывают про кэш под длинный запрос и про память, которая нужна самой системе.
  • Думают, что больше ядер процессора сделает генерацию быстрее, хотя упор чаще в скорость памяти.
  • Считают, что модель со смесью экспертов «весит» столько, сколько её активная часть. Активная часть определяет скорость, а память нужна под всё.

Вес (параметр). одно число внутри модели, подобранное при обучении.

8B, 70B. число параметров в миллиардах; от него напрямую зависит нужная память.

FP16 и BF16. два вида 16-битных дробных чисел, по 2 байта на вес; исходный формат большинства открытых моделей.

Байт на параметр. сколько памяти занимает один вес; множитель в формуле памяти.

Кэш ключей и значений (KV cache). промежуточные числа для уже прочитанных токенов; растёт вместе с длиной запроса.

Пропускная способность памяти. сколько гигабайт в секунду память может отдать; чаще всего именно она ограничивает скорость ответа.

Смесь экспертов (MoE). устройство модели, где на каждый токен работает только часть весов, но хранить нужно все.

2 Что делает с числами квантование

Зачем это в работе. Квантование — главный способ уменьшить модель без переобучения. Если понимать, как именно огрубляются числа, становится ясно, почему 8 бит почти всегда безопасны, почему на 4 битах уже нужно проверять, а ниже трёх модель часто начинает заметно путаться. Тогда выбор файла превращается из угадывания в осознанное решение.

Квантование (quantization) — замена точных дробных чисел на маленькие целые из короткой шкалы. В 16 битах вес может принимать десятки тысяч разных значений. В 4 битах — только 16 значений: например, целые от −8 до 7. Задача — так подобрать эти 16 ступенек, чтобы каждый вес лёг на ближайшую и при этом ошибка была как можно меньше. Важно: это не новая модель и не переобучение, а те же самые веса, записанные грубее.

По шагам это выглядит так. Веса режут на небольшие блоки, обычно по 32 или 64 числа подряд. В каждом блоке находят самое большое по модулю число и считают масштаб (scale): во сколько раз нужно уменьшить числа, чтобы самое большое стало равно 7. Потом каждый вес делят на масштаб и округляют до целого. Хранят эти маленькие целые плюс один масштаб на блок. Когда модели нужен вес, программа умножает целое обратно на масштаб и получает приближённое исходное число. Масштаб и есть те служебные числа, из-за которых в первой ступени получилось 4,5 бита, а не 4.

Главное ограничение — выбросы (outliers): редкие веса, которые намного больше соседей. Один такой вес растягивает масштаб всего блока, и маленькие соседи после округления превращаются в ноль. Поэтому блоки делают маленькими: выброс портит только свои 32 числа, а не весь слой. Поэтому же существуют более умные методы, которые отдельно берегут важные веса; о них на третьей ступени. Чем меньше бит, тем грубее шкала и тем сильнее бьют выбросы: при 8 битах ступенек 256, при 4 — шестнадцать, при 2 — всего четыре.

Есть разница, что именно сжимают. Большинство форматов для домашнего запуска сжимают только веса (weight-only): при вычислении вес распаковывают обратно в 16 бит, а промежуточные числа, которые бегут между слоями, остаются точными. Эти промежуточные числа называют активациями (activations). Их сжимать сложнее, потому что выбросы среди них встречаются чаще. Новые серверные видеокарты умеют считать сразу в 8-битном дробном формате FP8 и сжимают и веса, и активации: это экономит не только память, но и вычисления. Для ноутбука важнее первый вариант, для большого сервиса — второй.

Квантование легко спутать с двумя соседними приёмами. Дистилляция (distillation) — обучение новой, меньшей модели повторять ответы большой: у неё другое число параметров и нужен полноценный цикл обучения. Прореживание (pruning) — удаление части весов целиком. Квантование оставляет все веса на месте и только округляет их. И к квантовым компьютерам слово отношения не имеет: общий у них только латинский корень «квант» — порция.

Подробный пример. Сожмём «веса» одного слоя в 4 бита сами и посмотрим на ошибку. Код ниже берёт 4096 случайных чисел, похожих по размеру на настоящие веса, сжимает их двумя способами: блоками по 32 и одним общим масштабом на весь слой. Потом подкладывает один выброс и показывает, что стало с его соседями.

import numpy as np

rng = np.random.default_rng(0)
w = rng.normal(0, 0.02, size=4096).astype(np.float32)   # «веса» одного слоя

def quantize_blocks(x, bits=4, block=32):
    qmax = 2 ** (bits - 1) - 1                  # для 4 бит это 7
    x = x.reshape(-1, block)
    scale = np.abs(x).max(axis=1, keepdims=True) / qmax
    q = np.clip(np.round(x / scale), -qmax - 1, qmax).astype(np.int8)
    return q, scale

def restore(q, scale):
    return (q * scale).reshape(-1)

for name, block in [("блок 32", 32), ("один блок на всё", 4096)]:
    q, s = quantize_blocks(w, bits=4, block=block)
    err = np.abs(restore(q, s) - w).mean()
    print(f"{name:<18} средняя ошибка {err:.5f}")

w_out = w.copy()
w_out[100] = 0.5                                 # один выброс
q, s = quantize_blocks(w_out, bits=4, block=32)
print("соседи выброса после сжатия:", np.round(restore(q, s)[96:104], 4))
print("нулей в его блоке:", int((q.reshape(-1, 32)[3] == 0).sum()), "из 32")

Когда я прогнал этот код, ошибка с блоками по 32 вышла почти вдвое меньше, чем с одним масштабом на всё, а в блоке с выбросом 30 чисел из 32 превратились в ноль, хотя в исходных данных нулей не было. Поменяй bits=4 на 8 и на 2 и посмотри, как меняется ошибка: это ровно та картина, из-за которой 8 бит обычно безопасны, а 2 бита — нет.

Где обычно ошибаются.

  • Думают, что квантованная модель — «облегчённая версия» с другими знаниями. Знания те же, просто записаны грубее, и ошибки появляются там, где важна точность.
  • Путают квантование с дистилляцией и ждут, что файл Q4 от модели 70B будет вести себя как отдельная маленькая модель.
  • Считают, что раз 8 бит не испортили модель, то и 3 бита не испортят. Ошибка растёт не плавно: каждый убранный бит вдвое сокращает число ступенек.

Квантование (quantization). запись весов меньшим числом бит через округление к короткой шкале целых.

Разрядность. сколько бит отведено на одно число: 16, 8, 4 и так далее.

Масштаб (scale). множитель на блок, которым маленькие целые превращают обратно в приближённые веса.

Блок (группа). несколько десятков весов подряд с общим масштабом.

Выброс (outlier). редкое очень большое число, которое растягивает масштаб и стирает соседей.

Активации. промежуточные числа, которые передаются между слоями во время ответа.

FP8. 8-битный дробный формат, в котором новые серверные видеокарты умеют считать напрямую.

Дистилляция. обучение отдельной маленькой модели повторять большую; не путать с квантованием.

3 Как читать названия файлов: GGUF, Q4_K_M, GPTQ, AWQ

Зачем это в работе. На странице открытой модели в Hugging Face (крупнейший каталог открытых моделей) рядом лежат десятки файлов с непонятными суффиксами. Часть из них рассчитана на процессор и обычную память, часть — только на видеокарту, часть — на Mac. Если не уметь их читать, легко скачать 40 гигабайт, которые твоя программа даже не откроет, или взять самый маленький файл и решить, что «модель плохая».

Начнём с формата файла. GGUF — формат программы llama.cpp, самой распространённой открытой программы для запуска моделей на обычном компьютере; его же используют Ollama и LM Studio, которые построены поверх неё. В одном GGUF-файле лежат сжатые веса, словарь токенов и описание модели, поэтому его достаточно скачать и открыть. Такие файлы хорошо работают на процессоре с оперативной памятью и умеют частично переносить слои на видеокарту. Формат файла и способ сжатия — разные вещи: формат говорит, как числа упакованы на диске, метод — как их округляли.

Названия внутри GGUF читаются так. Число после Q — примерная разрядность: Q8_0 — 8 бит, Q4 — 4 бита, Q2 — 2. Суффикс _0 означает простую схему из второй ступени: блок и один масштаб. Буква K — более новое семейство схем (k-quants), где блоки сгруппированы и масштабы тоже сжаты, что даёт меньшую ошибку при том же размере. Последняя буква S, M или L (small, medium, large) говорит, сколько важных частей модели оставлено в повышенной разрядности: в Q4_K_M часть слоёв, к которым модель особенно чувствительна, хранится точнее, поэтому файл немного больше, чем Q4_K_S. Если видишь буквы IQ, это ещё одно семейство схем, рассчитанное на очень низкую разрядность.

Дальше — методы для видеокарты. GPTQ и AWQ — способы подобрать округление умнее, чем «ближайшая ступенька». Оба используют калибровочный набор (calibration set): небольшую пачку обычных текстов, которую прогоняют через модель, чтобы увидеть, какие веса реально влияют на результат. GPTQ подбирает округление слой за слоем так, чтобы выход слоя изменился как можно меньше. AWQ (activation-aware, «с учётом активаций») находит веса, которые умножаются на крупные активации, и бережёт их. В llama.cpp есть похожий приём: матрица важности (importance matrix, imatrix), посчитанная на калибровочных текстах. Отсюда практическое следствие: если калибровочные тексты были на английском, сжатие могло хуже сберечь то, что важно для русского. Это не правило, а повод проверить на своих задачах.

Ещё два слова, которые встречаются рядом. MLX — библиотека Apple для запуска моделей на Mac со своими сжатыми вариантами; на Mac процессор и видеоядро делят одну общую память, поэтому туда влезают модели крупнее, чем на обычную видеокарту с тем же объёмом. safetensors — формат файла, в котором лежат просто числа; старые файлы .bin и .pt сохранялись через механизм Python, который при загрузке может выполнить чужой код. GGUF и safetensors такого не делают, поэтому при прочих равных берут их, а файлы от неизвестных загрузчиков проверяют, особенно если формат старый.

Подробный пример. Ты хочешь запустить модель на 8 миллиардов параметров на ноутбуке с 16 ГБ памяти и без отдельной видеокарты. На странице модели ищешь файлы GGUF, лучше от авторов модели или от известных загрузчиков. По расчёту из первой ступени тебе подходят варианты от Q4_K_M до Q8_0: первый займёт около 5 ГБ, второй около 8,5. Начинаешь с Q4_K_M, потому что на процессоре скорость особенно упирается в память. Если у тебя есть исходные веса в 16 битах, сжать их можно самому через llama.cpp. Названия файлов ниже условные, подставь свои.

# 1. Перевести исходные веса из папки Hugging Face в GGUF (16 бит)
python convert_hf_to_gguf.py ./my-model-8b --outfile my-model-8b-f16.gguf

# 2. Сжать в 4 бита по схеме Q4_K_M
./llama-quantize my-model-8b-f16.gguf my-model-8b-Q4_K_M.gguf Q4_K_M

# 3. Запустить и задать вопрос
./llama-cli -m my-model-8b-Q4_K_M.gguf -p "Объясни, что такое токен, в двух предложениях."

Сравни размеры двух файлов на диске: это и есть реальный выигрыш по памяти. Сам сжатый файл потом можно открыть в Ollama или LM Studio, если удобнее окно, а не командная строка.

Где обычно ошибаются.

  • Качают GPTQ или AWQ для запуска на процессоре, хотя эти варианты рассчитаны на видеокарту и нужную библиотеку.
  • Берут самый маленький файл (Q2, IQ1) «чтобы точно влезло» и делают вывод о модели по испорченной копии.
  • Считают, что все Q4_K_M одинаковы. Один и тот же суффикс у разных загрузчиков может быть сделан с калибровкой и без неё, и вести себя по-разному.

GGUF. формат файла программы llama.cpp: сжатые веса, словарь токенов и описание модели в одном файле.

llama.cpp. открытая программа для запуска моделей на обычном компьютере; на ней построены Ollama и LM Studio.

Q4_K_M. 4-битная схема семейства K, где чувствительные части модели хранятся точнее; частый выбор по умолчанию.

Калибровочный набор. небольшая пачка текстов, по которой метод сжатия понимает, какие веса важнее.

GPTQ. метод для видеокарты, подбирающий округление так, чтобы выход каждого слоя менялся минимально.

AWQ. метод для видеокарты, который бережёт веса, умножаемые на крупные активации.

Матрица важности (imatrix). посчитанная на текстах оценка, какие веса важнее; используется при сжатии в GGUF.

safetensors. формат файла, где лежат только числа, без кода, который выполнится при загрузке.

4 Как выбрать разрядность под своё железо

Зачем это в работе. Почти всегда стоит выбор не «сжимать или нет», а «какую модель и в каком виде уместить в имеющуюся память». Можно взять маленькую модель в 16 битах или модель побольше в 4 битах того же размера. Можно оставить место под длинные документы или под скорость. Эта ступень даёт порядок расчёта, чтобы решать за пять минут, а не за вечер экспериментов вслепую.

Бюджет памяти складывается из трёх частей: веса, кэш под запрос и запас для системы и самой программы. Веса считаются формулой из первой ступени. Кэш считается по устройству модели: 2 (ключ и значение) × число слоёв × число головок для ключей и значений × размер головки × число токенов × байт на число. Все эти числа есть в файле config.json рядом с моделью, придумывать их не нужно. Запас зависит от системы, но заполнять память впритык нельзя: когда память кончается, система начинает выгружать данные на диск (подкачка, swap), и генерация замедляется в разы.

Где хранятся веса — важно не меньше, чем сколько. Если есть видеокарта, её собственная память (VRAM) намного быстрее обычной оперативной, и чем больше слоёв в неё влезло, тем быстрее ответ. В llama.cpp число слоёв, которые переносят на видеокарту, задаёт параметр -ngl (n-gpu-layers). Если модель влезла в видеокарту не целиком, оставшиеся слои считает процессор из оперативной памяти, и вся генерация идёт со скоростью самого медленного участка. На Mac память общая (unified memory): видеоядро и процессор читают одни и те же гигабайты, поэтому граница проходит по общему объёму.

Как выбирать между «больше модель, меньше бит» и «меньше модель, больше бит». В открытых сравнениях часто видно, что более крупная модель в 4 битах отвечает лучше более мелкой в 16 битах при том же объёме памяти, а ниже 3 бит качество падает резко. Это наблюдение, а не закон: на точных задачах вроде арифметики, кода и строгого формата ответа сжатие бьёт сильнее, чем на пересказе. Поэтому порядок такой: начать с 4–5 бит у самой крупной модели, которая влезает с запасом, и сравнить её с вариантом на 8 бит, если он тоже влезает.

Отдельный рычаг — сам кэш. Его тоже можно хранить в 8 битах вместо 16: в llama.cpp для этого есть параметры --cache-type-k и --cache-type-v. Это освобождает память под длинные документы, но тоже добавляет ошибку, причём именно на длинных запросах. И ещё одно различие, которое путает при замерах скорости: чтение запроса (prefill) и написание ответа — разные этапы. Чтение длинного запроса упирается в вычисления и идёт пачкой, написание ответа идёт по токену и упирается в память. Короткий тест «привет» показывает только второе.

Подробный пример. Ноутбук с 16 ГБ памяти, модель Llama 3.1 8B, задача — задавать вопросы по документам длиной до 8 тысяч токенов. Из config.json этой модели берём: 32 слоя, 8 головок для ключей и значений, размер головки 128. Считаем код ниже. В 16 битах выходит около 17 ГБ — не влезает. В 8 битах около 9 ГБ — влезает, но с небольшим запасом, особенно если открыт браузер. Около 4,5 бит (Q4_K_M) — примерно 5,6 ГБ, остаётся запас и под более длинные документы. Решение: берём Q4_K_M, а если на проверке из пятой ступени ответы окажутся хуже, пробуем Q8_0 при закрытых лишних программах.

def weights_gb(params_billion: float, bits: float) -> float:
    return params_billion * bits / 8

def kv_cache_gb(layers, kv_heads, head_dim, context, bytes_per_value=2):
    """2 (ключ и значение) × слои × головки × размер головки × токены × байт."""
    return 2 * layers * kv_heads * head_dim * context * bytes_per_value / 1e9

# Числа слоёв и головок — из config.json модели Llama 3.1 8B
for bits in (16, 8, 4.5):
    w = weights_gb(8, bits)
    kv = kv_cache_gb(layers=32, kv_heads=8, head_dim=128, context=8192)
    print(f"{bits:>4} бит: веса {w:5.1f} ГБ + кэш {kv:.1f} ГБ = {w + kv:5.1f} ГБ")

Поменяй context на 32768 и посмотри, как кэш из одного гигабайта превращается в четыре с лишним: это причина, по которой длинные документы «внезапно» не влезают в ту же модель.

Где обычно ошибаются.

  • Считают только веса и удивляются, что модель падает или замедляется на длинном документе.
  • Заполняют память впритык, система уходит в подкачку, и модель «тормозит» по причине, которая не имеет отношения к её размеру.
  • Меряют скорость на коротком «привет» и переносят результат на работу с длинными документами, где большую часть времени занимает чтение запроса.

Бюджет памяти. сумма весов, кэша под запрос и запаса для системы.

Видеопамять (VRAM). собственная быстрая память видеокарты; чем больше слоёв в ней, тем быстрее ответ.

Общая память (unified memory). память на Mac, которую одновременно используют процессор и видеоядро.

Перенос слоёв на видеокарту (-ngl). параметр llama.cpp, сколько слоёв модели считать на видеокарте.

config.json. файл с описанием устройства модели: число слоёв, головок и размеров.

Подкачка (swap). выгрузка данных на диск, когда кончилась память; резко замедляет генерацию.

Чтение запроса (prefill). этап, когда модель обрабатывает весь входной текст пачкой до первого токена ответа.

Сжатие кэша. хранение кэша ключей и значений в 8 битах вместо 16 ради длинных запросов.

5 Как проверить, что сжатие не сломало твою задачу

Зачем это в работе. Сжатая модель редко ломается заметно: она продолжает гладко отвечать, просто чуть чаще ошибается в цифрах, в коде или в формате ответа. Такое падение не видно в паре диалогов, зато видно на сотне запросов в работе. Проверка нужна один раз при выборе файла и потом при каждой его замене.

Есть общие числа, которые печатают авторы файлов. Перплексия (perplexity) — насколько модель в среднем «удивляется» следующему токену на большом тексте: чем ниже, тем лучше она его предсказывает. В llama.cpp её считает программа llama-perplexity. Точнее для сравнения со сжатием — расхождение с оригиналом (KL-дивергенция, KL divergence): насколько распределение вероятностей следующего токена у сжатой модели отличается от исходной на тех же текстах. Эти числа хороши как быстрый фильтр: если расхождение у одного файла намного больше, чем у соседнего, его можно даже не пробовать.

Ограничение общих чисел в том, что они усредняют всё подряд. Пересказ, болтовня и простые факты почти не страдают, а длинные вычисления, код, строгий JSON, длинные документы и не самые частые языки могут страдать заметно, и в среднем это теряется. Поэтому решающая проверка — на твоих задачах. Это тот же приём, что на дорожке про проверку качества: заранее собранный набор вопросов с известными ответами, один и тот же запрос для обеих версий, одинаковые настройки и сравнение не только средней доли верных, но и того, на каких именно задачах разошлись ответы.

Чтобы сравнение было честным, отключи случайность выбора: температура 0, одинаковая подсказка, одинаковая длина контекста. Про температуру — дорожка о выборе слова. Эталоном служит либо та же модель в 8 или 16 битах, если она запускается хоть где-то, хотя бы медленно, либо просто правильные ответы, которые ты знаешь сам. Отдельно считай, сколько ответов соблюли формат, если ты требуешь JSON: сжатие часто сначала бьёт именно по форме, это подробно разбиралось на дорожке про формат ответа.

Подробный пример. Собираешь 40 вопросов из своей работы: 15 на пересказ своих сводок, 15 на подсчёты с датами и суммами, 10 с ответом строго в JSON. Запускаешь две версии одной модели как локальные серверы llama.cpp на разных портах; программа llama-server отвечает в том же формате, что и API OpenAI, поэтому подойдёт обычная библиотека openai. Скрипт ниже задаёт каждый вопрос обеим версиям, сравнивает с эталоном и печатает итоги по группам и список расхождений.

import json
from openai import OpenAI

servers = {
    "Q8_0":   OpenAI(base_url="http://localhost:8080/v1", api_key="local"),
    "Q4_K_M": OpenAI(base_url="http://localhost:8081/v1", api_key="local"),
}
tasks = json.load(open("tasks.json", encoding="utf-8"))  # [{"group", "question", "answer"}]

def ask(client, q):
    r = client.chat.completions.create(
        model="local", temperature=0, max_tokens=300,
        messages=[{"role": "user", "content": q}],
    )
    return r.choices[0].message.content.strip()

score = {name: {} for name in servers}
diffs = []
for t in tasks:
    got = {name: ask(c, t["question"]) for name, c in servers.items()}
    for name, text in got.items():
        ok = t["answer"].lower() in text.lower()
        g = score[name].setdefault(t["group"], [0, 0])
        g[0] += ok; g[1] += 1
    if (t["answer"].lower() in got["Q8_0"].lower()) != (t["answer"].lower() in got["Q4_K_M"].lower()):
        diffs.append((t["question"], got))

for name, groups in score.items():
    print(name, {k: f"{a}/{n}" for k, (a, n) in groups.items()})
print("Разошлись:", len(diffs))
for q, got in diffs:
    print("-", q[:80])

Проверка «эталон содержится в ответе» грубая, но для дат, сумм и коротких фактов её хватает; для JSON добавь попытку разобрать ответ через json.loads и считай удачные разборы отдельно. Если версии разошлись на подсчётах и формате, а на пересказе нет, вывод конкретный: для пересказа бери Q4_K_M, для расчётов — Q8_0 или облачную модель. Прогони набор два раза: если результат одной версии меняется даже при температуре 0, сначала разберись с этим разбросом, а потом сравнивай.

Где обычно ошибаются.

  • Выбирают файл только по перплексии, не проверив, что происходит с кодом, цифрами и форматом на своих задачах.
  • Проверяют на трёх вопросах, видят, что «отвечает нормально», и пропускают падение, заметное только на десятках.
  • Сравнивают версии с разными подсказками, температурой или длиной контекста и приписывают сжатию разницу, которая взялась из настроек.

Перплексия (perplexity). средняя «удивлённость» модели на тексте; общий и грубый показатель качества.

KL-дивергенция. мера того, насколько вероятности следующего токена у сжатой модели отличаются от исходной.

Эталонная версия. та же модель в 8 или 16 битах, с которой сравнивают сжатую.

Падение качества (регрессия). задачи, которые раньше решались, а после замены файла перестали.

Температура 0. настройка без случайного выбора токенов, чтобы сравнение было повторяемым.

llama-server. программа из llama.cpp, которая запускает модель как локальный сервер с API в формате OpenAI.

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

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.