4.Методы обратного прохода LSTM-блока

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

За процесс обратного прохода в базовом классе нейронного слоя у нас отвечают три метода:

• CalcHiddenGradient — распределение градиента через скрытый слой;
• CalcDeltaWeights — распределение градиента до матрицы весовых коэффициентов;
• UpdateWeights — метод обновления весовых коэффициентов.

Их нам и предстоит переопределить.

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

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

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

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

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

В завершение подготовительного процесса мы сохраним в локальную переменную размер буферов внутреннего потока.

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

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

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

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

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

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

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

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

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

MQL5-код описанных операций представлен ниже.

На этом завершается блок разделения потоков по устройству вычислительных операций, и мы объединяем потоки алгоритма. Мы лишь установим «заглушку» для ответвления OpenCL и пойдем дальше.

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

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

Первым мы проведем градиент через врата забвения. Напомню, что для передачи исходных данных во внутренние нейронные слои мы создавали базовый слой исходных данных и после проведения операций прямого прохода сохраняли указатель на него в стеке исходных данных. Данный тип объектов уже содержит буферы для записи данных и градиента ошибки. Поэтому сейчас мы просто берем этот указатель и передаем в параметрах метода CNeuronBase::CalcHiddenGradient. После этого отработает наш метод базового класса и заполнит буфер градиентов ошибки на уровне исходных данных врат забвения. Но это лишь одни врата, а нам нужно собрать информацию со всех. Чтобы не потерять уже посчитанный градиент ошибки при вызове аналогичного метода других внутренних слоев, мы скопируем данные в созданный нами заранее буфер для накопления градиентов ошибки m_cInputGradient.

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

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

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

• довести градиент ошибки до предыдущего слоя;
• довести градиент ошибки до матриц весов внутренних нейронных слоев.

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

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

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

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

Мы с вами разобрали два наиболее сложных и запутанных метода построения рекуррентного алгоритма LSTM-блока. Оставшаяся часть будет намного проще. К примеру, метод CalcDeltaWeights. Функционал этого метода предусматривает передачу градиента ошибки на уровень матрицы весов. Какой-либо отдельной матрицы весов LSTM-блок не имеет. Все параметры расположены внутри вложенных нейронных слоев, а градиент ошибки до уровня их матриц весов мы уже довели в предыдущем методе. Поэтому метод переписываем пустой заглушкой с положительным результатом.

Еще один метод обратного прохода UpdateWeights — метод обновления матрицы весов. Метод также наследуется из базового класса нейронного слоя и переопределяется при необходимости. LSTM-блок в отличие от ранее рассмотренных типов нейронных слоев не имеет единой матрицы весов. Вместо этого используются внутренние нейронные слои со своими матрицами весов. Поэтому мы не можем просто воспользоваться методом родительского класса и вынуждены переопределить его.

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

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

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

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

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

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