ENID
Lensa ML

Cara LSTM Mengingat

Penjelasan network Long Short-Term Memory

Langkah 1 dari 6: Di Dalam Sel LSTM

Empat komponen yang memberi LSTM kemampuan mengingat

C_t-1C_t×Forgetf_t=σ(…)+×i_t × c̃_tInputi_t=σ(…)Candidatec̃_t=tanh(…)Outputo_t=σ(…)tanh×h_t[ h_t-1 , x_t ]h_t-1x_tSemua gate dan candidate dapat input yang sama, tapi mempelajari weight berbeda
Gate
3
Forget
f_t
Input
i_t
Output
o_t

Sel LSTM punya empat bagian utama: cell state yang membawa memori jangka panjang, dan tiga gate (forget, input, output) yang mengatur apa yang diingat, ditulis, dan ditampilkan. Klik tombol di bawah untuk menyorot tiap bagian.

Klik Cell State, Forget Gate, Input Gate, Output Gate, dan Input secara bergantian. Sel ini menjalankan empat layer kecil pada input yang sama, [h_t−1, x_t]: tiga gate sigmoid dan satu candidate tanh. Dengan hidden size n dan input size m, tiap layer punya n × (n + m) weight ditambah n bias, sehingga parameter LSTM empat kali lipat parameter RNN biasa berukuran sama. Untuk n = m = 3, seperti di sini, jumlahnya 4 × (18 + 3) = 84. Versi asli 1997 belum punya forget gate; Gers dkk. menambahkannya pada 2000.

Langkah 2 dari 6: Kenapa LSTM Berhasil

Cara cell state mengatasi masalah vanishing gradient

Kekuatan sinyal seiring waktu: RNN vs LSTMRNN80%t=056%t=139%t=227%t=319%t=4sinyalmemudar×0.7 per langkah (RNN) vs ~×1.0 per langkah (cell state LSTM)LSTM80%t=079%t=177%t=276%t=375%t=4sinyalbertahan
Sinyal awal: 0.80
Lemah (0.3)Kuat (1.0)
Time step: 5
Pendek (3)Panjang (8)
RNN @ awal
80%
RNN @ t=4
19%
LSTM @ awal
80%
LSTM @ t=4
75%

Perhatikan lingkarannya: sinyal RNN cepat menyusut (×0,7 tiap langkah), sedangkan sinyal LSTM nyaris tetap penuh (×0,97). Di jalan tol cell state, informasi mengalir lurus tanpa dimampatkan berulang kali. Tambah time step untuk melihat selisihnya membesar.

Geser slider Sinyal awal, lalu ubah Time step dari 3 ke 8. Laju ×0,7 dan ×0,97 hanya ilustrasi. Alasan sebenarnya ada di turunannya. Karena C_t = f_t ⊙ C_(t−1) + i_t ⊙ c̃_t, gradient C_t terhadap C_(t−1) di jalur ini hanya f_t, tanpa matriks weight dan tanpa turunan tanh di antaranya. Sepanjang k langkah, gradient adalah hasil kali k forget gate, yang tetap mendekati 1 selama gate terbuka. Hochreiter dan Schmidhuber menyebut jalur ini constant error carousel.

Langkah 3 dari 6: Forget Gate

Menentukan informasi lama yang dibuang

Input: [ h_t-1, x_t ] = [0.12, -0.05, 0.30, 0.85, 0.10, -0.20]C_t-1 = [0.60, 0.68, 0.77]tersisa = [0.54, 0.27, 0.58]×Forget gatef_t = σ([h_t-1, x_t])C_t-1 adalah vector: tiap dimensi dikalikan f_t secara terpisahC_t-1tersisa0.60×0.9→0.54dim 10.68×0.4→0.27dim 20.77×0.8→0.58dim 3
f_t[0] = 0.90
dim 1: lupakan (0)simpan (1)
f_t[1] = 0.40
dim 2: lupakan (0)simpan (1)
f_t[2] = 0.75
dim 3: lupakan (0)simpan (1)
f_t[0]
0.90
f_t[1]
0.40
f_t[2]
0.75

Forget gate menghitung f_t = σ(W_f · [h_t-1, x_t] + b_f), satu nilai per dimensi. Tiap slider mengendalikan satu dimensi f_t. 0 berarti "lupakan sepenuhnya", sedangkan 1 berarti "simpan seluruhnya". Perhatikan bahwa tiap dimensi bisa melupakan dalam jumlah berbeda.

Geser ketiga slider f_t dan bandingkan seberapa banyak C_t−1 = [0.60, 0.68, 0.77] yang disimpan tiap dimensi. Gate hasil training berasal dari sigmoid, jadi nilainya tidak pernah persis 0 atau 1. Framework sering menginisialisasi bias forget gate b_f ke 1, sehingga f_t dimulai di dekat σ(1) ≈ 0.73 dan sel cenderung mengingat di awal training. Jozefowicz dkk. (2015) menemukan bahwa satu perubahan ini menutup sebagian besar selisih antara LSTM dan desain gated lainnya. Gate memakai σ, bukan tanh, karena gate berfungsi sebagai pengali antara 0 dan 1.

Langkah 4 dari 6: Input Gate

Memilih informasi baru yang disimpan

Input: [ h_t-1, x_t ] = [0.12, -0.05, 0.30, 0.85, 0.10, -0.20]setelah forget = [0.54, 0.27, 0.58]+C_t = [0.93, 0.06, 0.82]Input gatei_t = σ([h,x])Candidatec̃_t=tanh([h,x])×C_t = tersisa + (i_t × c̃_t) per dimensitersisaditambahC_t baru0.54+0.39=0.93dim 10.27-0.21=0.06dim 20.58+0.24=0.82dim 3
i_t[0] = 0.70
dim 1: tahan (0)tulis (1)
c̃_t[0] = 0.55
dim 1: −1+1
i_t[1] = 0.85
dim 2: tahan (0)tulis (1)
c̃_t[1] = -0.25
dim 2: −1+1
i_t[2] = 0.30
dim 3: tahan (0)tulis (1)
c̃_t[2] = 0.80
dim 3: −1+1
C_t[0]
0.93
C_t[1]
0.06
C_t[2]
0.82

i_t = σ(W_i · [h_t-1, x_t] + b_i) dan c̃_t = tanh(W_c · [h_t-1, x_t] + b_c) sama-sama dihitung dari input tetap yang sama, tetapi dengan weight hasil belajar yang berbeda, sehingga tiap dimensi bisa menulis dalam jumlah berbeda. Hasil kalinya ditambahkan ke cell state yang tersisa.

Geser slider i_t dan c̃_t, lalu lihat tiga angka C_t. Dengan nilai awal, dim 1 menjadi 0.90 × 0.60 + 0.70 × 0.55 = 0.925. Candidate memakai tanh supaya bisa menurunkan memori, bukan hanya menaikkannya: candidate dim 2 sebesar −0,25 menurunkan sel itu ke sekitar 0,06. Pembaruannya berupa penjumlahan, dan penjumlahan inilah yang membuat gradient bisa mengalir balik tanpa menyusut. Beberapa varian mengikat gate dengan i_t = 1 − f_t, sehingga sel hanya menulis sebanyak yang dilupakannya. GRU memakai pengikatan ini.

Langkah 5 dari 6: Output Gate

Menyaring cell state menjadi hidden state

Input: [ h_t-1, x_t ] = [0.12, -0.05, 0.30, 0.85, 0.10, -0.20]C_t = [0.93, 0.06, 0.82]tanh[0.73, 0.06, 0.67]×Output gateo_t = σ([h,x])h_t[0.58, 0.04, 0.61]h_t = o_t × tanh(C_t) per dimensitanh(C_t)h_t0.73×0.800.58dim 10.06×0.600.04dim 20.67×0.900.61dim 3
o_t[0] = 0.80
dim 1: tahan (0)loloskan (1)
o_t[1] = 0.60
dim 2: tahan (0)loloskan (1)
o_t[2] = 0.90
dim 3: tahan (0)loloskan (1)
h_t[0]
0.58
h_t[1]
0.04
h_t[2]
0.61

o_t = σ(W_o · [h_t-1, x_t] + b_o) adalah vector: tiap dimensi mengatur seberapa banyak C_t yang ditampilkan. C_t dilewatkan ke tanh (memampatkan nilai ke −1…1), lalu dikalikan o_t per dimensi. Hasilnya h_t, yaitu hidden state yang dikirim ke layer berikutnya dan time step berikutnya.

Geser ketiga slider o_t dan lihat h_t berubah sementara C_t tetap. Pemisahan ini berarti LSTM membawa dua state: C_t adalah memori internal, dan h_t adalah yang dilihat layer berikutnya dan time step berikutnya. Dengan gate bawaan, h_t[0] = 0.80 × tanh(0.925) ≈ 0.58. Output gate yang tertutup bisa menahan fakta yang tersimpan selama banyak langkah dan baru menampilkannya saat dibutuhkan, misalnya mencatat apakah subjek berbentuk tunggal sampai muncul kata kerja yang harus cocok dengannya. LSTM bertumpuk meneruskan h_t ke atas sebagai x_t untuk layer berikutnya.

Langkah 6 dari 6: LSTM Beraksi

Memproses kalimat kata demi kata

Thecatsatonthe___
LSTM yang dibentangkan, mulai dari C_t-1 = [0.60, 0.68, 0.77]LSTMTheLSTMcatLSTMsatLSTMonLSTMthesubjekkonteks verbaposisi
t = 0Time step 0: "The"t = 4
C_t[0]
1.10
C_t[1]
0.61
C_t[2]
0.63
h_t[0]
0.48
h_t[1]
0.27
h_t[2]
0.22

Mulai dari C_t-1 = [0.60, 0.68, 0.77] yang sama dengan langkah 3–5, tiap time step menerapkan gate per dimensi (f_t, i_t, o_t) dengan weight hasil belajar yang berbeda. Perhatikan bagaimana info subjek bertahan, sementara konteks verba dan posisi berubah.

Tekan Jeda, lalu klik tombol kata untuk memeriksa tiap time step dari "The cat sat on the". Nilai gate di sini ditulis tangan untuk menunjukkan idenya; model hasil training menghitungnya dari weight di setiap langkah. h_t terakhir akan masuk ke softmax layer di atas kosakata untuk memprediksi kata berikutnya, "mat" dalam demo ini. Sistem terjemahan neural Google tahun 2016 dibangun dari LSTM bertumpuk, dan model sequence-to-sequence Sutskever dkk. (2014) memakai satu LSTM untuk membaca input dan satu lagi untuk menulis output.

Apa itu LSTM (long short-term memory)?

LSTM (long short-term memory) adalah recurrent neural network dengan memori terpisah bernama cell state, plus tiga gate yang menentukan apa yang dilupakan, ditulis, dan dikeluarkan di setiap langkah. Gate adalah sigmoid layer kecil yang mengeluarkan nilai antara 0 dan 1, dan nilai itu mengalikan informasi yang mengalir di dalam sel. Karena cell state diperbarui lewat penjumlahan, LSTM bisa menyimpan informasi hingga ratusan langkah, sedangkan RNN biasa kehilangan informasi itu setelah beberapa langkah.

LSTM menjadi model sequence standar sejak akhir 2000-an sampai Transformer muncul. Model ini dipakai untuk pengenalan suara, penerjemahan mesin, pengenalan tulisan tangan, dan prediksi teks, dan masih dipakai untuk peramalan time series, data sensor, serta model kecil di perangkat. Memahami cell state juga membuat residual connection dan gated layer di arsitektur yang lebih baru lebih mudah diikuti.

Ide utama

  • LSTM menambahkan cell state yang diperbarui lewat penjumlahan, bukan ditulis ulang di setiap langkah.
  • Forget gate menskalakan memori lama, input gate menskalakan isi baru, dan output gate menskalakan yang ditampilkan.
  • Tiap gate adalah sigmoid layer yang diterapkan pada [h_t−1, x_t], dengan satu nilai per dimensi.
  • Pembaruan sel adalah C_t = f_t ⊙ C_(t−1) + i_t ⊙ c̃_t, dan output-nya h_t = o_t ⊙ tanh(C_t).
  • Di sepanjang cell state, gradient hanya dikalikan dengan forget gate, jadi bisa bertahan di sequence panjang.
  • LSTM punya weight empat kali lipat RNN biasa dengan hidden size yang sama.

Pertanyaan umum

Apa bedanya LSTM dan GRU?

GRU (gated recurrent unit) menggabungkan cell state dan hidden state menjadi satu vector dan memakai dua gate, update dan reset, bukan tiga. Parameternya kira-kira tiga perempat parameter LSTM berukuran sama. Dalam perbandingan, performa keduanya biasanya mirip, jadi pilihannya sering ditentukan oleh kecepatan atau dengan mencoba keduanya.

Apakah LSTM lebih baik daripada Transformer?

Untuk sebagian besar tugas bahasa dengan data melimpah, Transformer lebih akurat dan lebih cepat dilatih karena memproses semua posisi secara paralel. LSTM masih bagus pada dataset kecil, input streaming, dan perangkat dengan memori terbatas, karena setiap langkah baru memakan komputasi yang tetap. Untuk time series, keduanya dipakai.

Apa arti input size dan hidden size pada LSTM?

Input size adalah panjang tiap x_t, misalnya dimensi word embedding atau jumlah pembacaan sensor per langkah. Hidden size adalah panjang h_t dan C_t, yang menentukan seberapa banyak yang bisa diingat sel. Library seperti PyTorch menerima keduanya sebagai argumen, bersama jumlah layer yang ditumpuk.

Apa itu bidirectional LSTM?

Bidirectional LSTM menjalankan satu LSTM dari kiri ke kanan dan satu lagi dari kanan ke kiri, lalu menyambung hidden state keduanya di setiap posisi. Representasi tiap kata jadi mencerminkan konteks di kedua sisi. Model ini dipakai untuk tagging dan klasifikasi, tetapi tidak untuk menghasilkan teks, karena kata-kata berikutnya belum diketahui.

Penjelasan terkait

Referensi

  1. Hochreiter & Schmidhuber (1997), "Long Short-Term Memory", Neural Computation
  2. Gers, Schmidhuber & Cummins (2000), "Learning to Forget: Continual Prediction with LSTM", Neural Computation
  3. Greff et al. (2017), "LSTM: A Search Space Odyssey"
  4. Cho et al. (2014), "Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation"
  5. Dive into Deep Learning, "Long Short-Term Memory (LSTM)"

Terakhir diperbarui