Как написать рекуррентную нейронную сеть

В данной статье мы рассмотрим, что такое рекуррентные нейронные сети и как создать нейронную сеть с нуля в Python.

Содержание

• Зачем нужны рекуррентные нейронные сети
• Создание рекуррентной нейронной сети на примере
• Поставление задачи для рекуррентной нейронной сети
• Составление плана для нейронной сети
• Предварительная обработка рекуррентной нейронной сети RNN
• Фаза прямого распространения нейронной сети
• Фаза обратного распространения нейронной сети
• Параметры рассматриваемой нейронной сети
• Тестирование рекуррентной нейронной сети

Рекуррентные нейронные сети (RNN) — это тип нейронных сетей, которые специализируются на обработке последовательностей. Зачастую их используют в таких задачах, как обработка естественного языка (Natural Language Processing) из-за их эффективности в анализе текста. В данной статье мы наглядно рассмотрим рекуррентные нейронные сети, поймем принцип их работы, а также создадим одну сеть в Python, используя numpy.

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

Приступим!

Зачем нужны рекуррентные нейронные сети

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

Входные данные отмечены красным, нейронная сеть RNN — зеленым, а вывод — синим.

Способность обрабатывать последовательности делает рекуррентные нейронные сети RNN весьма полезными. Области использования:

• Машинный перевод (пример Google Translate) выполняется при помощи нейронных сетей с принципом «многие ко многим». Оригинальная последовательность текста подается в рекуррентную нейронную сеть, которая затем создает переведенный текст в качестве результата вывода;
• Анализ настроений часто выполняется при помощи рекуррентных нейронных сетей с принципом «многие к одному». Этот отзыв положительный или отрицательный? Такая постановка является одним из примеров анализа настроений. Анализируемый текст подается нейронную сеть, которая затем создает единственную классификацию вывода. Например — Этот отзыв положительный.

Далее в статье будет показан пример создания рекуррентной нейронной сети по схеме «многие к одному» для анализа настроений.

Создание рекуррентной нейронной сети на примере

Представим, что у нас есть нейронная сеть, которая работает по принципу «многое ко многим«. Входные данные — x0, х1, … xn, а результаты вывода — y0, y1, … yn. Данные xi и yi являются векторами и могут быть произвольных размеров.

Рекуррентные нейронные сети RNN работают путем итерированного обновления скрытого состояния h, которое является вектором, что также может иметь произвольный размер. Стоит учитывать, что на любом заданном этапе t:

1. Следующее скрытое состояние ht подсчитывается при помощи предыдущего ht - 1 и следующим вводом xt;
2. Следующий вывод yt подсчитывается при помощи ht.

Рекуррентная нейронная сеть RNN многие ко многим

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

• Wxh используется для всех связок xt → ht
• Whh используется для всех связок ht-1 → ht
• Why используется для всех связок ht → yt

Для рекуррентной нейронной сети мы также используем два смещения:

• bh добавляется при подсчете ht
• by добавляется при подсчете yt

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

Следующие уравнения являются компактным представлением всего вышесказанного:

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

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

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

Поставление задачи для рекуррентной нейронной сети

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

Вот несколько примеров из небольшого набора данных, который был собран для данной статьи:

Текст	Позитивный?
Я хороший	Да
Я плохой	Нет
Это очень хорошо	Да
Это неплохо	Да
Я плохой, а не хороший	Нет
Я несчастен	Нет
Это было хорошо	Да
Я чувствую себя неплохо, мне не грустно	Да

Составление плана для нейронной сети

В следующем примере будет использована классификация рекуррентной сети «многие к одному». Принцип ее использования напоминает работу схемы «многие ко многим», что была описана ранее. Однако на этот раз будет задействовано только скрытое состояние для одного пункта вывода y:

Рекуррентная нейронная сеть RNN многие к одному

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

Приступим к созданию нашей рекуррентной нейронной сети.

Предварительная обработка рекуррентной нейронной сети RNN

Упомянутый ранее набор данных состоит из двух словарей Python:

True = Позитивное, False = Негативное

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

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

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

Рекуррентная нейронная сеть не различает слов — только числа.

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

Так как в словаре 18 уникальных слов, каждый xi будет 18-мерным унитарным вектором.

Мы используем createInputs() позже для создания входных данных в виде векторов и последующей их передачи в рекуррентную нейронную сеть RNN.

Фаза прямого распространения нейронной сети

Пришло время для создания рекуррентной нейронной сети. Начнем инициализацию с тремя параметрами веса и двумя смещениями.

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

Для инициализации веса из стандартного нормального распределения мы используем np.random.randn().

Затем мы реализуем прямую передачу рассматриваемой нейронной сети. Помните первые два уравнения, рассматриваемые ранее?

Эти же уравнения, реализованные в коде:

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

Давайте попробуем следующее:

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

Фаза обратного распространения нейронной сети

Для тренировки рекуррентной нейронной сети будет использована функция потери. Здесь будет использована потеря перекрестной энтропии, которая в большинстве случаев совместима с функцией Softmax. Формула для подсчета:

Здесь pc является предсказуемой вероятностью рекуррентной нейронной сети для класса correct (позитивный или негативный). Например, если позитивный текст предсказывается рекуррентной нейронной сетью как позитивный текст на 90%, то потеря составит:

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

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

Оригиналы всех кодов, которые использованы в данной инструкции, доступны на GitHub.

Готовы? Продолжим!

Параметры рассматриваемой нейронной сети

Параметры данных, которые будут использованы в дальнейшем:

• y — необработанные входные данные нейронной сети;
• р — конечная вероятность: р = softmax(y);
• с — истинная метка определенного образца текста, так называемый «правильный» класс;
• L — потеря перекрестной энтропии: L = -ln(pc);
• Wxh, Whh и Why — три матрицы веса в рассматриваемой нейронной сети;
• bh и by — два вектора смещения в рассматриваемой рекуррентной нейронной сети RNN.

Установка

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

Градиенты

Настало время математики! Начнем с вычисления . Что нам известно:

Здесь используется фактическое значение , а также применяется дифференцирование сложной функции. Результат следующий:

К примеру, если p = [0.2, 0.2, 0.6], а корректным классом является с = 0, то конечным результатом будет значение = [-0.8, 0.2, 0.6]. Данное выражение несложно перевести в код:

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

Здесь hn является конечным скрытым состоянием. Таким образом:

Аналогичным способом вычисляем:

Теперь можно приступить к реализации backprop().​

Напоминание: мы создали self.last_hs в forward() в предыдущих примерах.

Наконец, нам понадобятся градиенты для Whh, Wxh, и bh, которые использовались в каждом шаге нейронной сети. У нас есть:

Изменение Wxh влияет не только на каждый ht, но и на все у , что, в свою очередь, приводит к изменениям в L. Для того, чтобы полностью подсчитать градиент Wxh, необходимо провести обратное распространение через все временные шаги. Его также называют Обратным распространением во времени, или Backpropagation Through Time (BPTT):

Обратное распространение во времени

Wxh используется для всех прямых ссылок xt → ht, поэтому нам нужно провести обратное распространение назад к каждой из этих ссылок.

Приблизившись к заданному шагу t, потребуется подсчитать :

Производная гиперболической функции tanh нам уже известна:

Используем дифференцирование сложной функции, или цепное правило:

Аналогичным способом вычисляем:

Последнее нужное значение — . Его можно подсчитать рекурсивно:

Реализуем обратное распространение во времени, или BPTT, отталкиваясь от скрытого состояния в качестве начальной точки. Далее будем работать в обратном порядке. Поэтому на момент подсчета значение будет известно. Исключением станет только последнее скрытое состояние hn:

Теперь у нас есть все необходимое, чтобы наконец реализовать обратное распространение во времени ВРТТ и закончить backprop():

Моменты, на которые стоит обратить внимание:

Мы сделали это! Наша рекуррентная нейронная сеть готова.

Тестирование рекуррентной нейронной сети

Наконец настал тот момент, которого мы так долго ждали — протестируем готовую рекуррентную нейронную сеть.

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

Теперь можно написать цикл для тренировки сети:

Результат вывода main.py выглядит следующим образом:

Неплохо для рекуррентной нейронной сети, которую мы построили сами!

Хотите поэкспериментировать с этим кодом сами? Можете запустить данную рекуррентную нейронную сеть RNN у себя в браузере. Она также доступна на GitHub.

Подведем итоги

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

• Подробнее ознакомьтесь с LTSM. Это долгая краткосрочная память, которая характерна более мощной архитектурой рекуррентных нейронных сетей. Будет не лишним ознакомиться с управляемым рекуррентными блоками, или GRU. Это наиболее популярная вариация LTSM;
• Поэкспериментируйте с более крупными и сложными RNN. Для этого используйте подходящие ML библиотеки, например, Tensorflow, Keras или PyTorch;
• Прочтите о двунаправленных нейронных сетях, которые обрабатывают последовательности как в прямом, так и в обратном направлении. Это позволяет получить больше информации на уровне вывода;
• Ознакомьтесь с векторными представлением слов. Для этого можно использовать GloVe или Word2Vec;
• Познакомьтесь поближе с Natural Language Toolkit (NLTK), популярной библиотекой Python для работы с данными на языках, которые используют люди, а не машины.

Благодарим за внимание!

N+1 совместно с МФТИ продолжает знакомить читателя с наиболее яркими аспектами современных исследований в области искусственного интеллекта. В прошлый раз мы писали об общих принципах машинного обучения и конкретно о методе обратного распространения ошибки для обучения нейросетей. Сегодня наш собеседник — Валентин Малых, младший научный сотрудник Лаборатории нейронных систем и глубокого обучения. Вместе с ним мы поговорим о необычном классе этих систем — рекуррентных нейросетях, их особенностях и перспективах, как на поприще всевозможных развлечений в стиле DeepDream, так и в «полезных» областях. Поехали.

Что такое рекуррентные нейросети (РНС) и чем они отличаются от обычных?
Давайте сначала вспомним, что такое «обычные» нейросети, и тогда сразу станет понятно, чем они отличаются от реккурентных. Представим себе самую простую нейросеть — перцептрон. Он представляет собой один слой нейронов, каждый из которых принимает кусочек входных данных (один или несколько битов, действительных чисел, пикселей и т.п.), модифицирует его с учетом собственного веса и передает дальше. В однослойном перцептроне выдача всех нейронов объединяется тем или иным образом, и нейросеть дает ответ, но возможности такой архитектуры сильно ограниченны. Если вы хотите получить более продвинутый функционал, можно пойти несколькими путями, например, увеличить количество слоев и добавить операцию свертки, которая бы «расслаивала» входящие данные на кусочки разных масштабов. В этом случае у вас получатся сверточные нейросети для глубинного обучения, которые преуспели в обработке изображений и распознавании котиков. Однако что у примитивного перцептрона, что у сверточной нейросети есть общее ограничение: и входные и выходные данные имеют фиксированный, заранее обозначенный размер, например, картинка 100×100 пикселей или последовательность из 256 бит. Нейросеть с математической точки зрения ведет себя как обычная функция, хоть и очень сложно устроенная: у нее есть заранее обозначенное число аргументов, а также обозначенный формат, в котором она выдает ответ. Простой пример — функция x², она принимает один аргумент и выдает одно значение. 
Вышеперечисленные особенности не представляет больших трудностей, если речь идет о тех же картинках или заранее определенных последовательностях символов. Но что, если вы хотите использовать нейросеть для обработки текста или музыки? В общем случае — любой условно бесконечной последовательности, в которой важно не только содержание, но и порядок, в котором следует информация. Вот для этих задач и были придуманы рекуррентные нейросети. Их противоположности, которые мы называли «обычными», имеют более строгое название — нейросети прямого распространения (feed-forward neural networks), так как в них информация передается только вперед по сети, от слоя к слою. В рекуррентных нейросетях нейроны обмениваются информацией между собой: например, вдобавок к новому кусочку входящих данных нейрон также получает некоторую информацию о предыдущем состоянии сети. Таким образом в сети реализуется «память», что принципиально меняет характер ее работы и позволяет анализировать любые последовательности данных, в которых важно, в каком порядке идут значения — от звукозаписей до котировок акций.

Наличие памяти у рекуррентных нейросетей позволяет несколько расширить нашу аналогию с x

²

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

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

Вероятно, первой РНС была сеть Хопфилда (впервые упомянута в 1974 году, окончательно оформилась в 1982-м), которая реализовывала на практике ячейку ассоциативной памяти. От современных РНС она отличается тем, что работает с последовательностями фиксированного размера. В простейшем случае сеть Хопфилда имеет один слой внутренних нейронов, связанных между собой, а каждая связь характеризуется определенным весом, задающим ее значимость. С такой сетью ассоциируется некий эквивалент физической «энергии», который зависит от всех весов в системе. Сеть можно обучить при помощи градиентного спуска по энергии, когда минимум соответствует состоянию, в котором сеть «запомнила» определенный шаблон, например 10101. Теперь, если ей на вход подать искаженный, зашумленный или неполный шаблон, скажем, 10000, она «вспомнит» и восстановит его аналогично тому, как работает ассоциативная память у человека. Эта аналогия достаточно отдаленна, поэтому не стоит воспринимать ее чересчур серьезно. Тем не менее, сети Хопфилда успешно справлялись со своей задачей и обходили по возможностям существовавшие тогда перцептроны. Интересно, что оригинальная публикация Джона Хопфилда в Proceedings of the National Academy of Sciences вышла в разделе «Биофизика».

Следующим шагом в эволюции РНС была

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

1100

и

0110

, можно ли их считать одним и тем же набором, сдвинутым во времени? Конечно, можно, но как обучить этому нейросеть? Обычный перцептрон легко запомнит эту закономерность для любых примеров, которые ему предложат, но каждый раз это будет задачей сравнения двух разных сигналов, а не задачей об эволюции или сдвиге одного и того же сигнала. Решение Элмана, основанное на предыдущих наработках в этой области, основывалось на том, что в простую нейросеть добавлялся еще один — «контекстный» — слой, в который просто копировалось состояние внутреннего слоя нейронов на каждом цикле работы сети. При этом связь между контекстным и внутренним слоями можно было обучать. Такая архитектура позволяла сравнительно легко воспроизводить временные ряды, а также обрабатывать последовательности произвольной длины, что резко отличало простую РНС Элмана от предыдущих концепций. Более того, эта сеть смогла распознать и даже классифицировать существительные и глаголы в предложении, основываясь только на порядке слов, что было настоящим прорывом для своего времени и вызвало огромный интерес как лингвистов, так и специалистов по исследованию сознания.

За простой РНС Элмана последовали все новые разработки, а в 1997 году Хохрейтер и Шмидхубер опубликовали статью «

» («долгосрочная краткосрочная память», также существует множество других вариаций перевода), заложившую основу для большинства современных РНС. В своей работе авторы описывали модификацию, решавшую проблему долгосрочной памяти простых РНС: их нейроны хорошо «помнят» недавно полученную информацию, но не имеют возможности надолго сохранить в памяти что-то, что обработали много циклов назад, какой бы важной та информация ни была. В LSTM-сетях внутренние нейроны «оборудованы» сложной системой так называемых ворот (gates), а также концепцией клеточного состояния (cell state), которая и представляет собой некий вид долгосрочной памяти. Ворота же определяют, какая информация попадет в клеточное состояние, какая сотрется из него, и какая повлияет на результат, который выдаст РНС на данном шаге. Подробно разбирать LSTM мы не будем, однако отметим, что именно эти вариации РНС широко используется сейчас, например, для машинного перевода Google.

Все прекрасно звучит на словах, но что все-таки РНС умеют делать? Вот дали им текст почитать или музыку послушать — а дальше что?

Одна из главных областей применения РНС на сегодняшний день — работа с языковыми моделями, в частности — анализ контекста и общей связи слов в тексте. Для РНС структура языка — это долгосрочная информация, которую надо запомнить. К ней относятся грамматика, а также стилистические особенности того корпуса текстов, на которых производится обучение. Фактически РНС запоминает, в каком порядке обычно следуют слова, и может дописать предложение, получив некоторую затравку. Если эта затравка случайная, может получиться совершенно бессмысленный текст, стилистически напоминающий шаблон, на котором училась РНС. Если же исходный текст был осмысленным, РНС поможет его стилизовать, однако в последнем случае одной РНС будет мало, так как результат должен представлять собой «смесь» случайного, но стилизованного текста от РНС и осмысленной, но «неокрашенной» исходной части. Эта задача уже настолько напоминает популярные ныне

для обработки фотографий в стиле Моне и Ван Гога, что невольно напрашивается аналогия.

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

и с музыкой (также с помощью сверточных нейросетей): в этом случае мелодия является содержанием, а аранжировка — стилем. И вот с написанием музыки РНС как раз успешно

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

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

смысла

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

выглядеть

текст в определенном стиле, но создать и донести какую-то идею или информацию РНС (пока) не могут.

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

язык

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

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

«Генерация бреда» это забавно, но бессмысленно, а для каких настоящих задач применяются РНС?

Разумеется, РНС, помимо развлекательных, должны преследовать и более прагматичные цели. Из их дизайна автоматически следует, что главные области их применения должны быть требовательны к контексту и/или временной зависимости в данных, что по сути одно и то же. Поэтому РНС используются, к примеру, для анализа изображений. Казалось бы, эта область обычно воспринимается в контексте сверточных нейросетей, однако и для РНС здесь находятся задачи: их архитектура позволяет быстрее распознавать детали, основываясь на контексте и окружении. Аналогичным образом РНС работают в сферах анализа и генерации текстов. Из более необычных задач можно

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

А каковы успехи РНС в машинном переводе? В Google Translate ведь именно они используются?

На текущий момент в Google для машинного перевода

РНС типа LSTM, что позволило добиться наибольшей точности по сравнению с существующими аналогами, однако, по словам самих авторов, машинному переводу еще очень далеко до уровня человека. Сложности, с которыми сталкиваются нейросети в задачах перевода, обусловлены сразу несколькими факторами: во-первых, в любой задаче существует неизбежный размен между качеством и скоростью. На данный момент человек очень сильно опережает искусственный интеллект по этому показателю. Поскольку машинный перевод чаще всего используется в онлайн-сервисах, разработчики вынуждены жертвовать точностью в угоду быстродействию. В недавней публикации Google на эту тему разработчики подробно описывают многие решения, которые позволили оптимизировать текущую версию Google Translate, однако проблема до сих пор остается. Например, редкие слова, или сленг, или нарочитое искажение слова (например, для более яркого заголовка) может сбить с толку даже переводчика-человека, которому придется потратить время, чтобы подобрать наиболее адекватный аналог в другом языке. Машину же такая ситуация поставит в полный тупик, и переводчик будет вынужден «выбросить» сложное слово и оставить его без перевода. В итоге проблема машинного перевода не настолько обусловлена архитектурой (РНС успешно справляются с рутинными задачами в этой области), насколько сложностью и многообразием языка. Радует то, что эта проблема имеет более технический характер, чем написание осмысленных текстов, где, вероятно, требуется кардинально новый подход.

А более необычные способы применения РНС есть? Вот нейронная машина Тьюринга, например, в чем тут идея?

Нейронная машина Тьюринга (

), предложенная два года назад коллективом из Google DeepMind, отличается от других РНС тем, что последние на самом деле не хранят информацию в явном виде — она кодируется в весах нейронов и связей, даже в продвинутых вариациях вроде LSTM. В нейронной машине Тьюринга разработчики придерживались более понятной идеи «ленты памяти», как в классической машине Тьюринга: в ней информация в явном виде записывается «на ленту» и может быть считана в случае необходимости. При этом отслеживание того, какая информация нужна, ложится на особую нейросеть-контроллер. В целом можно отметить, что идея НМТ действительно завораживает своей простотой и доступностью для понимания. С другой стороны, в силу технических ограничений современного аппаратного обеспечения применить НМТ на практике не представляется возможным, потому что обучение такой сети становится чрезвычайно долгим. В этом смысле РНС являются промежуточным звеном между более простыми нейросетями и НМТ, так как хранят некий «слепок» информации, который при этом не смертельно ограничивает их быстродействие.

А что такое концепция внимания применительно к РНС? Что нового она позволяет делать?

Концепция внимания (attention) — это способ «подсказать» сети, на что следует потратить больше внимания при обработке данных. Другими словами, внимание в рекуррентной нейронной сети — это способ увеличить важность одних данных по сравнению с другими. Поскольку человек не может выдавать подсказки каждый раз (это нивелировало бы всю пользу от РНС), сеть должна научиться подсказывать себе сама. Вообще, концепция внимания является очень сильным инструментом в работе с РНС, так как позволяет быстрее и качественнее подсказать сети, на какие данные стоит обращать внимание, а на какие — нет. Также этот подход может в перспективе решить проблему быстродействия в системах с большим объемом памяти. Чтобы лучше понять, как это работает, надо рассмотреть две модели внимания: «мягкую» (soft) и «жесткую» (hard). В первом случае сеть все равно обратится ко всем данным, к которым имеет доступ, но значимость (то есть вес) этих данных будет разной. Это делает РНС более точной, но не более быстрой. Во втором случае из всех существующих данных сеть обратится лишь к некоторым (у остальных будут нулевые веса), что решает сразу две проблемы. Минусом «жесткой» концепции внимания является тот факт, что эта модель перестает быть непрерывной, а значит — дифференцируемой, что резко усложняет задачу ее обучения. Тем не менее, существуют решения, позволяющие исправить этот недостаток. Поскольку концепция внимания активно развивается в последние пару лет, нам остается ждать в ближайшее время новостей с этого поля.
Под конец можно привести пример системы, использующей концепцию внимания: это Dynamic Memory Networks — разновидность, предложенная исследовательским подразделением Facebook. В ней разработчики описывают «модуль эпизодической памяти» (episodic memory module), который на основании памяти о событиях, заданных в виде входных данных, а также вопроса об этих событиях, создает «эпизоды», которые в итоге помогают сети найти правильный ответ на вопрос. Такая архитектура была опробована на bAbI, крупной базе сгенерированных заданий на простой логический вывод (например, дается цепочка из трех фактов, нужно выдать правильный ответ: «Мэри дома. Она вышла во двор. Где Мэри? Во дворе».), и показала результаты, превосходящие классические архитектуры вроде LSTM.
Что еще происходит в мире рекуррентных нейросетей прямо сейчас?
По словам Андрея Карпатого (Andrej Karpathy) — специалиста по нейросетям и автора превосходного блога, «концепция внимания — это самое интересное из недавних архитектурных решений в мире нейросетей». Однако не только на внимании акцентируются исследования в области РНС. Если постараться кратко сформулировать основной тренд, то им сейчас стало сочетание различных архитектур и применение наработок из других областей для улучшения РНС. Из примеров можно назвать уже упомянутые нейросети от Google, в которых используют методы, взятые из работ по обучению с подкреплением, нейронные машины Тьюринга, алгоритмы оптимизации вроде Batch Normalization и многое другое, — все это вместе заслуживает отдельной статьи. В целом отметим, что хотя РНС не привлекли столь же широкого внимания, как любимцы публики — сверточные нейросети, это объясняется лишь тем, что объекты и задачи, с которыми работают РНС, не так бросаются в глаза, как DeepDream или Prisma. Это как в социальных сетях — если пост публикуют без картинки, ажиотажа вокруг него будет меньше.
Поэтому всегда публикуйтесь с картинкой.

Тарас Молотилин

  Перевод

  Ссылка на автора

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

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

Что такое RNN?

Рекуррентная нейронная сеть — это нейронная сеть, которая специализируется на обработке последовательности данных.x(t)= x(1), . . . , x(τ)с индексом временного шагаtначиная от1 to τ, Для задач, которые включают последовательные вводы, такие как речь и язык, часто лучше использовать RNN. В задаче НЛП, если вы хотите предсказать следующее слово в предложении, важно знать слова перед ним. RNNs называютсявозвратныйпотому что они выполняют одну и ту же задачу для каждого элемента последовательности с выходом, зависящим от предыдущих вычислений. Еще один способ думать о RNN — это то, что у них есть «память», которая собирает информацию о том, что было рассчитано до сих пор.

Архитектура:Давайте кратко пройдемся по базовой сети RNN.

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

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

Скрытое состояние: ч (т)Представляет скрытое состояние в момент времени t и действует как «память» сети.ч (т)Рассчитывается на основе текущего ввода и скрытого состояния предыдущего временного шага:h(t)​ = f(U x(t)​ + W h(t−1)​).Функцияfпринимается за нелинейное преобразование, такое какTANH,РЕЛУ.

Веса: RNN имеет вход для скрытых соединений, параметризованных весовой матрицей U, скрытых к скрытым рекуррентным соединениям, параметризованным весовой матрицей W, и скрытых к выходу соединений, параметризованных весовой матрицей V и всеми этими весами (U,В,W)распределяются по времени.

Выход:о (т)Иллюстрирует вывод сети. На рисунке я просто поместил стрелку послео (т)который также часто подвергается нелинейности, особенно когда сеть содержит дополнительные уровни ниже по потоку.

Форвард Пасс

На рисунке не указан выбор функции активации для скрытых юнитов. Прежде чем продолжить, сделаем несколько предположений: 1) мы предполагаем гиперболическую касательную функцию активации для скрытого слоя. 2) Мы предполагаем, что выходные данные являются дискретными, как будто RNN используется для предсказания слов или символов. Естественным способом представления дискретных переменных является учет выходных данных.oкак предоставление ненормированных логарифмических вероятностей каждого возможного значения дискретной переменной. Затем мы можем применить операцию softmax в качестве шага постобработки, чтобы получить векторŷнормированных вероятностей на выходе.

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

Это пример рекуррентной сети, которая отображает входную последовательность на выходную последовательность той же длины. Общая потеря для данной последовательностиxзначения в паре с последовательностьюyЗначения тогда будут просто суммой потерь за все временные шаги. Мы предполагаем, что выводыo(t)используются в качестве аргумента функции softmax для получения вектораŷвероятностей на выходе. Мы также предполагаем, что потеряLотрицательная логарифмическая вероятность истинной целиy(t)учитывая вклад до сих пор.

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

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

Вычислительные градиенты

Учитывая нашу функцию потерьLнам нужно вычислить градиенты для наших трех весовых матрицU, V, W иусловия смещенияДо нашей эрыи обновить ихсо скоростью обученияα, Подобно нормальному обратному распространению, градиент дает нам представление о том, как изменяется потеря по отношению к каждому весовому параметру. Мы обновляем веса W, чтобы минимизировать потери с помощью следующего уравнения:

То же самое должно быть сделано и для других весов U, V, b, c.

Давайте теперь вычислим градиенты по BPTT для приведенных выше уравнений RNN. Узлы нашего вычислительного графа включают в себя параметры U, V, W, b и c, а также последовательность узлов, индексированных t для x (t), h (t), o (t) и L (t). Для каждого узлаnнам нужно вычислить градиент∇nLрекурсивно, на основе градиента, вычисленного в узлах, следующих за ним в графе.

Градиент по выходу o (t)рассчитывается при условии, что o (t) используются в качестве аргумента функции softmax для получения вектораŷвероятностей на выходе. Мы также предполагаем, что потеря является отрицательной логарифмической вероятностью истинной цели y (t).

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

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

Мы работаем в обратном направлении, начиная с конца последовательности. На конечном шаге по времени τ h (τ) имеет только o (τ) в качестве потомка, поэтому его градиент прост:

Затем мы можем выполнить итерацию назад во времени для обратного распространения градиентов во времени, от t = τ − 1 до t = 1, отметив, что h (t) (для t <τ) имеет в качестве потомков o (t) и h ( T + 1). Таким образом, его градиент определяется как:

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

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

Реализация

Мы реализуем полную Рекуррентную Нейронную Сеть с нуля, используя Python. Мы попытаемся построить модель генерации текста с использованием RNN. Мы обучаем нашу модель прогнозированию вероятности персонажа с учетом предыдущих символов. Этогенеративная модель, Учитывая существующую последовательность символов, мы выбираем следующий символ из предсказанных вероятностей и повторяем процесс, пока у нас не будет полного предложения. Эта реализация от Андрея Карпарти отличный пост построение уровня персонажа RNN. Здесь мы обсудим детали реализации шаг за шагом.

Общие шаги, чтобы следовать:

1. Инициализировать весовые матрицыU, V, Wот случайного распределенияи смещение b, c с нулями
2. Прямое распространение для вычисления прогнозов
3. Вычислить потери
4. Обратное распространение для вычисления градиентов
5. Обновление весов на основе градиентов
6. Повторите шаги 2–5

Шаг 1: Инициализация

Чтобы начать с реализации базовой ячейки RNN, мы сначала определим размеры различных параметров U, V, W, b, c.

Размеры: Допустим, мы выбрали размер словаряvocab_size= 8000и скрытый размер слояhidden_size=100, Тогда мы имеем:

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

С нашими немногими гиперпараметрами и другими параметрами модели давайте начнем определять нашу ячейку RNN.

Правильная инициализация весов, похоже, влияет на результаты тренировок, в этой области было проведено много исследований. Оказывается, что лучшая инициализация зависит от функции активации (в нашем случае tanh) и одной рекомендуемые подход состоит в том, чтобы инициализировать веса случайным образом в интервале от[ -1/sqrt(n), 1/sqrt(n)]гдеnэто количество входящих соединений с предыдущего слоя.

Шаг 2: прямой проход

В соответствии с нашими уравнениями для каждой временной метки t мы вычисляем скрытое состояние hs [t] и выводим os [t], применяя softmax, чтобы получить вероятность для следующего символа.

Вычисление softmax и численная стабильность:

Функция Softmax берет N-мерный вектор действительных чисел и преобразует его в вектор действительного числа в диапазоне (0,1), который складывается в 1. Отображение выполняется с использованием приведенной ниже формулы

Реализация softmax это:

Хотя это выглядит хорошо, однако, когда мы называем это softmax с большим числом, как показано ниже, это дает значения «nan»

Числовой диапазон чисел с плавающей точкой, используемых Numpy, ограничен. Для float64 максимальное представляемое число порядка 10³⁰⁸. Экспонирование в функции softmax позволяет легко сбросить это число, даже для входов довольно скромного размера. Хороший способ избежать этой проблемы — нормализовать входные данные, чтобы они не были слишком большими или слишком маленькими. Существует небольшой математический трюк Вот для деталей. Итак, наш софтмакс выглядит так:

Шаг 3: вычислить потери

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

• M — количество возможных меток классов (уникальные символы в нашем словаре)
• y — двоичный индикатор (0 или 1) того, является ли метка классаCправильная классификация для наблюденияO
• р — прогнозируемая вероятность модели, что наблюдение

Шаг 4: обратный проход

Если мы обращаемся к уравнениям BPTT, реализация осуществляется в соответствии с уравнениями. Добавлены достаточные комментарии, чтобы понять код.

вопросы

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

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

Это исчезающее ограничение градиента было преодолено различными сетями, такими как длинная кратковременная память (LSTM), стробируемые рекуррентные блоки (GRU) и остаточные сети (ResNets), где первые две являются наиболее часто используемыми вариантами RNN в приложениях NLP.

Шаг 5: Обновление весов

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

В оригинале реализация Андрей Карпарти, Adagrad используется для обновления градиента. Адаград работает намного лучше, чем СГД. Пожалуйста, проверьте и сравните оба.

Шаг 6: повторите шаги 2–5

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

Создать текст

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

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

Давайте посмотрим, как наш RNN учится после нескольких эпох обучения.

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

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

Бонус:Хотите увидеть, что на самом деле происходит во время обучения RNN, смотрите Вот,

Надеюсь, что это было полезно для вас. Спасибо за прочитанное.

Ссылки:

[1] http://www.deeplearningbook.org/contents/rnn.html

[2] https://gist.github.com/karpathy/d4dee566867f8291f086

[3] http://www.wildml.com/2015/09/recurrent-neural-networks-tutorial-part-1-introduction-to-rnns/

[4] https://medium.com/towards-artificial-intelligence/whirlwind-tour-of-rnns-a11effb7808f

Перевод руководства по рекуррентным нейросетям с сайта Tensorflow.org. В материале рассматриваются как встроенные возможности Keras/Tensorflow 2.0 по быстрому построению сеток, так и возможности кастомизации слоев и ячеек. Также рассматриваются случаи и ограничения использования ядра CuDNN позволяющего ускорить процесс обучения нейросети.

Рекуррентные нейронные сети (RNN) — это класс нейронных сетей, которые хороши для моделирования последовательных данных, таких как временные ряды или естественный язык.

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

Keras RNN API разработан с фокусом на:

Простоту использования: встроенные слои tf.keras.layers.RNN, tf.keras.layers.LSTM, tf.keras.layers.GRU позволяют вам быстро построить рекуррентные модели без необходимости делать сложные конфигурационные настройки.

Простота кастомизации: Вы можете также задать собственный слой ячеек RNN (внутреннюю часть цикла for) с кастомным поведением и использовать его с общим слоем `tf.keras.layers.RNN` (сам цикл `for`). Это позволит вам быстро прототипировать различные исследовательские идеи в гибкой манере, с минимумом кода.

Установка

from __future__ import absolute_import, division, print_function, unicode_literals

import collections
import matplotlib.pyplot as plt
import numpy as np

import tensorflow as tf

from tensorflow.keras import layers

Построение простой модели

В Keras есть три встроенных слоя RNN:

1. tf.keras.layers.SimpleRNN, полносвязная RNN в которой выход предыдущего временного шага должен быть передан в следующий шаг.
2. tf.keras.layers.GRU, впервые предложен в статье Изучение представлений фраз с использованием кодера-декодера RNN для статистического машинного перевода
3. tf.keras.layers.LSTM, впервые предложен в статье Долгая краткосрочная память

В начале 2015, у Keras появились первые переиспользуемые реализации LSTM и GRU на Python с открытым исходным кодом.

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

model = tf.keras.Sequential()
# Добавим слой Embedding ожидая на входе словарь размера 1000, и
# на выходе вложение размерностью 64.
model.add(layers.Embedding(input_dim=1000, output_dim=64))

# Добавим слой LSTM с 128 внутренними узлами.
model.add(layers.LSTM(128))

# Добавим слой Dense с 10 узлами и активацией softmax.
model.add(layers.Dense(10))

model.summary()

Выходы и состояния

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

Слой RNN может также возвращать всю последовательность выходных данных для каждого элемента (по одному вектору на каждый шаг), если вы укажете return_sequences=True. Размерность этих выходных данных равна (batch_size, timesteps, units).

model = tf.keras.Sequential()
model.add(layers.Embedding(input_dim=1000, output_dim=64))

# Выходом GRU будет 3D тензор размера (batch_size, timesteps, 256)
model.add(layers.GRU(256, return_sequences=True))

# Выходом SimpleRNN будет 2D тензор размера (batch_size, 128)
model.add(layers.SimpleRNN(128))

model.add(layers.Dense(10))

model.summary()

Кроме того, слой RNN может вернуть свое конечное внутреннее состояние (состояния).

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

Для того чтобы слой RNN возвращал свое внутреннего состояния, установите параметр return_state в значение True при создании слоя. Обратите внимание, что у LSTM 2 тензора состояния, а у GRU только один.

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

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

encoder_vocab = 1000
decoder_vocab = 2000

encoder_input = layers.Input(shape=(None, ))
encoder_embedded = layers.Embedding(input_dim=encoder_vocab, output_dim=64)(encoder_input)

# Возвращает состояния в добавление к выходным данным
output, state_h, state_c = layers.LSTM(
    64, return_state=True, name='encoder')(encoder_embedded)
encoder_state = [state_h, state_c]

decoder_input = layers.Input(shape=(None, ))
decoder_embedded = layers.Embedding(input_dim=decoder_vocab, output_dim=64)(decoder_input)

# Передает 2 состояния в новый слой LSTM в качестве начального состояния
decoder_output = layers.LSTM(
    64, name='decoder')(decoder_embedded, initial_state=encoder_state)
output = layers.Dense(10)(decoder_output)

model = tf.keras.Model([encoder_input, decoder_input], output)
model.summary()

RNN слои и RNN ячейки

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

Ячейка находится внутри цикла for слоя RNN. Оборачивание ячейки слоем tf.keras.layers.RNN дает вам слой способный обрабатывать пакеты последовательностей, напр. RNN(LSTMCell(10)).

Математически, RNN(LSTMCell(10)) дает тот же результат, что и LSTM(10). Фактически, реализацией этого слоя внутри TF v1.x было лишь создание соответствующей RNN ячейки и оборачивание ее в слой RNN. Однако использование встроенных слоев GRU и LSTM позволяет использовать CuDNN что может дать лучшую производительность.

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

• tf.keras.layers.SimpleRNNCell соответствует слою SimpleRNN.
• tf.keras.layers.GRUCell соответствует слою GRU.
• tf.keras.layers.LSTMCell соответствует слою LSTM.

Абстракция ячейки вместе с общим классом tf.keras.layers.RNN, позволяет очень легко реализовать кастомные RNN архитектуры для ваших исследований.

Кросс-пакетное сохранение состояния

При обработке длинных последовательностей (возможно бесконечных), вы можете захотеть использовать паттерн кросс-пакетное сохранение состояния (cross-batch statefulness).

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

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

Вы можете сделать это установив в конструкторе `stateful=True`.

Если у вас есть последовательность `s = [t0, t1,… t1546, t1547]`, вы можете разбить ее например на:

s1 = [t0, t1, ... t100]
s2 = [t101, ... t201]
...
s16 = [t1501, ... t1547]

Потом вы можете обработать ее с помощью:

lstm_layer = layers.LSTM(64, stateful=True)
for s in sub_sequences:
  output = lstm_layer(s)

Когда вы захотите почистить состояние, используйте layer.reset_states().

Примечание: В этом случае, предполагается что пример i в данном пакете является продолжением примера i предыдущего пакета. Это значит, что все пакеты содержат одинаковое количество элементов (размер пакета). Например, если пакет содержит [sequence_A_from_t0_to_t100, sequence_B_from_t0_to_t100], следующий пакет должен содержать [sequence_A_from_t101_to_t200, sequence_B_from_t101_to_t200].

Приведем полный пример:

paragraph1 = np.random.random((20, 10, 50)).astype(np.float32)
paragraph2 = np.random.random((20, 10, 50)).astype(np.float32)
paragraph3 = np.random.random((20, 10, 50)).astype(np.float32)

lstm_layer = layers.LSTM(64, stateful=True)
output = lstm_layer(paragraph1)
output = lstm_layer(paragraph2)
output = lstm_layer(paragraph3)

# reset_states() сбосит кешированное состояние до изначального initial_state.
# Если initial_state не было задано, по умолчанию будут использованы нулевые состояния.
lstm_layer.reset_states()

Двунаправленные RNN

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

Keras предоставляет простой API для создания таких двунаправленных сетей RNN: обертку tf.keras.layers.Bidirectional.

model = tf.keras.Sequential()

model.add(layers.Bidirectional(layers.LSTM(64, return_sequences=True), 
                               input_shape=(5, 10)))
model.add(layers.Bidirectional(layers.LSTM(32)))
model.add(layers.Dense(10))

model.summary()

Под капотом, Bidirectional скопирует переданный слой RNN layer, и перевернет поле go_backwards вновь скопированного слоя, и таким образом входные данные будут обработаны в обратном порядке.

На выходе`Bidirectional RNN по умолчанию будет сумма вывода прямого слоя и вывода обратного слоя. Если вам нужно другое поведение слияния, напр. конкатенация, поменяйте параметр `merge_mode` в конструкторе обертки `Bidirectional`.

Оптимизация производительности и ядра CuDNN в TensorFlow 2.0

В TensorFlow 2.0, встроенные слои LSTM и GRU пригодны для использования ядер CuDNN по умолчанию, если доступен графический процессор. С этим изменением предыдущие слои keras.layers.CuDNNLSTM/CuDNNGRU устарели, и вы можете построить свою модель, не беспокоясь об оборудовании, на котором она будет работать.

Поскольку ядро CuDNN построено с некоторыми допущениями, это значит, что слой не сможет использовать слой CuDNN kernel если вы измените параметры по умолчанию встроенных слоев LSTM или GRU. Напр:

• Изменение функции activation с tanh на что-то другое.
• Изменение функции recurrent_activation с sigmoid на что-то другое.
• Использование recurrent_dropout > 0.
• Установка unroll равным True, что заставляет LSTM/GRU декомпозировать внутренний tf.while_loop в развернутый цикл for.
• Установка use_bias равным False.
• Использование масок, когда входные данные не выровнены строго справа (если маска соответствует строго выровненным справа данным, CuDNN может быть все еще использовано. Это наиболее распространенный случай).

Когда это возможно используйте ядра CuDNN

batch_size = 64
# Каждый пакет изображений MNIST это тензор размерностью (batch_size, 28, 28).
# Каждая входная последовательность размера (28, 28) (высота рассматривается как время).
input_dim = 28

units = 64
output_size = 10  # метки от 0 до 9

# Построим RNN модель
def build_model(allow_cudnn_kernel=True):
  # CuDNN доступен только на уровне слоя, а не на уровне ячейки.
  # Это значит `LSTM(units)` будет использовать ядро CuDNN,
  # тогда как RNN(LSTMCell(units)) будет использовать non-CuDNN ядро.
  if allow_cudnn_kernel:
    # Слой LSTM с параметрами по умолчанию использует CuDNN.
    lstm_layer = tf.keras.layers.LSTM(units, input_shape=(None, input_dim))
  else:
    # Обертка LSTMCell слоем RNN не будет использовать CuDNN.
    lstm_layer = tf.keras.layers.RNN(
        tf.keras.layers.LSTMCell(units),
        input_shape=(None, input_dim))
  model = tf.keras.models.Sequential([
      lstm_layer,
      tf.keras.layers.BatchNormalization(),
      tf.keras.layers.Dense(output_size)]
  )
  return model

Загрузка датасета MNIST

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
sample, sample_label = x_train[0], y_train[0]

Создайте экземпляр модели и скомпилируйте его

Мы выбрали sparse_categorical_crossentropy в качестве функции потерь. Выходные данные модели имеют размерность [batch_size, 10]. Ответом модели является целочисленный вектор, каждое из чисел находится в диапазоне от 0 до 9.

model = build_model(allow_cudnn_kernel=True)

model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), 
              optimizer='sgd',
              metrics=['accuracy'])

model.fit(x_train, y_train,
          validation_data=(x_test, y_test),
          batch_size=batch_size,
          epochs=5)

Постройте новую модель без ядра CuDNN

slow_model = build_model(allow_cudnn_kernel=False)
slow_model.set_weights(model.get_weights())
slow_model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), 
                   optimizer='sgd', 
                   metrics=['accuracy'])
slow_model.fit(x_train, y_train, 
               validation_data=(x_test, y_test), 
               batch_size=batch_size,
               epochs=1)  # Обучим только за одну эпоху потому что она медленная.

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

Ту же модель с поддержкой CuDNN можно использовать при выводе в однопроцессорной среде. Аннотация tf.device просто указывает используемое устройство. Модель выполнится по умолчанию на CPU если не будет доступно GPU.

Вам просто не нужно беспокоиться о железе на котором вы работаете. Разве это не круто?

with tf.device('CPU:0'):
  cpu_model = build_model(allow_cudnn_kernel=True)
  cpu_model.set_weights(model.get_weights())
  result = tf.argmax(cpu_model.predict_on_batch(tf.expand_dims(sample, 0)), axis=1)
  print('Predicted result is: %s, target result is: %s' % (result.numpy(), sample_label))
  plt.imshow(sample, cmap=plt.get_cmap('gray'))

RNN с входными данными вида список/словарь, или вложенными входными данными

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

[batch, timestep, {"video": [height, width, channel], "audio": [frequency]}]

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

[batch, timestep, {"location": [x, y], "pressure": [force]}]

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

Определите пользовательскую ячейку поддерживающую вложенный вход/выход

NestedInput = collections.namedtuple('NestedInput', ['feature1', 'feature2'])
NestedState = collections.namedtuple('NestedState', ['state1', 'state2'])

class NestedCell(tf.keras.layers.Layer):

  def __init__(self, unit_1, unit_2, unit_3, **kwargs):
    self.unit_1 = unit_1
    self.unit_2 = unit_2
    self.unit_3 = unit_3
    self.state_size = NestedState(state1=unit_1, 
                                  state2=tf.TensorShape([unit_2, unit_3]))
    self.output_size = (unit_1, tf.TensorShape([unit_2, unit_3]))
    super(NestedCell, self).__init__(**kwargs)

  def build(self, input_shapes):
    # # ожидает input_shape содержащий 2 элемента, [(batch, i1), (batch, i2, i3)]
    input_1 = input_shapes.feature1[1]
    input_2, input_3 = input_shapes.feature2[1:]

    self.kernel_1 = self.add_weight(
        shape=(input_1, self.unit_1), initializer='uniform', name='kernel_1')
    self.kernel_2_3 = self.add_weight(
        shape=(input_2, input_3, self.unit_2, self.unit_3),
        initializer='uniform',
        name='kernel_2_3')

  def call(self, inputs, states):
    # входы должны быть в [(batch, input_1), (batch, input_2, input_3)]
    # состояние должно быть размерностью [(batch, unit_1), (batch, unit_2, unit_3)]
    input_1, input_2 = tf.nest.flatten(inputs)
    s1, s2 = states

    output_1 = tf.matmul(input_1, self.kernel_1)
    output_2_3 = tf.einsum('bij,ijkl->bkl', input_2, self.kernel_2_3)
    state_1 = s1 + output_1
    state_2_3 = s2 + output_2_3

    output = [output_1, output_2_3]
    new_states = NestedState(state1=state_1, state2=state_2_3)

    return output, new_states

Постройте модель RNN с вложенными входом/выходом

Давайте построим модель Keras которая использует слой tf.keras.layers.RNN и кастомную ячейку которую мы только определили.

unit_1 = 10
unit_2 = 20
unit_3 = 30

input_1 = 32
input_2 = 64
input_3 = 32
batch_size = 64
num_batch = 100
timestep = 50

cell = NestedCell(unit_1, unit_2, unit_3)
rnn = tf.keras.layers.RNN(cell)

inp_1 = tf.keras.Input((None, input_1))
inp_2 = tf.keras.Input((None, input_2, input_3))

outputs = rnn(NestedInput(feature1=inp_1, feature2=inp_2))

model = tf.keras.models.Model([inp_1, inp_2], outputs)

model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])unit_1 = 10
unit_2 = 20
unit_3 = 30

input_1 = 32
input_2 = 64
input_3 = 32
batch_size = 64
num_batch = 100
timestep = 50

cell = NestedCell(unit_1, unit_2, unit_3)
rnn = tf.keras.layers.RNN(cell)

inp_1 = tf.keras.Input((None, input_1))
inp_2 = tf.keras.Input((None, input_2, input_3))

outputs = rnn(NestedInput(feature1=inp_1, feature2=inp_2))

model = tf.keras.models.Model([inp_1, inp_2], outputs)

model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])

Обучите модель на случайно сгенерированных данных

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

input_1_data = np.random.random((batch_size * num_batch, timestep, input_1))
input_2_data = np.random.random((batch_size * num_batch, timestep, input_2, input_3))
target_1_data = np.random.random((batch_size * num_batch, unit_1))
target_2_data = np.random.random((batch_size * num_batch, unit_2, unit_3))
input_data = [input_1_data, input_2_data]
target_data = [target_1_data, target_2_data]

model.fit(input_data, target_data, batch_size=batch_size)

Со слоем tf.keras.layers.RNN от вас требуется только определить математическую логику отдельного шага внутри последовательности, а слой tf.keras.layers.RNN будет обрабатывать для вас итерацию последовательности. Это невероятно сильный способ быстрого прототипирования новых видов RNN (напр. вариант LSTM).

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

Автор: stabuev

Источник