Что такое рекуррентные нейронные сети (RNN)?

Рекуррентные нейронные сети (RNN)

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

Основные характеристики

Главная особенность RNN — наличие рециркулирующихся связей (feedback loops). В отличие от обычных нейронных сетей (feedforward networks), где информация идёт только вперёд, в RNN скрытое состояние передаётся на следующий временной шаг.

# Упрощённая RNN ячейка (RNN cell)
h_t = tanh(W_hh @ h_{t-1} + W_xh @ x_t + b_h)
y_t = softmax(W_hy @ h_t + b_y)

Где:

• h_t — скрытое состояние (hidden state) в момент t
• x_t — входные данные в момент t
• W_hh, W_xh, W_hy — матрицы весов
• h_{t-1} — предыдущее скрытое состояние (память сети)

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

1. Обработка последовательности — сеть обрабатывает данные элемент за элементом
2. Актуализация памяти — на каждом шаге скрытое состояние обновляется
3. Контекст — сеть сохраняет информацию о предыдущих элементах

import numpy as np

class SimpleRNN:
    def __init__(self, input_size, hidden_size):
        self.W_xh = np.random.randn(hidden_size, input_size) * 0.01
        self.W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
        self.W_hy = np.random.randn(input_size, hidden_size) * 0.01
        self.b_h = np.zeros((hidden_size, 1))
        self.b_y = np.zeros((input_size, 1))
    
    def forward(self, x_sequence):
        h = np.zeros((self.hidden_size, 1))
        outputs = []
        
        for x_t in x_sequence:
            h = np.tanh(self.W_xh @ x_t + self.W_hh @ h + self.b_h)
            y_t = self.W_hy @ h + self.b_y
            outputs.append(y_t)
        
        return outputs

Применение RNN

1. Обработка языка (NLP)

• Предсказание следующего слова
• Классификация текста
• Перевод (machine translation)
• Распознавание сущностей (NER)

2. Временные ряды

• Прогнозирование цен акций
• Прогноз погоды
• Предсказание спроса
• Детектирование аномалий

3. Генерация текста

• Автодополнение
• Генерация стихов/кода
• Синтез речи

Проблемы базовой RNN

Проблема: Vanishing/Exploding Gradient

При обучении через backpropagation through time (BPTT) градиенты могут:

• Экспоненциально уменьшаться (vanishing) — сеть не учится
• Экспоненциально расти (exploding) — нестабильное обучение

Это происходит, когда сеть должна учить зависимости между далёкими элементами последовательности.

Решение: LSTM (Long Short-Term Memory)

LSTM решает проблему vanishing gradient с помощью "gates":

# LSTM ячейка (упрощённо)
f_t = sigmoid(W_f @ [h_{t-1}, x_t] + b_f)  # forget gate
i_t = sigmoid(W_i @ [h_{t-1}, x_t] + b_i)  # input gate
C_tilde = tanh(W_C @ [h_{t-1}, x_t] + b_C) # candidate cell state
C_t = f_t * C_{t-1} + i_t * C_tilde         # cell state
o_t = sigmoid(W_o @ [h_{t-1}, x_t] + b_o)  # output gate
h_t = o_t * tanh(C_t)                       # hidden state

Компоненты LSTM:

• Forget gate — что забыть из предыдущего состояния
• Input gate — что добавить из нового входа
• Cell state — долгосрочная память
• Output gate — что выдать на выход

GRU (Gated Recurrent Unit)

Упрощённая версия LSTM с 2 gates вместо 3:

r_t = sigmoid(W_r @ [h_{t-1}, x_t])  # reset gate
z_t = sigmoid(W_z @ [h_{t-1}, x_t])  # update gate
h_tilde = tanh(W @ [r_t * h_{t-1}, x_t])
h_t = (1 - z_t) * h_{t-1} + z_t * h_tilde

Практический пример: предсказание временного ряда

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Данные: (batch, timesteps, features)
X_train = np.random.randn(1000, 30, 1)  # 1000 примеров, 30 шагов, 1 признак
y_train = np.random.randn(1000, 1)

model = Sequential([
    LSTM(64, activation='relu', input_shape=(30, 1)),
    Dense(32, activation='relu'),
    Dense(1)
])

model.compile(optimizer='adam', loss='mse')
model.fit(X_train, y_train, epochs=10, batch_size=32)

Современная альтернатива: Transformers

С появлением Transformer архитектуры (BERT, GPT) RNN теряют популярность:

• Transformers обрабатывают всю последовательность параллельно
• Attention mechanism эффективнее для долгих зависимостей
• Параллелизм — намного быстрее на GPU

Однако RNN остаются полезны для:

• Потоковых данных (online learning)
• Ограниченных вычислительных ресурсов
• Небольших данных

Заключение

RNN — фундаментальная архитектура для последовательных данных. LSTM/GRU решают её проблемы и остаются популярны в production. Но для новых проектов часто выбирают Transformers для лучшей производительности.