SSD Nodes Learn Hosting plans →
Руководства Matt ConnorАвтор: Matt Connor · Обновлено 2026-10-19

Ollama: сравнение квантования q4, q8 и fp16

Узнайте, как выбрать квантование для Ollama. Сравнение q4_K_M, q8_0 и fp16 по потреблению RAM и скорости генерации токенов. Поймите, когда потеря точности становится критичной.

На что влияет квантование в Ollama

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

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

Если Ollama еще не запущена, начните с установки Ollama на VPS. На этой странице предполагается, что ollama ls уже работает.

Как читать теги квантования Ollama, например q4_K_M

Локальные модели поставляются в виде файлов GGUF — формата, который llama.cpp использует для хранения весов на диске. Ollama построена на базе llama.cpp, поэтому теги Ollama содержат названия квантования из llama.cpp без изменений.

Число обозначает целевую разрядность. q4 означает, что большинство тензоров весов упакованы по четыре бита каждый. q8 означает восемь бит. fp16 означает отсутствие квантования: это модель с плавающей запятой 16 бит, точность, в которой публикуется большинство моделей.

K обозначает K-квантование. Веса группируются в небольшие блоки, и для каждого блока рядом с упакованными значениями сохраняется собственный масштаб. Блок, веса которого близки к 0.01, получает точный масштаб. Блок, содержащий одно большое аномальное значение, получает грубый масштаб. Именно эти поблочные масштабы позволяют использовать четырехбитный файл, и именно поэтому четырехбитный файл никогда не весит ровно четыре бита на вес.

Последняя буква обозначает комбинацию. S, M и L определяют, сколько тензоров будет приведено к разрядности выше целевой. В q4_K_M тензоры, которые сильнее всего теряют в точности при округлении, сохраняются с большей разрядностью, в то время как основная часть остается четырехбитной. Именно поэтому q4_K_M выдает более качественный результат, чем старый q4_0, при почти одинаковом размере файла.

Вместо того чтобы угадывать параметры по введенному имени, запросите у Ollama информацию о том, что находится на диске:

ollama pull qwen3:8b-q4_K_M
ollama show qwen3:8b-q4_K_M

ollama show выводит architecture, parameters, quantization, context length и embedding length. Строка quantization — это достоверный источник информации о модели, которую вы загрузили несколько месяцев назад и уже не помните, какой вариант выбрали.

Биты на вес определяют размер файла

Любая оценка размера начинается с одного числа: сколько бит формат расходует на один вес в среднем по всему файлу. Проект llama.cpp публикует измеренные показатели для Llama 3.1 8B в своей документации по квантованию, и они хорошо переносятся на любую плотную модель схожей архитектуры.

ГрафикGGUF quantization types measured on Llama 3.1 8B (published llama.cpp figures)
Данные, на которых построен график
[
  {
    "label": "F16",
    "bits_per_weight": 16,
    "file_gib": 14.96
  },
  {
    "label": "Q8_0",
    "bits_per_weight": 8.5,
    "file_gib": 7.95
  },
  {
    "label": "Q6_K",
    "bits_per_weight": 6.56,
    "file_gib": 6.14
  },
  {
    "label": "Q5_K_M",
    "bits_per_weight": 5.7,
    "file_gib": 5.33
  },
  {
    "label": "Q4_K_M",
    "bits_per_weight": 4.89,
    "file_gib": 4.58
  },
  {
    "label": "Q3_K_M",
    "bits_per_weight": 3.99,
    "file_gib": 3.74
  }
]

Неожиданность в этой таблице кроется во втором столбце. Q4_K_M — это не четыре бита на вес. Он занимает 4.89 бит, так как масштабирующие коэффициенты блоков и тензоры с повышенной точностью также требуют места. Q8_0 занимает 8.5 бит, а не восемь, по той же причине. Используйте измеренное значение, и результат вычислений будет отличаться от реального размера файла лишь на несколько процентов:

weight bytes = parameter count x bits per weight / 8
8.03e9 params x 4.89 bits / 8 = 4.91e9 bytes = 4.57 GiB

Это и есть файл Q4_K_M размером 4.58 GiB, полученный из двух чисел. Это также, с достаточной точностью, объем памяти, который занимают веса после загрузки. Ollama не распаковывает данные при загрузке: квантованные веса остаются в памяти в том же упакованном виде, а каждый блок преобразуется непосредственно в момент использования.

Что на самом деле поставляет Ollama для каждого размера модели

Библиотека публикует теги q4_K_M, q8_0 и fp16 для большинства семейств моделей. Несколько новых семейств нарушают этот шаблон и представлены в библиотеке только как облачные теги, которые нельзя загрузить локально; именно с этим ограничением вы сталкиваетесь, пытаясь запустить GLM 5.2 на VPS. Ниже приведены размеры Qwen3 по состоянию на октябрь 2026 года, полученные из списка тегов на странице модели. Каждая цифра ниже — это объем на диске до того, как модель попадет в RAM; две или три такие модели вместе заполнят корневой раздел небольшого VPS, поэтому стоит знать, где Ollama хранит загруженные модели, прежде чем начинать собирать теги.

ГрафикDownload size of Qwen3 tags in the Ollama library, GB
Данные, на которых построен график
[
  {
    "label": "Qwen3 4B",
    "q4_K_M_gb": 2.6,
    "q8_0_gb": 4.4,
    "fp16_gb": 8.1
  },
  {
    "label": "Qwen3 8B",
    "q4_K_M_gb": 5.2,
    "q8_0_gb": 8.9,
    "fp16_gb": 16
  },
  {
    "label": "Qwen3 14B",
    "q4_K_M_gb": 9.3,
    "q8_0_gb": 16,
    "fp16_gb": 30
  },
  {
    "label": "Qwen3 32B",
    "q4_K_M_gb": 20,
    "q8_0_gb": 35,
    "fp16_gb": 66
  }
]

Тег по умолчанию здесь имеет значение. ollama pull qwen3:8b загружает ровно те же 5.2 ГБ, что и ollama pull qwen3:8b-q4_K_M, поскольку тег без суффикса и есть сборка q4_K_M. Q4_K_M — это не компромисс, на который библиотека идет неохотно. Это выбор по умолчанию, сделанный разработчиками upstream, поэтому использование этого варианта — разумный первый шаг для любой модели, которую вы еще не тестировали самостоятельно. Те же соображения определяют выбор тегов при запуске Qwen 3 на VPS.

Эти пропорции сохраняются для каждой строки. Переход от q4_K_M к q8_0 увеличивает размер примерно на семьдесят процентов, а не ровно в два раза, поскольку тензоры эмбеддингов и вывода масштабируются иначе, чем остальные параметры. Версия fp16 примерно в три раза больше q4_K_M. Модель 32B в формате q4_K_M занимает 20 ГБ весов, что уже превышает объем, который может вместить сервер с 16 ГБ RAM при использовании любого контекстного окна. Более широкий обзор того, что подходит для конкретной машины, см. в разделе какие модели можно разместить самостоятельно.

Почему KV-кэш — это вторая, зависящая от контекста статья расходов

Веса — это фиксированные затраты. KV-кэш (кэш ключей и значений) — переменные. Каждый токен в окне контекста сохраняет свои векторы ключей и значений для каждого слоя, поэтому размер кэша растёт линейно в зависимости от заданного окна. Память под него выделяется целиком при загрузке модели, а не по мере заполнения диалога, поэтому большое окно потребляет память даже при запросе из одного слова.

KV bytes per token = 2 (key and value) x layers x kv_heads x head_dim x bytes_per_element
Qwen3 8B at f16:  2 x 36 x 8 x 128 x 2 = 147456 bytes = 144 KiB per token

Эти параметры модели берутся из её конфигурации: 36 слоев, 8 голов ключей/значений и размерность головы 128. ollama show содержит архитектуру и количество параметров, а config.json модели на Hugging Face — остальные данные. Умножьте стоимость одного токена на размер окна, и кэш перестанет быть незначительной величиной.

Графикqwen3:8b-q4_K_M: KV cache and floor RAM by context length, GB
Данные, на которых построен график
[
  {
    "label": "4k",
    "kv_cache_gb": 0.6,
    "floor_ram_gb": 5.8
  },
  {
    "label": "8k",
    "kv_cache_gb": 1.21,
    "floor_ram_gb": 6.4
  },
  {
    "label": "16k",
    "kv_cache_gb": 2.42,
    "floor_ram_gb": 7.6
  },
  {
    "label": "32k",
    "kv_cache_gb": 4.83,
    "floor_ram_gb": 10
  }
]

При 4096 токенах — значении окна по умолчанию, которое Ollama выбирает при наличии менее 24 GiB VRAM (включая VPS только с CPU), кэш добавляет 0.6 GB сверх весов. Увеличьте окно до 32k, и только кэш достигнет 4.83 GB, что почти равно объёму памяти для квантованных весов, а минимальный порог для всей модели составит 10 GB. Это именно минимальный порог, так как поверх него располагаются вычислительные буферы и операционная система. Реальное значение можно увидеть в столбце SIZE команды ollama ps после загрузки модели. На GPU с 24–48 GiB VRAM окно по умолчанию составляет 32k, а от 48 GiB — 256k, поэтому на мощных картах не стоит ориентироваться на значение 4k.

Размер окна задаётся на сервере, а не для каждого запроса, если вы запускаете Ollama как сервис:

OLLAMA_CONTEXT_LENGTH=8192 ollama serve

Для установки через systemd используйте drop-in файл:

sudo systemctl edit ollama
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"

Перезапустите с помощью sudo systemctl restart ollama, затем проверьте столбец CONTEXT в ollama ps, чтобы подтвердить размер окна, с которым фактически была загружена работающая модель. OLLAMA_KV_CACHE_TYPE квантует сам кэш: f16 используется по умолчанию, q8_0 требует примерно вдвое меньше памяти, чем f16, а q4_0 — примерно вчетверо меньше. Это глобальная настройка, поэтому все модели на этом сервере получают одинаковую конфигурацию. Квантизация кэша действует только при включённом Flash Attention. Ollama включает его автоматически, если это поддерживается backend, а OLLAMA_FLASH_ATTENTION=1 принудительно включает Flash Attention. На небольшом сервере с большим размером окна уменьшение кэша вдвое освобождает больше памяти, чем любое другое отдельное изменение. Если вы хотите проверить экономию до применения настройки, в материале переключение KV-кэша с f16 на q8_0 показано, как изменить эту настройку и уменьшить значение ollama ps после перезагрузки модели. В материале настройка num_ctx и её стоимость подробно рассматривается само окно. Кэш выделяется отдельно для каждого слота параллельных запросов, а не один раз на сервер. Поэтому разрешение Ollama одновременно обрабатывать два запроса удваивает рассчитанный объём памяти. На этом основаны рекомендации из материала выбор количества параллельных слотов и ограничения очереди.

Что поместится на VPS объемом 8, 16 или 32 ГБ

Учитывайте вес модели, размер KV cache, а также запас оперативной памяти для работы операционной системы и других процессов. Запас в 2 ГБ считается комфортным для небольшого VPS.

8 ГБ. Модель 4B в квантовании q4_K_M занимает 2.6 ГБ и оставляет место для длинного контекстного окна. Модель 8B в q4_K_M помещается со стандартным окном 4k, но свободного места остается очень мало. Не планируйте использовать 8B с окном 32k на этой конфигурации, так как минимальный объем 10 ГБ уже превышает возможности сервера.

16 ГБ. Модель 8B в q4_K_M с окном 16k или 32k работает комфортно. Модель 14B в q4_K_M весит 9.3 ГБ и помещается с небольшим окном. Модель 8B в q8_0 занимает 8.9 ГБ, поэтому она также поместится. Сравнение этих двух вариантов на ваших собственных промптах — самое полезное занятие, которое поможет разобраться в теме.

32 ГБ. Модели 14B в q8_0 (16 ГБ) и 32B в q4_K_M (20 ГБ) загружаются успешно. Сборка 32B с большим окном будет работать на пределе возможностей, поэтому следите за ollama ps, а не полагайтесь на предположения.

Что деградирует при квантовании в первую очередь

Ошибка квантования распределяется по работе модели неравномерно. Дольше всего сохраняется связность речи, именно поэтому повреждения легко пропустить: модель с сильным квантованием по-прежнему пишет грамотные предложения. В первую очередь страдает точность. Точное воспроизведение номера версии, сигнатуры API или даты. Длинные цепочки рассуждений, где небольшая ошибка на втором шаге приводит к неверному ответу на восьмом. Строгие форматы вывода, где одна неверная скобка приводит к сбою вызова инструмента.

Последний пункт — это практический тест. Когда модель должна вернуть JSON, который парсит ваш код, повреждение от квантования проявляется как ошибка парсинга, а не как едва заметное ухудшение качества текста, поэтому вы заметите это в тот же день. Агент для написания кода — самый суровый вариант этого теста, так как он заставляет модель выполнять вызовы инструментов один за другим, поэтому подключение агента к вашему серверу Ollama выявит слишком агрессивное квантование в течение нескольких часов.

Ниже четырех бит потери становятся значительными. Типы q3 и двухбитные квантования существуют для тех, кому нужно уместить большую модель на слабое оборудование, и это реальный вариант, когда альтернатива — вообще не запускать модель. Это плохой выбор по умолчанию. Между q4_K_M и q8_0 разрыв настолько мал, что опубликованная таблица перплексии не поможет выбрать вариант для вашей задачи, поэтому не пытайтесь полагаться на неё. Запустите оба варианта на тридцати собственных промптах и оцените результат.

Когда стоит использовать q8_0 или fp16 при ограниченном объеме RAM

Используйте q8_0, когда у вас есть свободная память, а задача критична к мелким ошибкам: структурированное извлечение данных, вызов инструментов или написание кода, который должен компилироваться. В данном случае вы покупаете страховку, а не заметно более умную модель.

Используйте fp16 только по двум причинам. Либо вы сами квантуете модель и вам нужен исходный файл, либо вы проводите замеры базовых показателей, чтобы понять, сколько теряет ваша 4-битная сборка. Запуск модели в fp16 требует в три раза больше памяти, чем q4_K_M, при разнице, которую большинство людей не заметит в слепом тесте, а на системе только с CPU это также снижает скорость генерации токенов в три раза.

Более важное правило при фиксированном бюджете памяти: более крупная модель в квантовании q4_K_M обычно превосходит меньшую модель в q8_0. 9.3 ГБ весов модели 14B против 8.9 ГБ весов модели 8B занимают почти одинаковый объем RAM (оперативной памяти), при этом более крупная модель обладает большими знаниями. Проверьте это на своих собственных промптах, вместо того чтобы принимать на веру.

Вывод данных только на CPU ограничен пропускной способностью памяти

Большинство тарифных планов VPS не включают GPU, поэтому модель выполняется в системной памяти на хост-процессоре. Скорость генерации в этом случае ограничивается пропускной способностью памяти, а не вычислительной мощностью, так как для создания одного токена необходимо считать каждый вес модели. Это создает верхний предел производительности, который не зависит от количества приобретенных ядер процессора.

tokens per second ceiling = memory bandwidth / bytes read per token
50 GB/s / 5.2 GB  =  9.6 tokens/s    qwen3 8B q4_K_M
50 GB/s / 8.9 GB  =  5.6 tokens/s    qwen3 8B q8_0
50 GB/s / 16 GB   =  3.1 tokens/s    qwen3 8B fp16

50 ГБ/с — это приблизительный теоретический показатель для двухканальной памяти DDR4-3200. Ваша доля будет меньше, так как на VPS эта шина делится между всеми арендаторами сервера, поэтому рассматривайте эти цифры как недостижимый максимум. Важна сама закономерность: при работе на CPU уменьшение количества бит на вес примерно удваивает скорость генерации токенов. Квантование — это самый эффективный рычаг ускорения на машине без GPU. Будет ли полученная скорость приемлемой, зависит от модели, а в Nemotron 3.5 Lightning на VPS этот расчет выполнен для конкретной сборки, тега и объема оперативной памяти. Вторая часть времени ожидания зависит от объема текста, который генерирует модель: при скорости 10 токенов в секунду ответ из 600 токенов займет целую минуту, поэтому ограничение ответа через num_predict часто экономит больше времени, чем очередной шаг снижения точности квантования.

Обработка промпта работает иначе. Чтение длинного промпта ограничено вычислительной мощностью, а не пропускной способностью, поэтому дополнительные ядра здесь помогают, хотя почти не влияют на скорость генерации. Если сервер быстро обрабатывает промпт на 4000 токенов, а затем медленно генерирует ответ — это нормальное поведение.

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

Самостоятельная квантование модели

Это необходимо, если вы дообучили модель, для которой нет готового тега в библиотеке. Путь зависит от желаемого формата, так как Ollama больше не создает GGUF K-quants, которые оцениваются на этой странице.

Для K-quant, например q4_K_M, выполните квантование до того, как Ollama получит файл. Ollama не квантует GGUF-модели при импорте и выдает ошибку --quantize при попытке использовать GGUF в качестве источника. Квантуйте неквантованный GGUF с помощью llama-quantize из состава llama.cpp, а затем импортируйте готовый файл. У этого способа импорта есть нюанс: несоответствие шаблона чата, из-за которого модель выдает бессвязные ответы. Процесс решения описан в импорте GGUF-файла в Ollama. Строка quantization из ollama show позволяет убедиться, что импортированный файл соответствует нужной вам сборке.

Собственная команда --quantize в Ollama работает только при импорте safetensors. Укажите в Modelfile путь к директории, содержащей неквантованные веса в формате safetensors:

FROM /path/to/safetensors/directory

Затем выполните сборку:

ollama create --quantize int4 mymodel

Начиная с версии Ollama v0.40.2 (проверено 2026-10-11), --quantize поддерживает int4, int8, nvfp4, mxfp4 и mxfp8, при этом q4 и q8 (а также fp4 и fp8) используются как псевдонимы для int4 и int8. Имена GGUF, такие как q4_K_M, q4_K_S, q8_0, q6_K и q5_K_M, отклоняются с ошибкой unsupported quantize type. Эти типы не являются GGUF K-quants из таблиц выше, поэтому не используйте приведенные на этой странице значения бит на вес и размера файла для их оценки.

Что вы увидите при возникновении проблем

Всё выполняется на CPU, хотя вы ожидали работу на GPU. Изучите столбец PROCESSOR:

ollama ps

Там выводится 100% GPU, 100% CPU или разделение вида 48%/52% CPU/GPU. Разделение означает, что веса вместе с KV-кэшем не поместились в VRAM (видеопамять, память на графической карте), поэтому часть модели была размещена в системной оперативной памяти. Скорость при этом падает почти до уровня работы только на CPU, так как каждый токен ожидает завершения работы медленной части. Уменьшите размер контекстного окна, квантуйте кэш или загрузите более компактную сборку. Добавление ядер CPU не поможет.

Модель завершается аварийно во время загрузки. Проверьте журнал ядра и службы:

sudo dmesg -T | grep -i "out of memory"
sudo journalctl -u ollama -n 50

Строка, содержащая Out of memory: Killed process, означает, что суммарный объем весов, KV-кэша и буферов превысил объем оперативной памяти на сервере. На VPS без настроенного swap вся система может зависнуть на несколько секунд перед появлением этой строки.

Качество ответов ухудшилось, хотя вы ничего не меняли. Две сборки одной и той же модели могут находиться рядом в ollama ls под разными тегами, и скрипт, который скачивает образ без суффикса, будет следовать за тем, на что в данный момент указывает библиотека. Выполните ollama show для конкретного тега, который запрашивает ваш клиент, и прочитайте строку quantization, вместо того чтобы доверять имени в файле конфигурации.

FAQ

Какую квантованную версию Ollama мне выбрать?

Начните с q4_K_M. Это стандартный тег, который библиотека Ollama использует по умолчанию для большинства моделей, поэтому ollama pull qwen3:8b и ollama pull qwen3:8b-q4_K_M загружают один и тот же файл. Переходите на q8_0 только в том случае, если у вас достаточно свободной оперативной памяти, а задача чувствительна к мелким ошибкам, например, при вызове инструментов (tool calling) или генерации структурированного JSON. При ограниченном объеме памяти более крупная модель с квантованием q4_K_M обычно работает лучше, чем модель меньшего размера с q8_0, поэтому протестируйте этот вариант, прежде чем выделять дополнительную RAM под точность.

Означает ли q4_K_M действительно четыре бита на вес?

Нет. Для Llama 3.1 8B это значение составляет 4.89 бита на вес, так как каждый блок весов хранит собственный масштаб, а наиболее важные тензоры переводятся в более широкий тип данных. По той же причине Q8_0 использует 8.5 бита, а не восемь. Используйте измеренное значение для расчетов: количество параметров, умноженное на количество бит на вес и деленное на восемь, дает размер файла в байтах.

Сколько RAM нужно для модели 8B на VPS только с CPU?

Сложите объем весов, KV-кэша и запас памяти. Модель Qwen3 8B с квантованием q4_K_M занимает 5.2 ГБ. При стандартном окне контекста в 4096 токенов кэш добавляет 0.6 ГБ, что дает минимальный порог около 5.8 ГБ без учета вычислительных буферов и операционной системы. При окне в 32k только один кэш занимает 4.83 ГБ. Планируйте 8 ГБ для короткого окна и 16 ГБ, если вам нужно длинное.

Почему модель загружает CPU на 100%, если на сервере есть GPU?

Выполните ollama ps и изучите столбец PROCESSOR. Значение 100% CPU или разделение, например 48%/52% CPU/GPU, означает, что веса вместе с KV-кэшем не поместились в VRAM, поэтому Ollama перенесла часть или всю модель в системную память. Чаще всего это происходит из-за того, что окно контекста больше, чем может вместить видеокарта, так как кэш выделяется под весь размер окна при загрузке модели. Уменьшите размер окна с помощью OLLAMA_CONTEXT_LENGTH, установите OLLAMA_KV_CACHE_TYPE=q8_0, чтобы сократить кэш вдвое, или загрузите модель с меньшей квантованной версией.

Была ли эта статья полезной?