Метод

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

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

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

А чтобы выпрямить траектории, авторы предлагают Rectified Flow - метод итеративного выпрямления траекторий.

Суть метода заключается в следующем: у нас есть изначальный метод генерации (сеть + солвер), выдающий некоторые траектории X(t). А новая сеть должна за один шаг, стартуя из начальной точки X(0) , попасть в X(t), но уже по прямому пути. А затем процесс повторяется с использованием сети с последней итерации для генерации траекторий. Таким образом, постепенно траектории становятся все более и более прямыми. Фиксированная точка итеративного процесса, когда прошлый генератор траекторий совпадает с текущим - и есть генератор идеально прямых траекторий.

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

Далее, последнюю модель с RectifiedFlow дистиллируют в модель, предсказывающую картинку из шума за раз. В качестве функций потерь на данной стадии используют MSE и the Learned Perceptual Image Patch Similarity (LPIPS), более коррелирующий с человеческим представлением о качестве изображения.

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

За основу авторы берут StableDiffusion v1.4 и ее же пробуют наивно дистиллировать по шагам (на исходных траекториях) и с использованием RectifiedFlow.

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

Далее авторы, экспериментируют с разными параметрами и модификациями сети

2 этапов выпрямления достаточно, и большее количество шагов выпрямления уже не отражается существенно на качестве. Для повышения выразительности сети, предлагается соединить (как два вагона железнодорожного состава) исходную сеть с ее копией (тоже инициализированной весами Stable Diffusion). Полученная сущность называется - StackedUNet. При значительном приросте качества (снижении FID с 20 до 13.7) время инференса растет не так сильно (c 0.09с до 0.12c на сэмпл). Архитектурный StableDiffusion, которая учится предсказывать за один шаг - называется Instaflow-0.9B. А Stacked версия - Instaflow-1.7B.

Конечный пайплайн обучения выглядит следующим образом:
1️⃣ 2 шага RectifiedFlow, второй шаг с большим размером батча
2️⃣ Дистилляция в Instaflow с MSE лоссом
3️⃣ Дистилляция в Instaflow с LPIPS лоссом

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

Instaflow-0.9B(1.7B) в 30 (24) раза быстрее базовой StableDiffusion, хоть и с некоторой потерей в качестве (13.10(11.83) против 9.62 на замерах FID-30k на MS COCO 14). При том же бюджете на время, модель выдает сопоставимые метрики с GANами (превосходя StyleGAN-T, но проигрывая GigaGAN).

Потом авторы сравнивают генерации StableDiffusion и Instaflow на разном количестве шагов генерации, и StableDiffusion ожидаемо дает низкокачественные и мыльные картинки на малом количестве шагов, а Instaflow - вполне приемлемого качества.

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

Кроме того, мало чувствительна к guidance scale, что безусловный плюс и позволяет сэкономить по памяти (так как не требуется дополнительно прогонять unconditioned расшумление в classifier-free guidance) . Авторы статьи утверждают, что не имеют обьяснения данному эффекту. Вероятно, classifier-free guidance нужен, чтобы не сбиться с траектории генерации, а так как у нас теперть прямые траектории, то и слететь с них не так просто.

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

Instaflow из коробки комбинируется с Refiner и SuperResolution в SDXL, и полученные картинки выглядят вполне себе сносно.

Вся процедура обучения занимает 108 для Instaflow-0.9B и 130 для Instaflow-1.7B A100 GPU дней, соответственно, что не так много по нынешним меркам (StableDiffusion v1.4 обучалась 6250 A100 GPU дней). Обучение RectifiedFlow и дистиллированной модели не успело сойтись до конца, так что при более длительном обучении качество может еще возрасти.

Вывод

Метод довольно прост и интуитивен, хоть и поди догадайся так сам придумать. Просадка по качеству генераций довольно заметна по сравнению с исходными моделями, но при таком ускорении результат все равно довольно впечатляющий. Наверняка, кто-то из бигтехов / исследовательских лабораторий с большими вычислительными ресурсами попробует воспроизвести идею. Генерация картинок за прогон - это движение в сторону к real-time генерации, снижении расходов на генерацию контента, улучшение useer experience. Будем посмотреть.

Beyond Surface Statistics:
Scene Representations in a Latent Diffusion Model
[Статья][Кода нет]

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

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

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

В данной работе, авторы находят еще 2 применения внутренним представлениям - salient object distinction и depth estimation.

Постановка

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

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

Рассматривают две постановки задачи - discrete binary depth, где предполагается разделять примечательные объекты и фон, и continious depth estimation с вещественными метками.

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

Для обучения линейных классификаторов авторы генерируют датасет из 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