Квантование локальных LLM: Q8 даёт запас, а обрыв качества начинается ниже Q4

Коротко (TL;DR)

• От Q8 до Q5 качество почти не двигается. На модели 7B прирост perplexity к исходным 16 битам составляет 0,0004 у Q8_0 и 0,0142 у Q5_K_M — это сотые доли, которые в ответе не видны.
• Обрыв проходит не между Q4 и Q8, а ниже Q4. На Llama-3.1-8B школьная математика GSM8K держится на 77,4 балла в Q4_K_M против 77,6 в исходной точности, а на Q3_K_S падает до 68,3.
• Ускорение живёт только в генерации. На M2 Ultra переход с 16 бит на Q4_0 поднимает выдачу с 41,0 до 94,3 токена в секунду, но обработку промпта опускает с 1401,9 до 1238,5 — квант не ускоряет чтение вашего запроса, он ускоряет ответ.
• Малой модели терять нечего. На четырёх битах Qwen3-0.6B сохраняет 70,8% собственного результата, а Qwen3-14B — 98,1%.
• Первыми ломаются математика, следование инструкции и редкие языки, последним — бытовой разговор. Разрыв между автоматическими метриками и живой оценкой на неанглийском доходит до девятикратного.
• KV-кэш квантуется отдельно и добавляет свою потерю: в q8_0 она измеряется тысячными долями perplexity, в q4_0 на моделях с агрессивной GQA ответы начинают ломаться.

Данные актуальны на 15 августа 2026 года. Своих замеров у редакции по этой теме нет: все цифры ниже — чужие, и у каждой названы модель, тест и бекенд.

Что квантование делает с весами модели: округление по блокам

Квантование LLM — это округление чисел (в русских текстах встречается и вариант «квантизация LLM», это одно и то же). Обученная модель хранит миллиарды весов, каждый вес — дробное число в 16 битах. Квантование переводит их в целые числа меньшей разрядности: 8, 5, 4 или 3 бита на вес. Файл сжимается пропорционально, а вместе с ним падает объём памяти, который модель занимает при работе.

Округляют не каждое число по отдельности, а блоками. Веса режутся на короткие отрезки — например, по 32 штуки, — и внутри отрезка ищется общий множитель (масштаб), на который умножается целое число, чтобы вернуть примерное исходное значение. В простейшей схеме вес восстанавливается как w = d × q, где q — сохранённое целое, d — масштаб блока. В схеме чуть сложнее к этому добавляется минимум блока: w = d × q + m. Именно эти две схемы в именах файлов обозначены нулём и единицей: Q4_0, Q4_1.

Отсюда два неочевидных следствия.

Первое: «4-битный» квант — не 4 бита на вес. Масштаб и минимум тоже нужно где-то хранить, и они занимают место. У современного формата Q4_K реальный расход — 4,5 бита на вес, у Q5_K — 5,5, у Q6_K — 6,5625. Так устроены k-кванты, введённые в llama.cpp: супер-блок из 8 блоков по 32 веса, масштабы и минимумы внутри супер-блока квантуются шестью битами.

GLM-5.3 нашла 1097 критических багов — Z.ai придержала веса на две недели

Видеопамять под LLM: 10 моделей, 5 квантов и формула для KV-кэша

Ollama, LM Studio и llama.cpp на одной модели: от 0,3% разницы до трёх раз

DGX Spark, Mac Studio и Strix Halo: 120B держат все три, 70B буксует у двух

RTX 5090, 4090 и 3090 в локальных LLM: чужие замеры в одной таблице

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

Q4_K_M, Q5_K_S, Q8_0: как читать обозначения GGUF

GGUF — это формат файла, в котором модель лежит на диске; сам по себе он ничего не квантует. Квант задаётся суффиксом имени, и читается он по трём частям.

Буквы S, M, L — это не «маленький, средний, большой файл», а разная щедрость к разным частям модели. В варианте M матрицы attention.wv, attention.wo и feed_forward.w2 квантуются на ступень выше, чем всё остальное: эти тензоры оказались самыми чувствительными к округлению. В варианте S вся модель квантуется одним типом. Разница в размере при этом невелика — на 8B-модели между Q4_K_S и Q4_K_M всего 0,23 ГБ.

Насколько k-кванты выиграли у старых схем, видно на одном сравнении. По таблице llama.cpp для модели 7B старый Q4_0 весит 3,50 ГБ и добавляет 0,2499 к perplexity, а Q4_K_M весит 3,80 ГБ и добавляет 0,0535. За 0,3 ГБ разницы в размере — почти пятикратное сокращение потери. Скачивать сегодня Q4_0 смысла нет, и именно поэтому в карточках моделей на Hugging Face этот формат стоит без пометки «рекомендуется».

Importance matrix: почему два разных Q4 одного размера не равны

Два файла с одинаковым именем Q4_K_M и одинаковым весом, выложенные разными людьми, могут вести себя по-разному. Причина — importance matrix, она же imatrix.

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

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

Каким должен быть калибровочный текст — вопрос, по которому интуиция подводит. Логично предположить, что калибровать надо на текстах той области, где модель будет работать. Замер в обсуждении llama.cpp показал обратное: 8 тысяч почти случайных токенов дали результат лучше, чем 90 тысяч «чистых» текстов в стиле обучающего корпуса — на профильных данных perplexity 8,3157 против 8,3577 при эталоне q8_0 8,1901, и на посторонних данных (тексты песен) тот же порядок: 15,4084 против 15,6798 при эталоне 14,8318. Разница небольшая, но устойчивая и в обе стороны.

Практические следствия три:

1. Один и тот же уровень кванта у разных сборщиков даёт разное качество — и по имени файла этого не видно. Смотреть надо в карточку модели: у аккуратных сборщиков вроде bartowski прямо указано, что квантование шло с imatrix и на каком калибровочном наборе.
2. Чем ниже квант, тем сильнее вклад калибровки. На восьми битах она почти не важна, на трёх и ниже — определяющая.
3. «Калибровано на нашем языке» само по себе не гарантирует лучшего результата — судя по замеру выше, состав калибровочного набора важнее его тематики. Проверять приходится на своих задачах, готового ответа тут нет.

Методика замеров: чья модель, какой тест, сколько прогонов

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

Теперь про метрику, которая встречается чаще всех остальных вместе взятых.

Perplexity — это мера «удивления» модели тексту, а не мера качества ответа. Модели дают прочитать эталонный текст и смотрят, насколько уверенно она предсказывала каждое следующее слово. Число удобное: считается быстро, сравнивается легко, растёт монотонно по мере ужатия модели. Но переводится в «стало хуже отвечать» оно плохо, и тому есть две прямые улики.

Первая — из той же работы, где считались бенчмарки Llama-3.1-8B. Форматы Q5_0 и Q5_K_S дают одну и ту же perplexity 7,43, а на школьной математике расходятся на 3,42 балла: 79,08 против 75,66. Одинаковое «удивление» тексту, разное поведение на задаче.

Вторая — из разбора KL-дивергенции на Mistral 7B, опубликованного на Хабре. У Q3_K_M средний прирост расхождения с исходной моделью составляет 0,037, а у худших 5% токенов — 0,263, разрыв в семь раз. У Q2_K — 0,082 против 0,713, разрыв в 8,6 раза. Иными словами, средняя цифра прячет ровно те случаи, где модель ломается: на девяти токенах из десяти квант незаметен, а на десятом даёт другое решение.

Третья улика — многоязычная, и о ней отдельный раздел ниже.

Таблица потерь: сколько качества стоит каждый шаг вниз от Q8

Начнём с формата, который цитируют чаще всего. Историческая таблица llama.cpp снята на модели 7B и показывает прирост perplexity к исходным 16 битам.

Читать её нужно с оговоркой, которой нет почти ни у кого из тех, кто её перепечатывает: это LLaMA первого поколения, модель 2023 года. Архитектуры с тех пор изменились, и переносить конкретные значения на свежую 8B нельзя. Что переносится — форма кривой: от Q8 к Q5 потеря измеряется сотыми, между Q5 и Q4 удваивается, ниже Q4 растёт кратно.

Свежий замер на Llama-3.1-8B-Instruct — рабочей лошадке локального запуска в семействе Llama — эту форму подтверждает и добавляет то, чего в таблице perplexity нет: поведение на задачах.

Размеры файлов — из карточки готовых сборок на Hugging Face; проценты сжатия в самой работе им соответствуют (у Q8_0 файл меньше исходного на 46,9%, у Q4_K_M — на 69,4%).

Что здесь видно.

От Q8 до Q4 разницы почти нет, и она не всегда в пользу старшего кванта. На математике Q5_K_M и Q6_K обошли исходную модель в 16 битах, а Q4_K_S поставил лучший результат на следовании инструкции. Это не «квантование улучшает модель» — это шум измерения в один прогон. Именно так и надо читать разницу в доли балла: как ноль.

Обрыв начинается на трёх битах. От Q4_K_S к Q3_K_M математика теряет 4,2 балла, а к Q3_K_S — 9,0. Perplexity за тот же путь растёт с 7,62 до 8,96.

Источники не сходятся, и это стоит сказать прямо. Работа с оценкой десяти моделей и работа IJCAI дают одно: крупные модели держат удар лучше. Замер компании Latitude даёт обратный пример — Llama 3.3 70B теряет 7,8 балла MMLU при переходе на четыре бита. Усреднять такое нельзя: у замеров разные методы квантования и разные наборы задач. Вывод, который выдерживают все три, — потеря нелинейна и сильно зависит от конкретной модели, а не только от числа бит.

Самостоятельный прогон на Хабре на той же Llama-3.1-8B, где perplexity считалась на тексте «Пиковой дамы», показывает ту же картину в других абсолютных числах: Q5_K_S даёт +1% к perplexity относительно 32 бит, Q2_K — +49%.

Скорость упирается в шину памяти, а не в вычисления

Расхожее объяснение «Q4 быстрее, потому что меньше вычислений» неверно. Вычислений при квантовании становится даже больше: перед умножением целые числа надо развернуть обратно в дробные. Выигрыш берётся из другого места.

Чтобы выдать один токен, модель обязана прочитать из памяти все свои веса. Не часть, а все. Значит, скорость генерации упирается не в мощность чипа, а в пропускную способность шины памяти: сколько гигабайт в секунду железо способно прокачать. Ужали файл вдвое — вдвое меньше данных на токен — быстрее ответ.

С обработкой промпта всё наоборот. Ваш запрос модель считает пачкой токенов сразу, веса при этом читаются один раз на всю пачку, и узким местом становится арифметика. Здесь квантование не помогает, а мешает — деквантование забирает такты.

Ровно это видно в общей таблице замеров llama.cpp на Apple Silicon. Столбец pp512 — обработка промпта, tg128 — генерация; инструмент llama-bench, все слои на GPU, модель 7B.

Генерация от кванта растёт в 2,2–3,3 раза, обработка промпта падает на 4–12%. Тот же эффект независимо получен на процессорном сервере с двумя Xeon Platinum: генерация 8B-модели идёт 2,83 токена в секунду в 16 битах и 4,65 в Q4_K_S, а обработка промпта — 79,6 против 92,5 при 61,4 у Q5_0, то есть скачет без всякой связи с размером файла.

Теперь наш расчёт, которого нет ни у одного из разобранных материалов. Возьмём M2 Ultra с шиной 800 ГБ/с и умножим размер файла на скорость генерации — получим, сколько гигабайт в секунду реально прокачивается.

Размеры взяты из таблицы llama.cpp для 7B, поэтому расчёт даёт порядок величины, а не точное значение. Но вывод устойчив: файл ужимается в 3,7 раза, а скорость растёт только в 2,3. Чем ниже квант, тем хуже железо утилизирует собственную шину — накладные расходы на разворачивание чисел съедают часть выигрыша. Практический смысл простой: не ждите от Q4 четырёхкратного ускорения относительно 16 бит, ждите двух-трёхкратного, а между Q8 и Q4 — примерно полуторного.

Сколько гигабайт в секунду прокачивает конкретно ваша машина — вопрос уже не к модели: цифры по видеокартам, Mac и мини-ПК собраны в гиде по железу для локального ИИ.

Где потеря видна: код, математика и украинский против болтовни

Средняя цифра по модели бесполезна, потому что вы не пользуетесь моделью «в среднем». Разложим потерю по типам задач — это и есть та часть, ради которой обычно и ищут ответ.

Переживают Q4 спокойно. Здравый смысл и бытовой разговор: на HellaSwag падение от 16 бит до Q3_K_S составляет 0,64 балла — меньше разброса между прогонами. Пересказ, переформулировка, черновик письма, ролевой диалог — та же зона. Здесь Q4_K_M честно эквивалентен старшим квантам.

Ломаются первыми. Порядок деградации на Llama-3.1-8B при переходе на Q3_K_S считается прямо по таблице выше:

• школьная математика GSM8K — минус 9,32 балла;
• следование инструкции IFEval — минус 5,04;
• фактические знания MMLU — минус 4,19;
• здравый смысл HellaSwag — минус 0,64.

Тот же порядок независимо подтверждает работа по деградации на десяти моделях: на трёх битах задачи на здравый смысл сохраняют заметно больше, чем задачи на знания и рассуждение. Работа IJCAI добавляет нюанс, который стоит проговорить: квантование не столько бьёт по «сложному», сколько усиливает собственные слабые места конкретной модели — сложные задачи не всегда теряют больше всех. Отдельно там же отмечены проблемы со следованием инструкции и с распознаванием собственных выдумок.

Код. Прямой замер на HumanEval и MBPP по двенадцати вариантам моделей четырёх семейств даёт падение «чистой» точности на 0,36% при восьми битах и 1,19% при четырёх. Цифра маленькая, но у неё есть две оговорки: замер сделан на bitsandbytes, а не на GGUF, и он про среднюю по набору задач точность. Оценка моделью-судьёй в работе IJCAI фиксирует по коду и STEM заметное падение там, где автоматический счёт его почти не показывает. Практический вывод: если модель пишет код в агенте, где ошибка в одной строке рушит запуск, лишний бит стоит своих гигабайт.

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

Редкие языки — включая украинский. Здесь самая крупная находка ресёрча. Работа Cohere сравнила три вида оценки квантованных многоязычных моделей и получила разрыв: падение в японском 1,7% по автоматическим тестам оборачивается 16,0% по оценке живых людей на реальных промптах. Хуже всех страдают языки с нелатинским письмом, а из задач быстрее всех деградирует математическое рассуждение. Второй независимой работой по машинному переводу подтверждено: чем меньше язык представлен в обучающих данных, тем сильнее удар.

Украинский в этих работах прямо не измерялся, поэтому конкретного числа для него нет. Но класс определяется: кириллица, не топ обучающих корпусов, калибровка сборщиков — англоязычная. Если модель нужна вам для украинских текстов, ориентироваться на англоязычные графики perplexity нельзя — они занижают ущерб. Разумный практический ход: держать на один шаг больше запаса, чем советуют англоязычные гайды, то есть там, где англичанину хватает Q4_K_M, брать Q5_K_M.

Большая модель в Q4 против маленькой в Q8 при равной памяти

Вопрос звучит так: в 16 ГБ памяти влезает либо модель на 14B в восьми битах, либо на 27B в четырёх. Что брать?

Ответ на него дан не мнением, а законом масштабирования. Работа Тима Деттмерса и Люка Зеттлмойера прогнала свыше 35 000 экспериментов на моделях от 19 млн до 176 млрд параметров в разрядностях от трёх до восьми бит и сформулировала вывод одной строкой: при фиксированном общем количестве бит четыре бита почти всегда оптимальны для качества. То есть при равной памяти большая модель в Q4 обыгрывает меньшую в Q8.

Работа IJCAI на моделях от 1B до 405B приходит к тому же с другой стороны: квантованные модели часто обходят FP16-версии моделей меньшего размера.

Границы у правила две, и обе важны.

Снизу. Ниже трёх бит правило разворачивается: 70B-модель в двух битах хуже, чем 7B в четырёх. Практический потолок ужатия — Q3, и то с оговорками; Q2 берут, когда альтернатива — не запускать вовсе.

Сверху по мелким моделям. У маленькой модели нет запаса прочности, и это видно в цифрах — ниже линейка Qwen3, самого удобного семейства для локального запуска по числу размеров. Доля от собственного результата в 16 битах:

Замер сделан на GPTQ, а не на GGUF K-квантах, поэтому переносить сюда абсолютные проценты нельзя — переносится закономерность. А она однозначна: чем меньше модель, тем раньше у неё обрыв. Для 0,6B четыре бита уже почти катастрофа, для 14B — плата в два процента.

Отсюда рабочее правило выбора:

1. Модель до 4B — берите Q6_K или Q8_0, экономия на квантах здесь бессмысленна: файл и так маленький, а потеря большая.
2. Модель 7–14B — Q4_K_M базовый выбор, Q5_K_M если памяти хватает и задачи сложные. Это диапазон, в котором живёт большинство рабочих моделей под одну видеокарту, включая Gemma 3 от Google.
3. Модель 27B и выше — Q4_K_M почти всегда выгоднее, чем модель поменьше в Q8. Ниже Q4 спускайтесь, только если иначе не запустится. Отдельно стоит держать в уме архитектуры из экспертов вроде Solar Open 2 на 250 млрд параметров: в работе активна лишь часть весов, и переносить на такую модель цифры плотных моделей нельзя.
4. Никогда не оценивайте выбор по одной цифре бит: Q4_K_M с калибровкой и Q4_0 без неё — разные вещи при одинаковой четвёрке в имени.

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

KV-кэш квантуется отдельно — и это второй источник потерь

Про кванты весов пишут все. Про то, что рядом есть второй, независимый контур сжатия, не пишет почти никто.

Пока модель работает с контекстом, она держит в памяти KV-кэш — промежуточные ключи и значения по каждому уже обработанному токену. Этот кэш не имеет отношения к файлу модели: он живёт отдельно, растёт линейно с длиной контекста и на длинных диалогах спокойно съедает больше памяти, чем сами веса. У 8B-модели с контекстом 32 тысячи токенов кэш в 16 битах занимает около 6 ГБ.

Кэш можно квантовать отдельным ключом запуска, и цена этого измерена. На Qwen 2.5 Coder 7B при длине текста 6114 токенов perplexity с кэшем в 16 битах составила 8,3891 ± 0,02016, а с кэшем в q8_0 — 8,3934 ± 0,02017. Разница 0,0043 не выходит за пределы доверительного интервала. Память при этом падает вдвое: те же 6 ГБ превращаются в 3 ГБ, а на q4_0 — примерно в 2 ГБ.

Что важно знать до того, как включать:

• Flash Attention обязателен. Без него квантование кэша не работает.
• q8_0 безопасен, q4_0 — нет. На моделях с агрессивной групповой упаковкой голов внимания (у Qwen2 она восьмикратная) четырёхбитный кэш даёт заметно испорченные ответы там, где восьмибитный работает нормально. Рабочий компромисс, который нашли в обсуждении, — ключи держать в q8_0, значения в q4_0.
• Замер один. Это не серия: одна модель, один прогон, сделанный автором самой реализации. Независимой проверки в открытом доступе я не нашёл.
• Порядок действий тоже имеет значение. Если памяти не хватает, сначала имеет смысл опустить кэш до q8_0 и оставить веса на Q5_K_M, а не наоборот: судя по цифрам, восьмибитный кэш стоит дешевле, чем шаг вниз по весам.

Слабые места чужих замеров: где методики не сходятся между собой

Это не наши замеры, и относиться к ним надо соответственно.

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

Каноническая таблица устарела. Ряд «Q4_K_M +0,0535, Q8_0 +0,0004» снят на LLaMA первого поколения. Его перепечатывают в 2026 году как актуальный, и это неверно: у современных архитектур с разреженными экспертами и агрессивной групповой упаковкой внимания чувствительность другая.

Данные о размере модели получены на другом инструменте. Таблица Qwen3 по разрядностям снята на GPTQ, AWQ, RTN и SPQR, а не на GGUF K-квантах. Закономерность переносится, проценты — нет.

Замер KV-кэша единственный. Одна модель, один прогон, автор — разработчик самой функции. Это лучше, чем ничего, но это не серия.

Прямого сравнения Q4 против Q8 на одной GeForce с опубликованной методикой найти не удалось. Открытая база замеров выкладывает RTX 4090 только в Q4_K medium, и сопоставить её с восемью битами не с чем. Механика скорости в статье показана на Apple Silicon и на процессорном сервере — там доступны обе точки.

Один прогон — это один прогон. В работе по Llama-3.1-8B декодирование детерминированное и прогон единственный. Разница в доли балла между соседними квантами внутри такого замера ничего не значит.

Локальные разборы содержат прямые ошибки. В украиноязычном материале по конвертации в GGUF на форуме DOU написано, что Q8_0 ухудшает качество примерно на 50% относительно 16 бит. На самом деле вдвое падает размер файла, а измеренная дельта perplexity составляет 0,0004. Если вы встречаете проценты качества без указания модели и теста — это почти всегда пересказ пересказа.

Что устареет первым. Быстрее всего — конкретные значения по моделям: новое семейство выходит раз в несколько недель, и Unsloth выкладывает GGUF-сборки в день релиза. Механика — блоки, шина памяти, порядок деградации задач — держится дольше. Свежие цифры всегда стоит смотреть в карточке конкретной модели на Hugging Face и в обсуждениях llama.cpp.

FAQ

Какой квант выбрать, если видеопамяти всего 8 ГБ?

Модель на 7–8B в Q4_K_M занимает около 4,9 ГБ, и это оставляет запас под контекст — базовый рабочий вариант. Если задачи разговорные, можно опуститься до Q4_K_S и сэкономить ещё 0,2 ГБ. Спускаться до Q3 на такой модели не стоит: именно там начинается обрыв, а выигрыш в памяти меньше гигабайта.

Q4_K_M или Q4_K_S — есть ли между ними разница на практике?

Разница в размере — около 0,23 ГБ на модели 8B, разница в perplexity в замере на Llama-3.1-8B — 0,06 (7,56 против 7,62). В варианте M на ступень выше квантуются самые чувствительные тензоры внимания. Если 0,23 ГБ у вас есть, берите M. Если не хватает буквально этих гигабайт под контекст, S — честный компромисс.

Стоит ли брать Q6_K вместо Q8_0, если памяти хватает на оба?

Как правило, да. На 8B-модели Q6_K весит 6,60 ГБ против 8,54 ГБ у Q8_0, а прирост perplexity составляет 0,0044 против 0,0004 на семимиллиардной модели — разница между двумя способами не потерять ничего. Освободившиеся почти два гигабайта полезнее потратить на длину контекста, чем на восьмой бит.

Почему один и тот же Q4_K_M от разных авторов на Hugging Face работает по-разному?

Из-за калибровки. Квантование с importance matrix бережёт те веса, которые реально активируются на калибровочном тексте, а без неё все веса считаются равноценными. Имя файла и его размер при этом совпадают. Смотрите в карточке модели, указан ли imatrix и на каком наборе он снят; чем ниже квант, тем сильнее эта разница.

Нужно ли квантовать KV-кэш, если контекст небольшой?

Нет смысла. На коротких диалогах кэш занимает немного, и выигрыш в памяти будет символическим, а риск ненулевой. Квантование кэша окупается на длинных контекстах, где он сравнивается по объёму с самой моделью. Начинать всегда стоит с q8_0: его цена в качестве измерена в тысячных долях perplexity.

Портится ли украинский язык у модели сильнее, чем английский?

По имеющимся данным — да, у неанглийских языков потери больше, и особенно у языков с нелатинским письмом. Прямого замера на украинском нет, но на японском разрыв показателен: 1,7% падения по автоматическим тестам против 16,0% по оценке людей. Практический вывод — держать на одну ступень кванта больше запаса, чем советуют англоязычные гайды.