LSTM и проблема длинной памяти

LSTM прокладывает через время почти линейный путь состояния. Ворота не являются маленькими разумными контролёрами: это дифференцируемые числа от нуля до единицы, которые учатся пропускать, стирать и показывать сигнал. Значение одного такого числа переводится в число шагов памяти простой формулой, а аддитивный путь решает не задачу «помнить», а задачу «донести градиент».

Пароль через длинную паузу

Последовательность начинается символом К, затем идут двести нерелевантных знаков, а в конце нужно воспроизвести первый символ. Простая RNN многократно переписывает $h_t$ и проводит градиент через произведение матриц: на каждом шаге состояние целиком пропускается через нелинейность, и от первого символа к концу почти ничего не доходит — ни сигнала вперёд, ни производной назад.

LSTM меняет одну вещь. Рядом со скрытым состоянием $h_t$ появляется отдельное состояние памяти $c_t$, которое обновляется аддитивно: старое значение умножается на число и к нему прибавляется новое. Никаких матриц на этом пути, никакого $\tanh$ поверх всего состояния. Для входа $x_t$ и предыдущего $h_{t-1}$ вычисляются ворота:

$$\begin{aligned} f_t&=\sigma(W_f[x_t,h_{t-1}]+b_f),\\ i_t&=\sigma(W_i[x_t,h_{t-1}]+b_i),\\ o_t&=\sigma(W_o[x_t,h_{t-1}]+b_o),\\ \widetilde c_t&=\tanh(W_c[x_t,h_{t-1}]+b_c). \end{aligned}$$

Затем

$$c_t=f_t\odot c_{t-1}+i_t\odot\widetilde c_t, \qquad h_t=o_t\odot\tanh(c_t).$$

Forget gate $f_t$ сохраняет часть старого, input gate $i_t$ дозирует запись, output gate $o_t$ решает, что показать наружу. Все операции покомпонентны: координата памяти живёт своей жизнью и имеет собственный временной масштаб.

Обратите внимание на порядок аргументов: они начали не с памяти, а с градиента. Проблема формулируется как «обратный поток ошибки затухает», и конструкция ячейки является ответом именно на неё.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Одна координата, семь чисел

Разберём шаг руками, потому что вся дальнейшая интуиция держится на этой арифметике. Пусть $c_{t-1}=2$, $f_t=0{,}8$, $i_t=0{,}25$, $\widetilde c_t=-0{,}4$, $o_t=0{,}6$. Память сохраняется в доле $f_t$:

$$f_tc_{t-1}=0{,}8\cdot2=1{,}6000,$$

запись добавляет

$$i_t\widetilde c_t=0{,}25\cdot(-0{,}4)=-0{,}1000,$$

и вместе

$$c_t=1{,}6000-0{,}1000=1{,}5000 .$$

Наружу выходит не $c_t$, а его сжатая и приглушённая версия:

$$h_t=o_t\tanh(c_t)=0{,}6\cdot0{,}9051=0{,}5431 .$$

Чувствительность выхода к памяти равна произведению двух множителей:

$$\frac{\partial h_t}{\partial c_t}=o_t\bigl(1-\tanh^2c_t\bigr) =0{,}6\cdot0{,}1807=0{,}1084 .$$

Если полностью закрыть запись, $i_t=0$, то $c_t=1{,}6$ и $h_t=0{,}5530$: внешнее различие двух ситуаций — четыре сотых, тогда как внутри память отличается на десятую. Это первый важный вывод: $h_t$ является отчётом о памяти, а не самой памятью, и $\tanh$ вместе с $o_t$ умеют сжимать большие внутренние различия до неразличимых внешних.

Почему сложение спасает градиент

Возьмём производную памяти по её же предыдущему значению вдоль прямого пути:

$$\frac{\partial c_t}{\partial c_{t-1}}\approx f_t .$$

Тогда на отрезке от $t$ до $T$

$$\frac{\partial c_T}{\partial c_t}\approx\prod_{k=t+1}^{T}f_k .$$

Сравните с простой RNN, где на каждом шаге градиент домножается на рекуррентную матрицу и производную нелинейности:

$$\frac{\partial h_T}{\partial h_t}=\prod_{k=t+1}^{T} \operatorname{diag}\bigl(1-h_k^2\bigr)W^\top .$$

В логарифмах разница видна лучше всего:

$$\ln\Bigl\lVert\frac{\partial c_T}{\partial c_t}\Bigr\rVert \approx\sum_{k=t+1}^{T}\ln f_k, \qquad \ln\Bigl\lVert\frac{\partial h_T}{\partial h_t}\Bigr\rVert \lesssim (T-t)\ln\lVert W\rVert+\sum_{k=t+1}^{T}\ln\bigl(1-h_k^2\bigr).$$

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

Множитель $1-h_k^2$ не превосходит единицы и при насыщении близок к нулю, поэтому произведение тает даже при аккуратно подобранной $W$. У аддитивного пути такого множителя нет вовсе — есть только ворота, и сеть может держать их близко к единице.

«Почти» в первой формуле существенно: ворота зависят от $h_{t-1}$, поэтому полный градиент имеет дополнительные пути. LSTM смягчает исчезновение, а не доказывает бесконечную память.

Измерим это на живой сети. Возьмём задачу «запомни первый бит» с паузой в $D=100$ посторонних символов и посмотрим, какая доля градиента доходит от запроса до первого шага при инициализации, до всякого обучения. У простой RNN норма $\lVert\partial\mathcal L/\partial h_t\rVert$ падает за сто шагов в 704 раза. У LSTM градиент по памяти $\lVert\partial\mathcal L/\partial c_t\rVert$ не падает вовсе: он даже вырастает в 3,72 раза, потому что вклады с разных шагов складываются вдоль магистрали. Отношение двух «дальностей» — около 2620 раз.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Время полураспада: перевод ворот в шаги

Число $f$ само по себе ничего не говорит. Переведём его в шаги. Если запись выключена и forget gate постоянен, то

$$c_{t+k}=f^k c_t ,$$

и время уменьшения амплитуды вдвое равно

$$t_{1/2}=\frac{\ln 0{,}5}{\ln f}.$$

Обратный перевод не менее полезен: если нужен горизонт $H$ шагов, то

$$f=0{,}5^{1/H}=\exp\!\left(\frac{\ln0{,}5}{H}\right).$$

Подставим: при $f=0{,}9$ получаем 6,6 шага, при $f=0{,}95$ — 13,5, при $f=0{,}99$ — 69,0, а при $f=0{,}999$ — 692,8. Разница между $0{,}99$ и $0{,}999$ на глаз ничтожна, а память отличается в десять раз. Это и есть причина, по которой обученные ворота выглядят «неинформативно»: почти все интересные значения теснятся у самой единицы.

Четыре режима из одной формулы

Пара чисел $(f,i)$ порождает качественно разные поведения одной и той же координаты:

• $f\approx1,\ i\approx0$ — хранить: значение стоит на месте;
• $f\approx0,\ i\approx1$ — заменить: старое стёрто, записано новое;
• $f\approx1,\ i>0$ — накапливать: значение растёт как сумма;
• $f<1,\ i\approx0$ — забывать с заданной скоростью;
• $o\approx0$ — скрыть память от выхода, не удаляя её.

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

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Про последнее стоит сказать отдельно. Накопитель не переполняется в смысле арифметики: $c$ растёт линейно и может дойти до сотен. Но $h_t$ ограничен единицей, поэтому внешне разница между $c=4$ и $c=40$ почти незаметна. Ограниченность выхода маскирует неограниченность внутреннего состояния — и именно на этом ломаются длинные потоки без сброса.

Забавно, что forget gate — не часть исходной конструкции 1997 года: его добавили через два года, когда LSTM стали кормить непрерывными потоками. Первая версия умела помнить, но не умела вовремя забывать.

Эксперимент: запомни первый бит

Проверим тезис честным измерением. Задача: на первом шаге приходит бит (0 или 1), затем $D$ посторонних символов из трёх «болтливых» значений, затем запрос — и модель обязана назвать первый бит. Мы обучили в numpy, с ручным обратным распространением, три ячейки с почти одинаковым бюджетом параметров: простую RNN ширины 64 (4674 параметра), GRU ширины 36 (4718) и LSTM ширины 31 (4776). Бюджет считается по формуле

$$P=g\,(dn+n^2+n)+nk+k,\qquad g=1,\ 3,\ 4$$

для RNN, GRU и LSTM соответственно ($d$ — размер входа, $k$ — число классов). Разброс размеров — 2,18 %, так что сравнение идёт не про число весов. Всё остальное общее: Adam с шагом $2\cdot10^{-3}$, батч 96, 1000 шагов, три случайные инициализации, тест на 2000 свежих последовательностей.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Три вывода, которые важнее самих чисел. Первый: разница между RNN и воротами существует и измерима, но она не бесконечна — граница просто сдвинулась с полусотни шагов к сотне-двум. Второй: результат сильно зависит от инициализации, поэтому одна цифра без разброса по seed’ам ничего не значит. Третий: GRU при паузе 100 не хуже LSTM, хотя ворот у неё меньше — заранее утверждать «LSTM помнит лучше» нельзя.

Что показывают ворота обученной сети

Обучим LSTM ширины 31 на паузе $D=30$ до точности 1,00 и посмотрим на её ворота — не нарисованные от руки, а настоящие. Среднее по координатам значение forget gate в паузе равно 0,956, что соответствует полураспаду 15,3 шага. Input gate в паузе равен 0,529, то есть не закрыт: сеть продолжает писать в память каждый шаг. Output gate тоже держится около 0,617 и слегка приоткрывается к запросу, до 0,675.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Это неудобная для красивых лекций картина, и именно поэтому её стоит показать. Учебная схема обещает $i_t\approx0$ в паузе, а реальная сеть выбрала другую стратегию: почти постоянное $f$ чуть меньше единицы и постоянную дозапись — и получила из этого монотонно расходящиеся траектории. Обе стратегии решают задачу; оптимизация выбрала ту, которая ближе к её инициализации.

Лаборатория ворот

Ключ приходит на шаге 5, ответ спрашивают на шаге 70. Виджет прогоняет один и тот же сценарий дважды — с ключом $+1$ и $-1$ — и показывает обе траектории памяти: сохранился ответ или нет, определяется расстоянием между ними, а не их уровнем. Начните с $f=0{,}95$ и убедитесь, что полураспад 13,5 шага не доносит сигнал через 65 шагов паузы; доведите $f$ до $0{,}99$ и посмотрите, как одновременно поднимаются обе кривые внизу — память и дальность градиента меняются одним и тем же числом. Затем закройте $o$ и увидите, что ответ остаётся в памяти, но исчезает с выхода.

Главный опыт — четвёртый ползунок. Включите шум в паузе при большом $i$: болтовня пишется в память теми же воротами, что и ключ, и разделение кривых тает. Уменьшите $i$ — перестанет записываться и ключ. Постоянными воротами эту задачу решить нельзя, и в этом весь смысл: в настоящей сети $i_t$ является функцией входа и закрывается именно на болтовне.

Не ищите буквальное «это нейрон памяти буквы К». Представление распределено: одна координата может участвовать в нескольких функциях, а один факт храниться в нескольких координатах.

Bias forget gate: prior на длинную память

В нашем эксперименте есть деталь, без которой ничего бы не вышло. Смещение forget gate инициализировано числом 3, то есть в начале обучения $f\approx\sigma(3)=0{,}953$. Мы это проверили прямым экспериментом: при смещении 1 та же LSTM с тем же шагом обучения не решила задачу с паузой 100 ни разу (0 успехов из 3 инициализаций, точность 0,494, 0,487 и 0,482 — чистое угадывание), а при смещении 3 решила во всех трёх с точностью 1,00.

Объяснение простое. Инициализация нулевым смещением даёт $f\approx0{,}5$ и полураспад в один шаг: сеть стартует с состоянием, которое ничего не помнит, и градиент, который должен научить её помнить, до нужного места не доходит. Положительное смещение — это prior: «по умолчанию храни». Слишком большое смещение вредно симметрично: сеть медленно учится забывать смену режима.

$$f=\sigma(b)\ \Longrightarrow\ t_{1/2}=\frac{\ln0{,}5}{\ln\sigma(b)} .$$

GRU: меньше ворот, тот же принцип

Gated Recurrent Unit объединяет память и скрытое состояние:

$$\begin{aligned} z_t&=\sigma(W_z[x_t,h_{t-1}]),\\ r_t&=\sigma(W_r[x_t,h_{t-1}]),\\ \widetilde h_t&=\tanh(W_h[x_t,r_t\odot h_{t-1}]),\\ h_t&=(1-z_t)\odot h_{t-1}+z_t\odot\widetilde h_t. \end{aligned}$$

Update gate $z_t$ интерполирует между старым и новым, играя роль сразу $f$ и $i$: связка $f=1-z$, $i=z$ жёстко связывает «сколько забыл» и «сколько записал». Reset gate $r_t$ позволяет вычислить кандидата, глядя на вход и лишь частично на прошлое.

$$h_t-h_{t-1}=z_t\odot(\widetilde h_t-h_{t-1})$$

— в такой записи видно, что $z_t$ есть скорость движения к новому значению. При постоянном $z$ развёртка даёт экспоненциальное сглаживание:

$$h_t=z\sum_{k=0}^{t-1}(1-z)^k\,\widetilde h_{t-k}+(1-z)^t h_0 ,$$

то есть вес наблюдения падает геометрически с эффективной памятью $1/z$ шагов. При $z=0{,}2$ половина пути проходится за 4 шага.

Параметров у GRU меньше: три матрицы вместо четырёх. При равной ширине это 13762 против 18306 в нашей задаче. Но одинаковое число координат не означает одинаковую ёмкость: при честном сравнении выравнивают хотя бы размер модели или время обучения, как мы и сделали выше.

Маска, padding и неодинаковая длина

В batch последовательности дополняют padding. Маска $m_t\in\{0,1\}$ должна сохранять состояние на фиктивных шагах:

$$c_t=m_t\,c_t^{\mathrm{new}}+(1-m_t)\,c_{t-1}, \qquad h_t=m_t\,h_t^{\mathrm{new}}+(1-m_t)\,h_{t-1}.$$

Loss также умножают на маску. Иначе короткие примеры получают лишние нулевые события, а последнее состояние относится к padding, не к данным. Нуль на входе для сети — не «ничего не произошло», а вполне конкретное наблюдение: она честно применит к нему ворота и сдвинет память.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

В медицинских рядах пропуск измерения несёт информацию: анализ могли назначить из-за ухудшения. Маска наблюдаемости и время с последнего измерения становятся входными признаками. Заполнить все пропуски нулём — значит смешать «значение равно нулю» с «не измерено».

Реальные данные: велопрокат по часам

Проверим ячейку на настоящем ряде: почасовой прокат велосипедов, 17379 часов наблюдений. Задача — предсказать число поездок в следующий час по окну из 24 предыдущих часов; первые 70 % времени идут в обучение, последние 30 % (5207 часов) — в тест, без перемешивания. Среднее и разброс для нормировки взяты только по обучающему периоду: 159,9 и 152,6 поездки.

Порядок сравнения тот же, что в уроке про регрессию: сначала глупые baseline, потом умные модели.

$$\text{MAE}=\frac1N\sum_{k=1}^{N}\bigl|\widehat y_k-y_k\bigr| .$$

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

$$\widehat y_t=y_{t-24}.$$

Прогноз «как час назад» даёт MAE 86,7 поездки; «как ровно сутки назад» — 81,4; ridge-регрессия по тем же 24 лагам и паре $\sin,\cos$ часа — 55,5; LSTM ширины 24 — 34,4. Выигрыш над сезонным baseline составляет 57,8 %.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Разбор по пикам обязателен. Порог «пикового часа» — 90-й процентиль обучающей нагрузки, 380 поездок; в тесте таких часов 25,6 % (сам по себе тревожный признак: во второй год проката стало заметно больше, распределение сдвинулось). На пиках MAE у LSTM равна 53,7 против 131,4 у сезонного прогноза — модель выигрывает, но её собственная ошибка на пиках в полтора с лишним раза выше средней. Средняя цифра скрывает, что все интересные часы предсказываются хуже обычных.

Автоматы Глушкова: состояние как понятие

За двадцать лет до трансформеров и за тридцать до LSTM понятие «состояние» получило точное определение в советской школе кибернетики. Виктор Михайлович Глушков, директор Института кибернетики в Киеве, в «Синтезе цифровых автоматов» (1962) развил теорию абстрактного автомата: пятёрка из множества входов, множества состояний, множества выходов и двух функций,

$$q_{t}=\delta(q_{t-1},x_t),\qquad y_t=\lambda(q_{t-1},x_t).$$

Сравните с нашей ячейкой: $q$ — это пара $(c_t,h_t)$, $\delta$ — формулы ворот, $\lambda$ — выходной слой. LSTM буквально является автоматом Глушкова, у которого множество состояний стало непрерывным, а функции $\delta$ и $\lambda$ — дифференцируемыми и обучаемыми.

Эквивалентность состояний определяется через поведение, а не через содержимое:

$$q\sim q'\iff\forall\,x_{1\:k}\ \lambda^*(q,x_{1\:k})=\lambda^*(q',x_{1\:k}),$$

где $\lambda^*$ — выход автомата на всей входной строке.

Из этой оптики следуют вполне практические вещи. Задача синтеза автомата — построить минимальную машину с нужным поведением; задача обучения LSTM — подобрать веса, чтобы поведение совпало с данными. Понятие эквивалентных состояний (двух состояний, неразличимых ни при каком продолжении входа) прямо объясняет, почему бессмысленно требовать от координат памяти «смысла»: у автомата есть целые классы состояний, ведущих себя одинаково, и обучение вправе выбрать любой представитель класса.

Что ворота не решают

LSTM всё ещё обрабатывает шаги последовательно, что ограничивает параллельность: сто шагов — это сто зависимых умножений, и никакая видеокарта их не совместит. Состояние остаётся фиксированного размера, поэтому объём памяти не растёт вместе с длиной входа: в сто чисел нельзя положить сто тысяч токенов без потерь. Дальняя информация может затухнуть или быть перезаписана — наш эксперимент при $D=200$ показал это прямо.

Для задач с прямыми связями между далёкими токенами attention создаёт короткий путь: каждый шаг смотрит на каждый, и длина пути равна единице, а не $T$. Для потоковой обработки на устройстве LSTM может быть дешевле: состояние постоянного размера и один шаг на наблюдение против квадратичной по длине памяти внимания. Архитектура выбирается по ограничениям, а не по хронологии моды.

Связь с остаточными соединениями содержательная: и аддитивный путь $c_t$, и residual $x+F(x)$ дают сигналу возможность пройти без полного нелинейного переписывания. В обоих случаях речь не о выразительности, а о проходимости — о том, чтобы производная имела короткую дорогу, как в уроке об обратном распространении.

Проверки, которые стоит написать

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

Контракт сброса. Явно определите событие, при котором $h,c$ обнуляются: новый пользователь, новый двигатель, разрыв длиннее часа. Сохраните этот контракт рядом с моделью, иначе offline и production вычислят разные состояния на одних и тех же данных.

Независимость от порядка. Отсортируйте объекты в батче двумя способами и сравните прогнозы. Если состояние перетекает между объектами, результат зависит от технического порядка строк — и такой баг даёт особенно высокий валидационный score, когда соседние записи относятся к одному устройству.

Длинное накопление. Прогоните последовательность в десять раз длиннее обучающей и посмотрите на $\max|c_t|$. Ограниченный $h_t$ способен скрывать рост внутреннего $c_t$; в mixed precision позднее открытие output gate насыщает $\tanh$ и стирает различия, о чём предупреждали авторы forget gate.

Неравномерное время. При irregular sampling добавьте $\Delta t$ как признак. Два одинаковых значения, разделённые минутой и сутками, означают разную скорость процесса. Естественная параметризация — заставить ворота зависеть от интервала:

$$f_t=\sigma(\cdot)^{\Delta t},$$

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

Мини-исследование: ворота на смене режима

Сгенерируйте ряд, где скрытый уровень $b_t$ постоянен 50–150 шагов, затем маркер $m_t=1$ сообщает, что уровень заново выбран. Наблюдение

$$x_t=b_t+\varepsilon_t,\qquad \varepsilon_t\sim\mathcal N(0,\,0{,}2^2).$$

LSTM должна усреднять шум внутри сегмента и быстро забывать старое после маркера. Постройте средние $f_t,i_t$ в окне от $-10$ до $+20$ вокруг переключения. Ожидается падение forget gate и рост input gate, но проверяйте одновременно ошибку: красивый профиль без улучшения прогноза ничего не доказывает — мы только что видели, как обученная сеть решила ту же задачу совсем другой стратегией.

Проведите counterfactual: удалите маркер из входа, сохранив сами значения. Время адаптации должно увеличиться. Затем вставьте ложный маркер без смены уровня. Если сеть полностью стирает память, возникнет краткий всплеск ошибки. Так выясняется, как она объединяет явное событие и статистическое свидетельство. Сравните с задачей об обнаружении разладки, где переключение ищется по вероятностному критерию: LSTM обучает внутренний детектор вместе с прогнозом, но не выдаёт калиброванную вероятность смены.

Ворота задают временной масштаб

LSTM делает память управляемой: отдельный аддитивный канал, запись, забывание и чтение. Формула $t_{1/2}=\ln0{,}5/\ln f$ переводит значение ворот в число шагов и объясняет, почему разница между $0{,}99$ и $0{,}999$ — это разница между семьюдесятью и семьюстами шагами. Аддитивный путь спасает не память, а градиент: до обучения он доносит сигнал через сто шагов в 2620 раз лучше, чем рекуррентная матрица.

Но измерения важнее лозунгов. Ворота отодвинули границу с полусотни шагов к сотне-двум, а не к бесконечности. Обученная сеть выбрала стратегию, которой не было в учебнике. На реальном ряде выигрыш дала не столько ячейка, сколько честное сравнение с baseline, нормировка по train и разбор ошибки на пиках. Ячейка — это гипотеза о том, какой путь сигнала должен быть коротким; всё остальное по-прежнему решают данные и дисциплина эксперимента.

Задачи