LSTM dan GRU

Gerbang pada LSTM dan GRU sebagai perbaikan memori jarak jauh.

Daftar isi

LSTM dan GRU adalah perbaikan RNN yang mengganti satu keadaan tersembunyi dengan mekanisme gerbang, sehingga informasi dapat dipertahankan atau dibuang secara selektif sepanjang waktu. Topik ini menjelaskan gerbang pada LSTM, versi rampingnya pada GRU, dan menghitung biaya parameternya berdampingan. Setelah selesai, pemilihan antara RNN sederhana, GRU, dan LSTM berdiri di atas perbandingan yang terukur.

Empat gerbang LSTM#

LSTM (long short-term memory) membawa dua keadaan sekaligus, yaitu keadaan sel $c_t$ yang berperan sebagai pita memori jangka panjang dan keadaan tersembunyi $h_t$ yang menjadi keluaran tiap langkah. Pergantian isinya dikendalikan tiga gerbang yang nilainya dihitung dari masukan dan keadaan sebelumnya. Gerbang lupa $f_t$ menentukan berapa lama isi lama dipertahankan, gerbang masukan $i_t$ menentukan seberapa besar informasi baru ditulis, dan gerbang keluaran $o_t$ menentukan berapa banyak isi sel diekspos sebagai keluaran.

Pembaruannya dirangkai dalam satu persamaan:

c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t, \qquad h_t = o_t \odot \tanh(c_t)

Tanda $\odot$ adalah perkalian elemen per elemen, dan kekuatan desainnya tersembunyi di sana. Keadaan sel diperbarui dengan penjumlahan berbobot, bukan ditulis ulang penuh seperti pada RNN sederhana, sehingga gradien memiliki jalur yang hampir tanpa gangguan sepanjang waktu ketika gerbang lupa bernilai dekat satu. Jalur inilah yang meredam masalah gradien menghilang yang terukur pada topik RNN, dan inilah satu-satunya perubahan besar yang menjadikan ketergantungan jauh terjangkau.

GRU: versi ramping dari gagasan yang sama#

GRU (gated recurrent unit) merampingkan LSTM menjadi dua gerbang, yaitu gerbang perbaruan yang menggabungkan peran lupa dan masukan, serta gerbang reset yang menentukan seberapa banyak masa lalu dipakai saat menghitung calon informasi baru. Keadaan selnya dilebur ke keadaan tersembunyi sehingga hanya satu keadaan yang dibawa, dan hasilnya adalah model yang lebih murah dengan kinerja yang umumnya berdekatan dengan LSTM pada masalah berukuran sedang.

Tidak ada pemenang mutlak di antara keduanya, dan praktik yang berlaku adalah memulai dari GRU karena parameternya lebih sedikit, lalu naik ke LSTM bila masalahnya menuntut kapasitas memori lebih besar atau literatur domainnya memakainya. Yang tidak lagi dipilih pada tugas baru adalah RNN sederhana, karena harganya hampir sama dengan GRU sementara jangkauan memorinya jauh lebih pendek.

Menghitung biaya parameter#

Biaya ketiganya dapat dihitung dari strukturnya. RNN sederhana menyimpan satu matriks masukan dan satu matriks keadaan per unit tersembunyi, sehingga parameternya $3 \cdot d \cdot d$ untuk masukan seukuran keadaan. GRU menampung tiga keluaran gerbangnya di dalam dua matriks gabungan, dan LSTM menampung empat, sehingga rasionya tetap. Kode berikut menghitungnya dari modul sungguhan.

python Contoh: parameter RNN, GRU, dan LSTM pada dimensi sama

import torch.nn as nn

d = 32
rnn = nn.RNN(d, d, batch_first=True)
gru = nn.GRU(d, d, batch_first=True)
lstm = nn.LSTM(d, d, batch_first=True)
for nama, modul in (("RNN", rnn), ("GRU", gru), ("LSTM", lstm)):
    n = sum(p.numel() for p in modul.parameters())
    print(f"{nama}: {n} parameter")

text Keluaran

RNN: 2112 parameter
GRU: 6336 parameter
LSTM: 8448 parameter

Rasio yang terbaca adalah 1 banding 2,25 banding 3, dan bilangan ini tetap pada ukuran keadaan yang berapa pun karena strukturnya linear terhadap $d^2$ . Empat kalipatnya LSTM atas RNN adalah harga dari tiga gerbang plus calon memori, dan perbandingan ini yang membuat GRU menjadi tengah jalan yang murah dengan dua gerbang.

Membaca bentuk keluaran yang berpasangan#

Modul LSTM dan GRU mengembalikan keluaran dengan pasangan keadaan yang berbeda bentuknya, dan kebingungan bentuk ini adalah sumber error paling umum pada pemakaian pertama. LSTM mengembalikan pasangan (output, (h_n, c_n)) karena membawa dua keadaan, sedangkan GRU mengembalikan (output, h_n) karena hanya satu, dan output pada keduanya memuat keadaan tersembunyi di setiap langkah.

python Contoh: bentuk keluaran LSTM dan GRU

import torch
import torch.nn as nn

torch.manual_seed(0)
x = torch.randn(2, 7, 16)
lstm = nn.LSTM(16, 24, num_layers=1, batch_first=True)
keluar, (h, c) = lstm(x)
print("keluaran     :", tuple(keluar.shape))
print("h akhir      :", tuple(h.shape), "| c akhir:", tuple(c.shape))
gru = nn.GRU(16, 24, num_layers=1, batch_first=True)
keluar_g, h_g = gru(x)
print("GRU keluaran :", tuple(keluar_g.shape), "| h akhir:", tuple(h_g.shape))

text Keluaran

keluaran     : (2, 7, 24)
h akhir      : (1, 2, 24) | c akhir: (1, 2, 24)
GRU keluaran : (2, 7, 24) | h akhir: (1, 2, 24)

Bentuk-bentuk tersebut mengikuti konvensi yang sama dengan topik RNN, ditambah satu keadaan sel pada LSTM. Untuk tugas klasifikasi, keadaan akhir yang dipakai, sedangkan jejak output yang dipakai untuk tugas per langkah, dan keputusan ini identik dengan yang diwarisi dari RNN sederhana.

Peran historis dan penerusnya#

LSTM dan GRU mendominasi pemodelan sekuens selama lebih dari satu dekade, dari terjemahan mesin hingga pengenalan ucapan, dan pembacaannya tetap wajib karena miliaran parameter masih bekerja dalam wujud ini di produksi. Namun pada pemodelan bahasa skala besar, kedua-duanya digantikan transformer, karena rekurensi melarang paralelisasi penuh antar langkah waktu, sedangkan attention menghubungkan dua posisi berapa pun tanpa melewati rantai panjang. Pergantian itu dipelajari pada modul Transformer dan attention, dan pemahaman gerbang di sini justru membuat keputusan desain transformer terlihat sebagai jawaban atas kelemahan yang barusan diukur.

Ringkasan#

LSTM membawa keadaan sel yang diperbarui dengan penjumlahan berbobot tiga gerbang, dan jalur itulah yang menjaga gradien tetap hidup sepanjang waktu.
GRU merampingkan gagasan yang sama menjadi dua gerbang dan satu keadaan, dengan kinerja yang umumnya berdekatan pada masalah sedang.
Pada dimensi 32, rasio parameter RNN, GRU, dan LSTM adalah 1 banding 2,25 banding 3, dan rasionya tetap pada ukuran lain.
Bentuk keluaran keduanya mengikuti konvensi RNN, dengan pasangan keadaan tambahan (h_n, c_n) milik LSTM.

Referensi#

Long Short-Term Memory — Springer — Makalah asli Hochreiter dan Schmidhuber yang memperkenalkan gerbang lupa dan masukan.
Empirical Evaluation of Gated Recurrent Neural Networks — arXiv — Makalah Cho dkk. yang membandingkan GRU dan LSTM secara empiris.
torch.nn.LSTM — PyTorch — Dokumentasi yang menyatakan persamaan gerbang dan bentuk keluaran berpasangan.