КПД

Есть ли способ в телеграме выбрать себе вид наказания ботами или обменяться с кем-то?

Если уж выбирать зло, я бы предпочел шлюхоботов вместо дурацких NFT-ботов.

Зло есть Зло. Большее. Меньшее. Среднее... Какая разница? Зло трудно измерить, его границы размыты. И если мне придётся выбирать между одним Злом и другим, я не стану выбирать вовсе.

(с) Геральт из Ривии

KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache
[Статья] [Код]

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

Группа исследователей (с забавным примечанием The order of authors is determined by flipping a coin 🪙) из разных мест на послендем ICML представила статью со звучным названием KIVI (терминал оплаты, фрукт и птица пишутся по-другому).

Метод

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

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

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

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

Метод валидируют на бенчах из LM-Eval, LongBench (наборе задач на длинный контекст) и Needle-in-a-Haystack (где нужно достать вытащить нужный факт из длинного промпта) на моделях Llama-2, Mistral.

Наивная квантизация в 2 бита сильно страдает по качеству, а предложенный подход работает с совсем небольшой просадкой. Есть, правда, маленький нюанс, что 2-битная квантизация использует размер группы 32 с fp zero-point, что означает на практике 3 бита 😅. Needle-in-a-Haystack решается почти идеально.

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

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

Вывод

Сжатие кэшей - богоугодное дело. А дабы эффективно квантизовать кэши полезно смотреть на распределение того - что сжимаешь.

LLM KV cache compression made easy
[Репозиторий]

В связи с ростом потребности в эффективной по памяти и скорости работе с длинным контекстом (особенно с учетом набирающего популярность test-time compute scaling) все острее стоит вопрос сжатия KV-кэшей. Данной теме уже посвящено немалое число работ (и существует уже интеграция в transformers).

И недавно ребята из одной зеленой компании выкатили либу, с реализацией разных техник сжатия KV-кэшей под названием kvpress.

В данной либе реализовано несколько простых и популярных техник сжатия кэшей:
🌟 Случайный прунинг
🌟 Основанный на нормах токенов
🌟 Несколько подходов, основанных на attention скорах (SnapKV, TOVAPress, H20)

Причем битность можно задавать послойно при помощи класса PerLayerCompressionPress.

Самую SOTA (например, PyramidKV) в области пока еще не завезли, увы.

В репозитории есть ноутбуки с демострацией использования библиотеки и замерами скорости и памяти.

Либа действительно удобная и приятная для использования.

Методы сжатия кэшей можно комбинировать с квантизацией кэшей у лицехватов 🤗.

noise_step: Training in 1.58b With No Gradient Memory
[Манускрипт] [Репозиторий]

Введение

Первый пост данного года будет несколько комедийного содержания, как раз в самый раз для прочтения после нескольких бокалов шампанского 🥂 (или чего покрепче 🥃).

Некто Уилл Брикнер выложил на гитхаб презанятнейший опус про обучение тернарной сети в 1.58 бит без необходимости выделения памяти 😱 на градиенты и состояния оптимизатора.

Метод

Товарищи из Мелкософта в серии работ про BitNet показали, что обучая сеть с тернарными весами (принимающими значения только -1, 0, 1 и умноженными на некий скаляр), и низкобитными активациями (4/8 бит) можно выжать качество, сравнимое с fp обучением при тех же бюджетах обучения. Однако, во время само обучения приходится хранить floating-point веса, и состояния оптимизатора, как для fp модели. То есть обучение все равно требует значительных затрат памяти.

Автор данного опуса, вспоминая статью Gradients without Backpropagation, замечают, что операция умножения якобиана по выходу модели на фиксированный вектор не требует backpropagation.

Потому предлагается делать случайные возмущения, причем для случая тернарных весов возмущения это -1, 0, 1. Для улучшения сходимости предлагается отбрасывать слишком малые возмущения (т.е своего рода прунить обновление).

Так как на практике мы используем псевдослучайные числа, то для параметризации модели достаточно хранить только случайные зерна со всех шагов оптимизации. И для обучения GPT-3, взяв данные из техрепорта (тогда еще ClosedAI еще не совсем Closed), получают ~100к шагов оптимизации, и всего несколько мегабайт на хранение 175B весов 🤪. А как вы будете эти сиды превращать в веса - это ваши проблемы)

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

Предложенный метод валидируют на 4-слойной MLP c hidden_size = 256, и данный метод (о, боже!) даже сходится и выдает космические 🚀 почти 90% качества 😱 на MNIST.

Единственный недостаток всей этой красоты, в том, что авторы не релизнули эффективные кернелы для обучения и инференса. Что ж поделать, не все познали дзен куды и тритона (в том числе и пишущий сии строки).

Вывод

Это, наверное, самый забавный каламбур на моей памяти в данной области) Интересно, автор сам дошел до этого или воспользовался помощью всесильного оракула в виде LLM. Я в полном восхищении 😱, в любом случае.

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

Ключевые моменты и достижения области за 2️⃣0️⃣2️⃣4️⃣ превосходно отметил у себя на канале Григорий Сапунов (https://t.me/gonzo_ML/3175).

Со своей стороны могу лишь добавить, что уходяший год, был интересным и примечательным в том числе и точки зрения техник сжатия и ускорения моделей:
🌟 Появились 2️⃣-битные квантизации, которые не приводят LLM в полную негодность. (AQLM, QuiP#, PV-Tuning, QTIP)
🌟 Спекулятивный декодинг подарил ряд интересных работ (до коих у вашего покорного слуги не дошли руки на разбор, но в следующем году планирую наверстать упущенное).
🌟 Ряд интересных решений по сжатию активаций и KV-кэшей.

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

Спасибо всем присутствующим здесь (кроме NFT-ботов 🤖) за то, что вы здесь, за вашу поддержку и комментарии.
Будем стараться и дальше делать полезный (и, надеюсь, интересный ) контент.

Быть добру!

Diffusion Meets Flow Matching: Two Sides of the Same Coin

В начале декабря группа чуваков из Глубокого Разума, среди коих признанные аксакалы, как Hoogeboom, De Bortoli и Salimans опубликовала презанятнейший пост Diffusion Meets Flow Matching: Two Sides of the Same Coin.

Нынче стало модно учить диффузионки в Flow Matching постановке. Тренд, по всей видимости, был задан SD3. И большинство нынешней SOTA в картиночной и видео генерации (из того, что известно) FLUX, MovieGen, HunyuanVideo.

И что это значит? Классическая парадигма - пережиток истории 🤔?

Ан нет.

В данном блогпосте авторы в деталях анализируют процесс сэмплирования и обучения в стандартной noise-prediction Variance Preserving (VE) диффузионной постановке и Flow matching, и показывают, что по сути обе сущности про одно и то же. Основная разница в коэффициентах при шуме/сигнале и использовании скорости в качестве выхода нейронной сети вместо шума/x0. И по ходу повествования эквивалентность двух парадигм авторы иллюстрируют с разных сторон.

Сам блогпост содержит красивые 🥰 иллюстративные визуализации с ползунками 😮.

Кроме того, авторы опровергают распространенное мнение, что Flow Matching дает непременно более прямые траектории, чем диффузия. Для узких распределений Flow Matching действительно дает более прямые траектории, чем типичный диффузионный процесс, но для широких распределений все может поменяться с точностью до наоборот. Впрочем, для наиболее типичного сценария text-2-image генерации или редактирования изображения, целевое распределение, по всей видимости, достаточно узкое.

Наткнулся на репозиторий, красиво и наглядно иллюстрирующий mode collapse для различных формулировок GANов на 2-мерных игрушечных задачах.

“GIVE ME BF16 OR GIVE ME DEATH”? ACCURACY-PERFORMANCE TRADE-OFFS IN LLM QUANTIZATION
[Статья] [Нет кода]

Введение

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

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

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

Метод/Эксперименты/Результаты

Авторы рассматривают 3 варианта квантизации:
1️⃣ W8A8-FP (поддерживаемый только на Hopper/Ada Lovelace+)
2️⃣ W8A8-INT
3️⃣ W4A16
В первом случае веса сжимают просто через RTN квантизацию, в остальных применяют оптимизированный GPTQ (с поиском оптимальных скейлов) с калибровкой на OpenPlatypus. В случае 4-битной квантизации весов сравнивают еще и с AWQ.

Замеряют качество по трем сериям задач (на Llama-3.1 {8B, 70B, 405B}):
1️⃣ Open LLM Leaderboard V1
2️⃣ Open LLM Leaderboard V2
3️⃣ И так называемые Real-World задачи - Arena-Hard, HumanEval, HumanEval+

На Open LLM Leaderboard V1 все методы в пределах 99% качества исходной модели, за исключением задачи TrurthfulQA, где наблюдается просадка до 3%.

На Open LLM Leaderboard V2 имеет тоже место почти полное восстановление с наиболее заметной просадкой на BigBenchHard.

На ArenaHard, HumanEval, HumanEval+ тоже все хорошо.

AWQ бывает немного лучше на Open LLM Leaderboard, но заметно уступает на Real-World задачах.

Далее смотрят на похожесть генераций на Arena-Hard у исходной модели через ROUGE-1, ROUGE-L и BertScore. ROUGE порядка 0.6-0.7, но по всей видимости, это означает большую похожесть 😅 .

Для оценки скорости рассматривают разные сценарии:
1️⃣ Длинный промпт / короткий выход
2️⃣ Промпт и выход примерно одной длины
3️⃣ Короткий промпт / длинный выход

Инференс гоняют на vLLM, как проверенном и быстром движке. Замеры гоняют на A6000, A100, H100.

Рассматривают сценарий сихронной и асинхронной (подается батч запросов) генерации.

В синхронном случае почти всегда быстрее всего работает W4A16 квантизация, кроме длинного промпта (compute-bound режим) и инференса H100, где предпочтительнее FP8, INT8 W8A8 квантизация.

В асинхронном сценарии INT4 предпочтительнее на более low-end девайсах, а FP8 при инференсе на H100.

Вывод

Квантовать модели полезно? 😝

ClosedAI назвали новую модельку o3, дабы обойти коллизию имен с o2 - британским оператором, но не учли, что o3 - это озон)

PrefixQuant: Static Quantization Beats Dynamic through Prefixed Outliers in LLMs
[Статья] [Код]

Введение

Для получения максимального ускорения, особенно при инференсе большими глотками батчами, нужно квантизовать не только веса, но и активации. Однако, богомерзкие выбросы сильно затрудняют квантизацию, и в прошлых работах (QuaRot, SpinQuant, DuQuant) было предложено применять Адамаровы матрицы (или некоторые обучаемые), которые размазывают 🧈 выбросы по каналам.

Однако, выбросы встречают не только в отдельных каналах, но есть и токены, например <BOS> и иные разделители, отличающиеся большими значениями активаций, и их квантизация большими группами (per-tensor) с максимальным ускорением приводит к большим ошибкам. Поэтому в упонятых выше методах использовали per-token квантизацию с некоторым замедлением инференса.

В этой статье авторы предлагают вынести аутлаерные токены в префикс последовательности дабы упростить квантизацию.

Метод

Сам подход мотивирован идеями про attention sinks и Quantizable Transformers: Removing Outliers by Helping Attention Heads Do Nothing. Иногда трансформерному блоку не нужно ничего делать, и дабы реализовать почти тождественную операцию, приходится выбрасывать весь attention в токены с низкой семантикой.

Потому авторы предлагают просто найти все эти токены и положить в префикс последовательности.

Токены находят на основе некоторой калибровочной выборки смотря на выход down_proj в MLP. Отбирают токены, чья L_{\infty} норма сильно больше медианной по последовательности.

Сам процесс достаточно быстрый - занимает всего несколько минут. Таких токенов оказывается от 1 до 4 в рассмотренных моделях (Llama-2,3, Qwen, Mistral). Обычно это <BOS>, и еще символы переноса строки \n, артикли и знаки препинания.

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

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

Метод валидидируют на 🦙-2,3 в режимах W8A8KV8, W4A8KV4, and W4A4KV4 квантизации (W - точность весов, A - активаций, KV - KV-кэшей).

Веса квантизуются поканально, кэши поголовно, активации потензорно.

Предложенный подход оказывается примерно на одном уровне с per-token квантизациями, чуть уступая лишь SpinQuant с дообучением матриц вращения каналов. При этом скорость инференса на 20-30% быстрее.

Поблочный файнтьюн немного накидывает.

Вывод

Простой и полезный трюк для квантизации. Тем не менее, кажется, что возможность делать ничего в блоке модели стоит закладывать изначально, и скорее всего, ввиду потребности в низко-битных моделях, сообщество до этого дойдет (через softmax+1 или иным образом).

Это математика с подвохом!

А вы тоже думали, что прибавление нуля к числу никогда ничего не меняет?

О, это подарок в честь присуждения степени?)

Отныне, присно и во веки веков ведущий данного канала не просто балабол, а заслуженный балабол!

Спасибо Сколтеху, всем товарищам, коллегам и соавторам за эти замечательные и продуктивные 3 года, путь полный трудностей, открытий и приключений)

Это была славная охота.

Сам текст диссертации интересующиеся могут найти здесь.

На днях наткнулся на канал в Youtube некоего Simon Oz.

Парень доступно, с красивыми визуализациями в стиле 3Blue1Brown рассказывает про всякие темы из теории информации и особенности программирования на CUDA.

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

1️⃣ Эффективный алгоритм редукции для нахождения максимума
2️⃣ Оптимизации доступов к памяти (coalescing)
3️⃣ Перенос части операций из shared memory в регистры GPU (которые еще быстрее)
4️⃣ Векторизация операций через float4
5️⃣ Однократная подгрузка данных для подсчета максимума и экспоненты вместо двухкратной

Красивое...

Собственноручно проверил наличие супервеса (см. оригинальную статью и разбор от gonzo-обзоры ML статей) в Llama-3.2-1B.

Aномальный вес находится в позиции (400 - выходной канал, 1417 - входной канал) в model.layers.1.mlp.down_proj.

Не столь ярко выражен (перплексия на Wikitext-2 (8k context length) выросла с 8.375 до 8.625 при занулении данного веса), но все же очень много для всего одно веса.

[Google Colab для желающих поиграться]

Эксперименты и результаты

Данные для обучения собраны из отфильтрованных LAION, COYO, OpenImages датасетов. Сначала учат на 256x256 разрешении, потом на 512x512 и в конце переходят на 1024x1024. Токенизатор, как и в оригинальной статье, осуществляет 16x уменьшение по пространству.

Качество оценивают по FID на некотором внутреннем датасете из 40к изображений вместо стандартного MS COCO. Кроме того, замеряют качество на GenEval и DPG, и предпочтения пользователей на ImageReward/HPSv2.1 по аспектам релевантности (Prompt Following) и эстетичности (Visual Aesthetics).

На бенчмарках Infinity уверенно побеждает все прошлые авторегрессионные модели (Switti в сравнениях нет ввиду очень малого промежутка времени между выходом моделей). Опережают по качеству и диффузионки SDXL/SD3-Medium/PixArt-Sigma.

Модель хорошо умеет в рендеринг текста, если верить черрипикам.

В ablations авторы показывают, что огромные кодбуки важны для качественной реконструкции, и самые большие кодбуки даже лучше continuous VAE.

Обучение с зашумлением заметно улучшает FID и немного другие метрики. 30% зашумление оптимально, согласно заявлениям авторов.

Модель генерирует быстро - одно изображение в разрешении 1024x1024 за 0.8 секунд против 2.1 и 2.7 у SD3 Medium и SDXL, соответственно.

Вывод

Годное подтверждение жизнеспособности scale-wise парадигмы. Ключевой вклад данной работы сильно улучшенный токенизатор (который и является основным ограничителем качества в случае Switti). “Умная” токенизация в картиночных и видео моделях вообще очень горячая тема во второй половине текущего года. Ждем с нетерпением релиза моделей, чтобы поиграться и забрать к себе наработки)

Infinity∞: Scaling Bitwise AutoRegressive Modeling for High-Resolution Image Synthesis
[Статья] [Пока только ридми и картинки]

Только-только мы успели выпустить Switti, как создатели VAR, опубликовали собственную text-2-image модель, позиционирующую себя так же как конкурент моделей уровня SDXL/SD3 Medium.

Метод

Наиболее примечателен токенизатор.

В оригинальной статье по VAR использовался Residual VAE c общей кодовой книгой на все масштабы. Выход энкодера на данном масштабе заменяется на ближайший вектор из кодовой книги. На этом этапе возникает некоторая ошибка аппроксимации, и, по всей видимости, в это кроется причина, по которой VQ-VAE традиционно уступают непрерывным аналогам по качеству реконструкции.

Чем больше кодовая книга - тем потенциально меньше ошибка квантизации, но огромные кодовые книги (скажем, с 2^64 векторами) не влезут в память никакой машины.

Потому авторы предлагают параметризовать кодбуки бинарными векторами (специфичными для каждого масштаба k), и квантизация осуществляется просто взятием знака от непрерывного вектора z_k, соответствующему уровню k в иерархии c домножением на некоторый коэффициент. Рассматривают две опции - LFQ, BSQ, отличающиеся на коэффициент 1 / \sqrt{d} и берут в итоге второй вариант, так для него существует эффективное выражение для вычисления энтропийной регуляризации (используемой для более эффективного использования кодбука).

Благодаря такой бинарной квантизации можно расход памяти, требуемый на кодбук размера 2^d, уменьшается с O(2^d), до O(d), благодаря чему, можно хранить колоссальные кодовые книги.

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

Дабы поддерживать разные aspect ratio и размеры используют факторизованные 2d RoPE позиционные эмбеды.

В качестве текстового энкодера используют Flan-T5. Обусловливание на текст осуществляется как через self-attention, за счет добавления токенов промпта в prefix, так и cross attention между картиночными и текстовыми токенами.

Хорошо мы успели залететь)

Авторы VAR (без первого, c которым вышла презанятная история) выкатили свою text-2-image модель под названием Infinity.

Обзорчик появится немного позднее)

В процессе серфинга по тытрубе и подготовке к собственной защите наткнулся на защиту кандидатской диссертации Егор Захарова в Сколтехе.

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

Нынче диффузия - всему голова, но многие идеи актуальны и до сих пор.

В общем, рекомендую.

И картиночки)

Эксперименты и результаты

Мы обучили нашу модель на внутреннем большом датасете из множества картинок (~100M).

В качестве бейзлайнов мы берем Stable Diffusion XL, и ее ускоренные версии - SDXL-Turbo, SDXL-DMD2, SD3-Medium, Lumina-Next, а так же современные авторегрессионные модели LlamaGen и упомянутый HART.

Для оценки качества моделей мы использовали принятые и стандартные в литературе метрики (FID, CLIP, Pickscore, Image Reward, все знают, что они 💩, но этикет же надо соблюдать) а также пользовательские предпочтения на корзинке из 128 запросов (Parti Prompts).

Пользователи оценивали следующие аспекты изображения:
📝 Релевантность - соответствие текстовому запросу
👩‍🎨 Эстетичность - общая ‘красивость” изображения
🤖 Комплексность - количество деталей и сложность композиции
💔 Дефектность - отсутствие дефектов и артефактов в изображении

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

С диффузионными моделями мы добились паритета по качеству, но при этом Switti генерирует в 7 раз быстрее оригинальной SDXL-модели, и 2 раза быстрее ускоренных версий - SDXL-Turbo, SDXL-DMD2.

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

Вывод

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

Тем не менее, есть еще куда расти. На текущий момент Switti генерирует только в 512x512, и до нынешней SOTA (FLUX, Recraft, Ideogram v2, Midjourney 6.1), еще очень далеко. Но диффузионные модели уже давно полируются и улучшаются, а VAR-inspired парадигма зародилась совсем недавно 👼. И есть еще большой потенциал для роста 📈.

Метод

За основу мы взяли архитектуру модели из STAR и последовательно анализируя и улучшая ее пришли к конечной модели.

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

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

Далее, мы проанализировали карты внимания авторегрессионной модели, и обнаружили, что текущее разрешение почти не смотрит на прошлые, поэтому разрешения можно генерировать независимо друг от друга. Убрав авторегрессию на прошлые разрешения мы нисколько не потеряли в качестве, и при этом ускорили модель примерно на 20-30%.

И последняя ключевая находка оказалась в том, что технику classifier-free-guidance (CFG), улучшающую качество генераций и соответствие текстовому запросу, но требующую два прогона через модель вместо одного, можно отключить на высоких разрешениях без ухудшения конечного результата. За счет этого, можно добиться почти двухкратного ускорения по сравнению со стандартной процедурой генерации с CFG.

Полученную модель мы назвали Switti - Scale-wise transformer for text-to-image synthesis, так как она генерирует изображение по тексту разрешение за разрешением.

Switti: Designing Scale-Wise Transformers for Text-to-Image Synthesis
📖Статья 🖥Код 📑Сайт проекта 🤗Демка

Введение

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

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

Однако, этой весной команда исследователей из ByteDance в работе VAR (Visual Autoregressive Modeling: Scalable Image Generation via Next-Scale Prediction) предложила модификацию авторегрессионной парадигмы, где за один проход предсказывается не один патч, а все разрешение целиком. С помощью специальной аамодели - Residual Quantization VAE (вариационно кодировщика с остаточной квантизацией) - изображение разбивается на разные уровни: нижние уровни соответствуют общей семантике изображения, а верхние уровни - тонким деталям и текстурам. На нижних уровнях немного патчей, поэтому прогон модели на них дешев, и стоимость прогона возрастает с переходом на каждое следующее разрешение. На этапе генерации модель смотрит на все прошлые разрешения и генерируют текущее. Полученная картинка получается посредством суммирования всех разрешений.

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

Увы, генерация из фиксированного набора (1000 классов) не так интересна пользователям, как генерация по произвольным и разнообразным текстовым запросам. Поэтому для верификации жизнеспособности идеи последовательной генерации изображений по разрешениям требовалась проверка в более сложном и интересном сценарии.

Некоторое время спустя после выхода работы VAR вышли STAR и HART, которые адаптировали вышеупомянутый подход для генерации изображений по тексту. В этих работах удалось добиться сносного качества генерации и следования текстовому запросу, но все же далеко позади современных диффузионных генеративных моделей (таких, как SDXL, PixArt, Lumina).

Поэтому мы, исследователи из Yandex Research, решили обучить свою генеративную text-2-image модель.

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

Метод валидируют в традиционном сетапе для сжатия LLM на Llama-3.1, Llama-3.2 и Qwen.

По качеству предложенный подход заметно опережает data-free AF, NF, HQQ (особенно при сжатии в 3.25 бит) даже при однородном сжатии. Чем больше размерность векторов в квантизацианной решетке - тем лучше качество, но p=2 (2-мерная) оптимальна точки зрения баланса между скоростью и качеством.

Неоднородная квантизация неплохо накидывает по сравнению с однородной.

HIGGS квантизация с FLUTE кернелами гораздо быстрее (на RTX 4090) навороченных векторных квантизаций (AQLM, QuIP#, QTIP) и даже быстрее, чем Marlin кернел для батчового инференса (для скалярной однородной квантизации).

По метрикам метод превосходит GPTQ/AWQ и немного уступает SOTA векторным квантизациям. Но просадка компенсируется куда большей производительностью с точки зрения практической привлекательности.

Линейная модель работает достаточно точно вплоть до сжатия в 2.5-3 бита.

Выводы

Классный результат от коллег. Ждем одобрения PR в transformers для выкатки на широкую публику. Интересно было бы еще протестировать на диффузионках а-ля FLUX.

Pushing the Limits of Large Language Model Quantization via the Linearity Theorem
[Статья][PR в transformers]

SOTA векторные методы квантизации, такие как AQLM (+PV), QuIP#, QTIP, способны достигать умеренной просадки качества при сжатии в 2-3 бита, и почти без просадки (смотря на чем замерять) в 4 битах.

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

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

И коллеги @galqiwi и @black_samorez, совместно с корешами из IST, KAUST и MIT предложили новый, data-free (в большинстве сценариев) метод квантизации с переменной битностью слоев, который дает одновременно и хорошее качество в 3-4 бита и значительное ускорение.

Метод

State-of-the-art методы квантизации и прунинга для LLM по большей части оптимизируют ошибку на выходе линейного слоя, так как прямой учет лосса слишком затратен на масштабе.

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

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

Но сама ошибка может существенно варьироваться от слоя к слою и зависит от распределения значений в матрицах весов. Кроме того, хочется иметь data-free метод квантизации, а наивный RTN просаживает качество довольно сильно при сжатии в 4 и и ниже бит.

Потому авторы применяют знакомые давним подписчикам канала Адамаровы вращения, которые убивают выбросы в весах и приводят распределение весов к нормальному i.i.d. А для нормального распределения существуют рассчитанные (численно) оптимальные решетки. Потому метод зовется Hadamard Incoherence and Gaussian MSE-optimal GridS (HIGGS). Причем рассматривается случай как скалярной, так и векторной квантизации. Векторная квантизация с 2-мерными кодбуками дает лучшее качество, чем скалярная, и при этом эффективно реализуется кернелами из библиотеки FLUTE.

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

Далее решением задачи линейного программирования при заданной степени сжатия определяет отпимальное распределение уровней сжатия среди несколько возможных вариантов.

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

Классный обзор на классную статью)

The Super Weight in Large Language Models
Mengxia Yu, De Wang, Qi Shan, Colorado Reed, Alvin Wan
Статья: https://arxiv.org/abs/2411.07191
Код: https://github.com/mengxiayu/LLMSuperWeight

Очень прикольная работа про то, что внутри LLM можно найти один единственный вес, зануляя который мы обрушиваем качество работы модели в пропасть. Такие параметры авторы называют супер весами (super weights) и предлагают метод их нахождения за один forward pass.

Внутри обученных LLM находится группа весов-аутлаеров с большой магнитудой, они могут составлять порядка 0.01% от всех весов модели, что в случае миллиардных моделей всё равно сотни тысяч. Это было известно ранее. В текущей работе показывают, что внутри этой группы находится один единственный вес (тот самый super weight, SW), не обязательно самый большой, важность которого превышает суммарную важность тысяч других аутлаеров. Он необходим для качества, без него LLM не может генерить нормальный текст. Перплексия вырастает на несколько порядков, а точность на zero-shot задачах падает до рандома.

Ранее (https://arxiv.org/abs/2402.17762) были найдены супер-активации, критичные для качества. Они существуют в различных слоях, имеют константную магнитуду и всегда обнаруживаются в одинаковой позиции несмотря на вход. Текущая работа находит, что канал активации совпадает с оным для супер веса и сперва активация обнаруживается сразу после супер веса. Прунинг этого супер веса значительно уменьшает активацию, так что вероятно активация вызвана им, а не просто скоррелирована. Такие активации называются супер активациями (super activations, SA).

Предыдущая работа объясняла супер активации через bias terms, но не объясняла как они получаются и почему на одних и тех же местах. Сейчас авторы эмпирически нашли, что до down проекции (down_proj) произведение Адамара (Hadamard product) gate и up проекций (gate_proj, up_proj) создаёт относительно большую активацию. Супер вес далее усиливает её ещё и даёт супер активацию.

Напомню, что MLP блок в Ламе выглядит так:

out = down_proj( act_fn(gate_proj(input)) x up_proj(input) )

SW можно найти, анализируя спайки в распределениях входов и выходов down_proj. Для этого достаточен прямой проход с одним промптом. Авторы нашли супер веса для Llama (7B,13B,30B), Llama 2 (7B,13B), Mistral-7B, OLMo (1B,7B), Phi-3.

Провели эксперименты по обнулению SW, в том числе с восстановлением SA до исходного значения, чтобы проверить влияние SW на другие активации. Это восстанавливает 42% потери, то есть влияние SW на качество выше, чем просто через SA.

По анализу 500 различных промптов из Lambaba validation set видно, что при убирании SW вероятности стоп-слов сильно возрастают (а обычные слова соответственно занижаются). Для “the” это 2×, для “.” -- 5×, и для “,” -- 10×. То есть наличие SW как бы подавляет стоп-слова и позволяет генерировать осмысленный текст.

Другой интересный эксперимент скейлит супер веса с коэффициентами от 0 до 3 (где оригинальный режим работы соответствует значению 1) и оказывается, что при увеличении SW качество модели ещё немного возрастает. Это забавный результат.

Имея это знание, можно предложить специальный метод квантования: Super-outlier aware quantization. Стандартные механизмы квантизации могут быть недостаточно хорошими, так как аутлаеры искажают распределение, влияя на размер шага и увеличивая ошибки квантования. Здесь под super outliers подразумеваются и SW, и SA. Предложенные методы восстанавливают SW и SA после квантований с клиппингом и заменами на медианное значение. Это всё работает лучше дефолтных методов, главный вывод -- надо защищать супер веса. В статье есть подробный разбор экспериментов, кому интересно поглубже. Также новый метод меньше теряет в качестве с увеличением размера блока.

Прикольный результат в общем. Это всё несколько перекликается с темой про лотерейные билеты (https://t.me/gonzo_ML/21), там внутри большой сети обнаруживалась сильно разреженная подсеть, обучая которую можно было достигать качества исходной сети (или даже выше). Интересно, входят ли супер-веса в лотерейный билет? Наверняка.

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

Метод валидируют на MUSE бенчмарке для забывания и датасетах NEWS (где нужно забыть новость) and BOOKS (забыть персонажей из Гарри Поттера). Какие модели используются, я не понял из текста. Кроме того, оценивают общие способности модели через MMLU, TruhtfulQA, TriviaQA, и энтропию n-грам на AlpacaEval.

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

Вывод

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

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).

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

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%), быстрые замеры перплексии, и немного лучшие по качеству квантизованные модели.

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

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

Вывод

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

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

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

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

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

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

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 и более низких битностях может быть не оптимально.

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.

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

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

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 начинает выглядеть все более жизнеспособной, несмотря на весь мой скептицизм по поводу кустарности метода. Во всяком случае, история выглядит уже вполне рабочей. Тем не менее, было бы важно проверить, насколько хороши модельки в качестве чат-ботов, ежели выкатят веса.

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

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, и это бы работало, скорее всего, чуть лучше.

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

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

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

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

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.

Если вам приспичит инферить 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.

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

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

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

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

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

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

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, интересных сообществу верно. Интересно 🤔, справедливы ли полученные выводы для более сложных задач?

Выбираете темную сторону силы?

Статьи на ArXiv, оказывается, можно читать в инвертированной цветовой схеме (черный фон / белый текст).

Для этого надо просто в pdf заменить arxiv -> arxiv.black:
https://arxiv.black/pdf/{arxiv-id}.

Не знаю зачем, но прикольно.

Результаты

Авторы тестируют VAE на непосредственно задаче реконструкции и применительно к латентной диффузии (DiT/UViT) на ImageNet/FFHQ, Mapillary Vistas (я тоже впервые слышу про такой). Рассматривают сжатие в 32/64/128 раз по пространству с количеством латентных каналов 32/64/128.
Для повышения эффективности vanilla transformer блоки заменяют на EfficientViT.

Residual autoencoding критичен при высоких факторах сжатия - сеть сама не может выучить этот skip connection. SD-like VAE оказывается беспомощен (жесткие дефекты и размытие на экстремальных факторах), а им удается иметь метрики более-менее на одном уровне с ростом downsampling.

При фиксированном количестве патчей в DIT/UViT качество выше при более сильном сжатии за счет автоэнкодера и меньших патчах из латента (размера 1) против меньшего сжатия и бОльших патчей. Утверждается, что с DC-VAE можно получить качество не хуже, а то и лучше, чем в сетапе, как в оригинальной статье, при этом имея 4-кратное ускорение инференса.

Предложенная процедура дообучения на высокое разрешение (Decoupled High-Resolution Adaptation) критична для адекватного качества на высоком разрешении.

Кроме того, DC-VAE проверют на коротком (100к итераций) 📝-2-image сетапе.

Вывод

Результаты выглядят весьма достойно. Прокачка энкодера - это комплиментарное направление повышения эффективности диффузионных моделей вкупе с архитектурной оптимизацией и дистилляцией по шагам. Похожую идею, во всей видимости реализовали в свежей SANA.

Deep Compression Autoencoder for Efficient High-Resolution Diffusion Models
[Статья][Код]

Введение

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

Более-менее все современные SOTA или около того диффузионные модели работают в латентном пространстве, с меньшим пространственным разрешением.

От автокодировщика (тандема 🚲 из сети, кодирующей из исходного пространства данных в латентное, называемой энкодером, и декодирующей обратно - декодера) хочется одновременно высокой степени сжатия и качественной реконструкции одновременно.

Наиболее популярный пространственный фактор сжатия - 8x (Stable Diffusion, FLUX, DALLE-3 (по всей видимости)). При таком сжатии (особенно если еще и поднять число каналов в латентном пространстве до 16, скажем) реконструкции почти не отличаются от оригинала. Однако карты признаков остаются все еще достаточно большими при подаче картинок высокого разрешения, и требуется немало вычислений.

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

Метод

По сути в предложенной статье две ключевых идеи:

1️⃣ Skip-connection (Residual Autoencoding):
- При downsample патчи 2x2 сворачиваются в 4 канала, а зачем группы по 2 канала усредняются (ребята изобрели average pooling?)
- При upsample 4 подряд идущих канала разворачиваются в 2x2, каждый канал дублируется
2️⃣ Процедура обучения
- Предобучение на низком разрешении только на реконструкцию (без адверсариального лосса)
- Дообучение на низком разрешении верхних слоев декодера с GAN лоссом (для получения резких 🔪 деталей)
- Дообучение глубоких слоев энкодера и декодера на реконструкцию на высокое разрешение (дабы адаптировать латенты под high-resolution c другим распределением частот / плотностью обьектов)

- У нас в компании оплата по количеству строчек написанного кода.
- Отлично, по рукам.

matmul_had.py в quip-sharp/lib/utils

Внимание - всему голова!
Attention is all you need

Нейросеть многоловая по ГОСТу

Ребята из unsloth выкатили блог про раздебаг gradient accumulation.
[Пост на Love. Death. Transformers. ]

TL;DR - наивное усреднение батчей при gradient accumulation приводит к тому, что результат отличается от того, чтобы прогнать за один шаг большой батч. Причем, как утверждают авторы, лосс всегда больше. В стандартном способе вычисления кросс-энтропии есть деление на длину последовательности, и если они разные в разных микробатчах - результат усреднения будет не такой, как лосс на суммарном батче. Потому предлагается избавлятьcя от усреднения.

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

Можно подобрать контрпример. Пусть на первом батче лосс L_1 = 1, и в батче 4 токена, а на втором батче L_2=9 и 6 токенов.

Тогда усредненный лосс на всем батче:
(1 + 9) / (4 + 6) = 1
А при наивном gradient_accumulation:
1/2(1/4 + 9/6) = 0.875 (то есть меньше)

MaskLLM: Learnable Semi-Structured Sparsity for Large Language Models

[Статья] [Страница проекта] [Код][Пост на Machine Learning]

Введение

2:4 (она же semistructured sparsity) дает какое-никакое ускорение на GPU от Ampere и новее. Однако, просадка при прунинге обычно слишком велика для LLMок, дабы быть интересной на практике.

В этой статье предлагают метод обучения хороших 2:4 масок через Gumbel-Softmax.

Метод

Маска суть дискретная сущность потому ее просто так не отпизируешь градиентным спуском, и авторы предлагают моделировать распределение масок через Gumbel-Softmax с 6 = binom(2, 4) вариантам. На обучении оптимизируются логиты вероятности сэмплирования одного из вариантов масок (т.е маска есть взвешенная сумма возможных вариантов), а на инференсе берется наиболее вероятный. Обучение суть просто оптимизация кросс-энтропии (как на pretrain). Веса при этом заморожены.

Если какой-то вес зануляется или близок к нулю, то логиты маски почти не получают градиентов, потому авторы добавляют регуляризационный член как weight_decay, но со знаком ➖, чтобы расталкивать веса от нуля, тем самым поддерживая не нулевую норму у немаскированных весов.

Кроме того, маски полученные условным SparseGPT/Wanda являются хорошей инициализацией для масок и позволяют чуть улучшить результат.

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

Метод валидируют на 🦙-2, Nemotron-4 15B и двух маленьких проприетарных GPT-3. Замеряют по классике перплексию на Wikitext и 0-шоты.

По метрикам опережают уверенно все бейзлайны (SparseGPT, Wanda, Magnitude). SparseGPT, правда, можно завести и получше. В отличие от алгоритмов one-shot прунинга, которые быстро насыщаются от количества данных, MaskLLM продолжает улучшаться при большем и большем количестве данных, что неудивительно ибо это есть по сути метод оптимизации с большим количеством обучаемых параметров.

Ablations:
1️⃣ Инициализация маской от one-shot прунера накидывает в конечном качестве.
2️⃣ Достаточная степень стохастичности сэмплирования важна для хорошего качества, дабы модель могла “попробовать” разные варианты масок.
3️⃣ Анти-weight decay не то чтобы сильно, но улучшает качество.
4️⃣ Кроме того, полученную маску можно оптимизировать на downstream и даже временами оверфитнуться улучшить перплексию по сравнению с floating-point моделью.

Вывод

Вполне годная стратегия для обучения 2:4, но требующая определенных вычислительных затрат (т.е прилично дороже чем прогнать SparseGPT). Результат достойный, но все же просадка остается довольно заметной - больше чем у SOTA методов 2-битной квантизации. Вероятно, если еще оптимизировать веса вместе с масками - можно выжать больше.

Почему дают токены на всякую фигню, а не на o1...

Isomorphic Pruning for Vision Models
[Статья] [Код]
Введение

Полагаю, что уже немного помнят, но когда-то выбить SOTA или создать мега эффективную по параметрам/флопсам на ImageNet-1k было модно и престижно.

В данной статье авторы предлагают метод структурированного прунинга, который достигает хорошего качества на ряде ViTов, СNN и их гибридов.

Метод

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

Каждому нейрону сопоставляется некий граф зависимости из входящих и выходящих в него ребер, кои погибнут, если выдернем нейрон. Собираем все изоморфные графы в соответствующие кучки (например с одинаковым числом входных/выходных ребер для прунинга нейрона из MLP) считаем для них некоторый importance score, и для тех у кого он меньше - выбрасываем.

Для случая трансформера естественные структуры следующие:
1️⃣ Внутренние каналы в MLP
2️⃣ Головы трансформера
3️⃣ Размерности голов трансформера
4️⃣ Размерность признаков во всей сети
Пробегаемся по всем возможным структурам и везде выбрасываем одну и ту же долю самых маловажных.

То, что получилось потом дообучаем дабы восстановить качество.

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

Валидируют метод на ConvNext, DeiT, ResNet-ах и MobileNet-v2. В плане критерия не шибко парятся, берут просто |w dw| - модуль веса на градиент, посчитанный на 100 батчах из 64 сэмплов (не то, что я пол ImageNet-а пихал в свое время).

Прунят довольно агрессивно, в 1.5 - 4 раза, восстанавливаться надо достаточно долго и основательно, потому обучают 300 эпох с дистилляцией на RegNetY.

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

На DeiT и ConvNext стартуя с DeiT-Base/ConvNext-Base удается получить запруненные сети с лучшим качеством, чем Small- и Tiny- модели с тем же количеством параметров и FLOPs (т.е достичь Парето-оптимальности).

По качеству на процент-два превосходят в среднем бейзлайны из литературы.

Вывод

Нравится идея с ранжированием структур с одинаковой топологией, но такое ощущение, что хороший результат обусловлен преимущественно дистилляцией с длительным обучением. На LLMки, к сожалению, масштабировать будет тяжко простым смертным. Но всякие там NVIDIA могут позволить для условного Minitron.

Из реализации FLUX в diffusers

Раз уж пошла такая гулянка - предлагаю дать Нобелевскую премию мира Суцкеверу за вклад в Ai Safety.

Или Юдковскому...

Спрашивает народ - по какой-такой физике присвоили Нобелевскую премию Хинтону и Хопфилду?

Ну, смотрите, есть Физика языковых моделей. И вряд ли бы она появилась без трудов Хинтона и Хопфилда (Хинтона уж точно). А в самой премии не указано по какой конкретной физике надо её давать или не давать. Все формальности соблюдены.

За что большое уважение компании Meta, помимо многого прочего, так это за реально подробные и занимательные технические отчеты.

Техрепорты по 🦙-м были довольно содержательными и полезными, и, полагаю, во многом опредилили направления развития LLM, хоть и основывались по большей части на идеях из прошлых работ.

Отчет по MovieGen не уступает по качеству и полноте содержания техрепортам по Llama и может служить своего рода обзором (с рассмотрением и ablation) современных техник и достижений в области генеративных моделей.

Прекрасная работа, @asanakoy!
Сам бы у себя разобрал в серии постов, но лучше, чем причастный к созданию MovieGen, это никто не сделает)

Лернинг Рейт, Бач Сайз и Вейт Декей звучат как отличные имена для героев фантастического романа.

VPTQ: EXTREME LOW-BIT VECTOR POST-TRAINING QUANTIZATION FOR LARGE LANGUAGE MODELS
[Статья][Код]

Пристегните ремни, а лучше прячьтесь в бомбоубежище 💣. Будет горячо 🔥.

На текущий момент, векторная квантизация является наиболее эффективным (с точки зрения качества) методом сжатия LLM (AQLM, AQLM+PV, QuiP#, GPTVQ). И ребяты из китайского 🇨🇳 отделения Мелкософта выкатили Yet Another Vector Quantization for LLM.

Метод

По существу метод представляет собой GPTQ с векторной (single- и multi- codebook) квантизацией с рядом нюансов:

1️⃣ Эффективной инициализацией центроид (векторов в кодбуках). Используют Hessian-weighted K-Means. Для полного Гессиана считать сложно и дорого, потому в этом месте прибегают в диагональному приближению. Подобное я в свое время заводил, когда работали с коллегами над SpQR и думали про неоднородную 1-мерную квантизацию.
2️⃣ Точность квантизации за счет повышения битности можно повысить за счет нескольких кодбуков. Используют Residual Quantization как в QuIP#, где новые кодбуки приближают ошибку квантования с прошлых шагов.
3️⃣ Outlierы. Находят outlierные колонки (входные размерности), которые выдают большую ошибку на выходе слоя и квантуют их отдельно. Часть без outlierов обрабатывается стандартным алгоритмом.

Далее прогоняется поблочный файнтьюн, как в AQLM/QuiP# и end-to-end дистилляция.

Результаты

Метод валидируют на моделях семейств 🦙-2, 🦙-3 и Mistral. В качестве бейзлайнов берут GPTVQ, AQLM, QuiP#.

И далее начинается самое интересное 😈)

Они применяют поблочный и end-2-end finetuning, как в QuIP# и обновленной версии AQLM, но при этом сравниваются со старой версией AQLM (а надо тогда с таблицей 4, где метрики на 7B и 13B примерно такие же, и немного даже лучше на 70B).

При сравнении скорости инференса разных подходов криво завели QuIP#, при этом мотивируя низкую скорость тем, что перемножение на Адамаровы матрицы требует O(n^2) операций, хотя любой детсадовец знает, что O(n log n).

Статья вышла в конце сентября, но про PV-tuning и QTIP , вышедшие в конце мая и июня, соотвественно, ни слова, как будто весть еще не успела дойти по Великому Шелковому Пути 🐫 в Поднебесную.

И вишенка 🍒 на торте 🍰 - отсутствие AQLM/QuIP# среди бейзлайнов мотивируют тем, что модели новые, никто не выложил, а самим впадлу и напряжно квантовать. На что можно тактично заметить, что AQLM модели лежат на хабе, и не просто лежат, а там еще есть и метрики, с которыми можно сравниться. Только одна беда - они несколько получше будут. Что делать, притворимся, что мы ничего не видели 🙈)

Моделей, кстати неплохо так выложили.

Зальем чем-нить на ICLR и засядем за квантование.
Тока сначала надо раздобыть веса.

Смотрите-ка, что появилось!

Fine-tuning LLMs to 1.58bit: extreme quantization made easy
[Блог] [Model card] [PR с добавлением BitNet в transformers]

Некоторое время назад здесь мы разбирали статью от мелкософта про BitNet-1.58, где авторам удалось завести QAT c тернарной квантизацией и добиться вполне сносного качества при обучении с нуля.

Лицехваты 🤗 недавно опубликовали весьма занятный и содержательный длиннопост про дообучение LLM в 1.58 (log2(3)) бит.

Метод и эксперименты

Напомню, что при тернарной квантизации каждый элемент тензора принимает одно из трех значений - {-1, 0, 1} и еще есть floating-point масштаб (вместо absmax берут среднюю абсолютную величину элемента тензора).

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

При попытке наивно затюнить Llama-3-8B в BitNet сходимость по лоссу не сильно лучше, чем у случайно инициализированной модели, и авторы начинают копать глубже.

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

Шаг обучения тоже пришлось основательно подбирать, чтобы выжать приемлемое качество. После подбора удачных гиперпараметров на коротких запусках, лучшую конфигурацию учат уже 100B токенов (0.6% бюджета обучения Llama-3-8B). Тем не менее, итоговая просадка по сравнению с исходной моделью довольно значительная.

Для маленьких LM (SmolLM 125M) разогрев (постепенная квантизация) не дает улучшений.

По бенчам просадки значительные по сравнению с fp16, но лучше чем у прошлых квантизаций в похожую битность. Сам протокол сравнения спорный 🤔, не у всех вариантов есть результаты, сравниваются перплексии разных версий Llama с разными словарями. Да и Llama-3 выбивает 65, а не 49 на MMLU 5-shot.

Авторы реализовали kernel для инференса на Тритоне, который дает некоторое ускорение. А с библиотекой BitBlas ускорение становится еще более заметным. Однако работа с ней требует небыстрой компиляции.

Вывод

Неплохой результат и исследование. Но есть вопросы 🙋‍♂️ к протоколу замеров качества, и пока BitNet теряет слишком много в качестве для того чтобы стать общепринятой практикой. Чтобы пользоваться модельками надо поставить версию transformers из PR.

EDEN: Communication-Efficient and Robust Distributed Mean Estimation for Federated Learning
[Статья] [Код]

Квантизовать можно веса, можно активации. А что еще можно?

Правильно, градиенты! 👻

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

Метод

Идея квантовать градиенты для распределенного не нова - датируется еще 2016 годом (QSGD). Но данная работа предлагает ряд интересных идей (некоторые из которых мы узнаем в литературе вышедшей позднее, а сама статья 2021 года).

1️⃣ Случайные повороты
2️⃣ Оптимальные решетки квантования
3️⃣ Случайный прунинг
4️⃣ Энтропийное кодирование

В тензоре значения могут быть распределены, вообще говоря, самым произвольным и поганым (с точки зрения удобства квантования) образом. Но, известно, что если “повернуть” тензор некоей случайной матрицей, то с большой вероятностью полученные значения будут распределены как N(0, sigma^2). В качестве случайных поворотов используют (кто бы мог подумать!) - случайные Адамаровы матрицы. Каждый процесс хранит seed генерации, а главный сервер, зная этот seed на деквантизации, может применить обратное преобразование.

Решетку квантизации (а тут дело идет о квантовании в 1 и 2 бита) надо выбирать с умом. Потому берут не абы какие, а MSE-оптимальные (для 1 бита находится аналитически, для 2-ух численно).

Дабы увеличить сжатие - можно еще случайным образом запрунить ☠️ часть весов. Маску передавать при этом не надо - она как и вращение задается состоянием случайного генератора.

Решетки квантизации можно еще дотюнить при заданном ограничении на битность посредством Entropy-Constrained Vector Quantization.

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

И вся эта кухня идет с теоретическими гарантиями на ошибку аппроксимации.

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

Метод валидируют на синтетических распределениях и распределенном обучении. В качестве бейзлайнов рассматривают QSGD, Hadamard + SQ (Stohastic Quantization), Kashin + SQ. В качестве бенчей для распределенного обучения рассматривают EMNIST (с маленькой CNNкой) и Shakespeare (с LSTM). Не самые свежие и впечатляющие бенчи, но что поделаешь 😞.

EDEN наиболее точно приближает исходные данные (в сравнении с бейзлайнами), при этом по скорости не такой быстрый как QSGD, но быстрее Kashin + SQ (ближайший с точки зрения качества подход).

В 4 бита разницы вообще нет между EDEN и float обучением, в 2 и 1 бит появляется некий зазор в качестве, но не критичный, и EDEN стабильно лучше конкурентных подходов.

Вывод

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

Есть просто банк, есть банк столбов и матриц, а есть банк оптимальных решеток для квантования данных из нормального распределения...

Если конректно, чуваки собрали MSE-оптимальные решетки для числа точек от 1 до 5000 для одномерного нормального распределения, и для всех размерностей от 2 до 10 и числа точек от 1 до 1450 для многомерной гауссианы (с нулевым средней и единичной матрицей ковариации).

Решетки были найдены через Lloyd-CLVQ algorithm.

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

[Сайт проекта]

Во вчерашнем посте на Kali Novskaya была разобрана статья Can LLMs Generate Novel Research Ideas? - про то, насколько хорошо нынешние LLMки умеют в генерацию наукоподобных статей.

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

Отсюда возникает идея 🤔 - давать вступительный экзамен рецензентам Core A* конференций, где им будут даны несколько публикаций от кожаных мешков и сгененированных условной гопотой или Sonnet. Если рецензент не способен адекватно отличить зерна от плевел - отфутболиваем ⚽️.

Проблема правда одна: кто ж рецензировать то будет...

Хотя было бы интересно посмотреть на рецензию GPT-4 с системным промптом Reviewer N2 😈.

Обман года.

2023 - LK-99
2024 - Reflection

Вчера наша статейка Accurate Compression of Text-to-Image Diffusion Models via Vector Quantization попала в подборку статей Daily Papers на 🤗 про диффузию, что большая честь для нашего скромного авторского коллектива из Yandex Research.

Так-то не то, чтобы 🚀 science - по существу перенесли AQLM на задачу text-2-image генерации с помощью диффузионнок с учетом специфики и нюансов диффузионных архитектур (плохой из меня бизнесмен).

Проверяли подход на SDXL и SDXL-Turbo. В целом, вышло сносно, получше скалярной квантизации по качеству (c Q-Diffusion, PTQ4DM в качестве бейзлайнов). В 4 бита удается даже достичь паритета по Side-by-Side с оригинальной fp16 моделью. Здесь уместно заметить, что SbS куда более репрезентативная и содержательная характеристика, чем все эти ваши FIDы и CLIP-скоры. 3-битные модели по метрикам почти не отличаются от fp16 по метрикам, но просадка качества налицо (не у всех есть толока за пазухой, справедливости ради).

С практической точки зрения пока есть над чем работать: имеет место замедление инференса на 50%, ибо в отличие от огромных LLM, SDXL/SDXL-Turbo малипусики c 2.5B параметрами, которые кроме того обрабатывают большие тензоры активаций за раз, а не токен за токеном, потому вычисления compute-bound, а не memory-bound. Процедура деквантизации начинает сказываться на времени прогона через сеть. Потому модельки пока не выкладываем. Нынче модный FLUX-1 выглядит более перспективным кандидатом для прогонки метода, там и трансформер с большими матрицами, и 12B параметров. Как руки дойдут, попробуем и его посжимать.

Кроме того, запилили еще симпатичный сайтик а-ля Nerfies (credits to @Vahe527887).

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

Эксперименты проводят на Llama-2,3 (7B, 8B, 13B). До-обучают на инструкциях TULU2 и OpenOrca. Обучение идет 500 шагов (т.е довольно короткое). “Выбросы” определяются на основе 500 сэмплов из Pile. Для оценки качества берут среднюю точность на 5 бенчмарках из lm-eval.

Есть 2 сценария:

1️⃣ Instruction-finetuning fp16 моделей. В качестве бейзлайнов рассматривается файтьюн всей модели, и LoRA/DoRA адаптеры с примерно тем же количеством обучаемых параметров. Непонятно, однако, какой шаг квантизации для шума в данном сценарии (если есть).

2️⃣ Квантизация (в 2/3/4 бита) + Instruction-finetuning. В качестве бейзлайнов берут QUIK + LoRA, и STE, где “выбросы” обучаются обычным бэкпропом, а квантизованные веса через STE. Я только не понял, QUIK без или с квантованием активаций? Больно уж грустно смотрится.

Предложенный подход достигает лучшего качества, чем адаптеры, и , как утверждается, ведет себя гораздо стабильнее от количества примеров (см Figure. 1 из статьи ). Данный график вызывает вопросы, ибо обыкновенно адаптеры демонстрируют довольно стабильную динамику обучения, будучи малыми возмущениями весов, если только не вкрутить чрезмерно большой шаг обучения.

При квантизации предложенный метод опережает QUIK и STE. Правда, есть более свежие и сильные бейзлайны - QuaRot и SpinQuant.

Из ablation study следует, что:
👉 Добавление шума во время до-обучения накидывает в качестве при квантизации в 2 бита.
👉 Большой разницы нет при разных опциях метрики определения выбросов. L∞ работает чуть лучше в среднем.
👉 Pre-GIFT-SW немного лучше при 4 битном сжатии, но при более аггресивном сжатии уступает альтернативам. При квантизации в 2 бита Post-GIFT-SW дает лучшее качество.

Вывод

Интересно, и неплохо по результатам. Сравнение с адаптерами, я бы рекомендовал перепроверить - не “шумят” они так на до-обучении. Еще любопытно, помогает ли добавление шума при до-обучении статистик квантования в методах типа PEQA и P-tuning (без V).