Руководство по модели кодировщика-декодера и механизму внимания | Эдуардо Муньос

Как мы упоминали ранее, мы заинтересованы в групповом обучении сети; поэтому мы создаем функцию, которая выполняет обучение пакета данных:

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

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

• Входная последовательность: массив целых чисел формы: [batch_size, max_seq_len, embedding dim] . Это входная последовательность для кодировщика.
• Целевая последовательность: Массив целых чисел формы: [batch_size, max_seq_len, embedding dim] .Это цель нашей модели, результат, который нам нужен для нашей модели.
• Целевая входная последовательность: Массив целых чисел формы: [batch_size, max_seq_len, embedding dim] . Это входная последовательность для декодера, потому что мы используем учитель, заставляющий .

Принуждение учителя

Принуждение учителя - это метод обучения, критически важный для разработки моделей глубокого обучения в НЛП. «Это способ быстрого и эффективного обучения повторяющихся моделей нейронных сетей, которые используют в качестве входных данных достоверную информацию из предыдущего временного шага.», [8]« Что учитель заставляет использовать рекуррентные нейронные сети? » Джейсон Браунли, доктор философии

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

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

- «Глубокое обучение» Иэна Гудфеллоу

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

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

Теперь мы можем закодировать основную функцию поезда:

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

Мы обучаем нашу модель кодировщика-декодера в течение ограниченного периода времени (примерно один час), используя 40 000 пар предложений и RNN из 512 единиц. Мы достигаем хороших результатов:

Делаем прогнозы

На этапе прогнозирования входными данными является последовательность длины один, токен sos . Затем мы повторно вызываем кодировщик и декодер, пока не получим токен eos или не достигнем максимальной заданной длины.

Вот несколько примеров полученных нами прогнозов:

 [«мы не пойдем», «почему тебе грустно?»] 
 [«нет вамос.  ',' ¿por que estas triste?  '] 

Трансформаторные модели кодировщика-декодера

 ! Pip install трансформаторы == 4.2.1
! pip install фраза == 0.1.95
  

Модель кодера-декодера на основе трансформатора была представлена ​​Васвани. и другие. в знаменитом Attention - это все, что вам нужно бумаги и сегодня это де-факто стандартная архитектура кодера-декодера при обработке естественного языка (НЛП).

В последнее время было проведено много исследований по разным предварительному обучению объективы для моделей кодеров-декодеров на базе трансформаторов, , например Т5, Барт, Пегас, ProphetNet, Мардж, и т. Д. ..., но модель архитектуры остался в основном прежним.

Цель сообщения в блоге - дать подробное объяснение как модели архитектуры кодера-декодера на основе трансформатора от последовательности к последовательности проблемы.Сфокусируемся на математической модели определяется архитектурой и тем, как модель может использоваться для вывода. Попутно мы дадим некоторую справочную информацию о последовательности в последовательность. модели в NLP и разбить кодировщик-декодер на базе трансформатора архитектура в его кодировщика и декодера частей. Мы предоставляем много иллюстрации и установить связь между теорией модели кодеров-декодеров на базе трансформаторов и их практическое применение в 🤗Трансформаторы для вывода.Обратите внимание, что это сообщение в блоге не объясняет , а не как такие модели можно обучить - это тема будущего блога Почта.

Модели кодировщиков-декодеров на базе трансформаторов являются результатом многолетней Исследование представлений , изучение архитектур моделей и . Этот Блокнот содержит краткое изложение истории нейронных кодировщики-декодеры модели. Для получения дополнительной информации читателю рекомендуется прочитать этот замечательный блог опубликовать Себастион Рудер. Кроме того, базовое понимание рекомендуется архитектура с самовниманием .Следующее сообщение в блоге автора Джей Аламмар служит хорошим напоминанием об оригинальной модели Transformer. здесь.

На момент написания этого блокнота «Трансформеры включают кодировщики-декодеры моделей T5 , Bart , MarianMT и Pegasus , которые кратко описаны в документации по модели резюме.

Ноутбук разделен на четыре части:

• Предпосылки - Краткая история моделей нейронных кодировщиков-декодеров дается с акцентом на модели на основе RNN.
• Кодер-декодер - Модель кодера-декодера на основе трансформатора представлена ​​и объясняется, как модель используется для вывод.
• Энкодер - Часть модели энкодера объяснена в деталь.
• Декодер - Декодерная часть модели объяснена в деталь.

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

Задачи генерации естественного языка (NLG), подполе NLP, являются лучшими выражаются как задачи от последовательности к последовательности.Такие задачи можно определить как поиск модели, которая отображает последовательность входных слов в последовательность целевые слова. Некоторые классические примеры - это суммирование и перевод . Далее мы предполагаем, что каждое слово закодировано в векторное представление. входные слова nnn могут быть представлены как последовательность входных векторов nnn:

X1: n = {x1,…, xn}. \ Mathbf {X} _ {1: n} = \ {\ mathbf {x} _1, \ ldots, \ mathbf {x} _n \}. X1: n = {x1,…, xn}.

Следовательно, проблемы от последовательности к последовательности могут быть решены путем нахождения отображение fff из входной последовательности nnn векторов X1: n \ mathbf {X} _ {1: n} X1: n в последовательность целевых векторов mmm Y1: m \ mathbf {Y} _ {1: m} Y1: m, тогда как число векторов-мишеней ммм априори неизвестен и зависит от входных данных последовательность:

f: X1: n → Y1: m.22 для решения задач от последовательности к последовательности следовательно, означает, что необходимо знать количество целевых векторов mmm apriori и должен быть независимым от ввода X1: n \ mathbf {X} _ {1: n} X1: n. Это неоптимально, потому что для задач в NLG количество целевых слов обычно зависит от ввода X1: n \ mathbf {X} _ {1: n} X1: n и не только на входной длине nnn. Например. , статья 1000 слов можно суммировать как до 200 слов, так и до 100 слов в зависимости от его содержание.

В 2014 г. Cho et al.33. После обработки последнего входного вектора xn \ mathbf {x} _nxn, Скрытое состояние кодировщика определяет входную кодировку c \ mathbf {c} c. Таким образом, кодировщик определяет отображение:

fθenc: X1: n → c. f _ {\ theta_ {enc}}: \ mathbf {X} _ {1: n} \ to \ mathbf {c}. fθenc: X1: n → c.

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

Математически декодер определяет распределение вероятностей целевая последовательность Y1: m \ mathbf {Y} _ {1: m} Y1: m с учетом скрытого состояния c \ mathbf {c} c:

pθdec (Y1: m∣c).{m} p _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {c}). pθdec (Y1: m ∣c) = i = 1∏m pθdec (yi ∣Y0: i − 1, c).

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

pθdec (yi∣Y0: i − 1, c), ∀i∈ {1,…, m}, p _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {c}), \ forall i \ in \ {1, \ ldots, m \}, pθdec (yi ∣Y0: i − 1, c), ∀ i∈ {1,…, m},

, то он может моделировать распределение любой последовательности целевого вектора, заданной скрытое состояние c \ mathbf {c} c путем простого умножения всех условных вероятности.

Так как же модель архитектуры декодера на основе RNN pθdec (yi∣Y0: i − 1, c) p _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _i | \ mathbf {Y} _ { 0: i-1}, \ mathbf {c}) pθdec (yi ∣Y0: i − 1, c)?

С точки зрения вычислений, модель последовательно отображает предыдущий внутренний скрытое состояние ci − 1 \ mathbf {c} _ {i-1} ci − 1 и предыдущий целевой вектор yi \ mathbf {y} _iyi до текущего внутреннего скрытого состояния ci \ mathbf {c} _ici и a вектор logit li \ mathbf {l} _ili (показано темно-красным цветом ниже):

fθdec (yi − 1, ci − 1) → li, ci.f _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _ {i-1}, \ mathbf {c} _ {i-1}) \ to \ mathbf {l} _i, \ mathbf {c } _i.fθdec (yi − 1, ci − 1) → li, ci. c0 \ mathbf {c} _0c0 таким образом определяется как c \ mathbf {c} c, являющийся выходом скрытое состояние кодировщика на основе RNN. Впоследствии softmax используется для преобразования вектора логита li \ mathbf {l} _ili в условное распределение вероятностей следующего целевого вектора:

p (yi∣li) = Softmax (li), где li = fθdec (yi − 1, cprev). p (\ mathbf {y} _i | \ mathbf {l} _i) = \ textbf {Softmax} (\ mathbf {l} _i), \ text {with} \ mathbf {l} _i = f _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _ {i-1}, \ mathbf {c} _ {\ text {prev}}).44. Из приведенного выше уравнения мы можно видеть, что распределение текущего целевого вектора yi \ mathbf {y} _iyi напрямую обусловлено предыдущим целевым вектором yi − 1 \ mathbf {y} _ {i-1} yi − 1 и предыдущим скрытым состоянием ci −1 \ mathbf {c} _ {i-1} ci − 1. Поскольку предыдущее скрытое состояние ci − 1 \ mathbf {c} _ {i-1} ci − 1 зависит от всех предыдущие целевые векторы y0,…, yi − 2 \ mathbf {y} _0, \ ldots, \ mathbf {y} _ {i-2} y0,…, yi − 2, он может быть заявлено, что декодер на основе RNN неявно ( например, косвенно ) моделирует условное распределение pθdec (yi∣Y0: i − 1, c) p _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {c}) pθdec (yi ∣Y0: i − 1, c).55, которые эффективно выбирают целевой вектор с высокой вероятностью последовательности из pθdec (Y1: m∣c) p _ {\ theta_ {dec}} (\ mathbf {Y} _ {1: m} | \ mathbf {c}) pθdec (Y1: m ∣c).

При таком методе декодирования во время вывода следующий входной вектор yi \ mathbf {y} _iyi может быть выбран из pθdec (yi∣Y0: i − 1, c) p _ {\ theta _ {\ text {dec}} } (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {c}) pθdec (yi ∣Y0: i − 1, c) и, следовательно, добавляется к входной последовательности, так что декодер Затем RNN моделирует pθdec (yi + 1∣Y0: i, c) p _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _ {i + 1} | \ mathbf {Y} _ {0: i }, \ mathbf {c}) pθdec (yi + 1 ∣Y0: i, c) для выборки следующего входного вектора yi + 1 \ mathbf {y} _ {i + 1} yi + 1 и т. д. в авторегрессивный мод.

Важной особенностью моделей кодеров-декодеров на основе RNN является определение специальных векторов , таких как вектор EOS \ text {EOS} EOS и BOS \ text {BOS} BOS. Вектор EOS \ text {EOS} EOS часто представляет собой окончательный входной вектор xn \ mathbf {x} _nxn, чтобы "указать" кодировщику, что вход последовательность закончилась, а также определяет конец целевой последовательности. В качестве как только EOS \ text {EOS} EOS выбирается из вектора логита, генерация завершено. Вектор BOS \ text {BOS} BOS представляет входной вектор y0 \ mathbf {y} _0y0, подаваемый в декодер RNN на самом первом этапе декодирования.Для вывода первого логита l1 \ mathbf {l} _1l1 требуется ввод, и поскольку на первом шаге не было создано никаких входных данных. специальный BOS \ text {BOS} BOS входной вектор поступает на декодер RNN. Хорошо - довольно сложно! Давайте проиллюстрируйте и рассмотрите пример.

Развернутый кодировщик RNN окрашен в зеленый цвет, а развернутый RNN декодер окрашен в красный цвет.

Английское предложение «Я хочу купить машину», представленное как x1 = I \ mathbf {x} _1 = \ text {I} x1 = I, x2 = want \ mathbf {x} _2 = \ text {want} x2 = хочу, x3 = to \ mathbf {x} _3 = \ text {to} x3 = to, x4 = buy \ mathbf {x} _4 = \ text {buy} x4 = buy, x5 = a \ mathbf {x} _5 = \ text {a} x5 = a, x6 = car \ mathbf {x} _6 = \ text {car} x6 = car и x7 = EOS \ mathbf {x} _7 = \ text {EOS} x7 = EOS переводится на немецкий: "Ich will ein Auto kaufen "определяется как y0 = BOS \ mathbf {y} _0 = \ text {BOS} y0 = BOS, y1 = Ich \ mathbf {y} _1 = \ text {Ich} y1 = Ich, y2 = will \ mathbf {y} _2 = \ text {will} y2 = will, y3 = ein \ mathbf {y} _3 = \ text {ein} y3 = ein, y4 = Auto, y5 = kaufen \ mathbf {y} _4 = \ text {Auto}, \ mathbf {y} _5 = \ text {kaufen} y4 = Auto, y5 = kaufen и y6 = EOS \ mathbf {y} _6 = \ text {EOS} y6 = EOS. 66.На рисунке выше горизонтальная стрелка, соединяющая развернутый кодировщик RNN представляет собой последовательные обновления скрытых штат. Окончательное скрытое состояние кодировщика RNN, представленное c \ mathbf {c} c, затем полностью определяет кодировку входных данных. последовательность и используется как начальное скрытое состояние декодера RNN. Это можно увидеть как преобразование декодера RNN на закодированный вход.

Для генерации первого целевого вектора в декодер загружается BOS \ text {BOS} BOS вектор, показанный как y0 \ mathbf {y} _0y0 на рисунке выше.Цель вектор RNN затем дополнительно преобразуется в вектор логита l1 \ mathbf {l} _1l1 с помощью уровня прямой связи LM Head для определения условное распределение первого целевого вектора, как объяснено выше:

pθdec (y∣BOS, c). p _ {\ theta_ {dec}} (\ mathbf {y} | \ text {BOS}, \ mathbf {c}). pθdec (y∣BOS, c).

Выбирается слово Ich \ text {Ich} Ich (показано серой стрелкой, соединяющей l1 \ mathbf {l} _1l1 и y1 \ mathbf {y} _1y1) и, следовательно, вторая цель вектор может быть выбран:

будет ∼pθdec (y∣BOS, Ich, c).\ text {will} \ sim p _ {\ theta_ {dec}} (\ mathbf {y} | \ text {BOS}, \ text {Ich}, \ mathbf {c}). will∼pθdec (y∣BOS, Ich, c).

И так далее, пока на шаге i = 6i = 6i = 6, вектор EOS \ text {EOS} EOS не будет выбран из l6 \ mathbf {l} _6l6, и декодирование не будет завершено. Результирующая цель последовательность составляет Y1: 6 = {y1,…, y6} \ mathbf {Y} _ {1: 6} = \ {\ mathbf {y} _1, \ ldots, \ mathbf {y} _6 \} Y1: 6 = {y1,…, y6}, что является «Ich will ein Auto kaufen» в нашем примере выше.

Подводя итог, модель кодера-декодера на основе RNN, представленная fθencf _ {\ theta _ {\ text {enc}}} fθenc и pθdec p _ {\ theta _ {\ text {dec}}} pθdec, определяет распределение p (Y1: m∣X1: n) p (\ mathbf {Y} _ {1: m} | \ mathbf {X} _ {1: n}) p (Y1: m ∣X1: n) к факторизация:

pθenc, θdec (Y1: m∣X1: n) = ∏i = 1mpθenc, θdec (yi∣Y0: i − 1, X1: n) = ∏i = 1mpθdec (yi∣Y0: i − 1, c), с c = fθenc (X).{m} p _ {\ theta _ {\ text {dec}}} (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {c}), \ text {with} \ mathbf {c} = f _ {\ theta_ {enc}} (X). pθenc, θdec (Y1: m ∣X1: n) = i = 1∏m pθenc, θdec (yi ∣Y0: i − 1, X1: n) = i = 1 ∏m pθdec (yi ∣Y0: i − 1, c), где c = fθenc (X).

Во время вывода эффективные методы декодирования могут авторегрессивно сгенерировать целевую последовательность Y1: m \ mathbf {Y} _ {1: m} Y1: m.

Модель кодера-декодера на основе RNN взяла штурмом сообщество NLG. В В 2016 г. компания Google объявила о полной замене разработанной услуги перевода с помощью единой модели кодировщика-декодера на основе RNN (см. здесь).44 Нейронная сеть может определять распределение вероятностей по всем слова, , т.е. p (y∣c, Y0: i − 1) p (\ mathbf {y} | \ mathbf {c}, \ mathbf {Y} _ {0: i-1}) p (y∣c , Y0: i − 1) как следует. Сначала сеть определяет отображение входов c, Y0: i − 1 \ mathbf {c}, \ mathbf {Y} _ {0: i-1} c, Y0: i − 1 во встроенное векторное представление y ′ \ Mathbf {y '} y ′, что соответствует целевому вектору RNN. Встроенный векторное представление y ′ \ mathbf {y '} y ′ затем передается на "язык модель головы ", что означает, что он умножается на слова. матрица внедрения , i.66 Sutskever et al. (2014) меняет порядок ввода так, чтобы в приведенном выше примере ввод векторы будут соответствовать x1 = car \ mathbf {x} _1 = \ text {car} x1 = car, x2 = a \ mathbf {x} _2 = \ text {a} x2 = a, x3 = buy \ mathbf { x} _3 = \ text {buy} x3 = buy, x4 = to \ mathbf {x} _4 = \ text {to} x4 = to, x5 = want \ mathbf {x} _5 = \ text {want} x5 = Хочу, x6 = I \ mathbf {x} _6 = \ text {I} x6 = I и x7 = EOS \ mathbf {x} _7 = \ text {EOS} x7 = EOS. В мотивация состоит в том, чтобы обеспечить более короткую связь между соответствующими пары слов, такие как x6 = I \ mathbf {x} _6 = \ text {I} x6 = I и y1 = Ich \ mathbf {y} _1 = \ text {Ich} y1 = Ich.Исследовательская группа подчеркивает, что обращение входной последовательности было ключевой причиной того, что их модель улучшена производительность машинного перевода.

  из трансформаторов импортных MarianMTModel, MarianTokenizer

tokenizer = MarianTokenizer.from_pretrained («Хельсинки-НЛП / opus-mt-en-de»)
model = MarianMTModel.from_pretrained ("Хельсинки-НЛП / opus-mt-en-de")


input_ids = tokenizer («Я хочу купить машину», return_tensors = «pt»).input_ids


output_ids = model.generate (input_ids) [0]


печать (tokenizer.decode (output_ids))
  

   Ich will ein Auto kaufen
  

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

fθenc: X1: n → X‾1: n. 11.Двунаправленный Слой самовнимания помещает каждый входной вектор x′j, ∀j∈ {1,…, n} \ mathbf {x '} _ j, \ forall j \ in \ {1, \ ldots, n \} x′j, ∀j∈ {1,…, n} по отношению ко всем входные векторы x′1,…, x′n \ mathbf {x '} _ 1, \ ldots, \ mathbf {x'} _ nx′1,…, x′n и тем самым преобразует входной вектор x′j \ mathbf {x '} _ jx′j в более "изысканный" контекстное представление самого себя, определяемое как x′′j \ mathbf {x ''} _ jx′′j. Таким образом, первый блок кодера преобразует каждый входной вектор входная последовательность X1: n \ mathbf {X} _ {1: n} X1: n (показана светло-зеленым цветом ниже) из контекстно-независимое векторное представление в контекстно-зависимое векторное представление, и следующие блоки кодировщика дополнительно уточняют это контекстное представление до тех пор, пока последний блок кодировщика не выдаст окончательное контекстное кодирование X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n (показано более темным зеленый внизу).22.

Наш примерный энкодер на базе трансформатора состоит из трех энкодеров. блоков, тогда как второй блок кодировщика показан более подробно в красный прямоугольник справа для первых трех входных векторов x1, x2andx3 \ mathbf {x} _1, \ mathbf {x} _2 и \ mathbf {x} _3x1, x2 иx3. Двунаправленный Механизм самовнимания проиллюстрирован полносвязным графом в показаны нижняя часть красного поля и два слоя прямой связи. в верхней части красного квадрата.Как было сказано ранее, мы сосредоточимся только на о двунаправленном механизме самовнимания.

Как видно, каждый выходной вектор слоя самовнимания x′′i, ∀i∈ {1,…, 7} \ mathbf {x ''} _ i, \ forall i \ in \ {1, \ ldots, 7 \} x′′i, ∀i∈ {1,…, 7} напрямую зависит от , от все входных вектора x′1,…, x′7 \ mathbf {x '} _ 1, \ ldots, \ mathbf {x'} _ 7x′1,…, x′7. Это означает, например , что входное векторное представление слова "хочу", то есть x′2 \ mathbf {x '} _ 2x′2, находится в прямой связи со словом "купить", я.е. x′4 \ mathbf {x '} _ 4x′4, но также со словом «I», то есть x′1 \ mathbf {x'} _ 1x′1. Выходное векторное представление «хочу», , то есть x′′2 \ mathbf {x ''} _ 2x′′2, таким образом, представляет собой более точную контекстную представление слова «хочу».

Давайте подробнее рассмотрим, как работает двунаправленное самовнимание. Каждый входной вектор x′i \ mathbf {x '} _ ix′i входной последовательности X′1: n \ mathbf {X'} _ {1: n} X′1: n блока кодера проецируется на ключевой вектор ki \ mathbf {k} _iki, вектор значений vi \ mathbf {v} _ivi и вектор запроса qi \ mathbf {q} _iqi (показаны ниже оранжевым, синим и фиолетовым соответственно) с помощью трех обучаемых весовых матриц Wq, Wv, Wk \ mathbf {W} _q, \ mathbf {W} _v, \ mathbf {W} _kWq, Wv, Wk:

qi = Wqx′i, \ mathbf {q} _i = \ mathbf {W} _q \ mathbf {x '} _ i, qi = Wq x′i, vi = Wvx′i, \ mathbf {v} _i = \ mathbf {W} _v \ mathbf {x '} _ i, vi = Wv x′i, ki = Wkx′i, \ mathbf {k} _i = \ mathbf {W} _k \ mathbf {x '} _ i, ki = Wk x′i, ∀i∈ {1,… n}.\ forall i \ in \ {1, \ ldots n \}. ∀i∈ {1,… n}.

Обратите внимание, что одинаковые весовые матрицы применяются к каждому входному вектору xi, ∀i∈ {i,…, n} \ mathbf {x} _i, \ forall i \ in \ {i, \ ldots, n \} xi, ∀i∈ {i,…, n}. После проецирования каждого входной вектор xi \ mathbf {x} _ixi в вектор запроса, ключа и значения, каждый вектор запроса qj, ∀j∈ {1,…, n} \ mathbf {q} _j, \ forall j \ in \ {1, \ ldots, n \} qj, ∀j∈ {1,…, n} равен в сравнении ко всем ключевым векторам k1,…, kn \ mathbf {k} _1, \ ldots, \ mathbf {k} _nk1,…, kn. Чем больше похожий один из ключевых векторов k1,… kn \ mathbf {k} _1, \ ldots \ mathbf {k} _nk1,… kn должен вектор запроса qj \ mathbf {q} _jqj, тем важнее соответствующий вектор значений vj \ mathbf {v} _jvj для выходного вектора x′′j \ mathbf {x ''} _ jx′′j.\ intercal \ mathbf {q} _j) Softmax (K1: n⊺ qj) как показано в уравнении ниже. Для полного описания слой самовнимания, читателю рекомендуется взглянуть на это сообщение в блоге или исходная бумага.

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

Слева показан ранее проиллюстрированный второй блок кодера. снова и справа, детальная визуализация двунаправленного Механизм самовнимания дан для второго входного вектора x′2 \ mathbf {x '} _ 2x′2, который соответствует входному слову «хочу». Вначале проецируются все входные векторы x′1,…, x′7 \ mathbf {x '} _ 1, \ ldots, \ mathbf {x'} _ 7x′1,…, x′7 к соответствующим векторам запросов q1,…, q7 \ mathbf {q} _1, \ ldots, \ mathbf {q} _7q1,…, q7 (вверху фиолетовым цветом показаны только первые три вектора запроса), значение векторы v1,…, v7 \ mathbf {v} _1, \ ldots, \ mathbf {v} _7v1,…, v7 (показаны синим) и ключ векторы k1,…, k7 \ mathbf {k} _1, \ ldots, \ mathbf {k} _7k1,…, k7 (показаны оранжевым).{\ intercal} K1: 7⊺ и q2 \ mathbf {q} _2q2, таким образом, делает его можно сравнить векторное представление "хочу" со всеми другими входные векторные представления «Я», «К», «Купить», «А», «Автомобиль», "EOS", чтобы веса самовнимания отражали важность каждого из другие входные векторные представления x′j, с j ≠ 2 \ mathbf {x '} _ j \ text {, с} j \ ne 2x′j, с j = 2 для уточненного представления x′′2 \ mathbf { x ''} _ 2x′′2 слова «хочу».

Чтобы лучше понять значение двунаправленного слой самовнимания, предположим, что следующее предложение обрабатывается: « Дом красивый и удачно расположенный в центре города. где легко добраться на общественном транспорте ».Слово "это" относится к «дому», который находится на расстоянии 12 «позиций». В энкодеры на основе трансформаторов, двунаправленный слой самовнимания выполняет одну математическую операцию, чтобы поместить входной вектор "дом" во взаимосвязи с входным вектором "оно" (сравните с первая иллюстрация этого раздела). Напротив, в RNN на основе кодировщик, слово, которое находится на расстоянии 12 "позиций", потребует не менее 12 математические операции, означающие, что в кодировщике на основе RNN линейный количество математических операций не требуется.Это делает его много кодировщику на основе RNN сложнее моделировать контекстные представления. Также становится ясно, что энкодер на основе трансформатора гораздо менее склонен к потере важной информации, чем основанный на RNN модель кодировщика-декодера, поскольку длина последовательности кодирования равна оставил то же самое, , т.е. len (X1: n) = len (X‾1: n) = n \ textbf {len} (\ mathbf {X} _ {1: n}) = \ textbf {len} (\ mathbf {\ overline {X}} _ {1: n}) = nlen (X1: n) = len (X1: n) = n, в то время как RNN сжимает длину из ∗ len ((X1: n) = n * \ textbf {len} ((\ mathbf {X} _ {1: n}) = n ∗ len ((X1: n) = n просто len (c) = 1 \ textbf {len} (\ mathbf {c}) = 1len (c) = 1, что очень затрудняет работу RNN для эффективного кодирования дальнодействующих зависимостей между входными словами.\ intercal \ mathbf {K} _ {1: n}) + \ mathbf {X '} _ {1: n}. X′′1: n = V1: n Softmax (Q1: n⊺ K1: n) + X′1: n.

Выходные данные X′′1: n = x′′1,…, x′′n \ mathbf {X ''} _ {1: n} = \ mathbf {x ''} _ 1, \ ldots, \ mathbf { x ''} _ nX′′1: n = x′′1,…, x′′n вычисляется с помощью серии умножений матриц и softmax операция, которую можно эффективно распараллелить. Обратите внимание, что в Модель кодировщика на основе RNN, вычисление скрытого состояния c \ mathbf {c} c должно выполняться последовательно: вычисление скрытого состояния первый входной вектор x1 \ mathbf {x} _1x1, затем вычислить скрытое состояние второй входной вектор, который зависит от скрытого состояния первого скрытого вектор и др.Последовательный характер RNN не позволяет эффективно распараллеливание и делает их более неэффективными по сравнению с модели кодировщиков на базе трансформаторов на современном оборудовании GPU.

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

Теперь давайте напишем небольшой пример кодирующей части нашего MarianMT модели кодировщика-декодера для проверки того, что объясненная теория выполняется на практике.11 Подробное объяснение роли слоев прямой связи в трансформаторных моделях выходит за рамки этого ноутбука. это утверждал в Yun et. al, (2017) что уровни прямой связи имеют решающее значение для сопоставления каждого контекстного вектора x′i \ mathbf {x '} _ ix′i индивидуально с желаемым выходным пространством, которое самовнимание слой самостоятельно не справляется. Должен быть здесь отмечено, что каждый выходной токен x ′ \ mathbf {x '} x ′ обрабатывается тот же слой прямой связи. Подробнее читателю рекомендуется прочитать бумага.22 Однако входной вектор EOS необязательно добавлять к входная последовательность, но, как было показано, во многих случаях улучшает производительность. В отличие от 0-го BOS \ text {BOS} целевой вектор BOS декодер на основе трансформатора требуется как начальный входной вектор для предсказать первый целевой вектор.

  из трансформаторов импортных MarianMTModel, MarianTokenizer
импортный фонарик

tokenizer = MarianTokenizer.from_pretrained («Хельсинки-НЛП / opus-mt-en-de»)
модель = MarianMTModel.from_pretrained ("Хельсинки-НЛП / opus-mt-en-de")

вложения = модель.get_input_embeddings ()


input_ids = tokenizer («Я хочу купить машину», return_tensors = «pt»). input_ids


encoder_hidden_states = model.base_model.encoder (input_ids, return_dict = True) .last_hidden_state


input_ids_perturbed = tokenizer («Я хочу купить дом», return_tensors = «pt»). input_ids
encoder_hidden_states_perturbed = model.base_model.encoder (input_ids_perturbed, return_dict = True) .last_hidden_state


print (f "Длина вложений ввода {вложений (input_ids).форма [1]}. Длина encoder_hidden_states {encoder_hidden_states.shape [1]} ")


print ("Кодировка для` I` равна его возмущенной версии ?: ", torch.allclose (encoder_hidden_states [0, 0], encoder_hidden_states_perturbed [0, 0], atol = 1e-3))
  

Выходы:

  Длина вложений ввода 7. Длина encoder_hidden_states 7
    Кодировка для `I` равна его возмущенной версии ?: False
  

Сравниваем длину вложений входного слова, i.е. вложений (input_ids) , соответствующих X1: n \ mathbf {X} _ {1: n} X1: n, с длина encoder_hidden_states , соответствующая X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n. Кроме того, мы переадресовали последовательность слов «Хочу купить машину» и слегка возмущенный вариант «Хочу купить дом "через кодировщик, чтобы проверить, есть ли первая выходная кодировка, соответствует «I», отличается, когда в входная последовательность.

Как и ожидалось, выходная длина вложений входного слова и кодировщика выходные кодировки, i.е. len (X1: n) \ textbf {len} (\ mathbf {X} _ {1: n}) len (X1: n) и len (X‾1: n) \ textbf {len} (\ mathbf { \ overline {X}} _ {1: n}) len (X1: n), равно. Во-вторых, это может быть отметил, что значения закодированного выходного вектора x‾1 = "I" \ mathbf {\ overline {x}} _ 1 = \ text {"I"} x1 = "I" отличаются, когда последнее слово меняется с "автомобиль" на "дом". Однако это не должно вызывать сюрприз, если кто-то понял двунаправленное самовнимание.

Кстати, модели с автокодированием , такие как BERT, имеют точно такие же Архитектура как на базе трансформатора модели кодировщика . Автокодирование модели используют эту архитектуру для массового самоконтроля предварительное обучение текстовых данных в открытом домене, чтобы они могли сопоставить любое слово последовательность к глубокому двунаправленному представлению. В Devlin et al. (2018) авторы показывают, что предварительно обученная модель BERT с одним классификационным слоем для конкретной задачи сверху может достичь результатов SOTA по одиннадцати задачам НЛП. Все автокодирование модели 🤗Трансформаторов можно найти здесь.

Как упоминалось в разделе Кодер-декодер , преобразователь на основе преобразователя декодер определяет условное распределение вероятностей цели последовательность с учетом контекстуализированной кодирующей последовательности:

pθdec (Y1: m∣X‾1: n), p _ {\ theta_ {dec}} (\ mathbf {Y} _ {1: m} | \ mathbf {\ overline {X}} _ {1: n} ), pθdec (Y1: m ∣X1: n),

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

pθdec (Y1: m∣X‾1: n) = ∏i = 1mpθdec (yi∣Y0: i − 1, X‾1: n).{m} p _ {\ theta_ {dec}} (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {\ overline {X}} _ {1: n}). pθdec (Y1: m ∣X1: n) = i = 1∏m pθdec (yi ∣Y0: i − 1, X1: n).

Давайте сначала разберемся, как декодер на основе трансформатора определяет распределение вероятностей. Трансформаторный декодер представляет собой набор блоки декодера , за которыми следует плотный слой, «голова LM». Стек блоков декодера сопоставляет контекстуализированную последовательность кодирования X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n и последовательность целевого вектора с добавлением вектор BOS \ text {BOS} BOS и переход к последнему целевому вектору i.е. Y0: i − 1 \ mathbf {Y} _ {0: i-1} Y0: i − 1, в закодированную последовательность целевых векторов Y‾0: i − 1 \ mathbf {\ overline {Y}} _ {0: i-1} Y0: i-1. Затем «голова LM» отображает закодированные последовательность целевых векторов Y‾0: i − 1 \ mathbf {\ overline {Y}} _ {0: i-1} Y0: i − 1 до a последовательность логит-векторов L1: n = l1,…, ln \ mathbf {L} _ {1: n} = \ mathbf {l} _1, \ ldots, \ mathbf {l} _nL1: n = l1,…, ln, тогда как размерность каждого логит-вектора li \ mathbf {l} _ili соответствует размер словарного запаса. Таким образом, для каждого i∈ {1,…, n} i \ in \ {1, \ ldots, n \} i∈ {1,…, n} a распределение вероятностей по всему словарю может быть получено с помощью применение операции softmax к li \ mathbf {l} _ili. {\ intercal} \ mathbf {\ overline {y}} _ {i-1 }) = Softmax (Wemb⊺ y i − 1) = Softmax (li).= \ text {Softmax} (\ mathbf {l} _i). = Softmax (li).

Собираем все вместе, чтобы смоделировать условное распределение последовательности целевых векторов Y1: m \ mathbf {Y} _ {1: m} Y1: m, целевые векторы Y1: m − 1 \ mathbf {Y} _ {1: m-1} Y1: m − 1 Добавляется специальным вектором BOS \ text {BOS} BOS, , то есть y0 \ mathbf {y} _0y0, сначала отображаются вместе с контекстуализированными кодирующая последовательность X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n в вектор логита последовательность L1: m \ mathbf {L} _ {1: m} L1: m. Следовательно, каждый целевой вектор логита li \ mathbf {l} _ili преобразуется в условную вероятность распределение целевого вектора yi \ mathbf {y} _iyi с использованием softmax операция.{m} p _ {\ theta_ {dec}} (\ mathbf {y} _i | \ mathbf {Y} _ {0: i-1}, \ mathbf {\ overline {X}} _ {1: n}). pθdec (Y1: m ∣X1: n) = i = 1∏m pθdec (yi ∣Y0: i − 1, X1: n).

В отличие от трансформаторных энкодеров, в трансформаторных декодеры, закодированный выходной вектор y‾i \ mathbf {\ overline {y}} _ iy i должен быть хорошее представление следующего целевого вектора yi + 1 \ mathbf {y} _ {i + 1} yi + 1 и не самого входного вектора. Кроме того, закодированный выходной вектор y‾i \ mathbf {\ overline {y}} _ iy i должен быть обусловлен всеми контекстными кодирующая последовательность X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n.22. Слой однонаправленного самовнимания. ставит каждый из своих входных векторов y′j \ mathbf {y '} _ jy′j только во взаимосвязь с все предыдущие входные векторы y′i, с i≤j \ mathbf {y '} _ i, \ text {with} i \ le jy′i, с i≤j для все j∈ {1,…, n} j \ in \ {1, \ ldots, n \} j∈ {1,…, n} для моделирования распределения вероятностей следующие целевые векторы. Слой перекрестного внимания помещает каждый из входные векторы y′′j \ mathbf {y ''} _ jy′′j во взаимосвязи со всеми контекстуализированными кодирующие векторы X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n, чтобы обусловить распределение вероятностей следующих целевых векторов на входе кодировщик тоже.

Хорошо, давайте визуализируем декодер на основе трансформатора для нашего Пример перевода с английского на немецкий.

Мы видим, что декодер отображает вход Y0: 5 \ mathbf {Y} _ {0: 5} Y0: 5 "BOS", «Ich», «will», «ein», «Auto», «kaufen» (показаны светло-красным) вместе с контекстуализированной последовательностью «я», «хочу», «к», «купить», «а», «автомобиль», «EOS», т.е. X‾1: 7 \ mathbf {\ overline {X}} _ {1: 7} X1: 7 (показано темно-зеленым) в векторы логита L1: 6 \ mathbf {L} _ {1: 6} L1: 6 (показано на темно-красный).

Применение операции softmax к каждому l1, l2,…, l5 \ mathbf {l} _1, \ mathbf {l} _2, \ ldots, \ mathbf {l} _5l1, l2,…, l5 может таким образом определить условные распределения вероятностей:

pθdec (y∣BOS, X‾1: 7), p _ {\ theta_ {dec}} (\ mathbf {y} | \ text {BOS}, \ mathbf {\ overline {X}} _ {1: 7} ), pθdec (y∣BOS, X1: 7), pθdec (y∣BOS Ich, X‾1: 7), p _ {\ theta_ {dec}} (\ mathbf {y} | \ text {BOS Ich}, \ mathbf {\ overline {X}} _ {1: 7 }), pθdec (y∣BOS Ich, X1: 7), …, \ Ldots,…, pθdec (y∣BOS Ich будет ein Auto kaufen, X‾1: 7). p _ {\ theta_ {dec}} (\ mathbf {y} | \ text {BOS Ich будет ein Auto kaufen}, \ mathbf {\ overline {X}} _ {1: 7}).pθdec (y∣BOS Ich будет ein Auto kaufen, X1: 7).

Общая условная вероятность:

pθdec (Ich будет ein Auto kaufen EOS∣X‾1: n) p _ {\ theta_ {dec}} (\ text {Ich будет ein Auto kaufen EOS} | \ mathbf {\ overline {X}} _ {1: n }) pθdec (Ich будет ein Auto kaufen EOS∣X1: n)

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

pθdec (Ich∣BOS, X‾1: 7) ×… × pθdec (EOS∣BOS Ich будет ein Auto kaufen, X‾1: 7). p _ {\ theta_ {dec}} (\ text {Ich} | \ text {BOS}, \ mathbf {\ overline {X}} _ {1: 7}) \ times \ ldots \ times p _ {\ theta_ {dec} } (\ text {EOS} | \ text {BOS Ich будет ein Auto kaufen}, \ mathbf {\ overline {X}} _ {1: 7}).pθdec (Ich∣BOS, X1: 7) ×… × pθdec (EOS∣BOS Ich будет использовать Auto kaufen, X1: 7).

В красном поле справа показан блок декодера для первых трех целевые векторы y0, y1, y2 \ mathbf {y} _0, \ mathbf {y} _1, \ mathbf {y} _2y0, y1, y2. В нижнем части, механизм однонаправленного самовнимания проиллюстрирован и в в центре проиллюстрирован механизм перекрестного внимания. Давай сначала сосредоточьтесь на однонаправленном самовнимании.

Как при двунаправленном самовнимании, при однонаправленном самовнимании, векторы запросов q0,…, qm − 1 \ mathbf {q} _0, \ ldots, \ mathbf {q} _ {m-1} q0,…, qm − 1 (показаны на фиолетовый внизу), ключевые векторы k0,…, km − 1 \ mathbf {k} _0, \ ldots, \ mathbf {k} _ {m-1} k0,…, km − 1 (показаны оранжевым ниже), и векторы значений v0,…, vm − 1 \ mathbf {v} _0, \ ldots, \ mathbf {v} _ {m-1} v0,…, vm − 1 (показаны на синий ниже) проецируются из соответствующих входных векторов y′0,…, y′m − 1 \ mathbf {y '} _ 0, \ ldots, \ mathbf {y'} _ {m-1} y′0,…, y′m −1 (показано светло-красным цветом ниже).Однако при однонаправленном самовнимании каждый вектор запроса qi \ mathbf {q} _iqi сравнивается только с его соответствующим ключевым вектором и все предыдущие, а именно k0,…, ki \ mathbf {k} _0, \ ldots, \ mathbf {k} _ik0,…, ki, чтобы получить соответствующие веса внимания . Это предотвращает включение любой информации в выходной вектор y′′j \ mathbf {y ''} _ jy′′j (показан темно-красным ниже) о следующем входном векторе yi, с i> j \ mathbf {y} _i, \ text {с} i> jyi, с i> j для все j∈ {0,…, m − 1} j \ in \ {0, \ ldots, m - 1 \} j∈ {0,…, m − 1}.\ intercal \ mathbf {q} _i) + \ mathbf {y '} _ i. y′′i = V0: i Softmax (K0: i⊺ qi) + y′i.

Обратите внимание, что диапазон индекса векторов ключей и значений равен 0: i0: i0: i вместо 0: m − 10: m-10: m − 1, который будет диапазоном ключевых векторов в двунаправленное самовнимание.

Давайте проиллюстрируем однонаправленное самовнимание для входного вектора y′1 \ mathbf {y '} _ 1y′1 для нашего примера выше.

Как видно, y′′1 \ mathbf {y ''} _ 1y′′1 зависит только от y′0 \ mathbf {y '} _ 0y′0 и y′1 \ mathbf {y'} _ 1y′1 .Поэтому положим векторное представление слова «Ich», т.е. y′1 \ mathbf {y '} _ 1y′1 только в отношении самого себя и Целевой вектор "BOS", то есть y′0 \ mathbf {y '} _ 0y′0, но не с векторное представление слова «будет», т.е. y′2 \ mathbf {y '} _ 2y′2.

Итак, почему так важно, чтобы мы использовали однонаправленное самовнимание в декодер вместо двунаправленного самовнимания? Как указано выше, декодер на основе трансформатора определяет отображение из последовательности ввода вектор Y0: m − 1 \ mathbf {Y} _ {0: m-1} Y0: m − 1 в логиты, соответствующие следующему входные векторы декодера, а именно L1: m \ mathbf {L} _ {1: m} L1: m.В нашем примере это означает например , что отображен входной вектор y1 \ mathbf {y} _1y1 = "Ich" в вектор логита l2 \ mathbf {l} _2l2, который затем используется для прогнозирования входной вектор y2 \ mathbf {y} _2y2. Таким образом, если y′1 \ mathbf {y '} _ 1y′1 будет иметь доступ к следующим входным векторам Y′2: 5 \ mathbf {Y '} _ {2: 5} Y′2: 5, декодер будет просто скопируйте векторное представление «воли», , т.е. y′2 \ mathbf {y '} _ 2y′2, чтобы получить его выход y′′1 \ mathbf {y' '} _ 1y′′1. Это было бы перенаправлен на последний уровень, так что закодированный выходной вектор y‾1 \ mathbf {\ overline {y}} _ 1y 1 по существу просто соответствовал бы векторное представление y2 \ mathbf {y} _2y2.

Это явно невыгодно, поскольку декодер на основе трансформатора никогда не учись предсказывать следующее слово, учитывая все предыдущие слова, а просто скопируйте целевой вектор yi \ mathbf {y} _iyi через сеть в y‾i − 1 \ mathbf {\ overline {y}} _ {i-1} y i − 1 для всех i∈ {1,… , m} i \ in \ {1, \ ldots, m \} i∈ {1,…, m}. В чтобы определить условное распределение следующего целевого вектора, распределение не может быть обусловлено следующим целевым вектором. Нет смысла предсказывать yi \ mathbf {y} _iyi из p (y∣Y0: i, X‾) p (\ mathbf {y} | \ mathbf {Y} _ {0: i}, \ mathbf {\ overline {X}}) p (y∣Y0: i, X), поскольку распределение обусловлено целевым вектором, который предполагается модель.Следовательно, однонаправленная архитектура самовнимания позволяет нам определить вероятностное распределение причинно-следственных связей , которое необходимо для эффективного моделирования условного распределения следующих целевой вектор.

Отлично! Теперь мы можем перейти к слою, который соединяет кодировщик и декодер - механизм перекрестного внимания !

Слой перекрестного внимания принимает в качестве входных данных две векторные последовательности: выходы однонаправленного слоя самовнимания, i.е. Y′′0: m − 1 \ mathbf {Y ''} _ {0: m-1} Y′′0: m − 1 и контекстуализированные векторы кодирования X‾1: n \ mathbf {\ overline {X }} _ {1: n} X1: n. Как и в слое самовнимания, запрос векторы q0,…, qm − 1 \ mathbf {q} _0, \ ldots, \ mathbf {q} _ {m-1} q0,…, qm − 1 являются проекциями выходные векторы предыдущего слоя, , то есть Y′′0: m − 1 \ mathbf {Y ''} _ {0: m-1} Y′′0: m − 1. Однако векторы ключа и значения k0,…, km − 1 \ mathbf {k} _0, \ ldots, \ mathbf {k} _ {m-1} k0,…, km − 1 и v0,…, vm −1 \ mathbf {v} _0, \ ldots, \ mathbf {v} _ {m-1} v0,…, vm − 1 - проекции контекстуализированные векторы кодирования X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n.Имея определены векторы ключа, значения и запроса, вектор запроса qi \ mathbf {q} _iqi затем сравниваются с все ключевых вектора и используется соответствующая оценка для взвешивания соответствующих векторов значений, как и в случае двунаправленное самовнимание, чтобы дать выходной вектор y ′ ′ ′ i \ mathbf {y '' '} _ iy ′ ′ ′ i для всех i∈0,…, m − 1i \ in {0, \ ldots , m-1} i∈0,…, m − 1. \ intercal \ mathbf {q} _i) + \ mathbf {y ''} _ я.y ′ ′ ′ i = V1: n Softmax (K1: n⊺ qi) + y′′i.

Обратите внимание, что диапазон индекса векторов ключей и значений равен 1: n1: n1: n соответствует количеству контекстуализированных векторов кодирования.

Давайте визуализируем механизм перекрестного внимания Давайте для ввода вектор y′′1 \ mathbf {y ''} _ 1y′′1 для нашего примера выше.

Мы видим, что вектор запроса q1 \ mathbf {q} _1q1 (показан фиолетовым цветом) равен получено из y′′1 \ mathbf {y ''} _ 1y′′1 (показано красным) и, следовательно, полагается на вектор представление слова «Ич».Вектор запроса q1 \ mathbf {q} _1q1 затем сравнивается с ключевыми векторами k1,…, k7 \ mathbf {k} _1, \ ldots, \ mathbf {k} _7k1,…, k7 (показаны желтым), соответствующими представление контекстного кодирования всех входных векторов кодировщика X1: n \ mathbf {X} _ {1: n} X1: n = "Я хочу купить автомобиль EOS". Это ставит вектор представление "Ich" в прямую связь со всеми входами кодировщика векторы. Наконец, веса внимания умножаются на значение векторы v1,…, v7 \ mathbf {v} _1, \ ldots, \ mathbf {v} _7v1,…, v7 (показаны бирюзовым) в вывести в дополнение к входному вектору y′′1 \ mathbf {y ''} _ 1y′′1 выходной вектор y ′ ′ ′ 1 \ mathbf {y '' '} _ 1y ′ ′ ′ 1 (показан темно-красным ).

Итак, интуитивно, что именно здесь происходит? Каждый выходной вектор y ′ ′ ′ i \ mathbf {y '' '} _ iy ′ ′ ′ i является взвешенной суммой всех проекций значений входы кодировщика v1,…, v7 \ mathbf {v} _ {1}, \ ldots, \ mathbf {v} _7v1,…, v7 плюс вход вектор y′′i \ mathbf {y ''} _ iy′′i ( см. формулу , проиллюстрированную выше). Ключ механизм понимания следующий: в зависимости от того, насколько похож проекция запроса входного вектора декодера qi \ mathbf {q} _iqi на проекция ключа входного вектора кодировщика kj \ mathbf {k} _jkj, тем более важна проекция значения входного вектора кодировщика vj \ mathbf {v} _jvj.В общих чертах это означает, что чем больше «родственный» входное представление декодера относится к входному представлению кодировщика, больше влияет ли входное представление на выход декодера представление.

Круто! Теперь мы можем видеть, как эта архитектура хорошо обрабатывает каждый вывод. вектор y ′ ′ ′ i \ mathbf {y '' '} _ iy ′ ′ ′ i на взаимодействии между входом кодировщика векторы X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n и входной вектор y′′i \ mathbf {y ''} _ iy′′i. Еще одно важное наблюдение на этом этапе заключается в том, что архитектура полностью не зависит от количества nnn контекстуализированные векторы кодирования X‾1: n \ mathbf {\ overline {X}} _ {1: n} X1: n, на которых выходной вектор y ′ ′ ′ i \ mathbf {y '' '} _ iy ′ ′ ′ i обусловлен.{\ text {cross}} _ {v} Wvcross для получения ключевых векторов k1,…, kn \ mathbf {k} _1, \ ldots, \ mathbf {k} _nk1,…, kn и векторов значений v1 ,…, Vn \ mathbf {v} _1, \ ldots, \ mathbf {v} _nv1,…, vn соответственно используются всеми позиции 1,…, n1, \ ldots, n1,…, n и все векторы значений v1,…, vn \ mathbf {v} _1, \ ldots, \ mathbf {v} _n v1,…, vn суммируются к одному взвешенный усредненный вектор. Теперь также становится очевидным, почему декодер на основе трансформатора не страдает зависимостью от дальнего действия Проблема, от которой страдает декодер на основе RNN.Потому что каждый декодер логит вектор напрямую зависит от каждого отдельного закодированного выходного вектора, количество математических операций для сравнения первого закодированного выходной вектор и последний логит-вектор декодера составляют по существу только один.

В заключение, однонаправленный слой самовнимания отвечает за согласование каждого выходного вектора со всеми предыдущими входными векторами декодера а текущий вектор ввода и слой перекрестного внимания - отвечает за дальнейшее кондиционирование каждого выходного вектора на всех закодированных входных данных. векторы.22 Опять же, подробное объяснение роли прямого игра слоев в моделях на основе трансформатора выходит за рамки этого ноутбук. Это утверждается в Yun et. аль, (2017), что слои с прямой связью имеют решающее значение для сопоставления каждого контекстного вектора x′i \ mathbf {x '} _ ix′i индивидуально в желаемое пространство вывода, которое слой самовнимания не может справиться самостоятельно. Здесь следует отметить, что каждый выходной токен x '\ mathbf {x'} x 'обрабатывается одним и тем же уровнем прямой связи. Для большего Подробности, читателю рекомендуется прочитать статью.

  из трансформаторов импортных MarianMTModel, MarianTokenizer
импортный фонарик

tokenizer = MarianTokenizer.from_pretrained («Хельсинки-НЛП / opus-mt-en-de»)
model = MarianMTModel.from_pretrained ("Хельсинки-НЛП / opus-mt-en-de")
вложения = модель.get_input_embeddings ()


input_ids = tokenizer («Я хочу купить машину», return_tensors = «pt»). input_ids


decoder_input_ids = tokenizer (" Ich will ein", return_tensors = "pt", add_special_tokens = False) .input_ids


decoder_output_vectors = модель.base_model.decoder (decoder_input_ids) .last_hidden_state


lm_logits = torch.nn.functional.linear (decoder_output_vectors, embeddings.weight, bias = model.final_logits_bias)


decoder_input_ids_perturbed = tokenizer (" Ich will das", return_tensors = "pt", add_special_tokens = False) .input_ids
decoder_output_vectors_perturbed = model.base_model.decoder (decoder_input_ids_perturbed) .last_hidden_state
lm_logits_perturbed = torch.nn.functional.linear (decoder_output_vectors_perturbed, embeddings.weight, bias = model.final_logits_bias)


print (f "Форма входных векторов декодера {embeddings (decoder_input_ids) .shape}. Форма логитов декодера {lm_logits.shape}")


print ("Кодировка для` Ich` равна его измененной версии ?: ", torch.allclose (lm_logits [0, 0], lm_logits_perturbed [0, 0], atol = 1e-3))
  

Выход:

  Форма входных векторов декодера torch.Size ([1, 5, 512]). Форма декодера logits torch.Size ([1, 5, 58101])
    Кодировка для `Ich` равна его измененной версии ?: True
  

Мы сравниваем выходную форму вложений входных слов декодера, i.е. вложений (decoder_input_ids) (соответствует Y0: 4 \ mathbf {Y} _ {0: 4} Y0: 4, здесь соответствует BOS, а «Ich will das» токенизируется до 4 токены) с размерностью lm_logits (соответствует L1: 5 \ mathbf {L} _ {1: 5} L1: 5). Также мы передали последовательность слов " Ich will das" и слегка возмущенная версия " Ich will das" вместе с encoder_output_vectors через кодировщик, чтобы проверить, есть ли второй lm_logit , соответствующий «Ich», отличается, когда только последнее слово изменено во входной последовательности («ein» -> «das»).

Как и ожидалось, выходные формы вложений входных слов декодера и lm_logits, , т.е. размерность Y0: 4 \ mathbf {Y} _ {0: 4} Y0: 4 и L1: 5 \ mathbf {L} _ {1: 5} L1: 5 в последнем измерение. В то время как длина последовательности такая же (= 5), размерность входа декодера вложение слов соответствует model.config.hidden_size , тогда как размерность lm_logit соответствует размеру словаря model.config.vocab_size , как описано выше.Во-вторых, можно отметить что значения закодированного выходного вектора l1 = "Ich" \ mathbf {l} _1 = \ text {"Ich"} l1 = "Ich" совпадают при изменении последнего слова от «эйн» до «дас». Однако это не должно вызывать удивления, если человек понял однонаправленное самовнимание.

В заключение отметим, что модели с авторегрессией , такие как GPT2, имеют та же архитектура, что и на базе трансформатора модели декодера если один удаляет слой перекрестного внимания, потому что автономный авторегрессивный модели не привязаны к каким-либо выходам энкодера.Так авторегрессивный модели по сути такие же, как модели с автоматическим кодированием , но заменяют двунаправленное внимание с однонаправленным вниманием. Эти модели также можно предварительно обучить работе с массивными текстовыми данными в открытом домене, чтобы показывать впечатляющая производительность в задачах генерации естественного языка (NLG). В Radford et al. (2019), авторы показывают, что предварительно обученная модель GPT2 может достичь SOTA или закрыть к результатам SOTA при выполнении различных задач NLG без особой настройки. Все авторегрессивные модели 🤗Трансформаторов можно найти здесь.

Хорошо, вот и все! Теперь вы должны хорошо понимать модели кодеров-декодеров на базе трансформатора и как их использовать с 🤗Библиотека трансформеров.

Большое спасибо Виктору Саню, Саше Рашу, Сэму Шлейферу, Оливеру Остранду, Теду Московицу и Кристиану Кивику за ценные отзывы.

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

  из трансформаторов импортных MarianMTModel, MarianTokenizer
импортный фонарик

tokenizer = MarianTokenizer.from_pretrained («Хельсинки-НЛП / opus-mt-en-de»)
model = MarianMTModel.from_pretrained ("Хельсинки-НЛП / opus-mt-en-de")


input_ids = tokenizer («Я хочу купить машину», return_tensors = «pt»). input_ids


decoder_input_ids = tokenizer ("", add_special_tokens = False, return_tensors = "pt").input_ids

assert decoder_input_ids [0, 0] .item () == model.config.decoder_start_token_id, "` decoder_input_ids` должен соответствовать `model.config.decoder_start_token_id`"




output = model (input_ids, decoder_input_ids = decoder_input_ids, return_dict = True)


encoded_sequence = (outputs.encoder_last_hidden_state,)

lm_logits = outputs.logits


next_decoder_input_ids = torch.argmax (lm_logits [:, -1:], ось = -1)


decoder_input_ids = torch.cat ([decoder_input_ids, next_decoder_input_ids], axis = -1)




lm_logits = модель (Нет, encoder_outputs = encoded_sequence, decoder_input_ids = decoder_input_ids, return_dict = True).логиты


next_decoder_input_ids = torch.argmax (lm_logits [:, -1:], ось = -1)


decoder_input_ids = torch.cat ([decoder_input_ids, next_decoder_input_ids], axis = -1)


lm_logits = модель (Нет, encoder_outputs = encoded_sequence, decoder_input_ids = decoder_input_ids, return_dict = True) .logits
next_decoder_input_ids = torch.argmax (lm_logits [:, -1:], ось = -1)
decoder_input_ids = torch.cat ([decoder_input_ids, next_decoder_input_ids], axis = -1)


print (f "Создано на данный момент: {tokenizer.decode (decoder_input_ids [0], skip_special_tokens = True)}")


  

Выходы:

  Сгенерировано пока: Ich Ich
  

В этом примере кода мы показываем именно то, что было описано ранее.Мы передайте ввод "Я хочу купить машину" вместе с BOS \ text {BOS} BOS токен модели кодера-декодера и выборка из первого логита l1 \ mathbf {l} _1l1 (, т.е. первая строка lm_logits ). Настоящим наша выборка стратегия проста - жадно выбрать следующий входной вектор декодера, который имеет наибольшую вероятность. Затем авторегрессивным образом мы передаем выбранный входной вектор декодера вместе с предыдущими входами для модель кодировщика-декодера и снова образец.Повторяем это в третий раз. В результате модель сформировала слова «Ич Ич». Первое слово точное! Второе слово не очень хорошее. Мы можем видеть здесь, что хороший метод декодирования является ключом к успешной генерации последовательности из заданного модельного распределения.

На практике используются более сложные методы декодирования для выборки lm_logits . Большинство из них покрыто это сообщение в блоге.

Понимание шумихи вокруг моделей Transformer NLP

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

История возникновения механизмов внимания: машинный перевод

Парадигма внимания вошла в сферу НЛП еще в 2014 году, до ажиотажа в области глубокого обучения, и впервые была применена к проблеме машинного перевода.

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

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

Но можно ли разумно предположить, что вектор контекста может сохранять ВСЮ необходимую информацию входного предложения? А что, если предложение состоит, скажем, из 50 слов? Из-за присущей RNN последовательной структуры каждая входная ячейка создает только один выходной вектор скрытого состояния для каждого слова в предложении, один за другим. Из-за последовательного порядка обработки текста контекстному вектору сложнее захватить всю информацию, содержащуюся в предложении, для длинных предложений со сложными зависимостями между словами - это называется «проблемой узкого места».

Устранение проблемы узких мест с вниманием

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

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

Если вы хотите еще больше разобраться в деталях моделей Transformer NLP и внутренней работе механизма внимания, мы рекомендуем вам прочитать этот пост в блоге Data From the Trenches .

На пути к моделям трансформатора NLP

Как вы теперь понимаете, внимание было революционной идеей в системах последовательного перевода, таких как модели перевода. Модели Transformer NLP основаны на механизме Attention, который развивает его основную идею еще дальше: в дополнение к использованию Attention для вычисления представлений (то есть векторов контекста) из векторов скрытого состояния кодировщика, почему бы не использовать Attention для вычисления векторов скрытых состояний кодировщика самих себя? Непосредственным преимуществом этого является избавление от неотъемлемой последовательной структуры RNN, которая препятствует распараллеливанию моделей.

Чтобы решить проблему распараллеливания, Attention увеличивает скорость преобразования модели из одной последовательности в другую. Таким образом, основным преимуществом моделей Transformer NLP является то, что они не являются последовательными, что означает, что, в отличие от RNN, их легче распараллелить, и что все большие и большие модели можно обучать путем распараллеливания обучения.

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

Декодирование AI и NLP для издателей

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

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

В этом блоге давайте расскажем, как ИИ и НЛП приносят пользу в издательском пространстве.

Расширение возможностей редакторов в принятии решений

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

Исправление мелких ошибок

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

Автоматизация рабочих процессов

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

Ускорение внутренних производственных процессов и сокращение времени выполнения заказа

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

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

Сокращение длительных циклов проверки

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

Итак, каков последний результат?

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

API декодирования | Текст | TensorFlow

Обзор

В недавнем прошлом было проведено много исследований в области генерации языков с помощью авторегрессивных моделей. В авторегрессивной языковой генерации распределение вероятностей токена на временном этапе K зависит от предсказаний токенов модели до этапа K-1 . Для этих моделей стратегии декодирования, такие как поиск луча, жадный, Top-p и Top-k, являются критическими компонентами модели и в значительной степени влияют на стиль / характер сгенерированного выходного токена на заданном временном шаге K .

Например, Поиск луча снижает риск пропуска скрытых токенов высокой вероятности на сохранение наиболее вероятного числа гипотез на каждом временном шаге и, в конечном итоге, выбор гипотезы с наибольшей общей вероятностью. Мюррей и др. (2018) и Ян и др. (2018) показывают, что поиск луча хорошо работает в задачах машинного перевода. Обе стратегии Beam search и Greedy могут генерировать повторяющиеся токены.

Fan et.al (2018) представил Top-K выборка , в которой K наиболее вероятных токенов отфильтрованы, а масса вероятности перераспределяется только между этими токенами K.

Ari Holtzman et. al (2019) представил Выборка Top-p , которая выбирает из наименьшего возможного набора токенов с совокупная вероятность, которая складывается с вероятностью p . Тогда вероятностная масса равна распространяется среди этого набора. Таким образом, размер набора токенов может динамически увеличиваются и уменьшаются. Top-p, Top-k обычно используются в таких задачах, как создание историй.

Decoding API предоставляет интерфейс для экспериментов с различными стратегиями декодирования на авторегрессионных моделях.

1. Следующие стратегии выборки представлены в sampling_module.py, который наследуется от базового класса Decoding:

2. Поиск луча предоставляется в файле beam_search.py. гитхаб

Установка

  pip install -q -U tenorflow-text 
 

  pip install -q tf-models-nightly 
 

  импортировать numpy как np
import matplotlib.pyplot как plt

импортировать тензорный поток как tf

из официального импорта nlp
from official.nlp.modeling.ops import sampling_module
from official.nlp.modeling.ops import beam_search
  

Инициализировать модуль выборки в TF-NLP.

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

  Аргументы:
  1] ids: Текущие декодированные последовательности.int тензор с формой (batch_size, index + 1 или 1, если padded_decode имеет значение True)],
  2] index [скаляр]: текущий шаг декодирования,
  3] cache [вложенный словарь тензоров]: используется только для более быстрого декодирования для хранения предварительно вычисленных скрытых состояний для ключей и значений. Больше объяснений в ячейке ниже.
Возврат:
  1] тензор для логитов следующего шага [batch_size, vocab]
  2] updated_cache [вложенный словарь тензоров].
  

Кэш используется для более быстрого декодирования. Вот эталонная реализация вышеуказанного закрытия.

• length_normalization_fn : Используйте это замыкание для возврата параметра нормализации длины.

  Аргументы:
  1] length: скаляр для индекса декодированного шага.
  2] dtype: тип данных выходного тензора
Возврат:
  1] значение коэффициента нормализации длины.
  

• vocab_size : Размер выходного словаря.

• max_decode_length : Скаляр для общего количества шагов декодирования.

• eos_id : Декодирование остановится, если все выходные декодированные идентификаторы в пакете имеют этот eos_id.

• padded_decode : Установите значение True, если работает на TPU. Тензоры дополняются до max_decoding_length, если это True.

• top_k : top_k включен, если это значение> 1.

• top_p : top_p включен, если это значение> 0 и <1.0

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

• enable_greedy : по умолчанию это True и жадное декодирование включено. Чтобы поэкспериментировать с другими стратегиями, установите значение False.

Инициализировать гиперпараметры модели

  params = {}
params ['num_heads'] = 2
params ['num_layers'] = 2
params ['batch_size'] = 2
params ['n_dims'] = 256
params ['max_decode_length'] = 4
  

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

Инициализировать кеш.

  cache = {
    'layer_% d'% layer: {
        'k': tf.zeros ([params ['batch_size'], params ['max_decode_length'], params ['num_heads'], int (params ['n_dims'] / params ['num_heads'])], dtype = tf.float32),
        'v': tf.zeros ([params ['batch_size'], params ['max_decode_length'], params ['num_heads'], int (params ['n_dims'] / params ['num_heads'])], dtype = тф.float32)
        } для слоя в диапазоне (params ['num_layers'])
    }
print ("форма ключа кеширования для слоя 1:", cache ['layer_1'] ['k']. shape)
  

форма ключа кэша для слоя 1 & двоеточие; (2, 4, 2, 128)
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.884533 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.892742 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.893649 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.895413 & двоеточие; I tenorflow / core / platform / cpu_feature_guard.cc & col; 151] Этот двоичный файл TensorFlow оптимизирован с помощью библиотеки глубокой нейронной сети oneAPI (oneDNN) для использования следующих инструкций ЦП в критических для производительности операциях & двоеточие; AVX2 AVX512F FMA
Чтобы включить их в других операциях, перестройте TensorFlow с соответствующими флагами компилятора.
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.896128 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.897135 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 44 & двоеточие; 59.898014 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 45 & двоеточие; 00.440341 ​​& двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 45 & двоеточие; 00.441305 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 45 & двоеточие; 00.442196 & двоеточие; I tensorflow / stream_executor / cuda / cuda_gpu_executor.cc & двоеточие; 939] успешное чтение узла NUMA из SysFS имело отрицательное значение (-1), но должен быть хотя бы один узел NUMA, поэтому узел NUMA возвращается ноль
2021-08-11 18 & двоеточие; 45 & двоеточие; 00.443081 & двоеточие; I tensorflow / core / common_runtime / gpu / gpu_device.cc & col; 1505] Создано устройство / задание & двоеточие; localhost / replica & двоеточие; 0 / задача & двоеточие; 0 / устройство & двоеточие; GPU & двоеточие; 0 с памятью 14662 МБ и двоеточием; -> устройство и двоеточие; 0, имя & двоеточие; Tesla V100-SXM2-16GB, идентификатор шины pci и двоеточие; 0000 & двоеточие; 00 & двоеточие; 05.0, вычислительные возможности и двоеточие; 7.0
 

Определите замыкание для нормализации длины, если необходимо.

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

  def length_norm (длина, dtype):
  "" "Коэффициент нормализации длины возврата." ""
  return tf.pow (((5. + tf.cast (длина, dtype)) / 6.), 0.0)
  

Создать model_fn

На практике это будет заменено реальной реализацией модели, такой как здесь

  Аргументы:
i: Шаг, который декодируется.Возврат:
  логит вероятности размера [batch_size, 1, vocab_size]
  

  вероятностей = tf.constant ([[[0,3, 0,4, 0,3], [0,3, 0,3, 0,4],
                              [0,1, 0,1, 0,8], [0,1, 0,1, 0,8]],
                            [[0,2, 0,5, 0,3], [0,2, 0,7, 0,1],
                              [0,1, 0,1, 0,8], [0,1, 0,1, 0,8]]])
def model_fn (i):
  вероятности возврата [:, i,:]
  

Инициализировать символы_to_logits_fn

  def _symbols_to_logits_fn ():
  "" "Вычисляет логиты следующих токенов."" "
  def symbols_to_logits_fn (ids, i, temp_cache):
    del ids
    logits = tf.cast (tf.math.log (model_fn (i)), tf.float32)
    вернуть логиты, temp_cache
  вернуть символы_to_logits_fn
  

Жадный

Жадное декодирование выбирает идентификатор токена с наибольшей вероятностью в качестве его следующего идентификатора: $ id_t = argmax_ {w} P (id | id_ {1: t-1}) $ на каждом временном шаге $ t $. На следующем рисунке показано жадное декодирование.

  greedy_obj = sampling_module.SamplingModule (
    length_normalization_fn = Нет,
    dtype = tf.float32,
    символы_to_logits_fn = _symbols_to_logits_fn (),
    voiceab_size = 3,
    max_decode_length = params ['max_decode_length'],
    eos_id = 10,
    padded_decode = Ложь)
ids, _ = greedy_obj.generate (
    initial_ids = tf.constant ([9, 1]), initial_cache = кеш)
print ("Жадно декодированные идентификаторы:", идентификаторы)
  

Жадно декодированные идентификаторы и двоеточие; tf.Tensor (
[[9 1 2 2 2]
 [1 1 1 2 2]], shape = (2, 5), dtype = int32)
 

top_k выборка

В выборке Top-K , K наиболее вероятных идентификаторов следующих токенов фильтруются, и масса вероятности перераспределяется только между этими K идентификаторами.

  top_k_obj = sampling_module.SamplingModule (
    length_normalization_fn = длина_норма,
    dtype = tf.float32,
    символы_to_logits_fn = _symbols_to_logits_fn (),
    voiceab_size = 3,
    max_decode_length = params ['max_decode_length'],
    eos_id = 10,
    sample_temperature = tf.constant (1.0),
    top_k = tf.constant (3),
    padded_decode = Ложь,
    enable_greedy = Ложь)
ids, _ = top_k_obj.generate (
    initial_ids = tf.constant ([9, 1]), initial_cache = кеш)
print ("топ-k выборочных идентификаторов:", ids)
  

ИД и двоеточие, выбранные для выборки топ-k; tf.Тензор(
[[9 1 2 2 2]
 [1 2 1 2 2]], shape = (2, 5), dtype = int32)
 

top_p выборка

Вместо выборки только из наиболее вероятных K идентификаторов токенов, в Top-p выборка выбирает из наименьшего возможного набора идентификаторов, совокупная вероятность которых превышает вероятность p .

  top_p_obj = sampling_module.SamplingModule (
    length_normalization_fn = длина_норма,
    dtype = tf.float32,
    символы_to_logits_fn = _symbols_to_logits_fn (),
    voiceab_size = 3,
    max_decode_length = params ['max_decode_length'],
    eos_id = 10,
    sample_temperature = tf.константа (1.0),
    top_p = tf.constant (0.9),
    padded_decode = Ложь,
    enable_greedy = Ложь)
ids, _ = top_p_obj.generate (
    initial_ids = tf.constant ([9, 1]), initial_cache = кеш)
print ("ID выборки top-p:", ids)
  

идентификаторы выборки top-p и двоеточие; tf.Tensor (
[[9 0 1 1 2]
 [1 0 1 2 2]], shape = (2, 5), dtype = int32)
 

Расшифровка поиска луча

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

  beam_size = 2
params ['batch_size'] = 1
beam_cache = {
    'layer_% d'% layer: {
        'k': tf.zeros ([params ['batch_size'], params ['max_decode_length'], params ['num_heads'], params ['n_dims']], dtype = tf.float32),
        'v': tf.zeros ([params ['batch_size'], params ['max_decode_length'], params ['num_heads'], params ['n_dims']], dtype = tf.float32)
        } для слоя в диапазоне (params ['num_layers'])
    }
print ("форма ключа кэша для слоя 1:", beam_cache ['layer_1'] ['k']. shape)
идентификаторы, _ = beam_search.sequence_beam_search (
    символы_to_logits_fn = _symbols_to_logits_fn (),
    initial_ids = tf.constant ([9], tf.int32),
    initial_cache = кэш-лучей,
    voiceab_size = 3,
    beam_size = beam_size,
    альфа = 0,6,
    max_decode_length = params ['max_decode_length'],
    eos_id = 10,
    padded_decode = Ложь,
    dtype = tf.float32)
print ("Идентификаторы поиска луча:", идентификаторы)
  

форма ключа кэша для слоя 1 & двоеточие; (1, 4, 2, 256)
Идентификаторы поиска луча и двоеточие; tf.Tensor (
[[[9 0 1 2 2]
  [9 1 2 2 2]]], shape = (1, 2, 5), dtype = int32)
 

Расшифровка ДНК потока данных с помощью NLP

Автор: Сатьякам Моханти , руководитель подразделения Leni and Mosaic Applied Intelligence, LTI

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

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

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

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

Вот как NLP может помочь максимально использовать медицинские данные:

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

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

Выявление факторов риска
Неструктурированные данные пациента могут предоставить кладезь информации и дать глубокое понимание состояния пациента. Мол, у пациента депрессия? Каковы бытовые условия больного? Они бездомные? Такие важные данные похоронены в неструктурированных форматах данных. Это может помочь поставщикам медицинских услуг выявлять и выявлять пациентов с повышенным фактором риска и предлагать им целевые программы лечения.

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

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

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

Другие темы, затронутые в серии :
Серия AI Remedy: рецепты для интеллектуальных преобразований
Серия AI Remedy: реформирование отрасли с помощью искусственного интеллекта
Серия AI Remedy: NLG - ускорение пути от данных до принятия решений