Рекуррентная нейронная сеть (RNN)

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

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

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

Основная идея RNN

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

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

RNN: Черезрекуррентные связи(Recurrent Connection) скрытое состояние с предыдущего шага передаётся на следующий шаг, образуя «память».

  • Вход на каждом шаге = текущие данные + скрытое состояние с предыдущего шага.

  • Выход зависит не только от текущего входа, но и от контекста всех предыдущих шагов.

Так же, как при чтении предложения, понимание текущего слова зависит от ранее прочитанного содержимого (например, «Он открыл __», вы предскажете «дверь» или «книгу»).

Пример

# Пример реализации простой ячейки RNN
import numpy as np

class SimpleRNN:
    def __init__(self, input_size, hidden_size):
        self.Wx = np.random.randn(hidden_size, input_size)  # Веса входа
        self.Wh = np.random.randn(hidden_size, hidden_size)  # Веса скрытого состояния
        self.b = np.zeros((hidden_size, 1))  # Член смещения
   
    def forward(self, x, h_prev):
        h_next = np.tanh(np.dot(self.Wx, x) + np.dot(self.Wh, h_prev) + self.b)
        return h_next

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

На каждом временном шаге t RNN выполняет следующие вычисления:

  1. Получает текущий вход xₜ и скрытое состояние hₜ₋₁ с предыдущего временного шага
  2. Вычисляет новое скрытое состояние hₜ = f(Wₕₕ·hₜ₋₁ + Wₓₕ·xₜ + b)
  3. Формирует выход yₜ = g(Wₕᵧ·hₜ + c)

Где f и g — обычно функции активации (такие как tanh или softmax).

Преимущества и недостатки RNN

Преимущества:

  • Может обрабатывать последовательности переменной длины
  • Теоретически может запоминать историческую информацию произвольной длины
  • Разделение параметров (один и тот же набор весов используется для всех временных шагов)

Недостатки:

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

Долгая краткосрочная память (LSTM)

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

2.1 Основная структура LSTM

LSTM вводит три механизма гейтирования и ячейку памяти:

Компонент Функция
Входной шлюз Управляет потоком новой информации
Вентиль забывания Решает, какую старую информацию отбросить
Выходной вентиль Управляет количеством информации для вывода
Ячейка памяти Хранит долговременное состояние

Пример

# Базовая реализация ячейки LSTM
class LSTMCell:
    def __init__(self, input_size, hidden_size):
        # Объединить веса всех вентилей
        self.W = np.random.randn(4*hidden_size, input_size+hidden_size)
        self.b = np.random.randn(4*hidden_size, 1)
   
    def forward(self, x, h_prev, c_prev):
        combined = np.vstack((h_prev, x))
        gates = np.dot(self.W, combined) + self.b
       
        # Разделить, чтобы получить каждый
        f_gate = sigmoid(gates[:hidden_size])  # Шлюз забывания
        i_gate = sigmoid(gates[hidden_size:2*hidden_size])  # Входной шлюз
        o_gate = sigmoid(gates[2*hidden_size:3*hidden_size])  # Выходной шлюз
        c_candidate = np.tanh(gates[3*hidden_size:])  # Память-кандидат
       
        # Обновить память и скрытое состояние
        c_next = f_gate * c_prev + i_gate c_candidate
        h_next = o_gate * np.tanh(c_next)
       
        return h_next, c_next

Как LSTM решает проблему долгосрочных зависимостей

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

Управляемый рекуррентный блок (GRU)

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

Базовая структура GRU

GRU объединяет некоторые компоненты LSTM:

Компонент Функция
Гейт обновления Решает, сколько старой информации сохранить
Гейт сброса Решает, как объединить новую и старую информацию
Активация кандидата Новое состояние вычисляется на основе вентиля сброса

Пример

# Реализация ячейки GRU
class GRUCell:
    def __init__(self, input_size, hidden_size):
        self.W = np.random.randn(3*hidden_size, input_size+hidden_size)
        self.b = np.random.randn(3*hidden_size, 1)
   
    def forward(self, x, h_prev):
        combined = np.vstack((h_prev, x))
        gates = np.dot(self.W, combined) + self.b
       
        # Разделение сигналов вентилей
        z = sigmoid(gates[:hidden_size])  # Вентиль обновления
        r = sigmoid(gates[hidden_size:2*hidden_size])  # Вентиль сброса
        h_candidate = np.tanh(np.dot(self.W[2*hidden_size:],
                              np.vstack((r*h_prev, x))) + self.b[2*hidden_size:]
       
        # Обновление скрытого состояния
        h_next = (1-z)*h_prev + z*h_candidate
        return h_next

GRU против LSTM

Характеристика GRU LSTM
Количество параметров Меньше Подробнее
Скорость обучения Быстрее Медленнее
Ячейка памяти Отсутствует Да
Количество вентилей 2 3
Производительность Лучше подходит для небольших наборов данных Может быть лучше для больших наборов данных

Двунаправленная RNN (Bi-RNN)

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

Архитектура двунаправленной RNN

Bi-RNN состоит из двух независимых слоёв RNN:

  1. Прямой слой: обрабатывает последовательность в хронологическом порядке
  2. Обратный слой: обрабатывает последовательность в обратном хронологическом порядке

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

Сценарии применения двунаправленной RNN

  1. Обработка естественного языка: разметка частей речи, распознавание именованных сущностей
  2. Распознавание речи: использует окружающий контекст для повышения точности
  3. Биоинформатика: предсказание структуры белков
  4. Прогнозирование временных рядов: учитывает исторические и будущие тенденции

Двунаправленная LSTM/GRU

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

Пример

from tensorflow.keras.layers import Bidirectional, LSTM

model.add(Bidirectional(LSTM(64)))  # Создать двунаправленный слой LSTM

Практические упражнения

Упражнение 1: Реализуйте простую RNN

Используйте Python и NumPy для реализации простой RNN, способной к посимвольной генерации текста.

Упражнение 2: анализ тональности с помощью LSTM

Используйте Keras для построения классификатора тональности отзывов на фильмы на основе LSTM.

Упражнение 3: Распознавание именованных сущностей с помощью двунаправленной GRU

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

Упражнение 4: Сравнительный эксперимент

Сравните различия в производительности Vanilla RNN, LSTM и GRU на одном и том же наборе данных.


Итоги и дальнейшее обучение

RNN и её варианты — мощные инструменты для обработки последовательных данных. Чтобы глубоко их освоить:

  1. Понять, как распространяются градиенты в RNN
  2. Узнать, как механизм внимания улучшает RNN
  3. Исследовать связь между архитектурой Transformer и RNN
  4. Практиковать различные задачи моделирования последовательностей (машинный перевод, синтез речи и т. д.)
Другие расширения