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

Для обучения линейных классификаторов авторы генерируют датасет из 1000 картинок с помощью Stable Diffusion и размечают на salient object distinction и depth estimation при помощи моделей Tracer и MiDaS. Промпты для картинок берут из LAION-AESTHETICS v2. Затем из датасета фильтруется непотребный контент и изображения без понятия о глубине. То, что остается, содержит 617 примеров и разбивается на обучающую и тестовую выборку в отношении 246/371 пример.

Метки имеют разрешение 512x512, а предсказания классификатора - куда меньшее разрешение скрытых представлений Stable Diffusion, потом последние интерполируют до размера конечного изображения.

Для оценки качества сегментации salient objects используется Dice Score и RMSE для предсказания глубины.

Для saliency distinction / depth estimation пробуют признаки с разных блоков UNet-а и разные шаги диффузии. Существенной разницы между выбором блока нет, а вот что примечательно понятие о глубине возникает на ранних шагах расшумления, еще задолго до того, как изображение напоминает что-то осмысленное. То есть расположение обьектов на сцене формируется еще до того, как из шума начинают выделяться обьекты. Интересно, что даже карты активаций низкого разрешения позволяют выделить мелкие обьекты.

Stable Diffusion со случайно инициализированными весами ожидаемо дает низкое качество линейного классификатора.

Авторы проверяют, что глубина заложена в UNet-е, а не VQ-VAE, преобразующем из латентного пространства в пространство изображений. Попытки обучить классификатор на признаках из VQ-VAE приводят к фиаско.

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

Вывод

Диффузионные модели, хоть и обучаются явно только на генеративное моделирование, в качестве приятного бонуса содержат в себе кладезь различной полезной информации, и в некотором роде могут рассматриваться как foundation models в области компьютерного зрения. Задача предсказания шума является dense-prediction task, потому можно предположить, что признаки из диффузионок более подходят для сегментации/детекции и прочих задачах с множественными предсказаниями по сравнению с image-level обучением - классификацией ImageNet, CLIP, разными SSL методами.

LongLoRA: Efficient Fine-tuning of Long-Context Large Language Models
[Статья][Код]

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

В литературе были предложены разные стратегии дообучения на длинные последовательности - но стандартное обучение вычислительно затратно, требует нескольких машин для современных LLM. А стратегии, модифицирующие attention, retrieval-based подходы обычно несколько хуже по качеству. Да и не все могут использовать преимущества эффективных CUDA-кернелов а-ля Flash Attention.

Метод

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

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

Группы перегоняются в размерность батча перед операцией attention, поэтому реализация не требует существенных усилий.

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

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

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

Предложенный метод валидируется на ряде бенчмарков по языковому моделированию с большим контекстом - PG19, proof-pile, topic retrieval на LongChat. Для обучения используется RedPajama.

LongLoRA работает значительно лучше обычного файнтьюна с LoRA, и не сильно уступает полному дообучению (там где это было посильно).

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

Упомянутый ранее тюнинг эмбеддингов и нормализаций, называемый LoRA+, неплохо накидывает.

Дообученная таким образом LLama-2 13b выступает на одном уровне или даже бьет специализированные модели под длинный контекст такие как MPT-Storywriter, LongChat.

Вывод

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

Pruning vs Quantization: Which is Better?
[Статья][Кода нет]

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

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

Метод

В данной работе авторы используют симметричное квантование к ближайшему значению на сетке (round-to-nearest) и magnitude (неструктурированный!) pruning, как простые для анализа и самые распространенные на практике. Размер и качество модели сравнивается относительно fp16 модели.

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

В первой части исследования авторы смотрят на норму разницы между исходными и сжатыми весами, или если быть точнее, log SNR разницы.

Сначала рассматривают аналитические распределения - нормальное и обрезанное t-распределение Стьюдента, чтобы моделировать тяжелые хвосты.

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

Для t-распределения Стьюдента при сильном сжатии и kurtosis (меры тяжести хвостов распределения) прунинг может быть лучше квантизации, однако такое распределение редко встречается на практике.

Затем авторы берут 46 моделек из torchvision и вновь смотрят на ошибку приближения весов и почти все оказывается, что при заданном сжатии у квантизации ошибка меньше.

Далее авторы смотрят на ошибку уже на выходе слоя и рассматривают более продвинутые алгоритмы прунинга и квантизации в сценарии post-training compression (то есть без дообучения), оптимизирующие ошибку на уровне слоя. Выводы, тем не менее, те же, что и раньше.

Но сохраняется ли преимущество квантования после обучения сжатой модели?

Оказывается, что да. Авторы берут несколько архитектур - ResNet, MobileNet, EfficientNet, ViT и прогоняют sparse training / quantization aware training, соотвественно, сжатых моделей на ряде задач компьютерного зрения - классификации, сегментации, детекции, и почти всегда квантованная модель оказывается лучше запруненной. Гиперпараметры процедуры обучения одинаковы в обоих случаях для честного сравнения.

Здесь стоить важную ремарку, что модели сжимают за один раз, в то время как для прунинга куда оптимальнее сжимать итеративно (и тот же MobileNet-V3 вполне реально сжать до 87.5% с умеренной просадкой в качестве).

Вывод

Довольно интересное, хоть и сравнительно короткое исследование. Наверное, основной вывод естественен, что небольшие пертурбации всех весов влияют на качество модели меньше, чем большие у части. Вероятно, результат зависит еще от деталей процедуры обучения, в особенности, weight decay. И было бы интересно посмотреть на аналогичное исследования для языковых моделей. Кроме того, прунинг можно комбинировать с квантованием и можно поставить задачу поиска оптимального соотношения между прунингом и квантованием. Тем для будущих исследований предостаточно…

QA-LoRA: Quantization-Aware Low-Rank Adaptation of Large Language Models
[Статья][Код]

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

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

И в этой статье авторы исследую причины, приводящие к просадке качества при переквантовании модели и предлагают способ бесшовного слияния LoRA c весами базовой модели.

Сразу скажу, что в статье есть несколько некорректных утверждений и ослабления бейзлайнов, по невнимательности или по злому умыслу.
Наиболее близкая по теме статья - разобранная ранее QLoRA. Напомню, что там модель квантуется в 4 бит, и поверх квантованной модели обучается низкоранговый адаптер на Instruction Finetuning.

Авторы QA-LoRA утверждают, что выгода от этого подхода только во время обучения, так как на инференсе все равно придется сливать веса с адаптерами. Но данное утверждение более чем спорно, ибо можно параллельно прогонять вход через квантованные веса и floating-point адаптер, и накладные расходы на последний довольно маленькие (так как типичный ранг добавки r в сотни и тысячи раз меньше размерности в сети).

Метод

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

Чтобы как-то повысить выразительность, предлагается (о боже!) квантовать входную размерность малыми группами, и тогда ранг добавки следует делать равным числу групп. И после этого можно сливать добавку без проблем.
Тут стоит напомнить, что маленькие группы (размера 64), которые дополнительно квантуют, - одна из ключевых идей в QLoRA.

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

Чтобы провалидировать предложенный подход авторы квантуют модель с помощью GPTQ с размером группы 32 и дообучают LoRA на ALPACA и FLANv2.

Для валидации используются MMLU и ряд других стандартных бенчмарков языковых моделей - ARC, Hellaswag, PIQA,
Замечу, что используемый размер группы дает более, чем 0.5 бит на параметр, что не пренебрежимо мало.

QA-LoRA на 4 битах несколько уступает QLoRA без вливания но уверенно бьет варианты с вливанием весов и повторным квантованием, как и PEQA с дообучением скейлов в квантизации. Метод неплохо себя показывает при низких битностях, давая качество статистически выше случайного даже при двух битном квантовании (качество случайного классификатора на MMLU - 25%).

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

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

Выводы

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

SCALING LAWS FOR SPARSELY-CONNECTED FOUNDATION MODELS
[Статья][Кода нет и хрен с ним]

Введение

Как известно, foundation модели, обученные на колоссальных объёмах данных, демонстрируют scaling laws - сравнительно простые зависимости качества работы с изменением количества данных и размера модели, выражающиеся обычно степенными законами. И на основе этих закономерностей подбирают модели оптимальные по размеру и количеству данных при заданном ограничении на бюджет обучения.

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

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

Постановка задачи

Авторы рассматривают 2 задачи -

1️⃣️ Обучение T5 на корпусе С4
2️⃣️ Обучение ViT на JFT-4B (проприетарный гугловский датасет)

Для ViT рассматривают 7 моделей размера от 0.66M до 42.4M параметров, и 4 конфигурации количества шагов обучения, а для T5 - 4 модели (от 1.3M до 85M параметров) и 3 конфигурации длительности обучения. Рассматривают 4 уровня прореживания - 0%, 50%, 75%, 87.5%. Менее 50% не целесообразно рассматривать обычно на практике, а выше 87.5% оптимизация становится затруднительной.

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

Первые 25% времени обучение обучается плотная модель, следующие 50% времени обучения уровень прореживания постепенно поднимается до целевого значения, и последние 25% модель обучается с постоянным прореживанием.

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

Вывод закона скейлинга

Авторы отталкиваются от стандартной формулы scaling law по количеству данных и размеру модели. В ней три аддитивных члена:

1️⃣️️️ Спадающий степенным образом с размером выборки.
2️⃣️️️ Спадающий степенным образом с размером модели.
3️⃣️️️ Неустранимая ошибка - некоторая константа.

Однако не очевидно, каким образом sparsity будет входить в конечный закон. Важно лишь общее количество параметров или sparsity может дать некоторое преимущество по сравнению с dense моделью того же размера?

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

1️⃣️️️ Графики лосса против количества параметров образуют почти параллельные линии
2️⃣️️️ Чем выше степень прореживания, тем меньше лосс, но выигрыш от прореживания быстро спадает с ростом степени сжатия.
3️⃣️️️ Форма кривых лосса против количества параметров почти не зависит от количества данных.

Из наблюдений выше возникает анзац для scaling law c прореживанием. Вместо константы помноженной на степень от размера модели, возникает степень доли ненулевых параметров + некоторая константа.

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

Оптимальная степень прореживания

Исходя из полученных scaling law можно вывести оптимальную степень прореживания при заданном количестве ненулевых параметров и FLOPs, потраченных на обучение. Чем больше перебор по длительности обучения по сравнению с Chinchilla law, тем выгоднее иметь более сильное прореживание.

Авторы рассматривают два способа оценки количества FLOPs - 1) в предположении, что железо умеет идеально пропускать операции с нулевыми весами, 2) и в типичном сценарии - где операции со спарсными матрицами требуют столько же вычислений, как и с произвольными. Оба метода будут отличаться на некоторый фактор.

Контуры # pretraining FLOPs против # non-zero parameters для разных значений sparsity, при которых данная степень прореживания оптимальна, удивительным образом оказываются параллельны scaling law Chincilla. Однако, даже для Chincilla law оптимальным является ненулевое значение sparsity.

В предположении идеальной утилизации спарсности при обучении 50% модель требует в примерно 2 раза (для ViT), 3 раза (для T5) больше FLOPs чем предсказание Chincilla law для Dense модели. А без этого предположения 5x и 70x, соотвественно. Кажется, что это слишком много, но на самом деле современные языковые модели обучаются нередко значительно больше, чем compute-optimal значение. Например, LLama-2-7B обучалась в 14 раз больше.

Дальше можно задаться вопросом, а какого размера должна быть плотная модель при том же количестве FLOPs, чтобы иметь при том же количестве то же качество, что и sparse модель? Для 50% sparse модели соответствующая ей модель должна быть в 1.6x раз больше, и для 75% - 2.16x, т.е преимущество от sparsity уменьшается с увеличением степени прореживания. Примечательно, что закономерность примерно одна и та же, для ViT и T5, хотя модели и задачи совершенно разные.

Затем авторы исследуют scaling laws для полуструктурированной N:M sparsity (N ненулевых значений). Данный паттерн более ограничителен, потому закономерно ожидать, что он менее эффективен, чем произвольное расположение нулевых/ненулевых весов. 2:4 паттерн (поддерживаемый Nvidia GPU начиная с Ampere) не уступает 50% неструктурированной sparsity, а вот 1:4, 2:8 уже заметно хуже с точки зрения масштабирования, чем 75% sparsity.

Прореживание предобученных моделей

На практике чаще берут обученную модель и сжимают ее. Авторы берут три модели ViT S/16, M/16, B/16 (S, M, B - Small, Medium, Base, а 16 - размер патча) и прореживают их тем же самым способом, что sparse модели в экспериментах выше (только прореживая сразу, а не через 25% времени обучения), используя 5.6% бюджета на обучение плотной модели.

Для 50%, 75% сжатия такой способ в 5 (4) раз эффективнее чем обучение sparse модели from scratch, но при большем сжатии выигрыш уменьшается. По всей видимости, причина этого в том, что модель сильно просаживается, по сравнению с исходной плотной. Если учитывать бюджет обучения плотной модели в суммарных затратах на создание sparse модели заданного качества, то генерация sparse модели с нуля значительно эффективнее.

Вывод

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

Подумал я, что длинные полотна, подобные Shine on you crazy diamond, с детальным описанием экспериментов выходят чрезмерно многословными и содержат слишком "многа букв". И думаю сократить среднюю длину постов, акцентируя внимания только на ключевых моментах и результатах. Тем самым заодно можно будет повысить и throughput постов.

Так как голоса, по всей видимости, разделяются поровну - сделаем гибридный формат)

В Pytorch 2.1 завезли 2:4 semi-structured sparsity!

Напомню, что произвольный паттерн неструтурированного прунинга не поддерживается на GPU, но начиная с поколения Ampere реализована аппаратная и программная поддержка 2:4 паттерна, где на 2 позициях из 4 стоят ненулевые веса. В общем случае N:M sparsity N ненулевых весов из M.

До недавних пор, чтобы воспользоваться 2:4 sparsity нужно было напрямую использовать ядра из cuSparse или CUTLASS или пользоваться скомпилированной с --sparsity моделью в TensorRT. Но теперь semi-structured sparsity доступна почти всем желающим.

Примечание 😐.
2:4 sparsity работает только на Ampere / Hopper. Не ожидайте ускорения на колабовской T4.

Теоретическое ускорение и сжатие, которое дает такой паттерн, 16/9 для half precision и 16/10 для int8. Но на практике, увы не все так радужно. Реальное ускорение инференса в районе 10-30% (в хорошем сценарии).

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

В приведенном примере c BERT качество сжатой модели такое же как у и исходной после дообучения. При маленьких батчах инференс BERT c 2:4 sparsity работает медленее, чем dense матричные операции, но с ростом батча выигрыш от разреженности становится заметным и стабилизируется в районе 20-30%. Заметим, что в BERT сравнительно небольшие матрицы, и на условной Llama выигрыш будет наблюдаться уже на батче с 1-2 последовательностями.

Документация в торче
Туториал с прунингом BERT
Статья Nvidia про 2:4

ECoFLaP: Efficient Coarse-to-Fine Layer-Wise Pruning for Vision-Language Models
[Статья][Код есть, но не почищен]

Большинство методов прунинга сжимают все слои нейронной сети с одинаковой силой .

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

Но как найти это распределение?

Метод

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

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

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

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

Авторы валидируют метод на BLIP-2 (задача VQA), Flan-T5 (на MMLU), EVA-ViT (на ImageNet-1k). Не то, чтобы подсчет градиентов был непосильной задачей для моделей этого размера, но зато можно оценить качество приближения нулевого порядка по сравнению с "честным" Фишером.
В качестве метода прунинга используется Wanda (SparseGPT, где заменили послойный гессиан его диагональю ) и модели не дообучаются после прунинга.

Предложенный метод неплохо накидывает по сравнению с uniform sparsity при сжатии 50-60%, однако просадка все же довольно существенна по сравнению с плотной моделью во всех трех сценариях. Приближение градиента разностью почти не просаживает качество по сравнению с использованием истинного градиента. Найденные sparsity распределения тоже близки. Метод сильнее прореживает текстовую модель в BLIP чем vision. Большее количество шумов для оценки градиента не влияет на качество.

Вывод

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

Monarch Mixer: A Simple Sub-Quadratic GEMM-Based Architecture
[Статья][Код есть, но непричесан]

Введение

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

Для специальных классов матриц / преобразований можно добиться субквадратичной сложности - разреженных, блочно-диагональных или обладающих определенной структурой. И в качестве иллюстративного примера уместно привести быстрое преобразование Фурье, имеющее сложность O(N log N).

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

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

Метод

Матрицы Monarch впервые появились в работе. Идея довольно простая - каждая матрица параметризуется последовательностью блочно-диагональных матриц, между которыми вставлены матрицы перестановок. Перестановочные матрицы эффективно обеспечивают dilation между размерностями матрицы. Вообще говоря, можно рассматривать последовательность нескольких dilation вида 1, N^{1/p}, … N^{p-1/p} , но в данной для простоты работают с p = 2. Количество параметров в такой матрице и сложность вычислений пропорциональна O(N^{3/2}).

В исходной статье про Monarch замена стандартных линейных слоев на Monarch в трансформерах сработала весьма недурно.
А в этой статье пошли дальше и используют монархов для обработки последовательности.

M2-миксер состоит из Sequence Mixer, содержащего длинные свертки и gating, и Dimension Mixer - обычная MLP с монархами в качестве линейных слоев.

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

Предложенную архитектуру валидируют на ряде задач и архитектур:
1️⃣️️️️️ Masked Language Modeling на BERT
2️⃣️️️️️ классификации изображений с ViT
3️⃣️️️️️ Causal Language Modeling по типу GPT.

При тех же скрытых размерностях M2-BERT, M2-ViT имеет на 25-27% меньше параметров, чем базовая Transformer модель, при этом не уступая в качестве. А если увеличить ширину модели, чтобы сравняться по числу параметров, то имеет место даже некоторый прирост.
На Causal-Language Modeling предложенная модель тоже показывает себя немного лучше GPT-2.

Monarch Mixer заметно лучше масштабируется с длиной последовательности в соотвествии с теоретическими выкладками. На больших длинах последовательностей прирост порядка 9x против BERT-base с vanilla attention и 2x против Flash Attention. Ускорение наблюдается как на GPU, так и на CPU.

Вывод

Использование структурных матриц вместо матриц общего вида - интересное направление в разработке нейросетевых архитектур. При том же количестве вычислений возможно работать с картами признаков большей размерности. Однако, без крупномасштабных экспериментов на современных больших языковых моделях нельзя доподлинно оценить, обладают ли Монархи и иные представители бабочек лучшей масштабируемостью по сравнению с первозданным трансформером. Кроме того в сравнениях по throughput везде фигурирует Flash-Attention-1, а есть Flash-Attention-2 с еще лушчей утилизацией железа.

ConvNets Match Vision Transformers at Scale
[Статья] [Кода нет, но у вас все равно нет JFT-4B и TPUv4, чтобы воспроизвести экспы]

Народная мудрость гласит, что трансформеры масштабируются лучше, чем сверточные сети при наличии большого количества данных и бюджета на обучение. Но убедительного экспериментального подтверждения в поддержку данной гипотезы никто не проводил ( В ConvNext-V2 имеется сравнение эффективности MAE-предобучения по сравнению с ViT, но на меньших масштабах данных)

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

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

В качестве семейства сверточных сетей авторы рассматривают NFNet-ы, одно из последних достижений в разработке CNN, до того как ViTы завладели нишей. Разные модели семейства отличаются глубиной (больше номер - больше глубина), и шириной (+ - более широкая модель). Обучается все хозяйство на проприетарном JFT-4M и чипах TPUv4.

Результаты

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

При сопоставимых бюджетах сверточные сети выдают сопоставимое качество. Авторы учитывают использование более новых TPUv4 против TPUv3 в прошлых работах и потому дают поправку при сравнении бюджетов.

Самые большие модели из семейства, обученные в течение 100k+ TPU часов выдают 90%+ топ-1 точности на ImageNet-1k при дообучении на нем. Использование Repeated Augmentation для самой большой модели накидывает аж 0.1% на ImageNet-1k.

Вывод

Очередной голос в пользу того, что важны не сколько архитектурные детали, сколько количество данных и время обучения. На большом объеме данных inductive bias уже не имеет особого значения, но и трансформеры, вероятно, не обладают чудесными свойствами с точки зрения масштабируемости. Тем не менее, для пущей убедительности в данном отчете было бы неплохо увидеть аналогичные кривые лосса против часов обучения для семейства ViTов. Три точки, отвечающие трансформерам, недостаточно репрезентативны. Интересно, если провести подобный эксперимент для LSTM, с поправкой на утилизацию железа, будет ли наблюдаться подобная картина?