Решил я запустить генерацию с meta-llama/Meta-Llama-3.1-8B-Instruct с <bos_token> (то есть без всякого контекста) с температурой 1, и было любопытно, что первое взбредет сеточке в голову.

Ответ оказался немного неожиданным)

慢性胰腺炎（CI）是一种慢性胰腺炎，其特点是胰腺炎症的持续存在和慢性损伤。胰腺炎是肾上腺皮质激素（CORT）过量释放的副作用之一。与CI相比，其作用更持久。

Если вбить в переводчик, выдает следующее:

Chronic pancreatitis (CI) is a kind of chronic pancreatitis, which is characterized by the persistence of pancreatitis and chronic damage.Pancreatitis is one of the side effects of excessive release of adrenal corticosteroids (CORT).Compared with CI, its effect is more lasting.

Self-calibration for Language Model Quantization and Pruning
[Статья] [Кода нет]

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

Ранее эти же авторы перебрали несколько вариантов (пост на КПД), и обнаружили, что некоторое, хоть и не столько значительное, различие в качестве есть в зависимости от источника данных.

В этой же статье авторы предлагают сжимаемой модели самой сгенерировать 🪄 данные для калибровки.

Метод

Калибровочные последовательности генерируют начиная с <bos> токена.
Дабы повысить качество данных предлагается динамически менять температуру - сначала больше, чтобы было разнообразие, а затем снижать по мере увеличения количества сгенерированных токенов.

Эксперименты

Рассматривают несколько небольших LLM:
⭐️ Gemma 2B
⭐️ Phi-2
⭐️ OPT 6.7B 👨‍🦳
⭐️ Mistral 7B
⭐️ Llama-3.1-8B
Которые сжимают при помощи AWQ, GPTQ (4-битная квантизация) и SparseGPT, Wanda (2:4 прунинг).

В качестве бейзлайнов берут Wikitext-2, C4, рандомные токены, Сosmopedia.
Качество замеряют на стандартных бенчах из lm-eval-harness.

⚡️ Синтетические данные, сгенерированные моделью, почти всегда лучше выборок из датасетов. Различие заметнее на прунинге, где просадки больше.

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

⚡️ Снижение температуры 🌡️ генерации от 2 до 1 по ходу генерации дает самые лучшие результаты, хоть и без значительного отрыва от фиксированной температуры - 1.

Вывод

Идея прикольная, и для используемого количества данных (128 последовательной длины 2048) достаточно дешева в проверке. Эффективность метода во многом зависит от качества базовой модели, что, впрочем, для современных LLM, интересных сообществу верно. Интересно 🤔, справедливы ли полученные выводы для более сложных задач?

Соавтор и коллега по Yandex Research @galqiwi выкатил демку AQLM на ржавчине.

Можно просто взять и запустить Llama 3.1-8b, квантованную в 2 бита AQLM+PV в браузере на CPU, со скоростью 1.4 токена в секунду на M1.
LM head квантизуется в int8.

Отличная работа, Вова!

[Демка][Пост на galqiwi boredom][Репост на Love. Death. Transformers][Репозиторий]

Breakpoint - уровень сеньор.

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

Если вам приспичит инферить LLMку на микроволновке. пока разогревается еда 🍣, мы как раз подогнали 2-битные меньшие версии Llama-3.2:

👶 Llama-3.2-1B-AQLM-PV-2Bit-2x8
👶 Llama-3.2-1B-Instruct-AQLM-PV-2Bit-2x8
👶 Llama-3.2-3B-AQLM-PV-2Bit-2x8
👶 Llama-3.2-3B-Instruct-AQLM-PV-2Bit-2x8

Основное место занимают уже эмбеды (которые хоть shared, но с FSDP немного покорячиться пришлось).

Ждем выкатки квантизации эмбедов в transformers.

Liger Kernel: Efficient Triton Kernels for LLM Training
[Техрепорт]
[Репозиторий]

Ребята из LinkedIn написали кернелы для разных операций в LLMках на Тритоне (когда нибудь я научусь писать на нем, а не про него), которые ускоряют процедуру обучения и снижают расход памяти по сравнению с ванильной торчовой реализации.

Метод

В частности, Liger Kernel предлагает следующее:

⭐️ Зафьюженные RMSNorm и LayerNorm на прямом и обратном проходе
⭐️ Зафьюженные SwiGLU и GeGLU на прямом и обратном проходе
⭐️ Оптимизированный RoPE
⭐️ И самое интересное - оптимизация вычисления кросс-энтропии

По поводу последнего:

Словари нынче у моделек перевалили за 100к, и на сколь-либо длинных последовательностях матрица логитов будет весить десятки гигов. Потому авторы реализовали прямой проход, вычисление кросс-энтропии и обратный проход в одном kernel-е без необходимости материализации одновременно матрицы логитов и градиентов по логитам. Кроме того, считать логиты можно не разом для всей последовательности, а чанками.

Бенчмарки

Замеряют на A100.

Предложенные нормализации дают хорошее ускорение по сравнению с торчом (не хватает сравнения с Apex). RoPE прямо знатно ускорился. SwiGLU и GeGLU по скорости такие же, как в торче, но снижают расход памяти в 1.6 раз.

В end-2-end сценарии гоняют finetune на 4A100 на Alpaca на Llama-3-8B, Qwen-2-7b, Gemma-1-7b. Скорость обучения возрастает от 10 до 40 %, и пиковый расход памяти уменьшается в среднем на 50%.

Метод также валидируют в связке с Medusa, методом где LLM учится предсказывать несколько следующих токенов за раз, и на каждый n+1 токен своя обучаемая голова. Liger Kernel снижает заметно расход памяти как с замороженной, так и обучаемой тушкой трансформера, благодаря трюкам с вычислениями логитов.

Использование

Liger Kernel можно вызвать по щелчку пальца через AutoLigerKernelForCausalLM или патчинг модели из 🤗. А можно импортировать модули и из них собрать модельку.

Liger Kernel уже интегрирован в transformers, TRL и axolotl.

В комментариях был задан резонный вопрос - а сравнивали с torch с или без compile?

Будучи лучшего мнения о людях, я полагал, что да.

Но если посмотреть в скрипты бенчмарков в репозитории проектов - compile не фигурирует нигде. RMSNorm берут сырой из modeling_llama.py в частности.

Хитрые собаки 🐶!

EoRA: Training-free Compensation for Compressed LLM with Eigenspace Low-Rank Approximation
[Статья][Написание кода предоставляется читателю в качестве несложного упражения]

Введение

Низкоранговые приближения применяются много где в Deep Learning и не только, про LoRA не слышал только ленивый. В данной статье группа миньонов кожаной куртки предлагает компенсировать ошибку методов сжатия (прунинга и квантизации) за счет вставки низкорангового разложения ошибки сжатия как адаптера паралелльно весам.

Метод

Метод прост как пробка.
1️⃣ Были у нас исходные веса W.
2️⃣ После сжатия имеем Wc.
3️⃣ SVD матрицы W - Wc
4️⃣ Берем сколько-то главных компонент и вставляем параллельно сжатым весам как LoRA адаптер.

При этом ничего не надо обучать.

Эксперименты

Метод тестируют поверх 50% / 60% unstructured sparsity, 2:4 sparsity с SparseGPT в качестве алгоритма сжатия и 3/4-битной квантизацией GPTQ. В большинстве экспериментов берут ранг добавки равным 128. Проверяют на Llama-2 (7B и 13B), Llama-3 (8B).

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

Вывод

Простой и бюджетный способ накинуть немного качества за счет небольшого количества параметров и дополнительных вычислений.
Так как базовые методы сжатия data-aware (SparseGPT, GPTQ), то вместо SVD можно было бы использовать Reduced Rank Regression, и это бы работало, скорее всего, чуть лучше.

Будь бы у меня дети, я бы их побенчмаркал на MMLU.

BitNet a4.8: 4-bit Activations for 1-bit LLMs
[Статья] [Репозиторий (пока не обновили код)]

Продолжение истории с BitNet от Microsoft.
1️⃣ В первой части была предложили бинарную квантизацию весов.
2️⃣ Во второй части вместо бинарной квантизации тернарная, но зато качество заметно возросло.

При этом активации квантовались absmax в INT8.

В данной статье фокусируются на сжатии активаций (в частности, KV-кэшей) в 4 и бита и меньше.

Метод

Авторы строят гистограммы весов активаций после линейных слоев. Выходы q, k, v, gate, и up неплохо описываются нормальным распределением. А вот out, down имеют тяжелые хвосты (потому тяжело квантизуются).

Поэтому предлагается квантовать в 4 бита активации только первой группы слоев, а для выхода out_proj (следуя работе QSparse, которую сам пока не читал 😂) прореживают активации через topk (с 50% sparsity).

Кроме того вместо swish в FFN gate применяют ReLU^2, чтобы форсировать прореживание активаций в down projection. Впрочем, так как паттерн случайный, использовать его для ускорения сходу не получится.

Также рассматривают FP4 квантизацию вместо INT4 с большим динамическим диапазоном.

Эксперименты

Обучают семейство 🦙-подобных моделей от 700M до 7B параметров на Красной Пижаме. Причем обучают в 2 стадии, сначала с 8-битными активациями большее время обучения (как в BitNet1.58), а затем в перечисленных выше группы слоев квантуют в 4 бита (или прореживают).

⭐️ BitNet a4.8 (INT4/FP4) почти не уступает по качеству fp бейзлайну (не очень сильному, впрочем).
⭐️ ReLU^2 дает значительную (около 80%) степень разреженности в down_proj.
⭐️ Обучение чисто в INT4 не сходится в принципе. С FP4 гораздо хуже, чем предложенный вариант.
⭐️ ReLU^2 дает +/- тоже качество, что более традиционный Swish.
⭐️ Кэши квантизуют в 3 бита кроме <bos>, <eos> токенов, которые более чувствительны и поддерживаются 4 битными, без просадки в качестве по сравнению с 4-битными кэшами.

Определив хорошую конфигурацию, 2B модель обучают на 2T токенах и получают метрики, конкурирующие с хорошими fp16 моделями в той же весовой категории (Llama-3.2, gemma-2, Qwen-2.5). Впрочем, ребята из Мелкософта известны тем, что добавляют тест в train (как было в случае с моделями Phi) 😈.

Вывод

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

Процесс чтения рецензий на ICLR

(впрочем, как и на любой другой Core A* конфе)

Scaling Laws for Precision
[Статья] [Кода нет, как и ресурсов у вас, чтобы воспроизвести]

Введение

Известно, что с увеличением размера модели и количества данных качество моделей (в некотором смысле - обычно по val лоссу) растет. Причем не абы как, а по простым степенным законом (а-ля Шиншилла). Также известно, что инферить большие модели тяжело и дорого, а методы квантизации позволяют существенно сжимать модели в пределах умеренной просадки качества. Есть наблюдение, что более современные LLM (Llama-3+, Gemma-2, Qwen2+) сжимаются заметно тяжелее 🥵, чем предшественники;

Отсюда вопрос, при заданном бюджете на обучение, какое оптимальное отношение числа токенов к размеру модели и битность квантизации?

И в рассматриваемой работе, авторы проводят детальное и масштабное исследование, делая целый ряд нетривиальных выводов.

Метод

Ниже:
D - количество данных
N - количество параметров модели
P - precision на обучении

Авторы обучают тучу моделей (465 штук а-ля 🦙) разного размера, битности (от 3 до 16) и с разным бюджетом обучения (вплоть до отношения числа токенов к параметрам 10^5). Тем самым авторы учитывают случай характерный для современных моделей, где перекос в сторону данных сильно выходит на Chinchilla-optimal закон (D/N = 2000 у Llama-3 против D/N=20 по Шиншилле).

Рассматривают 3 сценария:
1️⃣ Post-training Quantization. Учим во bf16 и квантизуем после обучения. Берут GPTQ, как ходовой и рабочий метод.
2️⃣ Quantization-aware training. Квантизуем по ходу обучения. Но только веса.
3️⃣ Low-precision training. Квантизуем во время обучения веса, активации и KV-кэши.

Предложенный scaling law для post-training квантизации имеет вид (P - precision, она же битность):
L(N, D, P) = AN^{-\alpha} + BD^{-\beta} + E + \delta_{PTQ} (N, D, P)
Где \delta_{PTQ} - прирост лосса, вызванный квантизацией.

Для QAT и Low-precision training:
L(N, D, P) = AN^{-\alpha} (1 - e^{P_{w} / \gamma_w}) (1 - e^{P_{a} / \gamma_a}) (1 - e^{P_{kv} / \gamma_kv}) + BD^{-\beta} + E
То есть, некоторые модификации исходного scaling law.

Эксперименты

Post-training Quantization

С увеличением количества данных на обучении (и качества модели), ошибка квантизации растет 🔼. Кроме того, ошибка для больших моделей фиксированном отношении D/N меньше 🔽 у больших 🔼 моделей.

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

Проанализировав зависимости, авторы выводят функциональную форму для \delta_{PTQ}, где ошибка растет степенным образом по количеству данных, убывает степенным образом по размеру модели, и растет экспоненциально с уменьшением битности.

QAT + Low-precision training

Далее авторы обучают модели, квантизуя либо только веса, либо веса и активации.

Оказывается, что эффект от квантизации можно описать как некую мультипликативную добавку к количеству параметров вида (1 - e^{P/gamma}). Т.е модель с квантизацией чего либо и эквивалентна модели с N (1 - e^{P/gamma}) параметрами. Коэффцициенты P, gamma свои у весов, активаций и кэшей. Кэши легче всего квантизуются, веса посередине, а активации тяжелее всего.

Причем ошибки квантизации w, a, kv независимы и предложенная зависимость хорошо фитируется на основе экспериментальных точек.

Предполагая, что у нас есть вычислитель, умеющий эффективно работать с любой точностью, авторы фиксируют бюджет обучения, определяемый как
C = 6 (P / 16) ND (16 от bf16) и ищут оптимум по лоссу.

Наблюдения следующие:
⭐️ Если учить в низкой точности, масштабировать размер модели надо быстрее, чем количество данных. (в Шиншилее, напомню, оптимально пропорционально)
⭐️ Compute-optimal precision не зависит от бюджета обучения и примерно равно 7 бит на параметр. Эксперименты проводят с INT-X, FP-X, floating-point чуть лучше, но общий вывод справедлив.

Отсюда замечание, что обучение в INT4/FP4 и более низких битностях может быть не оптимально.

Вывод

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

Интуитивно понятно, что сжимать модели до бесконечности невозможно, ибо так или иначе сеть должна в себе как-то хранить все знание о мире 🌍, но вопрос стоял именно в определении самих границ.

Крайне любопытно, что отношении оптимальной полученной битности к 16-ти близко к compute-optimal sparsity в Sparsity Scaling Laws (пост на КПД). Совпадение ли 🤔?

Кроме того, интересно, насколько полученные выводы справедливы для более навороченных векторных квантизаций (QuIP#, AQLM, QTIP) и что будет, если поменять точность обучения на ходу (учить в fp/bf16), прогнать PTQ, и далее QAT (Low-Precision Training).

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

Теперь с чистой душой можно лечь досыпать 😴

я добрая училка

GPTQModel
[Репозиторий]

GPTQ в настоящий момент является одним из самых популярных методов квантизации весов LLM в ~4 бита как дающий некий хороший баланс между качеством и временем работы. Он выдает стабильно лучшее качество по сравнению с наивным Round-to-Nearest и иными data-free квантизациями, при этом масштабируется сравнительно легко на огромные LLM.

Оригинальный репозиторий тестирует сугубо работоспособность метода и не годится для приложений.

Значительную популярность (4.5к ⭐ на гитхабе) набрала библиотека AutoGPTQ c а-ля лицехватским 🤗 интерфейсом и поддержкой различных моделей, а так же кернелов а-ля Marlin для эффективного инференса. К сожалению, maintainerы забросили либу, потому самые новые модели через нее квантовать не получится.

Ребята из ModelCloud продолжили их дело, создав GPTQModel, куда добавлены Llama-3.2, Qwen-2.5, и другие сравнительно новые модели.

Кроме того, авторы обещают более быструю калибровку (до 50%), быстрые замеры перплексии, и немного лучшие по качеству квантизованные модели.

Зубы заговаривают)

Catastrophic Failure of LLM Unlearning via Quantization
[Статья][Код]

Введение

LLM и прочие Foundational модели хранят в себе массу полезной информации.

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

Потому были разработаны разные техники unlearning, например, Gradient Ascent (градиентный подъем!) и NPO (Negative Preference Optimization), которые понижают правдоподобие нежелательных концептов.

Но действительно ли сеть забывает 😶‍🌫️ про них?

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

Метод

Авторы рассматривают два семейства методов забывания фактов:

🦋 Gradient Ascent , где оптимизационный процесс повышает кроссэнтропию нежелательного концепта
🦋 NPO, форма DPO (Direct Preference Optimization), с занижением правдоподобия того. что хочется забыть

Чтобы сеть не забывала кроме целевых концептов все остальное, параллельно с этим дообучают на данных как в обучающей выборке с выброшенными концептами (Retain Set), которые мы хотим забыть.

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

В качестве методов квантизации рассматривают RTN, GPTQ, AWQ. Выводы справедливы для всех методов.

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

Можно было использовать маску произвольного вида, но чтобы сэкономить память авторы отбирают “чувствительные” веса на уровне слоев (т.е обучают только подмножество слоев). Называется сия конструкция, конечно же, Saliency-Based Unlearning with a Large Learning Rate (SURE).