Посмотрел интенсив GPT Week от Yandex, где ребята записали цикл лекций по всему, что связано с современными LLM: от обучения претрейна и замера его качества до финального алайнмента и ускорения инференса модели в условиях ограниченных ресурсов. В целом считаю, что материал получился качественным + изложен понятным языком, так что если хочется занырнуть во всю эту тематику, советую посмотреть. Если все лекции смотреть некогда, то подготовил вам таймкоды, где, на мой взгляд, удачно объяснены некоторые вещи:

1. Эволюция архитектуры трансформера с 2017-ого года. Довольно большая секция с разбором каждого трюка.
2. Интуиция вокруг алгоритма распределенного обучения FSDP. Если не знакомы с Data/Model/Tensor Parallelism, то посмотрите сначала объяснение их в начале лекции.
3. Способы замера качества LLM, когда правильный ответ может быть сформулирован множеством способов.
4. Применение Log-derivative trick и вывод алгоритма Reinforce. Если осознать самый базовый алгоритм on-policy RL, то дальше значительно легче будет разобраться в A2C, PPO, и т.д.
5. Техники дистилляции на примере статьи MiniLLM и интересный разбор применения прямой/обратной KL дивергенции в качестве “меры похожести” моделей. По дистилляции совсем недавно вышла новая работа, показывающая результаты лучше, можно почитать здесь обзор.
6. Базовая идея квантизации и ее развитие в популярный метод SmoothQuant.
7. Объяснение Speculative Decoding для ускорения инференса. Немного писал об этом здесь.

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

Продолжаем серию #interview_questions. Напомню, под этим тегом я пытаюсь собрать не самые популярные вопросы с собеседований, которые часто вызывают трудности. В этот раз вопрос по теме статистики и проверки гипотез, который встретился на собеседовании в одну большую компанию, занимающуюся объявлениями.
Вопрос: при условии, что H0 верна, какое распределение будет у p_value?

Ответ: Равномерное. Вот хорошее чисто математическое объяснение https://statproofbook.github.io/P/pval-h0.html. Заключается оно в том, при H0 можно показать, что для любого 'a' P(p_val < a) = a (отсюда как раз и вытекает возможность устанавливать ограничения на ошибку первого рода в привычном виде по типу "сравни p_value с 0.05"). Единственный вариант, когда возможно такое равенство — когда p_value имеет равномерное распределение на отрезке [0, 1].

Недавно появилась мысль собрать небольшой список из вопросов подобного рода, например, 100 вопросов по темам ML, NLP, CV, DA в формате вопрос/ответ/доп. ссылки. Было бы такое интересно?

Сейчас все популярнее становится экспериментальное направление Model Merging, когда множество LLM моделей объединяют в одну. Причем процесс этот связан именно с получением новых весов для одной модели на основе других, а не с ансамблированием. На днях от HuggingFace вышел обзор подходов и вместе с ним результаты для мерджинга Mistral Instruct 0.1 и 0.2. Увидел много положительных отзывов, так что интересно будет почитать. В ближайшее время возможно напишу пост про эти алгоритмы.

В некоторых ML задачах синтетические данные (данные, полученные не из реального траффика/пользователей, а с помощью алгоритмов) могут помочь получить более качественные модели. С развитием LLM это стало еще актуальнее, особенно для NLP задач. Но есть проблема с разнообразием таких данных: если вам нужно собрать десятки/сотни тысяч примеров, то скорее всего вариативность их будет небольшая, и соответственно польза ограниченная. Чтобы бороться с этим есть множество методов от изменений промпта до эволюционных алгоритмов (что-то по типу QDAIF). Сегодня хочется рассказать о трех простых методах, которые зачастую могут решить проблему с разнообразием данных.

— Использовать стратегии для семплинга токенов с бОльшей вариативностью. Это может быть top-k или повышенная температура, но нужно быть аккуратнее: чем больше температура, тем менее связным может получиться текст, что особенно важно, когда данные нужны в определенном формате по типу JSON. Недавно у Chip Huyen вышел неплохой пост, где хорошо описаны основные подходы.
— Составлять динамический промпт. Это можно сделать через выбор некоторых элементов из множества на этапе вызова модели, например, сгенерируй {choice(формат текста)} о {choice(набор тем)} в {choice(набор стилей)} стиле. Каждый раз мы будем получать немного разный промпт, что будет отражаться на финальной генерации.
— Семплировать few-shot примеры из более широкого набора. Помимо того, что это помогает модели лучше следовать инструкциям, мы можем направлять ее таким образом в сторону определенных стилей и тем. Для этого нужно заранее отобрать, например, 50 примеров и каждый раз добавлять в промпт k << 50 штук.

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

Увидел тут у Артема из ai_newz прикольный ролик, как собака-робот учится ходить всего за один час без помощи каких-либо симуляторов, а прямо в режиме настоящего времени. Это пример из работы DayDreamer, захотелось внимательнее почитать и рассказать, по какому принципу авторы предлагают выстраивать процесс такого обучения. Для каждой задачи придумывается своя функция награды, и, имея множество удачных и неудачных примеров взаимодействия со средой, можно применять различные RL алгоритмы. Вопрос в том, откуда эти примеры взять. В использовании симуляторов есть проблема, что итоговое решение тяжело потом перенести на реальный мир. Более того, для каждой задачи нужно прорабатывать свой симулятор со всеми вытекающими вроде корнер кейсов или физики конкретных действий. Предложенное решение заключалось в добавлении еще одной модели, World Learner (WL), которая изучает динамику окружающего мира в онлайне и генерирует траектории для обучения нашего RL алгоритма.

— WL: По сути модель решает задачу next state prediction, где на вход подается состояние (информация с камер и сенсоров) и выполненное действия, и модель учится понимать среду путем предсказания следующего состояния (как LLM учится предсказывать следующее слово в последовательности). Сама модель представляет из себя State-Space Model — популярный нынче класс моделей для работы с последовательностями. На ум пришла лекция Ильи Гусева про них и не только, посмотрите если интересно (лекция сильно техническая, так что имейте в виду)
— Actor-Critic: имея WL, мы можем генерировать большое кол-во траекторий для обучения агента в риал-тайме. В статье авторы используют классический алгоритм AC с дополнительной регуляризацией в виде энтропии распределения действий (для того, чтобы сохранять некоторый exploration), это частый трюк в RL в целом.

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

Классная новая лекция Саши Раша про историю языковых моделей.

Включает в себя:
- Очень понятный вывод перплексии и её влияния на остальные метрики
- Сравнение с древними n-граммными моделями
- Вывод механизма внимания как аппроксимацию key-value памяти
- Понятные переходы “n-граммная модель -> word2vec -> трансформеры”
- Объяснение важности иерархии памяти в GPU при матричном умножении
- Scaling law Шиншиллы
- RASP, довольно забавный язык программирования, основанный на механизме внимания. Язык этот используется для того, чтобы показать, как трансформеры могут делать те или иные операции.

Что я узнал нового? Только часть про RASP, которую я как-то пропустил года 2 назад.
Но всё равно лекция довольно интересная.

Видео: https://www.youtube.com/watch?v=KCXDr-UOb9A
Презентация: https://link.excalidraw.com/p/readonly/aBWlNjEckdUlrszwwo6V

Со мной недавно поделились тредом в Twitter, где парень рассказывает про эксперименты с подходом ColBERT со всякими дополнительными трюками, которые помогли улучшить качество. Стало интересно разобрать основные моменты, так как это в данный момент актуально к моим текущим задачам. Давайте напомню, что такое ColBERT в контексте задачи Retrieval. В обычном сценарии мы прогоняем все наши документы через эмбеддер и строим по ним индекс (получая таким образом отображение document ↔ embedding). Далее для любого запроса мы можем посчитать его эмбеддинг и найти k ближайших соседей как кандидатов на выдачу. ColBERT предлагает здесь уйти от представления “1 вектор на 1 документ”, вместо этого у нас будет n эмбеддингов на документ и k эмбеддингов на запрос. На картинке можно увидеть, как получается итоговый скор для пары запрос-документ. Такое расщепление помогает более детально посмотреть на взаимодействие токенов запроса с токенами документа. В пару предложений тяжело запихнуть описание всего подхода, поэтому посмотрите также оригинальную статью, она написана понятным языком.

Из описанных приемов автора мне понравились следующие:

1. Прунинг индекса. Обрабатывая каждый токен по отдельности, мы получаем а) большой индекс б) много ненужных в нем элементов, которые скорее всего будут бесполезны при поиске. Статья
2. Поиск не по всем токенам из запроса, а только по некоторым из них. Своего рода тот же прунинг, но уже для запросов. Статья
3. Дополнительно использовать PRF (pseudo-relevance feedback), то есть делать ретривал в два этапа: на первом извлекать документы для формирования дополнительных эмбеддингов запроса (что-то по типу query expansion), а на втором уже искать финальные документы для выдачи. Схема изображена на картинке. Статья

Если использовали что-то из этого, расскажите, интересно послушать, что взлетело, а что нет. По моим экспериментам не могу сказать, что ColBERT вообще стат. значимо докидывал по сравнению с хорошо настроенными bi-encoder трансформерами, но это в задаче поиска товаров.

Наткнулся на забавную работу VeRA: Vector-based Random Matrix Adaptation. Из названия уже видна связь с LoRA. И действительно, авторы предлагают еще более эффективный метод тюнинга моделей, который в некоторых случаях экономит в 100 раз больше памяти, чем LoRA, хотя казалось бы, откуда столько? Основная идея лежит в том, что вместо двух обучаемых матриц A и B используются два обучаемых вектора b и d (представляются в виде диагональных матриц, чтобы можно было нормально умножать). При этом A и B матрицы берутся из нормального распределения, замораживаются и используются сразу для всех слоев. Таким образом, вектора b и d могут пропускать/занулять/усиливать сигнал, идущий через матрицы. На картинке мне кажется хорошо виден принцип работы.

С одной стороны, вроде показали, что работает не хуже LoRA, с другой — эксперименты ставились на RoBERTA-base/large, GPT-2 medium/large, ViT-B/L. На LLaMa 7/13B замеры есть, но результаты оценивались через GPT-4. В общем по метрикам показалось, что как-то скудно. Посмотрим, когда появятся более релевантные сравнения и когда это станет доступно из коробки, например, в PEFT. Сейчас в PR в прогрессе, но судя по обсуждениям, там все течет довольно медленно, а авторы код не пошарили. Ощущение, что больше проходная статья.

ICDPO (In Context Direct Preference Optimization), или DPO без файн-тюнинга

Очередная работа по методам тюнинга, на этот раз немного необычная. Основной плюс — мы по факту ничего не делаем с весами модели, то есть используем претрейн. За это расплачиваемся дополнительным временем и памятью. Теперь давайте подробнее. Обозначим заданный промпт как x, датасет с заготовленными чистыми примерами как D. Далее:

1. Извлекаем d примеров из D, которые похожи на x. Это классический ретривал, то есть можно использовать BM25 + Sbert, bert, colbert, you name it.
2. Генерируем n различных ответов, поместив примеры d в контекст.
3. Для каждого ответа считаем вероятность p(y | x) = a и p(y | d, x) = b, то есть с условием на примеры d в контексте и без. Можно сказать, что это оценка вероятности ответа y в формате zero-shot и few-shot.
4. Считаем некоторый скор S, который отражает разницу между b и a. Это число показывает, насколько хорошо заалайнен ответ, так как d — качественные примеры из заготовленного датасета. В итоге берем генерацию с максимальным S.

По экспериментам репортят, что удается добиться метрик на уровне тюнинга с LoRA. Ну и как раз за счет ретривера + n генераций мы сильно замедляемся по скорости, так что область применения такой техники сильно ограничена 😢

Статья ICDPO: https://arxiv.org/abs/2402.09320
Статья DPO: https://arxiv.org/abs/2305.18290

Опять статья по эффективному тюнингу, уже формируется целая коллекция из LoRA, VeRA, и на этот раз DoRA: Weight-Decomposed Low-Rank Adaptation. Совсем недавняя статья, где получились уже интересные результаты: по экспам неплохо обгоняет лору при том же числе обучаемых параметров. На самом деле лора и дора очень похожи, за исключением одной маленькой технической детали.
Вспомним как работает LoRA — У нас есть замороженная матрица весов W, мы учим две новые A и B и получаем out = (W + AB) * in. После тюнинга можно все это смерджить, чтобы получить одну матрицу W’ = W + AB.

В DoRA предложили немного изменить процедуру обучения и отдельно выделить вектор, задающий величину (любой вектор можно представить как vector = m * unit_vector, то есть величину, умноженную на единичный вектор, отвечающий за направление). То же самое можно сделать и для матрицы: W = ||W||_c * W/||W||_c = m * V, где m — вектор с нормами матрицы по столбцам. В таком случае мы будем использовать ровно так же LoRA для V, но дополнительно обучаем и вектор m. Размер вектора m можно сказать о малое от остальных параметров, поэтому практически не увеличивает требования по памяти. Возможно картинка на первый взгляд не очень понятная, но если немного посмотреть, то достаточно хорошо видно, в чем заключается суть.

Выглядит кажется логично: после обычной лоры у нас может в ту или другую сторону поехать норма матрицы, а здесь мы дополнительно контролируем этот фактор. Прикрепил также сравнения для LLaMA-7/13B.

Небольшая заметка об изменении архитектуры трансформера с 2017 года. Читая статьи про LLM, можно увидеть фразы вроде "мы используем стандартную архитектуру трансформера". Но что означает "стандартная", и есть ли изменения с момента выхода оригинальной статьи? Давайте на примере языковой модели (т.е. decoder-only) LLaMa-2 посмотрим на основные крупные архитектурные улучшения для LLM:

— Post LayerNorm → Pre LayerNorm. Это делает сходимость более устойчивой. Теперь процесс идет так, что исходные эмбеддинги просто идут сквозь блоки декодера, и к ним прибавляются “корректировки” из FFN и Attention. Выглядит изящно, на мой взгляд.

— Позиционное кодирование синусом → RoPE. Сам метод заключается в том, что мы вращаем эмбеддинги токенов на угол, зависящий от позиции. И это хорошо работает. Помимо этого, метод открыл целый ряд модификаций по расширению контекста до очень больших чисел.

— Функция активации ReLU → SwiGLU. Gated Linear Units (семейство методов, к которому принадлежит SwiGLU. В нем добавляется операция поэлементного умножения матриц, одна из которых прошла через сигмоиду и таким образом контролирует интенсивность сигнала, проходящего из первой матрицы) немного докидывают к качеству на ряде задач.

— LayerNorm → RMSNorm. RMSNorm вычислительно проще, но работает с тем же качеством.

— Модификации Attention, например, использование одной K-V пары матриц сразу на группу Q матриц. Это улучшение в основном уже влияет на оптимизацию инференса. Но здесь есть и огромное число методов, направленных в сторону снижения квадратичной сложности операции, писал об этом подробнее здесь и здесь.

Прокатилась новость про то, как исследователи из Гугл придумали способ выяснить веса последнего слоя и внутренний размер эмбеддингов у моделей, доступных ТОЛЬКО по апи (например, ChatGPT). Стало очень интересно, а как в принципе такое возможно, поэтому сегодня попытаюсь базово объяснить на самом простом примере: как достать размер эмбеддинга h, имея на руках значения логитов для ВСЕХ токенов из словаря. Понятно, на практике мы имеем доступ (и то не всегда) к топ-к логитам, но для простоты и интуиции лучше начать с простого. Для обзора всех методов (даже для случая, когда логитов вообще нет), нужно писать отдельный лонгрид.

Итак, алгоритм действий такой:

1. Создаем матрицу n на l, где l — размер словаря, а n — число, большее h. Мы его не знаем, но можем примерно предположить и вообще хоть взять 100_000. Но чем больше этого число, тем больше запросов нужно будет сделать в апи ⇒ весь процесс выйдет дороже.
2. n раз семплируем рандомный промпт, получаем логиты и заполняем нашу матрицу.
3. С помощью какого-нибудь алгоритма (например, SVD) находим сингулярные числа матрицы λ_i.
4. Размер эмбеддинга определим как argmax_i(λ_i/λ_{i+1}).

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

1. Несмотря на то что каждый вектор логитов состоит из l чисел, все они лежат в пространстве размерности h и затем преобразуются линейной проекцией.
2. Соответсвенно, запрашивая результаты модели достаточное число раз (бОльшее h), мы будем получать новые векторы логитов, линейно зависимые от предыдущих.
3. Теперь можно сказать, что нам достаточно найти ранг матрицы, который мы и возьмем в качестве предсказания размера эмбеддинга. А ранг матрицы — это кол-во ее сингулярных чисел. Но тк значения матрицы не целочисленные, а fp16 или вообще fp8, то такое определение нам не подойдет. Именно поэтому мы находим ту точку, в которой происходит максимальный скачок до очень маленьких значений сингулярных чисел — ненулевыми они получились из-за погрешности измерений.

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