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

Свёрточный классификатор из предыдущей заметки видит окно из $k$ токенов и забывает позицию при пулинге. N-граммная языковая модель из более ранней заметки видит $n - 1$ токенов и не умеет обобщать между ними. У обеих контекст фиксированного маленького размера. Эта заметка вводит модель, контекст которой в принципе — весь префикс: она читает токены по порядку и хранит их сводку в векторе, который обновляет на каждом шаге.

Обозначения. Входные векторы токенов $x_1, \dots, x_T \in \mathbb R^{d}$; скрытые состояния $h_t \in \mathbb R^{H}$; выходы $y_t$. Матрицы весов $W_x \in \mathbb R^{H \times d}$, $W_h \in \mathbb R^{H \times H}$, $W_y \in \mathbb R^{K \times H}$ и смещения $b, b_y$. $\odot$ — поэлементное произведение.

Рекурсия#

$$h_t = \tanh\big(W_x x_t + W_h h_{t-1} + b\big), \qquad h_0 = 0,$$ $$y_t = W_y h_t + b_y .$$

$W_x$ читает текущий токен, $W_h$ переносит предыдущее состояние вперёд, а $\tanh$ держит каждую координату $h_t$ в $(-1, 1)$. На каждом шаге используются одни и те же $W_x, W_h, b$, поэтому число параметров равно $H d + H^2 + H$ при любом $T$: последовательность из 5 токенов и последовательность из 500 прогоняют одну и ту же ячейку 5 или 500 раз. Развёрнутое во времени, вычисление — цепочка одинаковых ячеек, единственная связь между которыми — скрытое состояние.

Размерности для батча: вход $[B, T, d]$, скрытые состояния $[B, T, H]$, последнее состояние $[B, H]$. Модуль PyTorch nn.RNN(d, H, batch_first=True) возвращает и всю последовательность состояний, и последнее.

Разобранный пример#

Скалярный случай: $d = H = 1$, $W_x = 1$, $W_h = 0.5$, $b = 0$, входы $x = (1, 0, 0)$:

$t$	$x_t$	$W_x x_t + W_h h_{t-1}$	$h_t = \tanh(\cdot)$
1	1	$1 + 0 = 1$	$0.762$
2	0	$0 + 0.381 = 0.381$	$0.363$
3	0	$0 + 0.182 = 0.182$	$0.180$

Вход шага 1 всё ещё виден в $h_3$, ослабленный в $0.5$ раза на каждом шаге и ещё $\tanh$. При $W_h = 2$ тот же вход рос бы: $h_2 = \tanh(1.52) = 0.909$, $h_3 = \tanh(1.82) = 0.949$, с насыщением у края диапазона $\tanh$. Рекуррентный вес решает, затухает прошлое или затапливает всё, и это один и тот же вес на каждом шаге, так что что бы он ни делал, он делает это $T$ раз.

Шаг за шагом#

Рисунок

Шаг рекуррентной сети: что куда идёт

Номера на рисунке следуют за одним применением ячейки:

1. Прочитать вход. $W_x x_t$ — вклад текущего токена, вектор из $H$ чисел.
2. Прочитать память. $W_h h_{t-1}$ — вклад предыдущего состояния; на первом шаге $h_0 = 0$, и это слагаемое пропадает.
3. Сложить. Два вектора и смещение $b$ складываются покоординатно.
4. Сжать. $\tanh$ переводит каждую координату в $(-1, 1)$; результат — новое состояние $h_t$.
5. Предсказать, если нужно. $W_y h_t + b_y$ даёт оценки классов или токенов словаря, а softmax превращает их в вероятности.
6. Передать состояние дальше. $h_t$ становится $h_{t-1}$ следующего шага, который повторяет шаги 1–5 с теми же $W_x$, $W_h$ и $b$.

Модели следующих заметок сохраняют этот скелет — состояние, которое передаётся от шага к шагу и обновляется по текущему входу, — и каждая меняет одну его часть. LSTM меняет то, как обновляется состояние, seq2seq передаёт последнее состояние от одной сети другой, внимание позволяет второй сети оглядываться на каждое состояние первой, а self-attention отказывается от цепочки совсем. Их рисунки используют те же цвета: зелёный для входов, синий для состояний, янтарный для весов и гейтов, красный для выходов и янтарную рамку для того, что модель добавляет к предыдущей.

Два способа использовать состояния#

Рисунок

Одна рекурсия, два способа использовать состояния

RNN как классификатор#

Прочитать документ целиком и взять последнее состояние в качестве его представления: $\hat y = \mathrm{softmax}(W_y h_T + b_y)$. В отличие от max-pooling, $h_T$ вычисляется по порядку, поэтому в принципе может отличить not good от good not. В постановке AG News из предыдущей заметки однослойная GRU (ячейка с гейтами из следующей заметки) с $H = 128$ читает те же 100-мерные векторы Word2Vec и подаёт последнее состояние линейному слою. У неё $3(100 \cdot 128 + 128 \cdot 128 + 2 \cdot 128) + 128 \cdot 4 + 4 = 88\,836$ параметров — столько же по порядку, сколько у свёрточных моделей.

Одна практическая деталь. Последнее состояние дополненной последовательности — это состояние после токенов паддинга, а не после последнего настоящего токена. Можно упаковать последовательности, чтобы рекурсия останавливалась на истинной длине, можно ставить паддинг в начало, а можно брать состояние с индексом length - 1 для каждого примера.

RNN как языковая модель#

Выдавать выход на каждом шаге и делать его распределением по словарю:

$$P(w_{t+1} \mid w_{\le t}) = \mathrm{softmax}(W_y h_t + b_y), \qquad W_y \in \mathbb R^{|V| \times H}.$$

Это разложение по формуле умножения вероятностей из n-граммной заметки без марковского предположения: условная вероятность зависит от $h_t$, которое зависит от всего префикса. Обучение использует teacher forcing: входная последовательность — текст без последнего токена, $x = (w_1, \dots, w_{T-1})$, цели — $y = (w_2, \dots, w_T)$, а функция потерь — кросс-энтропия, просуммированная по позициям, то есть ровно отрицательный логарифм правдоподобия на токен, экспонента которого — перплексия. Позиции паддинга исключаются из функции потерь через ignore_index. При порождении на вход следующего шага подаётся собственный сэмпл модели, как в любой авторегрессионной модели.

Размерности: идентификаторы $[B, T]$ → эмбеддинги $[B, T, E]$ → состояния $[B, T, H]$ → логиты $[B, T, |V|]$. Кросс-энтропия считается на развёрнутых логитах $[B \cdot T, |V|]$ относительно целей $[B \cdot T]$.

Возьмём модель над словарём BPE из $|V| = 37\,580$ токенов с $E = 256$ и $H = 512$: у неё 9.6 млн параметров во входном эмбеддинге, 0.39 млн в рекуррентной ячейке и 19.3 млн в выходном слое, всего 29.3 млн. Две трети модели — выходной softmax: та же структура затрат, которая привела к негативному сэмплированию в Word2Vec; в языковой модели полный softmax сохраняют, потому что выходом служит само распределение. К перплексиям нейросетевых языковых моделей на трансформере возвращается заметка о GPT.

Градиенты во времени#

Обучение разворачивает рекурсию и распространяет ошибку обратно через каждый шаг. Градиент функции потерь на шаге $T$ по состоянию на шаге $t$ проходит через $T - t$ применений ячейки:

$$\frac{\partial h_T}{\partial h_t} = \prod_{s=t+1}^{T} \frac{\partial h_s}{\partial h_{s-1}} = \prod_{s=t+1}^{T} \mathrm{diag}\big(1 - h_s^2\big)\, W_h .$$

Каждый множитель — та же $W_h$, масштабированная производной $\tanh$ (не больше 1). Если наибольшее сингулярное число $W_h$ меньше 1, произведение убывает геометрически, и градиент затухает: функция потерь в конце предложения не может поправить то, что ячейка сделала в его начале. Если оно больше 1, произведение может расти, и градиент взрывается (Pascanu, Mikolov and Bengio, 2013 показывают, что это условие необходимое, но не достаточное). При скалярном рекуррентном весе $w = 2$ и состояниях в линейной части $\tanh$, где её производная близка к 1, пятьдесят шагов умножают градиент на $2^{50} \approx 10^{15}$. Рисунок ниже, общий с заметкой курса по генеративным моделям, где вычисление расписано подробно, показывает механизм.

Рисунок

Развёрнутая RNN с рекуррентным весом w = 2

Два следствия для практики. Обрезка градиентов (gradient clipping) масштабирует вектор градиента, когда его норма превышает порог, например 1.0; это не даёт взрывам разрушить веса, но ничего не делает с затуханием. А затухание — главное ограничение: обычная RNN выучивает зависимости на несколько токенов и теряет остальное, поэтому «контекст — весь префикс» верно для прямого прохода, но не для того, чему модель учится (Bengio, Simard and Frasconi, 1994). Следующая заметка меняет ячейку так, чтобы у состояния был аддитивный путь с множителем градиента около 1.

Что изменилось#

	CNN-классификатор	N-граммная ЯМ	RNN
Контекст	$k$ токенов на фильтр	$n - 1$ токенов	Весь префикс (в принципе)
Параметры и длина	Не зависят	Таблица растёт с данными	Не зависят
Позиция	Теряется при пулинге	Только последние $n-1$	Закодирована в порядке состояний
Обобщает между токенами	Да (эмбеддинги)	Нет	Да
Порождение	Нет	Да	Да, с выходом на $\lvert V \rvert$ классов
Параллельно по $T$	Да	—	Нет: $h_t$ требует $h_{t-1}$

Ограничения#

• Короткая эффективная память. Градиенты затухают за десятки шагов; состояние нельзя обучить долго хранить информацию.
• Последовательные вычисления. Шаг $t$ ждёт шага $t - 1$, поэтому RNN не может использовать параллелизм GPU вдоль последовательности. Время обучения на пример растёт линейно по $T$, и заметка о трансформере сделает это главным доводом против рекурсии.
• Одно состояние на всё. Единственный вектор $h_T$ должен подытожить весь вход. Для классификации этого достаточно; для перевода предложения из 30 слов это узкое место, в которое упирается заметка о seq2seq.
• Паддинг взаимодействует с последним состоянием. Переменная длина требует упаковки или масок, которые не были нужны свёрточной модели.

Что нужно запомнить#

• $h_t = \tanh(W_x x_t + W_h h_{t-1} + b)$: одна и та же ячейка на каждом шаге, параметры не зависят от длины, состояние несёт префикс.
• Классификатор: последнее состояние → линейный слой. Языковая модель: каждое состояние → softmax по $|V|$, обучение через teacher forcing на сдвинутой последовательности без учёта паддинга.
• Градиент через $T - t$ шагов — произведение $T - t$ копий $\mathrm{diag}(1 - h^2)W_h$; он затухает или взрывается геометрически. Обрезка справляется только со взрывом.
• Рекурсия последовательна: вдоль последовательности нет параллелизма.

Ноутбук#

Два ноутбука. Номера ячеек считают все ячейки, включая текстовые, начиная с 1. Приведённые числа взяты из прогона, сохранённого в курсе; у ячеек, изменённых с тех пор под текущие версии библиотек, сохранённого выхода нет.

week02_NN_text_classification.ipynb, ячейки 40–43: SimpleRNN оборачивает nn.GRU(100, 128, batch_first=True) и линейный слой на последнем скрытом состоянии и обучается тем же циклом, что и свёрточные модели, 5 эпох. Итоговой распечатки в сохранённых выходах нет, поэтому в курсе нет доли правильных ответов, чтобы сравнить эту GRU со свёрточными классификаторами и с базовым уровнем TF-IDF. Классификатор берёт последнее состояние после токенов паддинга, а не после последнего настоящего токена — упрощение, разобранное в разделе RNN как классификатор.

week03_lm.ipynb:

• Ячейки 46–49 токенизируют корпус анекдотов BPE и строят словарь из 37 580 записей с фиксированными идентификаторами для <pad> (0) и <unk> (1).
• Ячейка 51 строит батчи: каждый анекдот обрезается до 128 токенов, входы — s[:-1], цели — s[1:], и те и другие дополняются нулями.
• Ячейка 52 определяет SimpleRNNLM: nn.Embedding(V, 256, padding_idx=0), nn.RNN(256, 512, batch_first=True), nn.Linear(512, V) — модель на 29.3 млн параметров, посчитанная в разделе RNN как языковая модель.
• Ячейка 53 прогоняет одну эпоху: кросс-энтропия с ignore_index=0, обрезка нормы градиента на 1.0 и перплексия как $\exp$ от средних по токенам потерь (выше потерь 20 она полагается равной $\infty$, чтобы избежать переполнения). Ячейка 55 обучает три эпохи с AdamW при $3 \times 10^{-3}$ и батчами по 64; прогон, сохранённый в курсе, был прерван после нескольких батчей, поэтому сохранённых перплексий нет. Softmax на 37 580 токенов делает эту ячейку практичной только на GPU с CUDA, о чём говорит текстовая ячейка перед ней.

Дальше#

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

Литература#

• J. L. Elman. Finding Structure in Time. Cognitive Science, 14(2), 1990. Простая рекуррентная сеть.
• Y. Bengio, P. Simard, P. Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2), 1994.
• R. Pascanu, T. Mikolov, Y. Bengio. On the difficulty of training recurrent neural networks. ICML, 2013. Анализ произведения якобианов и обрезка градиентов.
• T. Mikolov, M. Karafiát, L. Burget, J. Černocký, S. Khudanpur. Recurrent neural network based language model. Interspeech, 2010.
• I. Goodfellow, Y. Bengio, A. Courville. Deep Learning. MIT Press, 2016. Глава 10 (моделирование последовательностей, teacher forcing, долгосрочные зависимости).