Długa pamięć krótkotrwała 📖 Wikipedia

Długa pamięć krótkotrwała (ang. long short-term memory, LSTM) – architektura rekurencyjnej sieci neuronowej zaprojektowana do uczenia zależności w danych sekwencyjnych, w szczególności zależności oddzielonych wieloma krokami czasowymi. LSTM została wprowadzona przez Seppa Hochreitera i Jürgena Schmidhubera w 1997 roku jako odpowiedź na problem zanikających i eksplodujących gradientów w klasycznych sieciach rekurencyjnych^[1][2].

LSTM jest jednym z najważniejszych wariantów sieci RNN. Przez wiele lat była szeroko stosowana w rozpoznawaniu mowy, przetwarzaniu języka naturalnego, rozpoznawaniu pisma ręcznego, analizie szeregów czasowych, modelowaniu sygnałów i innych zadaniach sekwencyjnych^[3][4].

Klasyczna rekurencyjna sieć neuronowa przetwarza sekwencję krok po kroku, aktualizując ukryty stan na podstawie bieżącego wejścia i poprzedniego stanu. Teoretycznie pozwala to modelować zależności długiego zasięgu, ale w praktyce trening takich sieci za pomocą propagacji wstecznej przez czas często prowadzi do zanikających albo eksplodujących gradientów. W efekcie sieć może mieć trudność z uczeniem zależności między elementami sekwencji odległymi o wiele kroków czasowych^[2][1].

LSTM wprowadza specjalną komórkę pamięci oraz bramki sterujące przepływem informacji. Dzięki temu sieć może przechowywać pewne informacje przez długi czas, usuwać informacje niepotrzebne i decydować, które części stanu pamięci ujawnić w stanie ukrytym. Nazwa long short-term memory oznacza, że architektura miała zapewnić mechanizm pamięci krótkotrwałej zdolnej do działania na długich przedziałach czasowych^[1].

Typowa komórka LSTM ma dwa główne stany:

• stan komórki ${\displaystyle c_{t}}$, pełniący rolę pamięci;
• stan ukryty ${\displaystyle h_{t}}$, będący wyjściem komórki w danym kroku czasowym.

Przepływem informacji sterują bramki:

• bramka wejściowa – decyduje, jaka część nowej informacji zostanie zapisana w pamięci;
• bramka zapominania – decyduje, jaka część poprzedniego stanu komórki zostanie zachowana;
• bramka wyjściowa – decyduje, jaka część pamięci zostanie ujawniona jako stan ukryty.

Bramki są zwykle realizowane jako warstwy z funkcją sigmoidalną, której wartości należą do przedziału od 0 do 1. Wartość bliska 0 oznacza niemal całkowite zablokowanie informacji, a wartość bliska 1 – jej przepuszczenie^[5][6].

Jedna z najczęściej używanych wersji komórki LSTM jest opisana równaniami:

${\displaystyle i_{t}=\sigma (W_{ii}x_{t}+b_{ii}+W_{hi}h_{t-1}+b_{hi}),}$

${\displaystyle f_{t}=\sigma (W_{if}x_{t}+b_{if}+W_{hf}h_{t-1}+b_{hf}),}$

${\displaystyle g_{t}=\tanh(W_{ig}x_{t}+b_{ig}+W_{hg}h_{t-1}+b_{hg}),}$

${\displaystyle o_{t}=\sigma (W_{io}x_{t}+b_{io}+W_{ho}h_{t-1}+b_{ho}),}$

${\displaystyle c_{t}=f_{t}\odot c_{t-1}+i_{t}\odot g_{t},}$

${\displaystyle h_{t}=o_{t}\odot \tanh(c_{t}).}$

gdzie:

• ${\displaystyle x_{t}}$ oznacza wejście w chwili ${\displaystyle t}$;
• ${\displaystyle h_{t-1}}$ oznacza poprzedni stan ukryty;
• ${\displaystyle c_{t-1}}$ oznacza poprzedni stan komórki;
• ${\displaystyle i_{t}}$ jest bramką wejściową;
• ${\displaystyle f_{t}}$ jest bramką zapominania;
• ${\displaystyle o_{t}}$ jest bramką wyjściową;
• ${\displaystyle g_{t}}$ jest kandydatem nowej zawartości pamięci;
• ${\displaystyle \sigma }$ oznacza funkcję sigmoidalną;
• ${\displaystyle \odot }$ oznacza mnożenie wektorów po współrzędnych^[6].

W literaturze i implementacjach występują różne konwencje oznaczeń, ale podstawowa idea pozostaje taka sama: stan komórki jest aktualizowany przez połączenie zapamiętanej informacji z nową informacją kontrolowaną bramkami.

Jedną z najważniejszych cech LSTM jest istnienie ścieżki, po której informacja może być przenoszona przez kolejne kroki czasowe z mniejszą utratą niż w prostej sieci RNN. W równaniu

${\displaystyle c_{t}=f_{t}\odot c_{t-1}+i_{t}\odot g_{t}}$

stan komórki ${\displaystyle c_{t}}$ zależy addytywnie od poprzedniego stanu ${\displaystyle c_{t-1}}$. W uproszczeniu pochodna stanu komórki względem poprzedniego stanu ma składnik

${\displaystyle {\frac {\partial c_{t}}{\partial c_{t-1}}}\approx f_{t}.}$

Jeżeli bramka zapominania ${\displaystyle f_{t}}$ przyjmuje wartości bliskie 1, gradient może przepływać przez wiele kroków czasowych bez szybkiego zaniku. Jeżeli ${\displaystyle f_{t}}$ jest bliskie 0, komórka uczy się wygaszać wcześniejszą informację^[5][7].

W pierwotnej terminologii Hochreitera i Schmidhubera rolę takiej stabilnej ścieżki odgrywał tzw. stały obieg błędu (ang. constant error carousel), dzięki któremu informacja o błędzie mogła być propagowana przez wiele kroków czasowych^[1].

Dla wejścia o wymiarze ${\displaystyle d}$ i stanu ukrytego o wymiarze ${\displaystyle h}$ pojedyncza warstwa LSTM musi obliczyć cztery zestawy wielkości: bramkę wejściową, bramkę zapominania, kandydata stanu komórki i bramkę wyjściową. W typowej implementacji oznacza to macierze wag dla wejścia i stanu ukrytego oraz wyrazy wolne dla każdej z tych czterech części.

W uproszczonej konwencji z jednym wektorem wyrazów wolnych liczba parametrów jednej jednokierunkowej warstwy wynosi:

${\displaystyle 4h(d+h+1).}$

W niektórych implementacjach, na przykład w PyTorch, występują osobne wyrazy wolne dla części wejściowej i rekurencyjnej, co daje:

${\displaystyle 4hd+4h^{2}+8h.}$^[6]

Dla sieci dwukierunkowej liczba parametrów jest odpowiednio większa, ponieważ utrzymywane są osobne parametry dla kierunku w przód i kierunku wstecz.

Pierwotna architektura LSTM z 1997 roku nie zawierała bramki zapominania w formie, która później stała się standardowa^[1]. Bramkę tę wprowadzili Felix Gers, Jürgen Schmidhuber i Fred Cummins w pracy z 2000 roku. Jej zadaniem jest umożliwienie komórce nauczenia się, kiedy zresetować albo osłabić wcześniejszą zawartość pamięci^[5].

Bramka zapominania jest szczególnie ważna w strumieniach danych, które nie są naturalnie podzielone na niezależne epizody. Bez niej komórka może utrzymywać w pamięci informacje, które przestały być istotne dla dalszego przetwarzania^[5].

Sieci LSTM trenuje się zwykle metodami gradientowymi, takimi jak stochastyczny spadek gradientu lub jego warianty. Dla danych sekwencyjnych stosuje się propagację wsteczną przez czas (ang. backpropagation through time, BPTT), polegającą na rozwinięciu sieci rekurencyjnej wzdłuż kolejnych kroków czasowych i obliczeniu gradientów parametrów względem funkcji straty.

Architektura LSTM ułatwia przepływ gradientu przez stan komórki, ale nie usuwa wszystkich problemów treningu. W praktyce używa się takich technik jak przycinanie gradientów, regularyzacja, dropout, normalizacja, staranna inicjalizacja oraz dobór długości sekwencji używanej w BPTT.^[1][7]

Dwukierunkowa LSTM (ang. bidirectional LSTM, BLSTM) przetwarza sekwencję w dwóch kierunkach: od początku do końca oraz od końca do początku. Wyjścia z obu kierunków są następnie łączone. Pozwala to używać informacji z przeszłości i przyszłości w zadaniach, w których dostępna jest cała sekwencja, na przykład przy klasyfikacji fonemów lub etykietowaniu tekstu^[3].

Wariant z tzw. połączeniami podglądowymi (ang. peephole connections) pozwala bramkom korzystać bezpośrednio ze stanu komórki. Gers, Schraudolph i Schmidhuber pokazali, że taki wariant może ułatwiać uczenie precyzyjnych zależności czasowych^[8].

Sieci LSTM można układać w kilka warstw. Taki model nazywa się często głęboką LSTM. Kolejne warstwy mogą uczyć się reprezentacji sekwencji na różnych poziomach abstrakcji. Warianty głębokie były stosowane między innymi w rozpoznawaniu mowy na dużą skalę^[4].

W niektórych zastosowaniach używa się warstwy projekcyjnej, która zmniejsza wymiar stanu ukrytego przekazywanego dalej. Taka architektura może ograniczyć liczbę parametrów i koszt obliczeniowy przy zachowaniu dużego stanu komórki. Rozwiązania tego typu były badane w rozpoznawaniu mowy^[4][6].

Konwolucyjna LSTM (ang. convolutional LSTM, ConvLSTM) zastępuje mnożenia macierzowe operacjami konwolucyjnymi. Jest używana do danych czasoprzestrzennych, takich jak sekwencje obrazów, mapy radarowe lub nagrania wideo. Shi i współautorzy zaproponowali ConvLSTM do prognozowania opadów w krótkim horyzoncie czasowym^[9].

W klasycznej sieci RNN stan ukryty aktualizuje się bez wyraźnego, osobnego stanu pamięci i bez bramek kontrolujących przepływ informacji. LSTM rozbudowuje tę architekturę o mechanizm pamięci i bramkowania, co ułatwia uczenie dłuższych zależności^[1].

GRU (ang. gated recurrent unit) jest inną bramkowaną architekturą rekurencyjną, zaproponowaną w 2014 roku w kontekście modeli encoder–decoder dla tłumaczenia maszynowego. GRU ma mniej parametrów niż typowa LSTM, ponieważ nie rozdziela jawnie stanu komórki i stanu ukrytego oraz używa mniejszej liczby bramek^[10].

Od końca lat 2010. w wielu zadaniach przetwarzania języka naturalnego i modelowania sekwencji duże znaczenie uzyskały transformery, oparte na mechanizmie uwagi i niewymagające rekurencji. Model Transformer został opisany w pracy Attention Is All You Need z 2017 roku jako architektura oparta wyłącznie na mechanizmach uwagi, bez rekurencji i konwolucji^[11]. LSTM pozostaje jednak użyteczna w wielu zadaniach, zwłaszcza tam, gdzie ważne są modele rekurencyjne, strumieniowe przetwarzanie danych, mniejsze modele lub ograniczenia obliczeniowe.

W języku Python warstwy LSTM są dostępne w najpopularniejszych bibliotekach głębokiego uczenia, w tym w PyTorch, TensorFlow i Keras. W PyTorch podstawową klasą jest `torch.nn.LSTM`, która stosuje wielowarstwową sieć LSTM do sekwencji wejściowej. Dla ustawienia `batch_first=True` wejście ma zwykle kształt:

${\displaystyle ({\text{liczba próbek}},\ {\text{długość sekwencji}},\ {\text{liczba cech}}).}$

Warstwa zwraca sekwencję wyjść oraz końcowe stany ${\displaystyle h_{n}}$ i ${\displaystyle c_{n}}$^[6].

Przykładowy schemat modelu w PyTorch:

import torch
from torch import nn

class ModelLSTM(nn.Module):
    def __init__(self, input_size: int, hidden_size: int, output_size: int) -> None:
        super().__init__()
        self.lstm = nn.LSTM(
            input_size=input_size,
            hidden_size=hidden_size,
            batch_first=True,
        )
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        output, (h_n, c_n) = self.lstm(x)
        last_output = output[:, -1, :]
        return self.linear(last_output)

W Keras odpowiednikiem jest warstwa `keras.layers.LSTM`. Przy standardowym użyciu oczekuje ona tensora trójwymiarowego, którego wymiary odpowiadają próbkom, krokom czasowym i cechom. Argument `return_sequences` decyduje, czy warstwa zwraca wyjście dla każdego kroku czasowego, czy tylko ostatnie wyjście; `return_state` pozwala dodatkowo zwrócić końcowy stan ukryty i stan komórki. Dokumentacja Keras wskazuje także, że przy odpowiednich ustawieniach i dostępności sprzętu warstwa może korzystać z szybkiej implementacji cuDNN.^[12]

Przykład w Keras:

from keras import layers, models

model = models.Sequential([
    layers.Input(shape=(None, 8)),
    layers.LSTM(64),
    layers.Dense(1)
])

W języku R sieci LSTM można budować między innymi za pomocą pakietów `keras` i `torch`. Pakiet `keras` udostępnia funkcję `layer_lstm()`, będącą interfejsem do warstwy LSTM z Keras/TensorFlow^[13].

Przykład w R z użyciem pakietu `keras`:

library(keras)

model <- keras_model_sequential() |>
  layer_lstm(units = 64, input_shape = c(NULL, 8)) |>
  layer_dense(units = 1)

model |>
  compile(
    optimizer = "adam",
    loss = "mse"
  )

Pakiet `torch` dla R zawiera funkcję `nn_lstm()`, która działa analogicznie do modułu `torch.nn.LSTM` w PyTorch. Pozwala określić między innymi wymiar wejścia, liczbę jednostek ukrytych, liczbę warstw, dropout i dwukierunkowość^[14].

Przykład w R z użyciem pakietu `torch`:

library(torch)

model <- nn_module(
  initialize = function(input_size, hidden_size, output_size) {
    self$lstm <- nn_lstm(
      input_size = input_size,
      hidden_size = hidden_size,
      batch_first = TRUE
    )
    self$linear <- nn_linear(hidden_size, output_size)
  },
  forward = function(x) {
    lstm_out <- self$lstm(x)
    output <- lstm_out[[1]]
    last_output <- output[ , dim(output)[2], ]
    self$linear(last_output)
  }
)

W praktyce dane wejściowe dla LSTM mają postać trójwymiarową: próbka, czas i cechy. Dla szeregów czasowych typowym etapem przygotowania danych jest więc utworzenie ruchomych okien czasowych, normalizacja cech oraz oddzielenie zbioru treningowego, walidacyjnego i testowego z zachowaniem kolejności czasowej.

LSTM jest stosowana do zadań, w których dane mają naturalną strukturę sekwencyjną. Przykłady obejmują:

• rozpoznawanie mowy;
• rozpoznawanie pisma ręcznego;
• modelowanie języka;
• etykietowanie sekwencji;
• analizę szeregów czasowych;
• predykcję sygnałów;
• generowanie tekstu;
• analizę danych biomedycznych;
• prognozowanie ruchu i danych czasoprzestrzennych.

W rozpoznawaniu mowy LSTM była badana zarówno w wersji dwukierunkowej, jak i w głębokich architekturach akustycznych^[3][4]. W zadaniach etykietowania niepodzielonych sekwencji LSTM bywa łączona z funkcją straty CTC, zaproponowaną przez Gravesa, Fernándeza, Gomeza i Schmidhubera^[15].

Do głównych zalet LSTM należą:

• zdolność uczenia zależności długiego zasięgu w sekwencjach;
• łagodzenie problemu zanikających gradientów w porównaniu z prostymi RNN;
• możliwość przetwarzania sekwencji o zmiennej długości;
• naturalne zastosowanie do danych strumieniowych;
• duża liczba sprawdzonych implementacji w bibliotekach uczenia maszynowego.

LSTM nie rozwiązuje wszystkich trudności związanych z modelowaniem sekwencji. Do jej ograniczeń należą:

• większa liczba parametrów niż w prostych RNN i często większa niż w GRU;
• sekwencyjny charakter obliczeń, utrudniający równoleglenie wzdłuż czasu;
• podatność na przeuczenie przy małych zbiorach danych;
• konieczność starannego doboru hiperparametrów;
• trudność interpretacji wewnętrznych stanów i bramek;
• ograniczona skuteczność przy bardzo długich kontekstach w porównaniu z architekturami opartymi na uwadze.

Badanie porównujące wiele wariantów LSTM wskazało, że nie wszystkie modyfikacje architektury prowadzą do znaczącej poprawy względem standardowej LSTM, a szczególnie istotnymi elementami są bramka zapominania oraz funkcja aktywacji wyjścia^[7].

Problem zanikających gradientów w dynamicznych sieciach neuronowych został opisany przez Hochreitera w pracy z 1991 roku^[2]. W 1997 roku Hochreiter i Schmidhuber opublikowali artykuł Long Short-Term Memory, w którym przedstawili architekturę LSTM i pokazali jej zdolność do rozwiązywania zadań z długimi opóźnieniami czasowymi^[1].

W 2000 roku Gers, Schmidhuber i Cummins wprowadzili bramkę zapominania, która stała się standardowym składnikiem nowoczesnych komórek LSTM.^[5] W 2002 roku Gers, Schraudolph i Schmidhuber opisali wariant z połączeniami podglądowymi, pozwalający bramkom obserwować stan komórki^[8]. W 2005 roku Graves i Schmidhuber zastosowali dwukierunkowe LSTM do klasyfikacji fonemów, a w kolejnych latach LSTM stała się jedną z podstawowych architektur głębokiego uczenia dla danych sekwencyjnych^[3].

• Rekurencyjna sieć neuronowa
• Problem zanikających gradientów
• Głębokie uczenie
• Transformer (architektura sieci neuronowej)
• Szereg czasowy

• Sepp Hochreiter, Jürgen Schmidhuber, Long Short-Term Memory, Neural Computation, 1997.
• Felix A. Gers, Jürgen Schmidhuber, Fred Cummins, Learning to Forget: Continual Prediction with LSTM, Neural Computation, 2000.
• Felix A. Gers, Nicol N. Schraudolph, Jürgen Schmidhuber, Learning Precise Timing with LSTM Recurrent Networks, Journal of Machine Learning Research, 2002.
• Alex Graves, Supervised Sequence Labelling with Recurrent Neural Networks, Springer, 2012.
• Ian Goodfellow, Yoshua Bengio, Aaron Courville, Deep Learning, MIT Press, 2016.

• Sepp Hochreiter, Jürgen Schmidhuber, Long Short-Term Memory
• Sepp Hochreiter, Untersuchungen zu dynamischen neuronalen Netzen
• eSezam 2.0 – Sieć głęboka LSTM
• Dokumentacja LSTM w PyTorch
• Dokumentacja warstwy LSTM w Keras
• Dokumentacja nn_lstm w R torch