Рубрики
Без рубрики

Окончательное руководство по рецидивирующим нейронным сетям в Python

Автор оригинала: Nick McCullum.

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

Этот учебник научит вам основы рекуррентных нейронных сетей. Вы также построите свою собственную рекуррентную нейронную сеть, которая предсказывает завтрашнюю цену на Facebook (FB).

Рекуррентные нейронные сети являются примером более широкого поля нейронные сети Отказ Другие примеры включают в себя:

Эта статья будет сосредоточена на рецидивирующих нейронных сетях.

В этом руководстве начнется наше обсуждение рекуррентных нейронных сетей, обсудив интуицию рекуррентных нейронных сетей.

Типы проблем решаются рекуррентными нейронными сетью

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

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

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

Сопоставление нейронных сетей к частям человеческого мозга

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

Три основные части мозга:

  • Мозга
  • Мозги
  • Мозжечок

Возможно, наиболее важной частью мозга является мозговой мозг. Содержит четыре доли:

  • Лобная доля
  • Париетальная доля
  • Временная доля
  • Затылочная доля

Основные инновации, которые содержат нейронные сети, – это идея весов.

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

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

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

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

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

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

  • Искусственные нейронные сети: временная доля
  • Сверточные нейронные сети: затылочная доля
  • Рекуррентные нейронные сети: лобная доля

Состав рецидивирующей нейронной сети

Давайте теперь обсудим композицию рекуррентной нейронной сети. Во-первых, напомнить, что состав базовой нейронной сети имеет следующий вид:

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

Затем необходимо сделать еще три модификации:

  • Нейронные нейронные синапсы Neural Network должны быть упрощены до одной строки
  • Вся нейронная сеть должна быть повернута на 90 градусов
  • Петля должна быть создана вокруг скрытого слоя нервной сети

Neural Network теперь будет иметь следующий вид:

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

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

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

Резюме – Интуиция рекуррентных нейронных сетей

В этом руководстве у вас было первое введение в рекуррентные нейронные сети. Более конкретно, мы обсудили интуицию рекуррентных нейронных сетей.

Вот краткое резюме того, что мы обсуждали в этом руководстве:

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

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

Из-за этого, имея понимание проблемы исчезновения градиента, важно, прежде чем построить свой первый RNN.

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

Что такое проблема исчезновения градиента?

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

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

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

Этот алгоритм градиента спускается затем в сочетании с алгоритмом обратной обработки для обновления весов синапса по всей нейронной сети.

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

Это означает, что затратная функция нейронной сети рассчитывается для каждого наблюдения в наборе данных. Эти значения функций затрат изображены в верхней части следующего изображения:

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

Математика, которая вычисляет это изменение, является мультипликативной, что означает, что градиент, рассчитанный на шаге, который глубоко в нейронной сети будет умножен через вес ранее в сети. Сказал по-разному, градиент, рассчитанный глубоко в сети, «разбавлен», поскольку он движется назад через сеть, что может привести к исчезновению градиента – давая название проблему исчезновения градиента!

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

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

Обратите внимание, что оба этих задача обычно называют более простым именем «проблема исчезаживания градиента».

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

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

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

Решение проблемы взрыва градиента

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

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

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

Решение проблемы исчезновения градиента

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

Вы также можете использовать Echo State Networks, которая является определенным типом нейронной сети, предназначенной для того, чтобы избежать проблемы с учетом исчезновения. Сетевые сети ECHO находятся за рамки этого курса. Наличие знаний о их существовании достаточно на данный момент.

Наиболее важным решением проблемы исчезновения градиента является определенный тип нейронной сети, называемой длинными краткосрочными сетями памяти (LSTMS), которые были впечатлены от SEPP Hochreiter и Юрген Шмидхубер Отказ Напомним, что г-н Хохрейтер был ученым, который первоначально обнаружил проблему исчезновения градиента.

LSTMS используются в проблемах, в основном связанных с признанием речи, с одним из самых заметных примеров, которые являются Google, используя LSTM для распознавания речи В 2015 году и переживание на 49% снижение ошибок транскрипции.

Считается, что LSTMS считается Neural Net для ученых, заинтересованных в реализации рекуррентных нейронных сетей. Мы будем в значительной степени сосредоточены на LSTMS через оставшуюся часть этого курса.

Резюме – проблема исчезновения градиента

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

Вот краткое резюме того, что мы обсуждали:

  • Этот сепп Хохрейтер был первым ученым, чтобы обнаружить проблему исчезновения градиента в рекуррентных нейронных сетях
  • Какова проблема исчезаживания градиента (и его двоюродный брат, проблема взрыва градиента) включает
  • Роль WREC в исчезновении проблем градиента и взрывающихся градиентом
  • Как решены проблемы с градиентом и взрывающимися градиентами.
  • Роль LSTMS как наиболее распространенного решения проблемы исчезновения градиента

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

Они различаются от «регулярных» рекуррентных нейронных сетей важных способов.

Это руководство представит вас с LSTMS. Позже в этом курсе мы строим и тренируем LSTM с нуля.

Оглавление

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

История LSTMS

Как мы намереваемся в последнем разделе, две наиболее важные цифры в области LSTMS являются SEPP Hochreiter и Юрген Шмидхубер Отказ

Последнее было PhD-руководителем бывшего в Техническом университете Мюнхена в Германии.

Докторскую тезис Hochreiter впервые представил LSTMS в мир.

Как LSTMS решает проблему исчезновения градиента

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

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

Так как работает LSTMS? Они просто меняют ценность WREC Отказ

В нашем объяснении проблемы исчезающего градиента вы узнали, что:

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

На самом деле мы можем быть гораздо более конкретно:

  • Когда WREC <1 , вы испытываете проблему исчезновения градиента
  • Когда WREC> 1 , вы испытываете взрывающую проблему градиента

Это имеет смысл, если вы думаете о мультипликативном характере алгоритма обратной обработки.

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

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

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

Этот раздел объяснит, как работает LSTMS. Прежде чем продолжить, стоит упомянуть, что я буду пользоваться изображениями из блогов Christopher Olah Понимание LSTMS , который был опубликован в августе 2015 года и имеет одни из лучших визуализации LSTM, которые я когда-либо видел.

Для начала давайте рассмотрим базовую версию рекуррентной нейронной сети:

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

Напротив, вот что выглядит lstm:

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

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

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

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

Первое, что происходит в пределах LSTM, это Функция активации из забыть ворота слой Отказ Он смотрит на входы слоя (с надписью XT для наблюдения и HT для вывода предыдущего слоя нейронной сети) и выводы либо 1 или 0 Для каждого количества в сотовом состоянии из предыдущего слоя (помечены CT-1 ).

Вот визуализация активации забыть ворота слой :

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

Цель состояния клеток состоит в том, чтобы решить, какую информацию для несут продвижения от разных наблюдений, на которых обучается рецидивирующая нейронная сеть. Решение о том, не носите информацию о передаче информации Гейтс – из которых Забудь ворота это главный пример. Каждое ворота в LSTM будут иметь следующий вид:

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

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

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

Вот визуализация этого процесса:

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

Это завершает процесс подготовки одного слоя модели LSTM. Как вы можете себе представить, есть много математики под поверхностью, которые у нас были блестящими. Точка этого раздела – это широко объяснить, как работает LSTMS, не для вас, чтобы глубоко понять каждую операцию в процессе.

Вариации архитектур LSTM

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

Как быстрый рецидил, вот как выглядит обобщенный узел LSTM:

Изменение глазки

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

Вот визуализация того, как может выглядеть вариант Гифола:

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

Вариация связанных ворот

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

Вот визуализация того, что эта архитектура выглядит как:

Другие вариации LSTM

Это только два примера вариантов в архитектуре LSTM. Есть еще много. Несколько перечислены ниже:

Сводка – длинные краткосрочные сети памяти

В этом уроке вы имели первое воздействие на длинные краткосрочные сети памяти (LSTMS).

Вот краткое резюме того, что вы узнали:

  • A (очень) краткая история LSTMS и роль, которую сепп Хохрейтер и Юрген Шмидхубер играл в их развитии
  • Как LSTMS решает проблему исчезновения градиента
  • Как работает LSTMS
  • Роль ворота, сигмоидных функций и гиперболической касательной функции в LSTMS
  • Несколько самых популярных вариантов архитектуры LSTM

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

Сейчас время построить свою первую рекуррентную нейронную сеть! Более конкретно, этот учебник научит вас создавать и тренировать LSTM, чтобы предсказать цену акций Facebook (FB).

Оглавление

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

Загрузка набора данных для этого учебника

Чтобы пройти через этот урок, вам понадобится два загрузки два набора данных:

  • Набор данных тренировок, содержащих информацию о цене акций на Facebook с начала 2015 года до конца 2019 года
  • Набор тестовых данных, содержащих информацию о цене акций Facebook в течение первого месяца 2020 года

Наша рецидивирующая нейронная сеть будет обучена на данных на 2015-2019 годы и будет использоваться для прогнозирования данных с января 2020 года.

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

Каждый из этих наборов данных просто экспортирует из Yahoo! Финансирование Похоже, они выглядят (при открытии в Microsoft Excel):

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

Импорт библиотек, которые вам понадобятся для этого учебника

Этот учебник будет зависеть от ряда библиотек Python с открытым исходным кодом, в том числе Numpy , Пандас и Матплотлиб Отказ

Давайте начнем наш сценарий Python, импортируя некоторые из этих библиотек:

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

Импортировка нашего обучения, установленного в сценарий Python

Следующая задача, которая должна быть завершена, – это импортировать наши данные, установленные в скрипт Python.

Мы изначально импортируем набор данных как Pandas DataFrame используя read_csv метод. Однако, поскольку Керас модуль Tensorflow только принимает Numpy массивы В качестве параметров структура данных должна быть преобразована после импорта.

Давайте начнем, импортируя весь .csv Файл как файл dataframe:

training_data = pd.read_csv('FB_training_data.csv')

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

Нам нужно будет выбрать определенный тип цен на акции, прежде чем продолжить. Давайте использовать Закрыть , что указывает несконционное закрытие цены на акции Facebook.

Теперь нам нужно выбрать этот столбец DataFrame и сохранить его в Numpy Array. Вот команда для этого:

training_data = training_data.iloc[:, 1].values

Обратите внимание, что эта команда перезаписывает существующую Training_data переменная, которую мы создали ранее.

Теперь вы можете убедиться, что наши Training_data Переменная действительно замечательная массива, работающая Тип (Wearning_data) , что должно вернуть:

numpy.ndarray

Применение функций масштабирования к нашему набору данных

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

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

  • Стандартизация
  • Нормализация

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

Вот функция нормализации определена математически:

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

Давайте начнем, импортируя этот класс в наш сценарий Python. Minmaxscaler Класс живет в пределах предварительная обработка модуль Scikit - Учите Таким образом, команда для импорта класса:

from sklearn.preprocessing import MinMaxScaler

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

scaler = MinMaxScaler()

Поскольку мы не указали никаких непонимательных параметров по умолчанию, это будет масштабировать наш набор данных, чтобы каждое наблюдение было между 0 и 1 Отказ

Мы создали наши Скажер объект, но наш Training_data Набор данных еще не был масштабирован. Нам нужно использовать fit_transform Метод для изменения исходного набора данных. Вот утверждение для этого:

training_data = scaler.fit_transform(training_data.reshape(-1, 1))

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

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

Мы будем использовать 40 Timesteps в этом руководстве. Это означает, что каждый день, когда нейронная сеть прогнозирует, она будет учитывать предыдущие 40 дней цен на акции для определения его выхода. Обратите внимание, что, поскольку в данном месяце только ~ 20 торговых дней, используя 40 Timesteps означает, что мы полагаемся на данные цен на акции за предыдущие 2 месяца.

Итак, как мы на самом деле указываем количество меток времени в нашем сценарии Python?

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

  • Одна структура данных, которую мы позвоним X_TRINGE_DATA Это содержит последние 40 наблюдений цен на акции в наборе данных. Это данные, что рецидивирующая нейронная сеть будет использовать для прогнозов.
  • Одна структура данных, которую мы позвоним Y_TRINGE_DATA который содержит цену акций на следующий торговый день. Это точка данных о том, что рекуррентная нейронная сеть пытается предсказать.

Для начала, давайте инициализируем каждую из этих структур данных как пустой список Python:

x_training_data = []

y_training_data =[]

Теперь мы будем использовать цикл для заполнения фактических данных в каждый из этих списков Python. Вот код (с дальнейшим объяснением кода после блока кода):

for i in range(40, len(training_data)):

    x_training_data.append(training_data[i-40:i, 0])

    y_training_data.append(training_data[i, 0])

Давайте распадаем компоненты этого блока кода:

  • Диапазон (40, Len (Training_data)) Функция вызывает петлю для итерации от 40 до последнего показателя учебных данных.
  • X_TRINGE_DATA.Append (Training_data [I-40: I, 0]) Строка заставляет цикл добавить 40 предыдущих цен на акции на X_TRINGE_DATA с каждой итерацией петли.
  • Точно так же Y_TRINGE_DATA.Append (Training_data [I, 0]) Заставляет цикл добавить цену акций на следующий день на Y_TRINGE_DATA с каждой итерацией петли.

Завершение наших наборов данных, превращая их в Numpy Armays

Tensorflow предназначен для работы в первую очередь с помощью numpy массивов. Из-за этого последнее, что нам нужно сделать, это преобразовать два списка Python, которые мы только что создали в Numpy Armays.

К счастью, это просто. Вам просто нужно обернуть списки Python в np.array функция. Вот код:

x_training_data = np.array(x_training_data)

y_training_data = np.array(y_training_data)

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

X_TRINGE_DATA Массив должен быть двунаправленным Numpy Array с одним измерением 40 (количество меток времени) и второе измерение, являющееся Len (Training_data) - 40 , который оценивает 1218 в нашем случае.

Точно так же Y_TRINGE_DATA Объект должен быть одномерным множественным массивом длины 1218 (который, опять же, это Len (Training_data) - 40 ).

Вы можете проверить форму массивов, печатая их Форма Атрибут, как это:

print(x_training_data.shape)

print(y_training_data.shape)

Это отпечатки:

(1218, 40)

(1218,)

У обоих массивов есть размеры, которые вы ожидаете. Тем не менее, нам нужно изменить наш X_TRINGE_DATA объект еще раз, прежде чем приступить к созданию нашей рекуррентной нейронной сети.

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

Чтобы изменить X_TRINGE_DATA объект, я буду использовать np.reeshape метод. Вот код для этого:

x_training_data = np.reshape(x_training_data, (x_training_data.shape[0], 

                                               x_training_data.shape[1], 

                                               1))

Теперь давайте распечатаем форму X_TRINGE_DATA снова:

print(x_training_data.shape)

Это выходы:

(1218, 40, 1)

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

Импорт наших библиотек Tensorflow

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

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from tensorflow.keras.layers import LSTM

from tensorflow.keras.layers import Dropout

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

Сейчас время построить нашу рекуррентную нейронную сеть.

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

Вот код для инициализации нашей рекуррентной нейронной сети:

rnn = Sequential()

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

Добавление нашего первого слоя LSTM

Первый слой, который мы добавим, это Lstm слой. Чтобы сделать это, пропустите вызов Lstm класс (что мы просто импортировали) в Добавить метод.

Lstm Класс принимает несколько параметров. Точнее, мы уточним три аргумента:

  • Количество нейронов LSTM, которое вы хотели бы включить в этот слой. Увеличение количества нейронов является одним из способов увеличения размерности вашей рецидивирующей нейронной сети. В нашем случае мы уточним единицы Отказ
  • return_sequences – Это всегда должно быть указано, если вы планируете включить еще один слой LSTM после того, как вы добавляете. Вы должны указать return_sequences Для последнего уровня LSTM в вашей рекуррентной нейронной сети.
  • input_shape : количество меток времени и количество предикторов в наших учебных данных. В нашем случае мы используем 40 Timesteps и только 1 предсказатель (цена акций), поэтому мы добавим

Вот полный Добавить Метод:

rnn.add(LSTM(units = 45, return_sequences = True, input_shape = (x_training_data.shape[1], 1)))

Обратите внимание, что я использовал x_tring_data.shape [1] Вместо жесткого значения в случае, если мы решили обучить рекуррентную нейронную сеть на более поздней дате.

Добавление некоторого регулирования выпадения

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

Это включает в себя случайное исключение – или «выпадение» – определенные выходы слоя на этапе обучения.

Tensorflow позволяет легко реализовать регуляризацию отсева, используя Открытие Класс, который мы импортировали ранее в нашем сценарии Python. Открытие Класс принимает один параметр: скорость выпадения.

Скорость выпадения указывает на то, сколько нейронов следует упасть в определенный слой нейронной сети. Обычно используют скорость выпадения 20%. Мы будем следовать этой конвенции в нашей рекуррентной нейронной сети.

Вот как вы можете проинструктировать Tensorflow упасть на 20% нейрона LSTM Layer во время каждой итерации стадии обучения:

rnn.add(Dropout(0.2))

Добавление еще трех слоев LSTM с регуляризацией

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

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

Мы будем сохранять количество нейронов (или единиц ) и рассыпания такими же в каждом из Lstm Завершение класса. С третьего Lstm Слой мы добавляем в этот раздел, будет наш последний слой LSTM, мы можем удалить return_sequences Параметр, как упоминалось ранее. Удаление наборов параметров return_sequences Для его значения по умолчанию Ложь Отказ

Вот полный код, чтобы добавить наши следующие три уровня LSTM:

rnn.add(LSTM(units = 45, return_sequences = True))

rnn.add(Dropout(0.2))

rnn.add(LSTM(units = 45, return_sequences = True))

rnn.add(Dropout(0.2))

rnn.add(LSTM(units = 45))

rnn.add(Dropout(0.2))

Этот код очень повторяется и нарушает сухое (не повторять себя) принцип разработки программного обеспечения. Давайте представим его в петле вместо этого:

for i in [True, True, False]:

    rnn.add(LSTM(units = 45, return_sequences = i))

    rnn.add(Dropout(0.2))

Добавление выходного слоя в нашу рекуррентную нейронную сеть

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

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

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

Вот код для создания нашего выходного слоя:

rnn.add(Dense(units = 1))

Компиляция нашей рекуррентной нейронной сети

Как вы вспомните из учебных пособий по искусственным нейронным сетям и сверточным нейронным сетям, шаг компиляции построения нейронной сети – это место, где мы указываем оптимизатор и функцию потери Neural Net.

Tensorflow позволяет нам компилировать нейронную сеть, используя aptly named Компилировать метод. Это принимает два аргумента: Оптимизатор и потеря Отказ Давайте начнем с создания пустого Компилировать Функция:

rnn.compile(optimizer = '', loss = '')

Теперь нам нужно указать Оптимизатор и потеря Параметры.

Давайте начнем с обсуждения Оптимизатор параметр. Рекуррентные нейронные сети обычно используют оптимизатор RMSPROP на своем этапе компиляции. С этим сказанным, мы будем использовать оптимизатор ADAM (как раньше). Оптимизатор ADAM – это оптимизатор рабочей лошадки, который полезен в широком спектре нейронных сетевых архитектур.

потеря Параметр довольно просто. Поскольку мы предсказываем непрерывную переменную, мы можем использовать среднюю ошибку в квадрате – так же, как если бы вы могли измерять производительность A Линейная регрессионная машина обучения модели Отказ Это означает, что мы можем указать потеря Отказ

Вот окончательный Компилировать Метод:

rnn.compile(optimizer = 'adam', loss = 'mean_squared_error')

Установка рецидивирующей нейронной сети на учебном наборе

Сейчас время тренировать нашу рекуррентную сеть на наших учебных данных.

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

  • Учебные данные : В нашем случае это будет X_TRINGE_DATA и y_tring_data.
  • Эпохи : Количество итераций, которые вы хотели бы, чтобы рецидивирующая нейронная сеть была обучена. Мы уточним эпохи в таком случае.
  • Размер партии : Размер партий, которые сеть будет обучена через каждую эпоху.

Вот код для обучения этой рецидивирующей нейронной сети в соответствии с нашими спецификациями:

rnn.fit(x_training_data, y_training_data, epochs = 100, batch_size = 32)

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

Как видите, каждый вывод показывает, как долго Eipoch взят, а также функция вычисленной потери в этой эпохе.

Вы должны увидеть значение функции потери, медленно снижается, поскольку рекуррентная нейронная сеть со временем установлена для тренировок. В моем случае значение функции потери снизилось от 0,0504 В первой итерации к 0,0017 в последней итерации.

Делать прогнозы с нашей рекуррентной нейронной сетью

Мы построили нашу рекуррентную нейронную сеть и обучали ее по данным цены акций Facebook за последние 5 лет. Сейчас время сделать некоторые прогнозы!

Импорт наших тестовых данных

Чтобы начать, давайте импортируем фактические данные цен на акции за первый месяц 2020 года. Это даст нам что-то, чтобы сравнить наши прогнозируемые ценности.

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

test_data = pd.read_csv('FB_test_data.csv')

test_data = test_data.iloc[:, 1].values

Если вы запустите оператор Печать (test_data.shape) , это вернется (21,) Отказ Это показывает, что наши тестовые данные представляют собой одномерное применение Nampy с 21-х годов, что означает, что в январе 2020 года было 21 дни фондового рынка.

Вы также можете генерировать быстрый график данных, используя PLT.PLOT (TEST_DATA) Отказ Это должно генерировать следующую визуализацию Python:

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

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

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

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

К сожалению, вы можете просто объединить The Numpy Marips немедленно. Это связано с тем, что мы уже применили функции масштабирования к данным тренировочных данных, но не применили никакой масштабирования функций к тестовым данным.

Чтобы исправить это, нам нужно повторно импортировать оригинал X_TRINGE_DATA Объект под новым именем переменной называется unscaled_x_tring_data Отказ Для последовательности мы также будем повторно импортировать тестовые данные в виде файла DataFrame, называемого unscaled_test_data :

unscaled_training_data = pd.read_csv('FB_training_data.csv')

unscaled_test_data = pd.read_csv('FB_test_data.csv')

Теперь мы можем объединить вместе Открыть Столбец из каждого DataFrame со следующим утверждением:

all_data = pd.concat((unscaled_x_training_data['Open'], unscaled_test_data['Open']), axis = 0)

Это All_data Объект – это серия Panda длиной 1279.

Теперь нам нужно создать массив всех цен на акции с 2020 года и 40 торговых дней до 40 лет до января. Мы назовем этот объект x_test_data Так как он содержит х Значения, которые мы будем использовать, чтобы сделать прогнозы цены на акции на 20 января.

Первое, что вам нужно сделать, это найти индекс первого торгового дня в январе в пределах нашего All_data объект. Утверждение len (all_data) - len (test_data) Определяет этот индекс для нас.

Это представляет верхнюю границу первого элемента в массиве. Чтобы получить нижнюю границу, просто вычитайте 40 Из этого номера. Сказал по-другому, нижняя граница – len (all_data) - len (test_data) - 40 Отказ

Верхняя граница всего x_test_data Массив будет последним элементом в наборе данных. Соответственно, мы можем создать этот Numpy Array со следующим утверждением:

x_test_data = all_data[len(all_data) - len(test_data) - 40:].values

Вы можете проверить, был ли этот объект создан по желанию печати len (x_test_data) , который имеет значение 61 Отказ Это имеет смысл – он должен содержать 21 Значения за январь 2020 года, а также 40 ценности до.

Последний шаг этого раздела – быстро изменить наш Numpy Array, чтобы сделать его подходящим для прогнозировать Метод:

x_test_data = np.reshape(x_test_data, (-1, 1))

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

Расширение наших тестовых данных

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

x_test_data = scaler.transform(x_test_data)

Обратите внимание, что мы использовали трансформировать Метод здесь вместо fit_transform метод (как раньше). Это связано с тем, что мы хотим преобразовать тестовые данные в соответствии со значением, генерируемой из всего набора данных тренировки.

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

Группировка наших тестовых данных

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

Код для этого похож на что-то, что мы использовали ранее:

final_x_test_data = []

for i in range(40, len(x_test_data)):

    final_x_test_data.append(x_test_data[i-40:i, 0])

final_x_test_data = np.array(final_x_test_data)

Наконец, нам нужно изменить Final_x_test_data переменная для удовлетворения стандартов Tensorflow.

Ранее мы видели это, поэтому код должен не понадобиться объяснения:

final_x_test_data = np.reshape(final_x_test_data, (final_x_test_data.shape[0], 

                                               final_x_test_data.shape[1], 

                                               1))

На самом деле делать прогнозы

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

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

predictions = rnn.predict(final_x_test_data)

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

Как вы можете видеть, прогнозируемые значения на этом участке составляют между 0 и 1 Отказ Это потому, что наш набор данных все еще масштабируется! Нам нужно не побаловать его для прогнозов, чтобы иметь какое-либо практическое значение.

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

unscaled_predictions = scaler.inverse_transform(predictions)

plt.clf() #This clears the first prediction plot from our canvas

plt.plot(unscaled_predictions)

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

Давайте создадим сюжет, который сравнивает наши прогнозируемые цены на акции с фактической ценой на акцию Facebook:

plt.plot(unscaled_predictions, color = '#135485', label = "Predictions")

plt.plot(test_data, color = 'black', label = "Real Data")

plt.title('Facebook Stock Price Predictions')

Полный код для этого учебника

Вы можете просмотреть полный код для этого руководства в Этот репозиторий Github Отказ Это также вставлено ниже для вашей ссылки:

#Import the necessary data science libraries

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

#Import the data set as a pandas DataFrame

training_data = pd.read_csv('FB_training_data.csv')

#Transform the data set into a NumPy array

training_data = training_data.iloc[:, 1].values

#Apply feature scaling to the data set

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

training_data = scaler.fit_transform(training_data.reshape(-1, 1))

#Initialize our x_training_data and y_training_data variables 

#as empty Python lists

x_training_data = []

y_training_data =[]

#Populate the Python lists using 40 timesteps

for i in range(40, len(training_data)):

    x_training_data.append(training_data[i-40:i, 0])

    y_training_data.append(training_data[i, 0])

    

#Transforming our lists into NumPy arrays

x_training_data = np.array(x_training_data)

y_training_data = np.array(y_training_data)

#Verifying the shape of the NumPy arrays

print(x_training_data.shape)

print(y_training_data.shape)

#Reshaping the NumPy array to meet TensorFlow standards

x_training_data = np.reshape(x_training_data, (x_training_data.shape[0], 

                                               x_training_data.shape[1], 

                                               1))

#Printing the new shape of x_training_data

print(x_training_data.shape)

#Importing our TensorFlow libraries

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from tensorflow.keras.layers import LSTM

from tensorflow.keras.layers import Dropout

#Initializing our recurrent neural network

rnn = Sequential()

#Adding our first LSTM layer

rnn.add(LSTM(units = 45, return_sequences = True, input_shape = (x_training_data.shape[1], 1)))

#Perform some dropout regularization

rnn.add(Dropout(0.2))

#Adding three more LSTM layers with dropout regularization

for i in [True, True, False]:

    rnn.add(LSTM(units = 45, return_sequences = i))

    rnn.add(Dropout(0.2))

#(Original code for the three additional LSTM layers)

# rnn.add(LSTM(units = 45, return_sequences = True))

# rnn.add(Dropout(0.2))

# rnn.add(LSTM(units = 45, return_sequences = True))

# rnn.add(Dropout(0.2))

# rnn.add(LSTM(units = 45))

# rnn.add(Dropout(0.2))

#Adding our output layer

rnn.add(Dense(units = 1))

#Compiling the recurrent neural network

rnn.compile(optimizer = 'adam', loss = 'mean_squared_error')

#Training the recurrent neural network

rnn.fit(x_training_data, y_training_data, epochs = 100, batch_size = 32)

#Import the test data set and transform it into a NumPy array

test_data = pd.read_csv('FB_test_data.csv')

test_data = test_data.iloc[:, 1].values

#Make sure the test data's shape makes sense

print(test_data.shape)

#Plot the test data

plt.plot(test_data)

#Create unscaled training data and test data objects

unscaled_training_data = pd.read_csv('FB_training_data.csv')

unscaled_test_data = pd.read_csv('FB_test_data.csv')

#Concatenate the unscaled data

all_data = pd.concat((unscaled_x_training_data['Open'], unscaled_test_data['Open']), axis = 0)

#Create our x_test_data object, which has each January day + the 40 prior days

x_test_data = all_data[len(all_data) - len(test_data) - 40:].values

x_test_data = np.reshape(x_test_data, (-1, 1))

#Scale the test data

x_test_data = scaler.transform(x_test_data)

#Grouping our test data

final_x_test_data = []

for i in range(40, len(x_test_data)):

    final_x_test_data.append(x_test_data[i-40:i, 0])

final_x_test_data = np.array(final_x_test_data)

#Reshaping the NumPy array to meet TensorFlow standards

final_x_test_data = np.reshape(final_x_test_data, (final_x_test_data.shape[0], 

                                               final_x_test_data.shape[1], 

                                               1))

#Generating our predicted values

predictions = rnn.predict(final_x_test_data)

#Plotting our predicted values

plt.clf() #This clears the old plot from our canvas

plt.plot(predictions)

#Unscaling the predicted values and re-plotting the data

unscaled_predictions = scaler.inverse_transform(predictions)

plt.clf() #This clears the first prediction plot from our canvas

plt.plot(unscaled_predictions)

#Plotting the predicted values against Facebook's actual stock price

plt.plot(unscaled_predictions, color = '#135485', label = "Predictions")

plt.plot(test_data, color = 'black', label = "Real Data")

plt.title('Facebook Stock Price Predictions')

Резюме – Интуиция рекуррентных нейронных сетей

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

Вот краткое резюме того, что вы узнали:

  • Как применить функциональную масштабирование к набору данных, на которые будет обучена рецидивирующая нейронная сеть
  • Роль Timesteps В обучении рецидивирующей нейронной сети
  • Что Tensorflow в первую очередь использует Numpy Armays в качестве структуры данных для обучения моделями с
  • Как добавить Lstm и Открытие слои до рекуррентной нейронной сети
  • Почему регуляризация выпадения обычно используется, чтобы избежать перенапряжения при обучении нейронных сетей
  • Что Густым Слой из Tensorflow обычно используется в качестве выходного слоя рецидивирующей нейронной сети
  • Что Компиляция Шаг построения нейронной сети включает в себя указывать свой оптимизатор и функцию его потерь
  • Как делать прогнозы, используя рекуррентную нейронную сеть
  • Что прогнозы делают использование нейронной сети, обученной на масштабированных данных, должны быть неальскошены, чтобы быть интерпретированными людьми

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

Читайте ещё по теме: