Recurrent Neural Network (RNN)

Рекуррентная нейронная сеть (RNN) — это нейронная сеть, которая обрабатывает последовательность по одному элементу за раз, передавая скрытое состояние от шага к шагу. Поэтому выход на каждом шаге может зависеть от всех ранее прочитанных данных. Одни и те же веса используются на каждом шаге, благодаря чему одна сеть справляется с последовательностями любой длины — от предложения до часов показаний датчиков. До того как в конце 2010-х трансформеры вытеснили RNN в большинстве языковых задач, они были основной архитектурой для обработки естественного языка (NLP), распознавания речи и анализа временных рядов. Их варианты с вентилями по-прежнему широко используются в потоковых и встроенных моделях, а рекуррентные архитектуры вернулись в моделях пространства состояний (SSMs), например Mamba.

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

Простая RNN, также называемая сетью Элмана в честь статьи Джеффри Элмана 1990 года, обновляет скрытое состояние по формуле hₜ = tanh(Wxₜ + Uhₜ₋₁ + b) и на каждом шаге может выдавать результат yₜ = Vhₜ + c. Скрытое состояние — это вектор фиксированного размера, который обобщает последовательность на текущий момент, а tanh удерживает его значения в диапазоне от −1 до 1 при обратной подаче. Если изобразить копию сети для каждого шага, цикл разворачивается в глубокую сеть прямого распространения, слои которой используют общие веса:

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

import torch
from torch import nn

torch.manual_seed(0)
rnn = nn.RNN(input_size=3, hidden_size=4, batch_first=True)
x = torch.randn(1, 6, 3)  # one sequence: 6 time steps, 3 features each

# PyTorch runs the whole sequence; output holds the hidden state after every step
output, h_n = rnn(x)

# The same recurrence by hand, reusing one set of weights at every step
h = torch.zeros(1, 4)
for t in range(x.shape[1]):
    h = torch.tanh(x[:, t] @ rnn.weight_ih_l0.T + rnn.bias_ih_l0 + h @ rnn.weight_hh_l0.T + rnn.bias_hh_l0)

print(f"Output shape: {tuple(output.shape)}, final state shape: {tuple(h_n.shape)}")
print(f"Hand-written loop matches nn.RNN: {torch.allclose(h, h_n[0], atol=1e-6)}")

Код выводит Output shape: (1, 6, 4), final state shape: (1, 1, 4) и Hand-written loop matches nn.RNN: True. В выходных данных содержится по одному скрытому состоянию размерности 4 для каждого шага времени, а цикл воспроизводит конечное состояние, используя одну матрицу весов для входа и одну — для предыдущего состояния.

Задачи с последовательностями#

Одна и та же рекуррентная операция подходит для задач с разной длиной входных и выходных данных:

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

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

Обучение с обратным распространением ошибки во времени#

RNN обучаются методом обратного распространения ошибки во времени (BPTT): сеть разворачивается по последовательности, функция потерь суммируется по шагам, а обратное распространение ошибки выполняется по развернутому графу. Градиент, приходящий к шагу t от шага T, проходит через T − t копий рекуррентного слоя и каждый раз умножается на U и производную tanh. Если эти множители в основном меньше 1, градиент геометрически затухает — возникает проблема затухающего градиента, проанализированная Ёшуа Бенжио, Патрисом Симаром и Паоло Фраскони в 1994 году. Если множители больше 1, градиент геометрически растет — возникает проблема взрывающегося градиента. Фрагмент кода ниже измеряет, насколько каждый вход 50-шаговой последовательности влияет на конечное скрытое состояние:

import torch
from torch import nn

torch.manual_seed(0)
rnn = nn.RNN(input_size=8, hidden_size=32, batch_first=True)
x = torch.randn(1, 50, 8, requires_grad=True)  # one 50-step sequence

# Backpropagate from the final hidden state to the input at every step
output, h_n = rnn(x)
h_n.sum().backward()
grad_norms = x.grad[0].norm(dim=1)

for distance in [0, 10, 20, 30, 40]:
    print(f"Input {distance:>2} steps before the end: gradient {grad_norms[-1 - distance]:.1e}")

Здесь выводятся градиенты 1.6e+00, 3.4e-03, 6.2e-06, 1.2e-08 и 1.1e-11 для входов на 0, 10, 20, 30 и 40 шагов до конца. Каждые десять шагов градиенты уменьшаются примерно на три порядка, поэтому во время обучения веса едва могут подстроиться так, чтобы учитывать входные данные, полученные несколько десятков шагов назад. Ограничение градиента, предложенное Разваном Паскану и коллегами в 2013 году для борьбы со взрывом градиентов в RNN, ограничивает их величину, а усечённое обратное распространение во времени (BPTT) ограничивает обратное распространение ошибки фиксированным окном, чтобы сдерживать расход памяти. Для борьбы с затухающими градиентами нужно изменить архитектуру — именно это и делают вентили LSTM и GRU.

RNN и родственные архитектуры#

• LSTM и GRU: RNN с вентилями и аддитивным обновлением состояния, благодаря которому информация и градиенты проходят через множество шагов. На практике под «RNN» часто подразумевают как одну из этих архитектур, так и простую RNN.
• Transformer: Напрямую обращается ко всем предыдущим позициям, а не сжимает историю в одно состояние, и обучается сразу на всех позициях параллельно. Вычислительные затраты на механизм внимания растут с длиной последовательности, а RNN расходует одинаковое количество вычислительных ресурсов и памяти на каждом новом шаге.
• Свёрточная нейронная сеть (CNN): Обрабатывает соседние позиции фильтрами фиксированного размера — в пространстве изображения или во времени с помощью одномерных свёрток. Размер её рецептивного поля зависит от глубины сети.
• Модели пространства состояний: Линейные рекуррентные модели, такие как Mamba, обучаются параллельно с помощью сканирования, а во время инференса выполняют вычисления пошагово, как RNN. Жидкие нейронные сети — это RNN непрерывного времени, нейроны которых подчиняются дифференциальным уравнениям.

Применение#

• Предсказание текста на клавиатуре: Модель Gboard для предсказания следующего слова представляла собой LSTM с объединёнными вентилями ввода и забывания — облегчённый вариант LSTM, обучавшийся с помощью федеративного обучения на телефонах пользователей, как описали исследователи Google в 2018 году.
• Прогнозирование спроса: DeepAR от Amazon обучает одну авторегрессионную RNN на множестве связанных временных рядов и выдаёт вероятностное распределение для каждого будущего значения.
• Потоковая обработка аудио: Детекторы ключевых слов и системы шумоподавления обрабатывают аудио покадрово с помощью небольших рекуррентных слоёв. Благодаря этому на телефонах и в наушниках объём памяти и задержка остаются постоянными.
• Отслеживание объектов: Трекер переносит состояние каждого объекта от кадра к кадру — эту же роль играет скрытое состояние RNN. Все трекеры, встроенные в режим отслеживания YOLO26, от ByteTrack и BoT-SORT до используемого по умолчанию TrackTrack, обновляют это состояние с помощью фильтра Калмана — линейной рекуррентной модели с заданными вручную уравнениями постоянной скорости вместо обучаемых весов.