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

Первая версия нашей попытки обзора литературы по BERT (Rogers et al., 2020) содержала обзор около 40 статей в феврале 2020 года. К июню их было более сотни.

Окончательная версия TACL c достаточно хорошим внешним видом содержит около 150 цитат, связанных с BERT, и нет никаких иллюзий завершённости: в августе 2020 года у нас закончились отведённые для журнала страницы.

Но даже несмотря на все эти исследования, всё ещё не ясно, почему BERT работает так хорошо. Давайте разбираться вместе с Анной Роджерс доцентом Копенгагенского университета, экспертом в области обработки естественного языка, машинного обучения и социальных данных.

---

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

Недавняя работа даёт подсказки для альтернативного направления исследований:

• Гипотеза лотерейного билета предполагает, что случайно инициализированные нейронные сети содержат подсети, которые могут быть повторно обучены отдельно, чтобы достичь (а иногда и превысить) производительности полной модели;
• Большинство параллельных проходов через механизм самонаблюдения BERT можно обрезать на основе оценок важности, полученных из градиентов модели;
• Для моделей Base-Transformer, обученных машинному переводу, последние упрощённые параллельные проходы самонаблюдения, как правило, имеют синтаксические функции.

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

В совместном проекте с Sai Prasanna (Zoho) и Anna Rumshisky (UMass Lowell) мы обнаружили, что неструктурированная обрезка весов BERT, основанная на их величине, согласуется с прогнозами основной гипотезы лотерейных билетов и даёт стабильные подсети. Однако обрезка параллельных проходов и MLP на основе оценок их важности не даёт хороших подсетей, согласованных при инициализациях тонкой настройки или даже при выполнении аналогичных задач (что указывает на согласованные стратегии рассуждений). Эти подсети также не содержат преимущественно параллельных проходов самонаблюдения, которые кодируют потенциально интерпретируемые паттерны. Для большинства задач GLUE хорошие подсети можно переобучить, чтобы достичь производительности, близкой к производительности полной модели, но то же самое можно сделать и для подсетей того же размера, выбранных случайным образом. Это хорошая новость для сжатия BERT (это лотерея, в которой нельзя проиграть), но плохая новость для интерпретируемости.

Обрезка BERT

Ещё раз: гипотеза лотерейного билета прогнозирует, что случайно инициализированные нейронные сети содержат подсети, которые можно переобучить отдельно, чтобы достичь производительности полной модели. Мы используем два метода обрезки, чтобы найти такие подсети и проверить, верна ли гипотеза: неструктурированное обрезка по величине и структурированная обрезка.

Классическая гипотеза лотерейного билета в основном проверялась с помощью неструктурированной обрезки, в частности обрезки по величине (m-обрезки), при котором веса с наименьшей величиной обрезаются независимо от их положения в модели. Мы итеративно сокращаем 10 % весов с наименьшей величиной по всей тонко настроенной модели (кроме векторных представлений) и оцениваем на наборе для разработки до тех пор, пока производительность обрезанной подсети составляет более 90 % производительности полной модели.

Мы также экспериментируем со структурированной обрезкой (s-обрезкой) целых компонентов архитектуры BERT на основе их оценок важности: в частности, мы удаляем наименее важные параллельные проходы самонаблюдения и MLP, применяя маску. На каждой итерации мы удаляем 10 % проходов BERT и 1 MLP, пока производительность обрезанной подсети это более 90 % производительности полной модели. Чтобы определить, какие проходы и MLP нужно обрезать, мы используем аппроксимацию, основанную на потерях: оценки важности, предложенные Michel, Levy and Neubig (2019) для проходов самонаблюдения, которые мы распространяем на MLP. Пожалуйста, ознакомьтесь с нашей статьёй и оригинальной формулировкой, чтобы узнать больше.

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

Насколько стабильны хорошие подсети при случайной инициализации?

Недавняя работа показала, что существует значительная разница в производительности BERT при случайных инициализациях слоя, который специфичен для конкретной задачи (Dodge et al., 2020), до такой степени, что разные инициализации приводят к резко различающейся производительности обобщения.

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

Пример хорошей подсети: два метода обрезки выбирают очень разные подсети.

Ясно, что подсети с m-обрезкой довольно стабильны (стандартное отклонение обычно около 0,01). Но этого нельзя сказать о s-обрезке: есть несколько параллельных проходов, которые особенно живучи (супер-выжившие) (т. е. они выживают во всех случайных данных инициализации), а некоторые после обрезки не выживают никогда, но примерно для 70 % параллельных проходов самонаблюдения стандартное отклонение находится в диапазоне 0,450,55. Каппа Флейсса для масок выживания прохода / MLP для случайных чисел инициализации также низкая, в диапазоне 0,10,3.

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

Распределение оценок внимания: CoLA, итерация 1. Большинство проходов имеют низкие оценки важности.

Насколько стабильны хорошие подсети при выполнении задач?

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

Кажется, что связанные задачи, с точки зрения хороших подсетей, не всегда имеют больше общего. На следующей диаграмме показано среднее количество общих параллельных проходов самонаблюдения в подсетях для всех пар задач GLUE. Например, QQP и MRPC ближе с точки зрения постановки задач, чем QQP и MNLI, но в хороших подсетях в обоих случаях общие 5255 проходов.

Общие проходы с самонаблюдением в хороших подсетях для задач GLUE: связанные теснее задачи не всегда имеют больше общих проходов (например, QQP/MRPC и QQP/MNLI).

Гипотеза лотерейного билета для BERT?

Мы рассматриваем три экспериментальные установки:

• Хорошие подсети: элементы, выбранные из полной модели с s- или m-обрезкой;
• Случайные подсети: элементы, случайно отобранные из полной модели, чтобы соответствовать хорошему размеру подсети;
• Плохие подсети: элементы, которые не пережили обрезку, плюс несколько элементов, отобранных из оставшихся, чтобы соответствовать хорошему размеру подсети.

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

Мы действительно находим такие подсети в случае m-обрезки: обрезанные и повторно настроенные хорошие подсети достигают полной производительности модели в 8 из 9 задач GLUE (за исключением WNLI, где модель обычно не обучается). Эти результаты согласуются с одновременной работой на обрезке по величине BERT (Chen et al., 2020). Случайные и плохие подсети также обычно работают лучше при повторной настройке, но плохие подсети постоянно хуже случайных.

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

Однако для подсетей с s-обрезкой тенденция иная. Для большинства задач подсети с s-обрезкой достигают не совсем полной производительности модели, хотя для многих задач разница находится в пределах двух баллов. Однако случайные подсети могут быть повторно обучены почти так же, как и хорошие; это согласуется с наблюдением о том, что оценки важности для большинства параллельных проходов одинаково низкие. Что касается плохих подсетей, обратите внимание, что, поскольку мы оцениваем наборы GLUE для разработчиков, которые мы также используем, чтобы выбрать маски, плохие подсети являются наихудшим выбором элементов BERT для этих конкретных данных. Тем не менее даже они остаются легко обучаемыми и в среднем соответствуют базовому уровню biLSTM + GloVe GLUE.

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

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

Насколько лингвистически информативны хорошие подсети?

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

Мы сосредотачиваемся на проходах самонаблюдения, поскольку они были в центре внимания многочисленных исследований BERT, показывающих, что они кодируют определённые лингвистические знания, а также дискуссии об интерпретируемости. Вместо того чтобы использовать зондирование для определения потенциальных функций параллельных проходов самонаблюдения BERT, мы выбираем прямой анализ их паттернов внимания. Есть 5 типов паттернов:

Типы паттернов самонаблюдения (Kovaleva et al., 2019)

Поскольку гетерогенный паттерн единственный, который потенциально может кодировать лингвистически интерпретируемые отношения, соотношение проходов самонаблюдения с такими паттернами даёт верхнюю границу интерпретируемых паттернов. Следуя, мы обучаем классификатор CNN на аннотированном вручную наборе из 400 карт самонаблюдения, представленном авторами. Мы также рассматриваем нормированные по весу карты самонаблюдения, которые должны снижать внимание к специальным токенам и для которых мы аннотируем ещё 600 образцов карт наблюдения. Затем мы кодируем 100 примеров из каждой задачи GLUE, генерируем карты наблюдения для каждого прохода BERT и используем наши обученные классификаторы, чтобы оценить, сколько паттернов каждого типа мы получаем. На аннотированных данных классификаторы дают F1 0,81 для необработанных карт наблюдения и 0,74 для карт наблюдения, нормированных по весу.

Мы наблюдаем, что для необработанных карт самонаблюдения супер-выжившие имеют больше блочных и вертикальных + диагональных паттернов, но количество гетерогенных паттернов не увеличивается. В нормированном по весу состоянии соотношение диагональных паттернов уменьшается, но для большинства задач у супер-выживших остается 3040 % диагональных паттернов. В обоих условиях две задачи обнаружения перефразирования (MRPC и QQP) имеют заметное увеличение количества вертикальных паттернов наблюдения, что обычно указывает на внимание к SEP, CLS и пунктуации.

Распределение паттернов самонаблюдения в параллельных проходах супер-выживших. Соотношение потенциально интерпретируемых паттернов самонаблюдения (синий) существенно не меняется в подсетях супер-выживших (слева) по сравнению с полным распределением моделей (справа) ни в исходном, ни в нормированном по весу внимании.

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

Заключение

Как наше исследование, так и параллельная работа (Chen et al., 2020) подтверждают, что гипотеза лотерейного билета верна при использовании обрезки по величине в BERT: хорошие подсети могут быть переобучены для достижения полной производительности модели.
Структурированная обрезка рассказала нам о другом: мы обнаружили, что обрезка большинства подсетей BERT этим методом приводит к аналогичной производительности между хорошими, случайными и плохими сетями и что ни одна из них не может достичь полной производительности исходной сети. Таким образом, можно сказать, что при структурированной обрезке BERT не имеет проигрышных билетов, даже если он не полностью выигрывает.

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

Всё это означает, что теперь у нас ещё больше вопросов, чем ответов о том, как BERT достигает замечательных результатов. Если так много важных проходов самонаблюдения даже потенциально не интерпретируются, стоит ли нам отказаться от идеи, что некоторые знания кодируются в конкретных компонентах архитектуры, а не распространяются по всей сети? Как изучать такие распределённые представления? Приписать ли в целом высокую производительность GLUE знаниях о языке в BERT или артефактам наборов данных? Ожидать ли, что они будут проявляться так же, как и в весах самонаблюдения? Речь вообще идёт о кодировании лингвистических знаний, или, возможно, это в большей степени связано с соответствием между инициализацией специфического для конкретной задачи слоя и оптимизационной поверхностью предварительно подготовленных весов? Результаты LSTM свидетельствуют о том, что для выполнения лингвистических задач может быть полезным нелингвистическое предварительное обучение.

Единственное, что мы знаем наверняка, это то, что исследования в BERTology ещё далеки до завершения.

Всем привет! В этом посте я расскажу о проекте, который выполнил совместно с командой Google Brain во время исследовательской стажировки в Цюрихе. Мы работали над моделью обработки естественного языка, которая решает задачи на общее понимание текста (задачи из набора GLUE: General Language Understanding Evaluation).

BERT-подобные модели мы комбинировали с помощью маршрутизирующих сетей и добились того, что при увеличении мощности скорость вывода почти не изменилась. Финальная модель объединяет 10 BERT_large моделей и имеет более 3,4 миллиарда параметров. Подробности под катом!

Меня зовут Никита Сазанович, я учусь на 2-м курсе магистратуры Программирование и анализ данных в Питерской Вышке. В январе я поехал на 17-недельную стажировку в Google Brain (правда, физически находился в Цюрихе только 11 из них: из-за карантина последние 6 недель пришлось работать удаленно). Мой проект был связан с обработкой естестественного языка с использованием маршрутизирующих сетей а это новое понятие в машинном обучении, с которым мы далее и разберемся.

Начнем издалека

Задачи обработки естественного языка (Natural Language Processing, NLP) включают в себя машинный перевод, распознавание текста, анализ тональности текстов и др. В этой статье мы поговорим про задачи из набора GLUE. Они были разработаны экспертами машинного обучения, чтобы оценивать, насколько модель способна к общему пониманию текста (откуда и название набора: General Language Understanding Evaluation).

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

Рассмотрим одну из них: Quora Question Pairs, или QQP. Как ясно из названия, нужно будет что-то сказать про пару вопросов из сайта Quora. Вопросы необходимо сравнить и сообщить, семантически эквивалентны ли они / является ли один дубликатом другого. Сразу приведу два примера:

1) Вопросы "What are natural numbers?" и "What is a least natural number?" не являются дубликатами.

2) А вопросы "How do you start a bakery?" и "How can one start a bakery business?" семантически эквивалентны.

То есть в этой задаче по тексту двух вопросов просят провести бинарную классификацию: разбить их на два класса. Задачу классификации в машинном обучении решают уже давно и научились это делать хорошо, но не в тех случаях, когда дело касается обработки естественного языка. Можно решить эту проблему, если привести текст к формату, на котором осуществлять классификацию более удобно. Например, преобразовать его в единый числовой вектор, который и послужит входом для классификации! Такой вектор называют представлением языка, а получением таких векторов занимается область обучения представлений языка, или language representation learning.

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

BERT: Теория

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

1) Входное предложение: "Jet makers feud over seat width with big orders at stake".

2) Разбиение на токены (где символ _ приписывается к токенам, с которых слова начинаются): "_J et _makers _fe ud _over _seat _width _with _big _orders _at _stake". Здесь можно видеть, что слов "Jet" и "feud" не оказалось целиком в словаре, поэтому они были разбиты на части, присутствующие в словаре.

В словаре WordPiece содержится несколько десятков тысяч токенов. Большинство слов, которые встречаются наиболее часто, он содержит целиком.

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

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

Если мы посмотрим на слово making в предложении It is in this spirit that a majority of American governments have passed new laws since 2009 making the registration or voting process more difficult, мы можем обратить внимание также на слова more difficult, laws, 2009: они помогают понять смысл. В предложении говорится о том, как с 2009 года правительства США принимали законы, которые делают процесс голосования сложнее. В таком контексте представление слова making в механизме внимания формируется в основном из представлений предыдущего слоя для слов making, more и difficult. Математически механизм внимания представляет собой блок модели, который отображает последовательность векторов токенов. При этом блок можно устроить таким образом, чтобы выходное представление каждого токена формировалось как взвешенная сумма всех представлений токенов с предыдущего слоя. В каком-то смысле у каждого слова есть ограниченное внимание, которое оно разделяет между всеми словами предыдущего слоя.

В той же статье авторы показали модель, которая состояла из нескольких последовательных блоков с механизмом внимания, и назвали ее Трансформер.

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

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

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

Маршрутизирующие сети

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

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

Формулировать и обучать процесс маршрутизации можно по-разному. К примеру, в статье по ссылке для каждой возможности маршрутизации задачи через модуль модели использовалось распределение Бернулли, которое обучалось с помощью Gumbel Softmax. Ниже вы можете видеть пример такой модели с двумя задачами. Цветами отмечено, какое подмножество модулей используется для каждой из них: красным обозначены модули, которые вычисляются на маршруте для первой задачи, синим для второй, а фиолетовым для обеих. Если в одном слое таких модулей для одной задачи несколько, нужна агрегация результатов, например, усреднение. Наличие общих модулей и позволяет задачам совместно обучать модули, которые выгодно разделять.

Как видно на картинке, модули этой сети состоят из сверточных слоев (Conv 3x3, Conv 5x5, Conv 7x7). Значит, задачи относились к области компьютерного зрения. А что если в качестве таких модулей мы будем использовать BERT-подобные модели и попытаемся искать маршруты для задач из набора GLUE? Это и стало идеей для моего проекта.

Маршрутизация и процесс тренировки

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

Представления задач моделируются как вектора размерности M (в экспериментах M было равно 10):

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

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

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

Далее под спойлером для любителей описаны технические подробности настройки этой модели. Для полноты картины расскажу про нее в нескольких словах. Лучший результат достигается, если использовать 10 BERT _large экспертов, а не трех или одного (из-за затрат времени и ресурсов мы провели эксперименты только для 1, 3 и 10 экспертов). Оптимальное количество путей два. Оптимизировать выгодно стохастическим градиентным спуском с импульсом. При такой настройке модель имеет 3,4 миллиарда параметров и обучать ее пришлось на 24 тензорных процессорах Google.

Анализ результатов

Для сравнения результатов в наборе GLUE был предложен способ комплексной оценки, который совмещает результаты на каждой из задач набора. Эта оценка лежит в диапазоне от 0 (все неверно) до 100 (идеальные ответы). Я сравнил маршрутизируемый BERT с опубликованными результатами мультизадачного обучения BAM! (оно основано на дистилляции) и настройкой одного BERTа под каждую задачу. Маршрутизируемый BERT достиг лучшей оценки общего понимания языка.

Интересны также различия между результатами на задачах. Например, выгоду при тренировке с маршрутизируемыми сетями получает задача RTE, которая имеет наименьший тренировочный набор (2,5 тысячи примеров). Сравните ее оценки в 1-й и 3-й строках. Эта выгода на задаче достигается засчет использования дополнительных знаний из других задач, тренировочный набор которых больше по размеру.

Еще один результат этой модели возможность исследовать отношения между задачами. Ниже представлен результат сокращения размерности векторов для представлений задач. Вектора, которые изначально находятся в 10-мерном пространстве (M=10), сокращены до векторов размера 2, т. е. точек. Это сделано при помощи метода t-SNE, который очень популярен для таких визуализаций и про который можно почитать в другом блоге на Хабре. Здесь каждая из задач располагается на плоскости, а расстояние между ними позволяет судить о том, насколько они близки с точки зрения маршрутизатора. Как и ожидалось, mnli-m и mnli-mm задачи с одним и тем же тренировочным набором располагаются близко. Так же близко расположены sst-2 и qqp, cola и rte пары, сходство которых отмечали и другие исследователи.

Итоги

В результате мы разобрались, как можно использовать маршрутизирующие сети для обучения представлений языка. С их помощью мы улучшили результат работы исходной модели с точки зрения оценки GLUE на 1,75 пункта и в качестве бонуса смогли визуализировать отношения между задачами набора. Важное свойство такого подхода сохранение скорости вывода в конечной модели. Было бы интересно продолжить работу над проектом, использовав разнородных экспертов с одинаковым интерфейсом (таких как ALBERT и RoBERTa), а также добавить к набору задачи предобучения представлений (таких как MLM BERT-а) для тренировки сети с нуля без использования предобученных моделей.

Код этой модели остался в Google, но могу сказать, что написан он был на любимом в компании TensorFlow.

Привет, Хабр!

С этой статьи мы начинаем публикацию серии статей про Data Science задачи, которые мы решаем в Центре Развития Финансовых Технологий Россельхозбанка.

В прошлом году Россельхозбанк объявил о создании и развитии экосистемы для предприятий агропромышленного комплекса. Для одной из базовых площадок экосистемы Своё Фермерство мы решили сделать пару полезных задач, о которых расскажем ниже.



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

Что делали?

В этой статье мы расскажем о том, как в рамках сотрудничества с Лабораторией МФТИ, специально созданной под задачи Банка, разработали инструмент, позволяющий с высокой точностью премодерировать текстовый контент.

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

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

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

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

В открытом доступе есть всего один размеченный русскоязычный датасет для поиска токсичности в тексте. Также нам удалось найти датасет для поиска оскорблений (частный случай токсичности). Плюс ко всему, мы собрали примеры объявлений с сельскохозяйственных порталов и разметили их как приемлемые (класс 0).

Поставленная нами задача оказалась довольно уникальной в плане заданной сельскохозяйственной тематики. Её специфика заключается в том, что фразы, которые в обычной жизни являются оскорблениями не всегда являются таковыми, когда речь идет о сельском хозяйстве. Из банальных примеров можно привести следующие: Не суй свое рыло текст явно неприемлемый, в то время как текст со свиным рылом вполне себе можно разместить на площадке (хоть и зависит от контекста). Тоже самое относится к определённым подвидам сельскохозяйственных животных и растений.

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

Как делали?

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

Общая схема

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

Теперь давайте рассмотрим каждую компоненту подробнее.

Наивный классификатор

Здесь все совсем просто: по словарю обсценной лексики довольно легко понять, содержится ли в тексте то или иное плохое слово или нет.

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

Логистическая регрессия

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

Великий и ужасный BERT

Мы использовали предобученную модель RuBert от DeepPavlov, которую дообучили на размеченных текстах. Процесс предсказания, не вдаваясь в детали, выглядит следующим образом:

Мы строили-строили и наконец построили!

Качество мы оценивали излюбленными метриками Accuracy, ROC-AUC и F1-мера. Итоговые метрики качества на отложенной выборке получились следующими:


Скорость работы: ~2800 текстов в минуту на GPU (GeForce 1080Ti) в случае отработки BERTа, как самого медленного алгоритма из представленных.

Как и ожидалось, c BERTом метрики получились чуть лучше, хоть и не сильно.

Какие мы сделали выводы

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

1. Всегда нужно учитывать специфику задачи, касательно разметки текстов.
2. Необходимо предусмотреть ручную модерацию текста, в случае, когда модель сомневается в своем решении. Вы же не хотите, чтобы неприемлемый контент в итоге присутствовал в вашем продукте.
3. Также необходимо отправлять размеченные руками тексты из предыдущего пункта на дообучение. Таким образом можно маленькими шагами улучшить модель и уменьшить со временем количество работы при ручной модерации.
4. Лучше использовать комплексный подход к решению задачи. Иногда даже самые простые модели на словарях уже дают неплохой результат.
5. Выбирайте лучшую модель исходя из задачи. В нашем случае мы выбрали BERT, так как он лучше логистической регрессии реагирует на контекст.

Спасибо за внимание!

В следующей статье мы поделимся своим опытом при премодерации изображений всё на той же площадке нашей экосистемы Своё Фермерство.

Вы можете спросить: почему эти полумагические модели машинного обучения работают так хорошо? Короткий ответ: эти модели чрезвычайно сложны и обучаются на огромном количестве данных. На самом деле, Lambda Labs недавно подсчитала, что для обучения GPT-3 на одном GPU потребовалось бы 4,6 миллиона долларов если бы такое было возможно.

Такие платформы, как PyTorch и Tensorflow, могут обучать эти огромные модели, потому что распределяют рабочую нагрузку по сотням (или тысячам) GPU одновременно. К сожалению, этим платформам требуется идентичность графических процессоров (они должны иметь одинаковую память и вычислительную производительность). Но многие организации не имеют тысячи одинаковых GPU. Малые и средние организации покупают разные компьютерные системы, что приводит к неоднородной инфраструктуре, которую нелегко адаптировать для вычисления больших моделей. В этих условиях обучение моделей даже среднего размера может занимать недели или даже месяцы. Если не принять меры, университеты и другие небольшие организации рискуют потерять конкурентоспособность в погоне за разработкой новых, лучших моделей машинного обучения. Но это можно исправить.

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

---

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

Эксперименты показывают, что систему на базе BERT можно за день обучить с помощью более чем 8 GPU, большинство из которых нам пришлось позаимствовать в неработающих лабораториях. Прежде чем мы представим HetSeq, нужна небольшая предыстория.

Типовое обучение нейронной сети

def train(args):    # main components    dataset = Dataset()    dataloader = DataLoader(dataset)    model = Model()    loss_ = Loss()    optimizer = Optimizer(model.parameters())    # specify the GPU and transfer model to the GPU     device = Device()     model.to(device)    model.train()        # actual training loops    for epoch in range(1, Max_Epoch):        for (data, target) in dataloader:            data, target = data.to(device), target.to(device)   # **load input data and target to GPU**            optimizer.zero_grad()            output = model(data)    # **forward compute the output of model given input data**            loss = loss_(output, target)   # **forward process to compute the real loss function**            loss.backward()    # **backward process to obtain the**            optimizer.step()    # **update parameters** 

Обучение на одном GPU

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

Фактически процесс обучения состоит из четырёх отдельных этапов: (1) загрузка данных, (2) прямой проход, (3) обратный проход, (4) обновление.

1. Загрузка данных

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


Прямой проход с одним GPU

2. Прямой проход

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

3. Обратный проход

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


Параметры обновления с единственным GPU

4. Обновление

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

Краткое описание этапов обучения

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

Что делать, если у нас несколько GPU?

Поскольку пакеты данных независимы друг от друга, довольно просто распараллелить этот процесс, отправив разные пакеты данных на разные GPU. Затем, если мы сможем каким-то образом объединить вычисленные потери и синхронизировать обновлённые параметры модели, тогда получится сделать обучение намного быстрее.

def torch.nn.parallel.DistributedDataParallel(    module,  # pre-defined model    device_ids=None, # input device_ids    output_device=None,  # output device_ids, in our case, input device = output device = single GPU    dim=0,     broadcast_buffers=True, # set to False in our implementation    process_group=None, # Core part    bucket_cap_mb=25,     find_unused_parameters=False,     check_reduction=False)view raw

Класс параллельного распределения данных

Это не новая идея. В PyTorch мы используем для модели модуль torch.nn.parallel.DistributedDataParallel (DDP) вместо модуля torch.nn.Module. Каждый GPU это отдельный процесс, и связь между ними осуществляется с помощью стандартного IPC. Но это ещё не всё. Четыре шага требуют некоторой настройки.

1. Загрузка данных с помощью DDP

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

Это основная идея параллельного распределения данных (DDP): каждый GPU имеет идентичные параметры модели, но одновременно обрабатывает разные пакеты данных.


Прямой проход с несколькими GPU

2. Прямой проход с DDP

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

3. Обратный проход с DDP

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


Синхронизация градиента

4. Обновление с DDP

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

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

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

def train_multiple_GPUs(args, device_id):    # main components    dataset = Dataset()    dataloader = DataLoader(dataset)    model = DDP(Model())    loss_ = Loss()    optimizer = Optimizer(model.parameters())    device = Device(device_id)     model.to(device)    model.train()        # actual training loops    for epoch in range(1, Max_Epoch):        for (data, target) in dataloader:            data, target = data.to(device), target.to(device)              optimizer.zero_grad()            model.synchronization()    #  parameter synchronization            output = model(data)                loss = loss_(output, target)            loss_average = average(loss)            loss.backward()            model.parameter.grad.average()            optimizer.step()

Обучение на нескольких GPU

Масштабирование несколько узлов с несколькими GPU

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

def torch.distributed.init_process_group(            backend=args.distributed_backend,    # 'nccl' is the best available backend for GPU            init_method=args.distributed_init_method,    # 'tcp' or shared file system            world_size=args.distributed_world_size,  # number of nodes in total            rank=args.distributed_rank, # index of current node        )

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

Коммуникация вот где возникают сложности

Внутриузловая и межузловая коммуникация

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

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

Когда родители заставляют вас делиться игрушками

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

1. Некоторые игрушки имеют сложные инструкции. Распределённая параллельная обработка данных пакета (DDP) это боль, трудно понять её и заставить работать. Особенно верно это для большинства исследователей машинного обучения, которые не очень хорошо разбираются в особенностях распределённых вычислений. В дополнение к базовой настройке DDP мирный тренировочный запуск различных архитектур GPU на многих узлах требует тщательного разделения данных и изнурительного налаживания связи между GPU и узлами.
   
2. С какими-то игрушками лучше играть лучше, чем с другими. В гетерогенной системе некоторые GPU работают быстрее других, а некоторые имеют больше памяти, чем у других. Это означает, что какие-то процессоры получают больше данных для обработки, чем другие, что прекрасно; но это также означает, что средние значения градиентов и обновления параметров должны тщательно взвешиваться.
   
3. Родители не разрешают нам играть с какими-то игрушками. Большинство существующих распределённых обучающих платформ GPU требуют дополнительных пакетов, таких как Docker, OpenMPI и т. д. К сожалению, большинство компетентных администраторов кластеров не позволяют пользователям иметь административные привилегии, необходимые для настройки каждого узла, чтобы обучить модель.
   
4. Какие-то игрушки плохо работают с другими. Пакеты глубокого обучения, такие как BERT и GPT2/3, разработанные крупными компаниями, как правило, имеют определённые форматы дизайна модели с несколькими логическими слоями, что затрудняет их использование и адаптацию к приложению.
   

Из-за этих проблем мы создали общую систему, которая охватывает все сложные части DDP: разделение данных, совместимость и настраиваемость, и развернули эту систему в Нотр-Даме.

Мы называем эту систему HetSeq. Она была адаптирована из популярного пакета PyTorch и обеспечивает возможность обучения больших моделей нейронных сетей в гетерогенной инфраструктуре. Её можно легко настроить через общую файловую систему без дополнительных пакетов и административных привилегий. Вот как обучать BERT с помощью HetSeq.

BERT в университете с HetSeq

Начнём с Anaconda. Создадим виртуальную среду и установим Python.

$ conda create --name hetseq$ conda activate hetseq$ conda install python=3.7.4

Затем мы установим пакеты и привязки HetSeq: загрузим HetSeq с GitHub, установим пакеты из requirements.txt, а также HetSeq и биндинги из setup.py.

$ git clone https://github.com/yifding/hetseq.git $ cd /path/to/hetseq $ pip install -r requirements.txt $ pip install --editable .

Последний шаг перед обучением это загрузка файлов данных BERT, включая корпус обучения, конфигурацию модели и словарь BPE отсюда. Загрузите DATA.zip, распакуйте его и поместите в каталог preprocessing/.

Обучение BERT с помощью HetSeq

Крутая вещь в HetSeq: она абстрагирует все детали о распределённой обработке. Таким образом, код обучения для 100 GPU почти такой же, как для одного! Давайте попробуем!

$DIST=/path/to/hetseq $python3 ${DIST}/train.py  \ $       --task bert   --data ${DIST}/preprocessing/test_128/ \ $       --dict ${DIST}/preprocessing/uncased_L-12_H-768_A-12/vocab.txt  \ $       --config_file ${DIST}/preprocessing/uncased_L-12_H-768_A-12/bert_config.json  \ $       --max-sentences 32  --fast-stat-sync --max-update 900000 --update-freq 4  \ $       --valid-subset test --num-workers 4 \ $       --warmup-updates 10000  --total-num-update 1000000 --lr 0.0001  \ $       --weight-decay 0.01 --distributed-world-size 1  \ $       --device-id 0 --save-dir bert_single_gpu

В этом случае предположим, что у нас есть два вычислительных узла.

На первом узле:

$DIST=/path/to/hetseq $python3 ${DIST}/train.py  \ $       --task bert   --data ${DIST}/preprocessing/test_128/ \ $       --dict ${DIST}/preprocessing/uncased_L-12_H-768_A-12/vocab.txt  \ $       --config_file ${DIST}/preprocessing/uncased_L-12_H-768_A-12/bert_config.json  \ $       --max-sentences 32  --fast-stat-sync --max-update 900000 --update-freq 4  \ $       --valid-subset test --num-workers 4 \ $       --warmup-updates 10000  --total-num-update 1000000 --lr 0.0001  \ $       --weight-decay 0.01 --save-dir bert_node2gpu4  \ $       --distributed-init-method tcp://10.00.123.456:11111 \ $       --distributed-world-size 8 --distributed-gpus 4 --distributed-rank 0

На втором узле:

$DIST=/path/to/hetseq $python3 ${DIST}/train.py  \ $       --task bert   --data ${DIST}/preprocessing/test_128/ \ $       --dict ${DIST}/preprocessing/uncased_L-12_H-768_A-12/vocab.txt  \ $       --config_file ${DIST}/preprocessing/uncased_L-12_H-768_A-12/bert_config.json  \ $       --max-sentences 32  --fast-stat-sync --max-update 900000 --update-freq 4  \ $       --valid-subset test --num-workers 4 \ $       --warmup-updates 10000  --total-num-update 1000000 --lr 0.0001  \ $       --weight-decay 0.01 --save-dir bert_node2gpu4  \ $       --distributed-init-method tcp://10.00.123.456:11111 \ $       --distributed-world-size 8 --distributed-gpus 4 --distributed-rank 4

Два блока кода работают на двух разных узлах. Адрес TCP/IP должен быть установлен как один из IP-адресов узла. Как только они будут запущены, вы сможете наблюдать за выполнением кода на 8 процессорах и 2 разных узлах!

Так насколько хорошо это работает? Мы провели несколько экспериментов (подробности тут) над различными однородными (гомогенными, hom) и неоднородными (гетерогенными, het) установками.


В общей сложности мы смогли управлять 32 GPU в 8 неоднородных узлах, сокращая время обучения языковой модели BERT с семи дней до примерно одного дня.

Под капотом HetSeq

Структура пакета HetSeq

Пакет HetSeq содержит три основных модуля, показанных на рисунке слева: train.py, task.py и controller.py для координации основных компонентов, показанных справа. Модуль train.py инициализирует распределённую систему и её различные компоненты.

Модуль task.py определяет функции модели, набора данных, загрузчика данных и оптимизатора; он также выполняет функции прямого и обратного распространения. Модуль controller.py действует как главный контроллер обучения. Он работает как модель, оптимизатор и планировщик скорости обучения; загружает и сохраняет чекпоинты, сообщает о потере и обновляет параметры.
Но я хочу обучить не BERT!

Но я хочу обучить не BERT!

Нет проблем. Вы можете использовать HetSeq с любой другой моделью. Но вам нужно определить новую задачу с соответствующей моделью, набором данных, оптимизатором. и планировщиком скорости обучения. Есть пример MNIST со всеми расширенными классами. Предварительно определённые оптимизаторы, планировщики скорости обучения, наборы данных и модели могут быть повторно использованы в других приложениях. Для получения дополнительной информации ознакомьтесь с пакетом HetSeq и документацией.

• Обучение профессии Data Science
• Обучение профессии Data Analyst
• Курс по Machine Learning

Первое что нужно сделать при разработке поисковых, диалоговых и прочих систем, основанных на natural language processing это научиться разбирать тексты пользовательских запросов и находить в них сущности рабочей модели. Задача нахождения стандартных сущностей (geo, date, money и т.д.) в целом уже решена, остается лишь выбрать подходящий NER компонент и воспользоваться его функционалом. Если же вам нужно найти элемент, характерный для вашей конкретной модели или вы нуждаетесь в улучшенном качестве поиска стандартного элемента, придется создать свой собственный NER компонент или обучить какой-то уже существующий под свои цели.

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

Если вы проектируете собственную систему, обучаете и настраиваете поисковые компоненты, например от Apache OpenNlp, Stanford NLP, Google Language API, Spacy или Apache NlpCraft для поиска собственных элементов, забот, разумеется, несколько больше, но и контроль над такой системой заметно выше.

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

Поиск пользовательских сущностей в Apache NlpCraft

При построении систем на базе Apache NlpCraft вы можете использовать следующие возможности по поиску собственных элементов:

• Встроенные компоненты поиска, основанные на конфигурации синонимов элементов. Пример описания элементов моделей, основанных на синонимах, Synonym DSL т.д. приведены в ознакомительной статье о проекте.
• Использование любого из вышеупомянутых внешних компонентов, интеграция с ними уже предусмотрена, вы просто подключаете их в конфигурации.
• Применение составных сущностей. Суть в возможности построения новых NER компонентов на основе уже существующих. Подробнее тут.
• Самый низкоуровневый вариант программирование и подключение в систему своего собственного парсера. Данная задача сводится к имплементации интерфейса и добавлении его в систему через IoC. На входе реализуемого компонента есть все для написания логики поиска сущностей в запросе: сам запрос и его NLP представление, модель и все уже найденные в тексте запроса другими компонентами сущности. Эта имплементация место для подключения нейросетей, использования собственных алгоритмов, интеграции с любыми внешними системами и т.д., то есть точка полного контроля над поиском.

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

Ниже представлен фрагмент конфигурации модели умный дом (подробнее о макросах и synonym DSL можно прочесть по ссылке).

macros: - name: "<ACTION>"   macro: "{turn|switch|dial|control|let|set|get|put}" - name: "<ENTIRE_OPT>"   macro: "{entire|full|whole|total|*}" - name: "<LIGHT>"   macro: "{all|*} {it|them|light|illumination|lamp|lamplight}"...- id: "ls:on" description: "Light switch ON action." synonyms:   - "<ACTION> {on|up|*} <LIGHT> {on|up|*}"   - "<LIGHT> {on|up}"

Элемент ls:on описан очень компактно, при этом данное описание содержит в себе более 3000 синонимов. Вот их малая часть: set lamp, light on, control lamp, put them, switch it all Синонимы конфигурируются в весьма сжатом виде, при этом вполне читаемы.

Несколько замечаний:

• Разумеется, при работе с поиском по синонимам учитываются начальные формы слов (леммы, стеммы), стоп-слова текста запроса, конфигурируется поддержка прерывистости многословных синонимов и т.д. и т.п.
• Часть сгенерированных синонимов не будет иметь практического смысла, это вполне ожидаемая плата за компактность записи. Если использование памяти станет узким местом (тут речь должна идти о миллионах и более вариантов синонимов на сущность), стоит задуматься об оптимизации. Вы получите все необходимые warnings при старте системы.

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

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

Расширение списка синонимов

Первое очевидное направление это в ручном режиме отслеживать логи и анализировать неотвеченные вопросы.

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



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

Помимо этого, разработчики Apache NlpCraft добавили в проект инструмент sugsyn, предлагающий, в процессе использования, дополнительные синонимы для элементов модели.

Компонент sugsyn работает стандартным образом через REST API, взаимодействуя с дополнительным сервером, поставляемым в бинарных релизах ContextWordServer.

Описание ContextWordServer

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

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

В целом данный подход работал удовлетворительно, но контекст слов учитывался недостаточно хорошо, даже при больших значениях N для n-граммов. Тогда было предложено использование Bert для решения задачи masked language modeling (поиск наиболее подходящих слов, которые можно подставить вместо маски в предложение). В предложении, которое передавал пользователь, маскировалось целевое слово, и выдача Bert являлась ответом. Недостатком использования одного лишь Bert также было получение не совсем удовлетворительного списка слов, подходящих по контексту использования, но не являющихся близкими синонимами заданного.

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

Далее, по результатам экспериментов, word2vec был заменен на fasttext (логический наследник word2vec), показывающий лучшие результаты. Была использована готовая модель, предобученная на статьях из Wikipedia, а модель Bert была заменена на улучшенную модель Roberta, смотри ссылку на предобученную модель.

Итоговый алгоритм не требует использования именно fasttext или Roberta в качестве составных частей. Обе подсистемы могут быть заменены альтернативными, способными решить схожие задачи. Кроме того, для лучшего результата предобученной модели могут быть fine-tuned, либо обучены с нуля.

Описание инструмента sugsyn

Работа с sugsyn, удобней всего осуществляется через CLI. Требуется скачать последнюю версию бинарного релиза, использование NlpCraft через maven central в данном случае будет недостаточно.

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

Пример. Пусть некий элемент какой-то модели сконфигурирован с помощью двух синонимов: ping и buzz (сокращенный вариант модели, взятой из примера с будильником), и пусть единственный интент модели содержит два примера: Ping me in 3 minutes и In an hour and 15mins, buzz me. Тогда sugsyn пошлет на ContextWordServer 4 запроса:

• text=ping me in 3 minutes, index=0
• text=buzz me in 3 minutes, index=0
• text=in an hour and 15mins, ping me, index=6
• text=in an hour and 15mins, buzz me, index=6

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

Использование инструмента sugsyn

Приступим к работе

1. Запускам ContextWordServer, то есть сервер с готовыми, предобученными моделями.
   > cd ~/apache/incubator-nlpcraft/nlpcraft/src/main/python/ctxword
   > ./bin/start_server.sh
   
   Обратите внимание на то, что ContextWordServer должен быть предварительно проинсталирован и для успешной работы ему требуется python версий 3.6 3.8. См. install_dependencies.sh для linux и mac или мануал по установке для windows. Имейте в виду, что процесс инсталляции влечет за собой скачивание файлов моделей существенных размеров, будьте внимательны.
   
2. Запускаем CLI, стартуем в нем server и probe с подготовленной моделью, подробности см. в разделе Quick Start. Для начальных экспериментов можно подготовить свою собственную модель или воспользоваться уже имеющимися в поставке примерами.
3. Используем команду sugsyn, с одним обязательным параметром идентификатором модели, которая должна быть уже запущена в probe. Второй, необязательный параметр значение минимального коэффициента достоверности результата, поговорим о нем ниже.

Все описанное выше расписано шаг за шагом в мануале по ссылке.

Получение результатов для разных моделей

Начнем с примера по прогнозу погоды. Элемент wt:phen сконфигурирован с помощью множества синонимов среди которых rain, storm, sun, sunshine, cloud, dry и т.д., а элемент wt:fcast с помощью future, forecast, prognosis, prediction и т.д.

Вот часть ответа sugsyn на запрос со значением коэффициента minScore = 0.
> sugsyn --mdlId=nlpcraft.weather.ex --minScore=0

"wt:phen": [   { "score": 1.00000, "synonym": "flooding" },   ...   { "score": 0.55013,  "synonym": "freezing" },   ...   { "score": 0.09613, "synonym": "stop"},   { "score": 0.09520, "synonym": "crash" },   { "score": 0.09207, "synonym": "radar" },   ..."wt:fcast": [   { "score": 1.00000, "synonym": "outlook" },   { "score": 0.69549, "synonym": "news" },   { "score": 0.68009, "synonym": "trend" },   ...   { "score": 0.04898, "synonym": "where" },   { "score": 0.04848, "synonym": "classification" },   { "score": 0.04826, "synonym": "the" },   ...

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

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

"lc:loc": [   { "score": 1.00000, "synonym": "apartment" },   { "score": 0.96921, "synonym": "bed" },   { "score": 0.93816, "synonym": "area" },   { "score": 0.91766, "synonym": "hall" },   ...   { "score": 0.53512, "synonym": "attic" },   { "score": 0.51609, "synonym": "restroom" },   { "score": 0.51055, "synonym": "street" },   { "score": 0.48782, "synonym": "lounge" },   ...

Но около коэффициента 0.5 для нашей модели уже попадается откровенный мусор street.

Для элемента x:alarm модели будильник, с синонимами: ping, buzz, wake, call, hit и т.д. имеем следующий результат:

"x:alarm": [   { "score": 1.00000, "synonym": "ask" },   { "score": 0.94770, "synonym": "join" },   { "score": 0.73308, "synonym": "remember" },   ...   { "score": 0.51398, "synonym": "stop" },   { "score": 0.51369, "synonym": "kill" },   { "score": 0.50011, "synonym": "send" },   ... 

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

Для элемента x:time модели текущее время (1, 2), с синонимами типа what time, clock, date time, date and time и т.д. имеем следующий результат:

"x:time": [   { "score": 1.00000, "synonym": "night" },   { "score": 0.92325, "synonym": "year" },   { "score": 0.58671, "synonym": "place" },   { "score": 0.55458, "synonym": "month" },   { "score": 0.54937, "synonym": "events" },   { "score": 0.54466, "synonym": "pictures"},   ...    

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

Оценка результатов

Перечислим факторы, от которых зависит качество синонимов, предлагаемых sugsyn для поиска в тексте элементов модели:

• Количество синонимов, определенных пользователем в конфигурации элементов.
• Количество и качество примеров запросов к интентам. Под качеством понимается естественность и распространенность добавленных примеров. Спросите гугл который час, и число полученных результатов будет примерно 2 630 000. Спросите час который, результатов будет примерно 136 000. Текст первого запроса более качественный, и для примера он подойдет лучше.
• Самое главное и непредсказуемое качество зависит от типа самого элемента и типа его модели.

Иными словами, даже при прочих равных условиях, таких как достаточное количество заранее сконфигурированных синонимов и примеров использования, для некоторых видов сущностей нейронная сеть предложит более качественный набор синонимов, а для некоторых менее качественный, и это зависит от природы самих сущностей и моделей. То есть для достижения сопоставимого уровня качества поиска, выбирая из списка предлагаемых к использованию синонимов, для разных элементов и разных моделей мы должны использовать разные значения минимального коэффициента достоверности предлагаемых вариантов. В целом это вполне объяснимо, так как даже одни и те же слова в разных смысловых контекстах могут быть заменены несколько разными наборами слов заменителей. Предобученная модель, используемая по умолчанию с ContectWordServer может быть адаптирована для одних типов сущностей лучше чем для других, однако перенастройка модели может и не улучшить итоговый результат. Так как Apache NlpCraft это opensource решение, вы всегда можете изменить все настройки модели, как параметры, так и саму модель с учетом специфики вашей предметной области. К примеру, для специфичной, изолированной области, имеет смысл обучить модель bert с нуля, поскольку данных об этой области в стандартной модели может оказаться недостаточно.

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

Заключение

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

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

Также поделюсь видео с моего недавнего выступления на онлайн-конференции Применение ML в Digital-продуктах, которую проводили коллеги из AGIMA и Epoch8.


В этом посте мы разберём следующее:

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

Вступление

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

отсутствие готовых датасетов;
отсутствие чёткой структуры классов, на которые можно разделить данные;
наличие сырых логов, в которых могут быть интересующие нас данные;
сильный дисбаланс классов, где самый многочисленный класс это класс нерелевантной информации.

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

Как мы используем BERT для задач NLU

Для начала поговорим немного об обработке естественного языка в контексте задач его понимания (natural-language understanding).

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

Для перевода слов и предложений в векторы используются разные подходы, но наиболее успешные нейронные сети на базе архитектуры трансформеров. По доброй традиции языковые модели на базе трансформеров называют иногда как маппетов, персонажей Улицы Сезам.
В свое время мы взяли модель от Google под названием BERT, обучили ее для русского языка и доработали под свои собственные задачи.



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



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

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

Находим первичные данные для нашей задачи

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

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



Или же можно поискать дополнительные полезные источники информации. Этим способом воспользовались и мы. Помните, в детстве в журналах были такие разделы, где люди искали себе друзей по переписке? Они писали: Хей, меня зовут Ибрагим, я слушаю Blink-182, катаюсь на скейте. Давайте меняться напульсниками!. Мы нашли датасет подобных анкеточных писем, где не было личных данных или индексов, но предложения, реплики, где люди рассказывали о своих интересах, там присутствовали. Таким образом мы получили первую пару сотен реплик о том, где люди рассказывают что-то о себе, о каких-то своих предпочтениях.

Обогащаем датасет с помощью парафраз

Отлично, у нас есть первичный датасет. Теперь нам нужно его как-то обогатить.

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

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

Векторы, в которые мы кодируем наше предложение, по своей сути являются точками в признаковом пространстве. Что это значит? Это значит, что предложения, схожие по смыслу или по какому-то другому признаку, скорее всего, будут располагаться рядом. Например, предложения Мне нравится группа Metallica. и Я обожаю слушать тяжелую музыку. будут располагаться где-то рядом друг с другом. Это значит, что мы можем попробовать найти похожие по смыслу или синонимичные предложения к размеченным примерам, которые у нас уже есть. Такие предложения называют парафразами. Можно для каждого исходного предложения, для которого нам известен его класс, провести быстрый поиск ближайших соседей. Для этого можно воспользоваться библиотеками FAISS от Facebook, ScaNN от Google или другими и найти парафразы с определенным порогом по расстоянию. Таким образом можно обогатить изначальный датасет. И, условно, если у нас была пара сотен реплик, теперь мы можем получить пару тысяч реплик или предложений, где люди что-то рассказывали о своих интересах и предпочтениях.

Получаем полезную часть большого датасета

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



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

Кластеризуем данные, чтобы определить возможные будущие классы

Предложения, которые представлены точками в признаковом пространстве, могут образовывать группы, объединенные конкретным признаком. К примеру, группой может являться набор предложений, где люди рассказывают о любимой музыке, о любимых сериалах или книге. Поэтому можно взять все предложения, векторизовать их с помощью BERT, понизить размерность с помощью UMAP (потому что исходная размерность векторов BERT это 1024, если мы говорим про large модель). И затем кластеризовать полученные векторы с пониженной размерностью алгоритмом HDBSCAN. Таким образом можно получить группы и просмотреть глазами случайные предложения в них, чтобы понять, о чем люди рассказывают в диалогах. Теперь можно подумать, какие могут быть классы, подходящие под нашу задачу, и какое между этими классами распределение.



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

Немного о разметке данных

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

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

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

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

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

Предложения, в которых модель была уверена, но при этом ее предсказания не совпадают с проставленной разметчиком меткой, можно отправить на доразметку. Условно, дать задание: Выберите один из двух классов: либо представленный моделью, либо разметчиком. Переразметив всего 5% исходного датасета, можно здорово повысить его чистоту, а значит и качество работы будущей модели. Либо, если вы уверены в результатах работы модели, вы можете с ее помощью проставить автоматические теги.

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

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

Внедрение модели и оценка метрик

Теперь нужно внедрять саму модель. Здесь мы активно используем практики MLOps. Во-первых, мы активно версионируем все наши модели не только с датасетом и кодом, но и между собой. Для этого мы используем DVC, потому что особенно важно, когда у вас двухступенчатая архитектура, версионировать модели между собой, чтобы была консистентность и между большой моделью-векторизатором (в нашем случае BERT), и между маленькими нейронными сетями, которые решают свои собственные задачи.

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

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

Итоги

Подведем итоги. Для того, чтобы определить интересы и предпочтения пользователей на базе их диалогов с виртуальным ассистентом, необходимо:

собрать первичный датасет с корректной разметкой;

обогатить его с помощью поиска ближайших соседей;

построить первую модель простой бинарной классификации (поможет нам вычленить максимально полезный участок датасета);

кластеризовать данные и оценить полученные классы и распределения;

обучить конечную модель (завернув всё в пайплайны, версионировав);

оценить результаты по метрикам.



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

***
Оставлю здесь ссылки по теме:

пост про то, как мы обучали BERT и как сделали его устойчивым для парафраз;
лекция моего коллеги для Sberloga о том, какие трюки мы использовали, чтобы сделать нашу модель лучше;
одна из итераций модели Bert-large для русского языка, которую мы используем, выложена в open source и доступна любому;
рассказ о том, как мы с коллегами из Сбера обучили и выложили в открытый доступ русскоязычную модель GPT-3.

Вы наверняка знакомы с ситуацией, когда при обращении в какую-либо крупную организацию приходится подавать целый пакет документов, точнее пакет их сканов. И это в век цифры! Теперь посмотрите на это глазами второй стороны и представьте, что у вас миллионы таких заявок со сканами, и они не содержат информации о границах документов. Апокалипсис? Всё придётся сегментировать вручную? К счастью, существуют алгоритмы автоматической сегментации потоков многостраничных документов. Здесь мы расскажем о новом подходе в сегментации с использованием модели BERT.

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

В классификации документов модель BERT (Bidirectional Encoder Representations for Transformers) уже применялась ранее. Но для задачи сегментации, насколько нам известно, это первая работа с использованием этой языковой модели.

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

Как это работает

Cегментация потоков документов (Page Stream Segmentation PSS) и сопутствующая задача классификации (Document Image Classification DIC) исследовались многими авторами. В работе Wiedemann, Heyer (2019) сделан обзор многих таких исследований, и среди них выделены два подхода к PSS и DIC: с помощью системы правил (Rule-Based Systems RBS) и с применением машинного обучения.

Системы RBS (Karpinski and Belaid, 2016; Hamdi at el. 2017) подразумевают выделение из распознанного текста с помощью регулярных выражений специальных дескрипторов, определяющих границы документов в потоке. Дескрипторами могут быть приветственные фразы, названия частотных сущностей, номера страниц, layout-признаки: размеры шрифтов, расположение сущностей на странице и др. RBS может оказаться довольно эффективным для однородных (homogeneous) датасетов с хорошим качеством сканов и определённой структурой документов, встречающихся, в частности, в бизнес-документации (счета, накладные, письма и т.п.). Но для RBS необходимо составлять вручную правила для выделения дескрипторов, что является несомненным минусом на датасетах с сильно разрозненными тематиками (heterogeneous datasets).

Подходы с применением машинного обучения (Rusinol at el. 2014; Daher, Belaid, 2014; Agin at el. 2015) и глубокого машинного обучения (Harley at el. 2015; Noce at el. 2016; Gallo at el. 2016; Wiedemann, Heyer, 2019) кажутся более привлекательными, поскольку не требуют глубокого погружения в суть текстов документов, как в RBS. Обучение в этих подходах в основном проводилось на текстовых и визуальных признаках и их комбинациях. Также применялось объединение (fusion) отдельных моделей на текстовых и визуальных признаках, когда одна модель может уточнить результат другой модели и в итоге улучшить общий результат.

В работе Harley at el. (2015) для классификации документов из датасета RVL-CDIP, введённого в этой же работе, используются глубокие свёрточные нейросети CNN на визуальных признаках. В работах Noce at el. (2016) и Gallo at el. (2016) для классификации документов применяются нейросети и трансфер-лёрнинг. В работе Gallo at el. (2016) классификация (DIC) строится только на визуальных признаках, но для повышения качества используются признаки соседних страниц. При этом автоматически решается задача сегментации (PSS): если предсказанный класс текущей страницы отличается от класса предыдущей, значит, начался новый документ. Стоит отметить, что сегментация (PSS) на основе классификации (DIC) имеет большой недостаток: она не разделяет документы одного и того же класса. Если в датасете сильно доминирует какой-либо класс, то сегментация (PSS) на основе классификации (DIC) практически бесполезна, поскольку уже разделённые потоки одного класса необходимо повторно разделять.

В работах Daher, Belaid (2014), Agin at el. (2015), Hamdi at el. (2018), Wiedemann, Heyer (2019) для нахождения границ документов в потоках довольно эффективно используется бинарная классификация: для каждой пары соседних страниц из потока модель предсказывает, является ли следующая страница в паре продолжением документа (SD Same Document) или начался новый документ (ND New Document). В работе Wiedemann, Heyer (2019) задача PSS решается с помощью бинарной классификации (SD/ND) с использованием комбинации текстовых и визуальных признаков и с применением глубоких нейросетей.

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

Идея использования модели BERT в задаче сегментации

Модели машинного обучения на основе BERT получили большую популярность, поскольку с их помощью были улучшены, и порой существенно, оценки многих задач NLP (Natural Language Processing).

Модель BERT сначала предобучают на широких корпусах текстов, а затем используют для решения конкретных задач, в том числе и на небольших датасетах. Во время предобучения модель решает две задачи: MLM (Masked Language Model) и NSP (Next Sentence Prediction). В задаче MLM случайно метится (маскируется) определённая доля токенов (слов или частей слов) входной последовательности, и задача состоит в том, чтобы восстановить значения токенов, которые были замаскированы. Задача NSP это бинарная классификация на парах предложений (или спанов текстов), когда нужно предсказать, является ли второе предложение (или спан текста) логичным продолжением первого. При решении конкретных задач предобученный BERT используют для трансфер лёрнинга, извлекая признаки из текста. В случае файн-тюнинга модель BERT делают составной частью специализированной модели, и его вес меняется вместе с весом этой модели. Более подробно о принципах построения этой модели мы рассказывали в нашем предыдущем посте о классификации документов.

Касательно нашей задачи: зачастую начало текста текущей страницы многостраничного документа является логичным продолжением конца текста предыдущей страницы и модель BERT, предобученная на задаче NSP, может улавливать сложные контекстные зависимости этих кусков текстов. Мы предполагаем, что сможем извлекать с помощью BERT сильные текстовые признаки на парах страниц для бинарной классификации (SD/ND).

Генерация входов модели

Мы будем решать задачу сегментации PSS на нашем закрытом датасете (Documents for Credit Dataset DCD), составленном из документов, предоставляемых компаниями для получения кредита в Банке ВТБ.

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

Бизнес-подразделениями банка были выделены около 300 категорий документов. Из них 10 базовых категорий: договор аренды, выписка из реестра участников, устав компании, свидетельство о постановке на учет в налоговом органе, вопросник для юридических лиц, паспорт РФ, лист записи ЕГРЮЛ, свидетельство о государственной регистрации юридического лица, приказы/распоряжения, решения/протоколы, а другие менее значимые документы отнесем к категории Иное.

Поскольку у нас не так много оригинальных неразделённых потоков (метки принадлежности к потокам не сохранялись после разделения), мы вынуждены были генерировать потоки заново из уже сегментированных документов, чтобы они были приближены по составу к потокам, поступающим на сегментацию:

• Каждый поток должен содержать по одному документу из каждой базовой категории.
• Каждый поток должен содержать три документа из категории Иное.
• К 2% потоков из каждой выборки добавляются ещё по два документа из каждого базового класса.
• 81% одно- и многостраничных документов датасета использовались для генерации потоков Train, 9% для генерации потоков Dev, и 10% для генерации потоков Test.
• Для формирования потока отдельные документы внутри потока перемешиваются случайным образом с сохранением порядка страниц внутри документа.

Согласно этим правилам мы сгенерировали 10000 потоков для Train, 2000 потоков для Dev, 2000 потоков для Test.

Потоки из Train мы случайным образом перемешали, выставили потоки друг за другом и получили один длинный поток, в котором пары соседних страниц (вернее, извлечённые из них признаки) и их метки (Same Document или New Document) будут, соответственно, входами и целевыми метками нашей будущей модели бинарной классификации. Аналогично из потоков получаем входы и целевые метки для Dev и Test.

Наш подход

Для решения задачи сегментации PSS мы будем использовать бинарную классификацию SD (Same Document) и ND (New Document), описанную выше во введении. В качестве признаков наша модель получает эмбеддинг пары соседних страниц, составленный из визуальных эмбеддингов каждой из страниц, и одного общего текстового эмбеддинга, полученного сразу для пары. Число пар страниц по каждой выборке Train/Dev/Test можно посмотреть в таблице 1.

Визуальный эмбеддинг каждой страницы вектор длины 512 мы получаем как выход предпоследнего слоя CNN ResNet34, He at al. (2015).

Текстовый эмбеддинг, общий для пары страниц, получаем с помощью модели RuBERT (Russian, cased, 12-layer, 768-hidden, 12-heads, 180M parameters) от DeepPavlov. Для этого на вход модели подаем вектор из 512 токенов следующего вида: на первом месте CLS-токен, потом N (информационных) токенов, соответствующих спану текста конца первой страницы из пары, далее (разделяющий) SEP-токен, потом M (информационных) токенов, соответствующих спану текста начала второй страницы из пары, и потом снова SEP-токен. Суммарное число информационных токенов, которое можно разместить во входном векторе, не более 509: N + M <= 509. Мы хотим как можно эффективнее использовать возможности модели BERT, поэтому стремимся максимально заполнить входной вектор модели токенами.

Схема получения текстовых признаков для пары страниц. Ti,j токен с номером i в тексте страницы j. Для удобства отображения отсчёт токенов страницы 1 идёт с конца.

Поскольку RuBERT предобучен на задачу NSP, то CLS-эмбеддинг (вектор длины 768) должен содержать в себе наиболее полную информацию, является ли второй текст логическим продолжением первого. Его и возьмём в качестве общего эмбеддинга для пары страниц.

Бейслайн
Итак, для каждой пары страниц два визуальных эмбеддинга (два вектора длины 512) и один текстовый эмбеддинг (вектор длины 768) объединяются в один общий визуально-текстовый эмбеддинг (вектор длины 1792). Далее на таких эмбеддингах строится бинарная классификация SD (Same Document) / ND (New Document) на основе MLP (Multi Layer Perceptron) с одним скрытым слоем нейронов длины 896, dropuout 0.3. Это наш бейслайн.

Общая схема модели

Основная модель
Следующим шагом мы провели дообучение (further-pretraining) модели RuBERT на обеих задачах MLM и NSP на нашем датасете DCD. Повторно сняли визуально-текстовые признаки, как в бейслайн, и на них построили бинарную классификацию на основе модели MLP с одним скрытым слоем нейронов длины 896 и dropout 0.3. В итоге получили основную модель улучшенного качества.

Результаты

Даже без дообучения модель BERT даёт приемлемое качество 0.9669. А после дообучения на нашем датасете, как и ожидалось, качество ещё немного улучшилось до 0.9819, при этом существенно увеличилась kappa.

Заключение

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

С тех пор как в 2018 году был представлен BERT, исследования в области обработки естественного языка охвачены новой парадигмой: использованием больших объемов существующего текста для предварительного обучения параметров модели на основе самообучения (self-supervision), не требующего разметки данных. Таким образом, вместо того, чтобы обучать модель для обработки естественного языка (NLP) с нуля, можно взять предобученную модель, уже имеющую некоторое знание о языке. Однако, для успешного применения этого нового подхода в NLP исследователю необходимо иметь некоторое представление о том, что же именно способствует языковому обучению модели: высота нейронной сети (т.е. количество слоев), ее ширина (размер представлений скрытых слоев), критерий обученности для самообучения или что-то совсем иное?

В статье ALBERT: облегченный BERT для самообучения языковым представлениям, принятой на ICLR 2020, была представлена обновленная версия BERTа, которая показывает более высокие результаты в 12 задачах обработки языка, включая соревнование Stanford Question Answering Dataset (SQuAD v2.0) и бенчмарк RACE для понимания текстов из экзаменов SAT. ALBERT выпускается в качестве открытого решения поверх TensorFlow и включает в себя несколько готовых к использованию предобученных языковых моделей.

Что повышает качество NLP моделей?

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

Ключом к оптимизации модели, заложенным в архитектуру ALBERT, является более эффективное распределение ее ресурсов. Входные эмбеддинги (слова, суб-токены и т.д.) выучивают векторные представления, независимые от контекста: например, представление слова bank. Эмбеддинги скрытых слоев, напротив, должны уточнять значения этих векторных представлений в зависимости от конкретного контекста: например, вектор bank как финансового учреждения или как берега реки.

Это достигается путем факторизации параметризации эмбеддингов: матрица эмбеддингов разделяется между векторами входного слоя с относительно небольшой размерностью (например, 128), в то время как вектора скрытого слоя используют бОльшие размерности (768, как в случае с BERT'ом, и больше). Только с помощью этого шага, при прочих равных, ALBERT на 80% снижает количество параметров проекционного блока ценой лишь незначительного падения производительности 80.3 балла вместо 80.4 для SQuAD2.0 и 67.9 вместо 68.2 для RACE.

Другое важное изменение в архитектуре ALBERT связано с исследованием избыточности. Архитектуры нейронных сетей на основе Трансформера (такие как BERT, XLNet и RoBERTa) полагаются на независимость слоев, расположенных друг над другом. Однако было замечено, что зачастую нейросеть выучивается выполнять схожие операции на разных уровнях, используя различные параметры сети. Эта возможная избыточность устраняется в ALBERT с помощью обмена параметрами между слоями, и, таким образом, один и тот же слой применяется друг к другу. И хотя такой подход немного снижает точность (accuracy), более компактный размер самой модели оправдывает потерю в качестве. Подобный обмен обеспечивает снижение параметров для блока с механизмом внимания внимания на 90% (общее снижение на 70%), что при применении в дополнение к факторизации параметризации эмбеддингов приводит к небольшому снижению показателей: до 80.0 (-0.3) для SQuAD2.0 и до 64.0 (-3.9 балла) для RACE.

Внедрение двух представленных изменений рождает модель ALBERT-base, которая имеет всего 12 миллионов параметров, что на 89% меньше базовой модели BERT, но при этом обеспечивает достойное качество в рассмотренных бенчмарках. Вместе с тем подобное уменьшение количества параметров дает возможность и дальнейшего масштабирования. Если объем памяти позволяет, можно увеличить размер эмбеддингов скрытого слоя в 10-20 раз. При размере скрытого слоя 4096 конфигурация ALBERT-xxlarge обеспечивает как общее снижение параметров на 30% по сравнению с моделью BERT-large, так и, что более важно, значительный прирост качества: +4.2 для SQuAD2.0 (88.1 по сравнению с 83.9) и +8.5 для RACE (82.3 по сравнению с 73.8).

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

Показатели оптимизированной модели на наборе данных RACE

Чтобы оценить способность модели понимать язык, можно провести тест на понимание прочитанного (например, схожий с SAT Reading Test). Крупнейший общедоступный ресурс для этой цели набор данных RACE (2017 г.). То, как компьютер справляется с этим испытанием, хорошо отражает достижения в области языкового моделирования последних лет: модель, предварительно обученная только на контекстно-независимых представлениях слов, получает низкие баллы в этом тесте (45.9; крайний левый столбик), в то время как BERT, получивший контекстно-зависимое знание языка, справляется достаточно хорошо 72.0 балла. Усовершенствованные модели BERT, такие как XLNet и RoBERTa, установили планку еще выше в диапазоне 8283 баллов. Конфигурация ALBERT-xxlarge, упомянутая выше, дает оценку RACE в том же диапазоне (82.3) при обучении на наборе данных базового BERT'a (Википедия и Книги). Однако при обучении на том же расширенном наборе данных, что и XLNet и RoBERTa, она значительно превосходит все существующие на сегодняшний день подходы и устанавливает новую оценку в 89.4.

Показатели моделей в бенчмарке RACE (задача на понимание текстов из экзаменов SAT). Оценка для случайного предсказания составляет 25.0. Максимально возможный балл 95.0.

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

Авторы

• Авторы оригинала Radu Soricut, Zhenzhong Lan
• Перевод Смирнова Екатерина
• Редактирование и вёрстка Шкарин Сергей

За последние несколько лет были сделаны значительные успехи в области обработки естественного языка (NLP), где такие модели, как BERT, ALBERT, ELECTRA и XLNet достигли поразительной точности (accuracy) в различных задачах. Во время предварительного обучения (pre-training) на основе обширного корпуса текстов (например, Википедии) формируются векторные представления, которые получают путем маскирования слов и попыток их предсказать (т.н. маскированное языковое моделирование). Получившиеся представления кодируют большой объем информации о языке и отношениях между понятиями, например, между хирургом и скальпелем. Далее начинается второй этап обучения тонкая настройка (fine-tuning) на котором модель использует заточенные под определенную задачу данные для того, чтобы с помощью общих предобученных представлений научиться выполнять конкретные задачи вроде классификации. Учитывая широкое использования подобных моделей в разных NLP задачах, критически важно понимать, какая информация в них содержится и как любые выученные отношения влияют на результаты модели в ее приложениях, чтобы обеспечить их соответствие Принципам искусственного интеллекта (ИИ).

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

Измерение корреляций

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

Классическая академическая формулировка этого задания тест OntoNotes (Hovy et al., 2006). На этих данных авторы оценивали с помощью F1-меры, насколько точно модель справляется с разрешением кореференции (как в Tenney et al. 2019). Так как OntoNotes представляет только одно распределение данных, авторы также рассмотрели бенчмарк WinoGender, который предоставляет дополнительный набор сбалансированных данных, составленный для нахождения случаев, когда ассоциативные связи модели между гендером и профессией способствуют неправильному разрешению кореференции. Высокие (близкие к 1) значения метрики WinoGender означают, что модель основывается на нормативных ассоциациях между полом и профессией (т.е. относит слово nurse к человеку женского пола, а не мужского). Когда предсказание модели не имеет никакой устойчивой корреляции пола и профессии, метрика равна нулю, что означает, что модель предсказывает на основе какой-то другой информации, например структуры или семантики предложения.

Метрики BERT и ALBERT на заданиях OntoNotes (точность) и WinoGender (гендерные корреляции). Низкие значения метрики WinoGender означают, что модель в своих предсказаниях в первую очередь руководствуется корреляциями, отличными от гендерных.

Настоящее исследование демонстрирует, что ни большая модель (Large) BERT, ни общедоступная модель ALBERT не достигают нулевого значения на примерах из WinoGender, несмотря на впечатляющие (близкие к 100%) показатели точности (accuracy) на задании OntoNotes. По меньшей мере отчасти это можно объяснить тем, что модель руководствуется преимущественно гендерными корреляциями в своих предсказаниях. Это неудивительно: существует ряд ключей к пониманию текста, и общая модель может воспринимать некоторые или даже все из них. К этому следует отнестись внимательно, т.к. крайне нежелательно, чтобы модель делала предсказания, основываясь преимущественно на гендерных корреляциях, а не на свидетельствах, встреченных в тексте на входе модели.

Лучшие практики

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

• Измеряйте нежелательные корреляции: Качество модели может быть измерено с помощью метрик точности, но они оценивают результаты только в одной плоскости, особенно если тестовые данные из того же распределения, что и данные для обучения. Например, веса BERT и ALBERT всего на 1% отличаются по метрике точности, однако на целых 26% по степени использования гендерных корреляций для разрешения кореференции. Эта разница может иметь большое значения в некоторых задачах: так, выбор модели с наименьшим значением метрики WinoGender может быть более предпочтителен в приложениях, где есть тексты о людях, профессии которых могут не соответствовать исторически сложившимся социальным нормам, таких, как, например, медбрат (male nurse).

  
  

• Будьте осторожны при внесении на первый взгляд безобидных изменений в конфигурацию: Процесс обучения нейронных сетей регулируется множеством гиперпараметров, которые обычно подбираются для наилучшего достижения целей обучения. И хотя выбор конфигурации обычно кажется безобидным, авторы обнаружили, что он может значительно влиять на гендерные корреляции, как в лучшую, так и в худшую сторону. Это справедливо, например, в случае с дропаут-регуляризацией (dropout regularization), которая используется для снижения переобучения больших моделей: при увеличении показателя дропаута (dropout rate) в предварительном обучении BERT и ALBERT, наблюдается значительное снижение показателя гендерных корреляций даже после тонкой настройки. Это означает, что простым изменением конфигурации можно снизить риск нежелательных корреляций, однако это также демонстрирует, что нужно внимательно относиться к любым изменениям в модели.

  
  

• Используйте возможности для снижения нежелательных последствий: Еще одним следствием возможного неожиданного влияния дропаута на гендерные корреляции является возможность использования универсальных методов для уменьшения непреднамеренных корреляций: так, в ходе своего исследования авторы выяснили, что увеличение показателя дропаута позволило модели лучше справляться с примерами WinoGender без уточнения вручную каких-либо параметров задачи или изменения этапа тонкой настройки. К сожалению, на OntoNotes с увеличением показателя дропаута точность начинает падать (что можно наблюдать в результатах BERT'а), однако сама возможность снижения нежелательных последствий на этапе предварительного обучения, когда изменения в конфигурации могут привести к улучшению модели без необходимости внесения каких-либо дополнительных изменений для решения конкретных задач, кажется очень перспективной. Авторы рассмотрели аугментацию контрфактическими данными как еще одну стратегию уменьшения нежелательных последствий с различными условиями (см. статью).

Что дальше

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

Авторы

• Авторы оригинала Kellie Webster
• Перевод Смирнова Екатерина
• Редактирование и вёрстка Шкарин Сергей

Введение

XLNet новейшая и самая крупная модель, появившаяся в активно развивающейся сфере обработки естественного языка (Natural Language Processing, NLP). Статья о XLNet объединяет современные достижения в NLP и инновационный подход к решению задачи языкового моделирования. Обученная на огромном корпусе, модель достигает выдающихся результатов в NLP-задачах бенчмарка GLUE.

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

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

Языковое моделирование

Языковое моделирование заключается в подсчете распределения совместной вероятности для последовательности токенов (слов), и зачастую достигается путем факторизации совместного распределения на распределение условной вероятности одного токена с учетом других токенов в последовательности. Например, дана последовательность: "New", "York", "is", "a", "city". Вероятность слова New модель подсчитает как $inline$Pr(\text{"New"} | \text{"is"}, \text{"a"}, \text{"city"})$inline$, т.е. вероятность того, что токен "New" находится в той же последовательности, что и токены "is", "a" и "city" (см. рис. 1).

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

Рис. 1. Языковая модель. Модель это функция, которая принимает на вход несколько контекстных токенов и выдает на выходе вероятность каждого токена в словаре. Толстыми линиями обозначены более информативные контекстные слова и более вероятные слова из словаря.

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

Стоя на плечах моделей-гигантов

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

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

У Трансформеров есть один недостаток: они работают с последовательностями фиксированной длины. Но что, если знание того, что "New" должно появиться в предложении "____ York is a city", также требует, чтобы модель прочитала что-то об Эмпайр-стейт-билдинг в предыдущем предложении? Transformer-XL решает эту проблему, позволяя текущей последовательности видеть информацию из предыдущих последовательностей. Именно на этой архитектуре строится XLNet.

Цель обучения XL

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

В бывшей SOTA-модели (BERT) целью обучения было восстановление маскированных слов в предложении: так, для каждого предложения в корпусе некоторые токены заменяются универсальным токеном [mask]. Задача модели восстановить изначальные токены.

Рис. 2. Изображение модели BERT. На входе модели контекстные токены, некоторые из которых маскированы. Обращая внимание на правильные токены контекста, модель узнает, что наиболее вероятным словом в маскированной позиции будет "boat".

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

Языковая модель должна кодировать как можно больше информации и нюансов из текста. Модель BERT пытается восстановить маскированные слова в предложении "The [mask] was beached on the riverside" (рисунок 2) ("[mask] была выброшена на берег реки"). Здесь могут встречаться такие слова, как "лодка" или "каноэ". BERT может знать это, потому что лодка может быть выброшена на берег, и ее часто можно найти на берегу реки. Но для BERT'а вовсе необязательно знать это про лодку, достаточно костыля вроде упоминания "берег реки", чтобы сделать вывод, что "лодка" является маскированным токеном.

Более того, BERT предсказывает маскированные токены независимо, поэтому не узнает, как они влияют друг на друга. Если бы пример был "The [mask] was [mask] on the riverside" ("[mask] была [mask] на берег реки"), то BERT мог выдать высокие вероятности не только для таких корректных пар, как ("лодка", "выброшена") и ("парад", "виднелся"), но и для пары ("парад", "выброшен").

Такие подходы, как BERT и ELMo, стали в свое время SOTA за счет включения в предсказание левого и правого контекстов. XLNet пошла еще дальше: модель предназначена для предсказания каждого слова в последовательности, используя любую комбинацию других слов в этой последовательности. XLNet могут попросить предсказать, какое слово может следовать за "The" в нашем предложении. Вероятно, много слов, но "лодка" более вероятна, чем "они", потому что модель уже кое-что узнала о лодке (в основном, что это не местоимение). Затем модель могут попросить предсказать второе слово, учитывая, что последующие слова "была" и "выброшена". И затем ее могут попросить предсказать четвертое слово, учитывая, что третье "был", пятое "на" и седьмое "берег реки.

Рис. 3. Изображение модели XLNet. Задача рассчитать, что лодка является вероятным токеном для многих различных контекстов, взятых из последовательности.

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

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

В следующих нескольких разделах будут рассмотрены более сложные аспекты статьи.

Перестановки

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

Авторегрессионные модели, такие как ELMo, позволяют также учиться отношениям между токеном и последующими токенами. Цель AR в этом случае может рассматриваться как . Это авторегрессия для обратной последовательности. Но зачем останавливаться? Ведь могут существовать отношения, интересные для задачи обучения, как между двумя ближайшими токенами , так и вообще для любой комбинации токенов .

XLNet предлагает в качестве цели обучения получить представление над всеми такими перестановками. Возьмем, например, последовательность $inline$\mathbf{x} = ["This", "is", "a", "sentence"]$inline$, где . Получится набор из всех 4! перестановок . Модель XLNet авторегрессионна для всех таких перестановок: она может посчитать вероятность токена , учитывая предыдущие токены для любого порядка из .

Например, можно вычислить вероятность третьего элемента с учетом двух предыдущих из любой перестановки. Три перестановки , и будут соответствовать $inline$Pr("a", | "This", "is")$inline$, $inline$Pr("sentence" | "This", "is")$inline$ и $inline$Pr("is" | "sentence", "a")$inline$. Схожим образом вероятность второго элемента с учетом первого можно выразить как $inline$Pr("is" | "This")$inline$, $inline$Pr("is" | "This")$inline$ и $inline$Pr("a" | "sentence")$inline$. Если же рассматривать все 4 позиции и все 4! перестановок, то модель будет учитывать все возможные зависимости.

Эти идеи включены в следующую формулу из статьи:

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

Маска внимания

Но в текущем представлении модели чего-то не хватает: откуда она знает о порядке слов? Модель может вычислить $inline$Pr("This" | "is")$inline$, а также $inline$Pr("This" | "a")$inline$. В идеале она должна кое-что знать об относительном положении "This" и "is", а также "a". В противном случае модель просто бы решила, что все токены в последовательности с равной вероятностью находятся рядом друг с другом. Нам нужна модель, которая предсказывает
$inline$Pr("This" | "is", 2)$inline$ и $inline$Pr("This" | "a", 3)$inline$, а для этого она должна знать индексы токенов контекста.

Архитектура Трансформера решает эту проблему, добавляя позиционную информацию в эмбеддинги токенов. Цель обучения можно представить как $inline$Pr("This" | "is+2")$inline$. Но в случае, если токены предложений действительно будут перемешаны, подобный механизм сломается. И здесь на помощь приходят маски внимания. Когда модель вычисляет контекст, который является входом для вычисления вероятности, она всегда использует один и тот же порядок токенов и просто маскирует те токены, которые не находятся в рассматриваемом контексте (т.е. те, которые поступают впоследствии в перемешанном порядке).

В качестве конкретного примера рассмотрим перестановку . При вычислении вероятности первого элемента в этом порядке (т.е. токена 3) модель не имеет контекста, поскольку другие токены еще не были поданы. Таким образом, маска будет . Для второго элемента (токен 2) маска равна , поскольку его единственный контекст это токен 3. Следуя этой логике, третий и четвертый элементы (токены 4 и 1) имеют маски и . Сложив все элементы в порядке токенов, получится матрица (как показано на рис. 2 статьи):

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

$inline$Pr("This"|\_\_\_,"is+2","a+3","sentence+4")$inline$

$inline$Pr("is"|\_\_\_,\_\_\_,"a+3",\_\_\_)$inline$

$inline$Pr("a"|\_\_\_,\_\_\_,\_\_\_,\_\_\_)$inline$

$inline$Pr("sentence"|\_\_\_,"is+2","a+3",\_\_\_)$inline$

Двухпотоковый механизм внутреннего внимания

Остается исправить одну ошибку: мы хотим, чтобы вероятность не только зависела от индексов токенов контекста, но и от индекса токена, вероятность которого вычисляется. Другими словами мы хотим вычислить $inline$Pr("This" | "1", "is+2")$inline$: вероятность "This" при условии, что это первый токен, а "is" второй. Но архитектура Трансформера кодирует позиционную информацию 1 и 2 внутри эмбеддинга для "This" и "is". Значит это должно выглядеть как $inline$Pr("This" | "This+1", "is+2")$inline$. К сожалению, модель теперь просто напросто знает, что токен "This" должен быть вероятен как часть предложения.

Решение этой проблемы двухпотоковый механизм внутреннего внимания. Каждая позиция токена имеет два связанных вектора на каждом слое внутреннего внимания : and . Векторы принадлежат потоку содержания (content stream), а векторы потоку запроса (query stream). Векторы потока содержания инициализируются эмбеддингами токенов, добавленными к позиционным эмбеддингам. Векторы потока запросов инициализируются общим вектором эмбеддинга , добавленного к позиционным эмбеддингам. Стоит отметить, что вектор будет одним и тем же независимо от токена, и поэтому не может использоваться для различения токенов.

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

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

На рисунке 4 показано, как подчитывается запрос для 4-го токена в -ом слое внутреннего внимания. Это показывает, что представляет собой совокупность "is + 2", "a + 3" и позиции 4, что в точности соответствует контексту, необходимому для вычисления вероятности токена "sentence".

Рис. 4. Двойной механизм внимания для подсчета четвертого токена в -ом слое внутреннего внимания. Стрелки указывают на передачу информацию от векторов. Пересечения линий и кругов указывают на подсчет и агрегацию операций запроса/ключа/значения механизма внутреннего внимания. Желтые линии обозначают обновления потока содержания для третьего символа (зависит только от себя самого) и второго символа (зависит от себя и от третьего символа). Голубые линии обозначают обновление потока запроса (зависит от себя, второго и третьего символа из потока содержания).

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

$inline$Pr("This"|*,"is+2","a+3","sentence+4")$inline$

$inline$Pr("is"|\_\_\_,*,"a+3",\_\_\_)$inline$

$inline$Pr("a"|\_\_\_,\_\_\_,*,\_\_\_)$inline$

$inline$Pr("sentence"|\_\_\_,"is+2","a+3",*)$inline$

Результаты

Работает ли все это? Краткий ответ да. Длинный ответ тоже да. Возможно, это не так уж и удивительно: XLNet опирается на предшествующие современные методы. Она была обучена на корпусе из 30 миллиардов слов (на порядок больше, чем тот, который использовался для обучения BERT'а, и был взят из более разнообразных источников), и это обучение потребовало значительно больше часов вычислительного времени, чем предыдущие модели:

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

Вероятно, более интересно, что исследование абляции XLNet показывает: XLNet работает лучше, чем BERT при честном сравнении (рис. 5). То есть когда модель обучается на том же корпусе, что и BERT, с использованием тех же гиперпараметров и того же количества слоев, она неизменно превосходит BERT. Что еще более интересно, XLNet также превосходит Transformer-XL в честном сравнении. Transformer-XL можно рассматривать как отказ от цели перестановки AR. Постоянное улучшение данного показателя свидетельствует об эффективности этого метода.

Результаты абляции

Рис. 5. Исследование абляции XLNet на четырех бенчмарках: RACE, SQuAD2.0 F1, MNLI mm и SST-2. Результаты сходны с результатами BERT на одном обучающем датасете. Различные столбцы представляют различные настройки обучения, описанные в части 3.7 статьи.

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

Авторы

• Авторы оригинала G. McGoldrick, Y. Cao, S. Prince
• Перевод Смирнова Екатерина
• Редактирование и вёрстка Шкарин Сергей