Lensa ML

Cara RNN Membaca Sequence

Dijelaskan lewat analisis sentimen

Langkah 1 dari 6: Tugasnya: Baca & Nilai

Dari sebuah ulasan film, tentukan: positif atau negatif?

Susun ulang kata yang sama
Themoviewasnotgood
Urutan kata
AsliDitukarDiacak
Sentimen
Negatif
Skor
-0.81
Kata → Embedding → RNN
The↓[0.1,0.0,
0.0,0.0]
→
movie↓[0.1,0.3,
0.1,0.1]
→
was↓[0.0,0.0,
0.0,0.0]
…
Setiap kata dipetakan ke vector numerik (embedding) sebelum bisa diproses RNN
Urutan kata berpengaruh
"not good" ≠ "good not"
Kata → vector
Embedding menyimpan makna
Perlu sequence
Satu kata saja tidak cukup

Geser slider untuk menyusun ulang kata. Urutan kata berpengaruh: "not good" bernilai negatif, sedangkan "good not" nyaris tidak bermakna. Setiap kata menjadi embedding vector numerik, dan RNN membacanya satu per satu, dari kiri ke kanan.

Geser slider Urutan kata dari Asli ke Ditukar, lalu Diacak. Model bag-of-words menghitung lima kata yang sama pada ketiga urutan itu dan tidak bisa membedakannya. RNN mengolah embedding secara berurutan, jadi posisi mengubah hasilnya. Embedding di sini berisi 4 angka per kata dan dipilih manual untuk demo. Model sungguhan mempelajarinya, biasanya dengan 100 sampai 1.000 dimensi. Teks lebih dulu dipecah menjadi token, dan setiap ID token memilih satu baris dari tabel embedding yang ikut dilatih bersama seluruh network.

Langkah 2 dari 6: Membaca Kata demi Kata

RNN membaca dari kiri ke kanan dan memperbarui pemahamannya di setiap langkah

Membaca:(awal)
ht-1(4d)× W_hxt(4d)× W_x+tanhht(4d)masuk lagi di langkah berikutnya
Time step: 0 / 7
Hidden state awal
h₀=[+0.000,+0.000,+0.000,+0.000]
Semua nol: RNN belum membaca apa pun. Maju selangkah untuk melihat hitungannya.
h0[0]
0.000
h0[1]
0.000
h0[2]
0.000
h0[3]
0.000
Sentimen
0.000
Langkah
0/7

Maju langkah demi langkah untuk melihat hitungan lengkap RNN dengan angka sungguhan. Di setiap langkah: kalikan hidden state sebelumnya dengan Wh, kalikan embedding kata dengan Wx, jumlahkan keduanya, lalu terapkan tanh. Klik tombol elemen untuk membuka tiap dot product. Perhatikan bagaimana "not" membalik hidden state menjadi negatif.

Geser slider Time step atau pakai Sebelumnya dan Berikutnya untuk membaca ulasan kata demi kata. Hidden state di sini berisi 4 angka, dan W_h bernilai 0,98 di diagonalnya dan 0 di tempat lain, sehingga setiap langkah menyimpan 98% dari setiap nilai sebelum kata baru ditambahkan. RNN sungguhan mempelajari W_h penuh dan menambahkan bias: h_t = tanh(W_h · h_(t−1) + W_x · x_t + b). Tanh menjaga setiap nilai tetap di antara −1 dan +1, sehingga state tidak membesar tanpa batas pada sequence yang panjang.

Langkah 3 dari 6: Hidden State Terus Berubah

Lihat "suasana hati" network bergeser saat membaca tiap kata

Themoviewasnotreallythatgood
0+−Themoviewasnotreallythatgood
Langkah: 0 / 7
Weight Sharing
Setiap time step memakai W_h dan W_x yang sama: cell RNN dipakai ulang, bukan disalin.

Saat di-unroll, RNN adalah satu cell yang berulang di setiap langkah. Semua salinan memakai weight yang sama, jadi jumlah parameter tidak bertambah seiring panjang sequence. Batang sentimen menunjukkan perubahan state internal saat tiap kata dibaca.

Geser slider Langkah dan perhatikan batang di sepanjang 7 kata "The movie was not really that good". Unrolling juga merupakan cara RNN dilatih. Rantai hasil unroll diperlakukan sebagai satu deep network, dan gradient mengalir mundur melewati setiap salinan. Proses ini disebut backpropagation through time (BPTT). Untuk teks panjang, rantai itu sering dipotong menjadi beberapa bagian dengan panjang tetap (truncated BPTT) untuk menghemat memori. Karena setiap langkah membutuhkan langkah sebelumnya, RNN tidak bisa mengolah sequence secara paralel, jadi training-nya lebih lambat daripada Transformer.

Langkah 4 dari 6: Ulasan Panjang, Memori Pendek

Vanilla RNN melupakan kata-kata awal, dan ini kelemahan besarnya

Kedalaman sequence: 6 langkah
2 (pendek)8 (panjang)
Besar gradient di setiap time step0.050t1hilang!0.092t20.166t30.303t40.550t51.000t6Gradient mengalir mundur ← langkah awal kehilangan sinyal
Gradient langkah pertama
0.0503
Gradient langkah terakhir
1.0000
Rasio
5.0%

Naikkan kedalaman untuk melihat gradient menghilang secara eksponensial. Di setiap langkah, gradient dikalikan sekitar 0,55, jadi setelah 6 langkah gradient kata pertama tinggal 0,0503. Kata-kata awal nyaris tidak memengaruhi proses belajar. Inilah masalah vanishing gradient.

Geser Kedalaman sequence dari 2 sampai 8. Decay factor 0,55 ditetapkan untuk demo ini. Pada RNN sungguhan, gradient yang melewati setiap langkah dikalikan dengan W_h dan turunan tanh, yang paling besar 1. Kalau faktor-faktor itu di bawah 1, gradient mengecil secara eksponensial, dan kalau di atas 1, gradient meledak. Exploding gradient punya solusi sederhana: gradient clipping membatasi norm gradient. Vanishing gradient butuh desain yang berbeda. Bengio, Simard, dan Frasconi menjelaskan masalah ini pada 1994.

Langkah 5 dari 6: LSTM: Memori Selektif

Gate membuat network bisa memilih apa yang diingat dan dilupakan

Cell state: jalur memori jangka panjang×F0.50Forget+I0.50Input×O0.50Output
Forget gate: 0.50
Input gate: 0.50
Output gate: 0.50
Cell sebelumnya
0.80
Cell baru
0.700
Output hidden
0.302
f × c_prev
0.400
i × cand
0.300
o × tanh(c)
0.302

Geser tiap slider gate untuk melihat efeknya. Forget gate di 0 menghapus memori lama; di 1 semuanya disimpan. Input gate mengatur seberapa banyak informasi baru yang ditulis. Output gate menyaring apa yang diteruskan ke langkah berikutnya. Rumus: c_t = f·c_(t-1) + i·candidate, h_t = o·tanh(c_t).

Geser slider Forget, Input, dan Output. Demo ini menetapkan nilai cell lama 0,8 dan candidate 0,6, jadi kalau ketiga gate bernilai 0,5, cell barunya 0.5 × 0.8 + 0.5 × 0.6 = 0.7. Pada LSTM yang sudah dilatih, tidak ada yang mengatur gate secara manual. Masing-masing adalah sigmoid dari input saat ini dan hidden state sebelumnya. Pembaruan cell bersifat aditif, sehingga gradient bisa mengalir mundur melewati banyak langkah selama forget gate tetap dekat dengan 1. GRU (2014) adalah varian yang lebih ringan dengan dua gate.

Langkah 6 dari 6: Putusan Akhir

Hidden state terakhir menyimpan cukup konteks untuk mengklasifikasikan seluruh ulasan

RNN membaca kata demi kata:Themoviewasnotreallythatgood
Time step: 0 / 7
h[0]
0.000
h[1]
0.000
h[2]
0.000
h[3]
0.000
Sentimen
0.000
Prediksi
—
Keyakinan
0%
NegatifPositif

Telusuri tiap kata untuk melihat RNN menyusun putusannya. Setelah membaca seluruh sequence, hidden state terakhir masuk ke output layer untuk menghasilkan skor. Perhatikan bagaimana "not" sebelum "good" membuat RNN menghasilkan Negatif.

Klik Ulasan negatif dan Ulasan positif, lalu telusuri setiap kata. Pada ulasan negatif, skornya turun sampai sekitar −0,98 di "not" dan berakhir di −0,81, jadi "good" hanya menariknya kembali sebagian. Di sini hanya hidden state terakhir yang dipakai, yaitu susunan many-to-one. Tugas lain memakai state dengan cara berbeda. Tagger membaca satu label di setiap langkah (many-to-many), dan bidirectional RNN menambahkan pembacaan kedua dari kanan ke kiri sehingga state tiap kata juga melihat kata sesudahnya.

Apa itu recurrent neural network (RNN)?

Recurrent neural network (RNN) adalah neural network yang membaca sequence satu elemen setiap kali dan membawa hidden state dari satu langkah ke langkah berikutnya. Di setiap langkah, RNN menggabungkan hidden state sebelumnya dengan input saat ini memakai weight yang sama, sehingga hidden state menjadi ringkasan berjalan dari semua yang sudah dibaca. State terakhir, atau state di setiap langkah, diteruskan ke output layer.

RNN adalah model utama untuk teks, ucapan, dan time series sebelum ada Transformer. RNN dipakai pada neural machine translation generasi awal, pengenalan ucapan, pengenalan tulisan tangan, dan prediksi kata berikutnya di keyboard ponsel. RNN masih relevan untuk data streaming dan perangkat kecil karena setiap input baru memakan biaya komputasi yang tetap, dan masalah training-nya menjelaskan kenapa LSTM, GRU, dan attention diciptakan.

Ide utama

  • RNN memperbarui hidden state dengan h_t = tanh(W_h · h_(t−1) + W_x · x_t + b).
  • Weight yang sama dipakai ulang di setiap time step.
  • Hidden state adalah ringkasan berukuran tetap dari semua yang sudah dibaca.
  • Training melakukan unroll pada network dan menjalankan backpropagation through time.
  • Gradient mengecil atau membesar secara eksponensial seiring panjang sequence.
  • Gated cell seperti LSTM dan GRU dirancang untuk menyimpan informasi jarak jauh.

Pertanyaan umum

Apa bedanya RNN dengan feedforward network?

Feedforward network memetakan satu input berukuran tetap ke satu output dan tidak menyimpan memori di antara input. RNN punya putaran: output di satu langkah masuk lagi di langkah berikutnya. Putaran itu membuat RNN bisa menangani input sepanjang apa pun dan memperhitungkan input sebelumnya.

Apakah RNN bisa menangani sequence sepanjang apa pun?

Secara prinsip bisa, karena cell yang sama berjalan satu kali per elemen. Dalam praktiknya, RNN biasa kehilangan informasi dari lebih dari beberapa puluh langkah ke belakang karena vanishing gradient dan state yang ukurannya tetap. LSTM memperpanjangnya sampai ratusan langkah, dan attention menghilangkan hambatan itu dengan melihat langsung ke setiap posisi.

Kenapa RNN memakai tanh, bukan ReLU?

Weight yang sama diterapkan lagi di setiap langkah, jadi aktivasi tanpa batas seperti ReLU bisa membuat hidden state membesar tak terkendali pada sequence yang panjang. Tanh membatasi setiap nilai di antara −1 dan +1 dan berpusat di nol. RNN dengan ReLU bisa berjalan dengan inisialisasi yang hati-hati, misalnya W_h berupa matriks identitas, tetapi tanh tetap menjadi pilihan default.

Apakah RNN masih dipakai sekarang?

Transformer sudah menggantikannya untuk sebagian besar tugas bahasa, tetapi model recurrent masih dipakai untuk audio streaming, keyboard di perangkat, dan data sensor, ketika memori dan latency terbatas. State space model terbaru seperti Mamba juga menyimpan state recurrent, sehingga bisa menghasilkan setiap token baru dengan biaya tetap.

Penjelasan terkait

Referensi

  1. Elman (1990), "Finding Structure in Time", Cognitive Science
  2. Bengio, Simard & Frasconi (1994), "Learning Long-Term Dependencies with Gradient Descent Is Difficult", IEEE Transactions on Neural Networks
  3. Pascanu, Mikolov & Bengio (2013), "On the Difficulty of Training Recurrent Neural Networks"
  4. Dive into Deep Learning, "Recurrent Neural Networks"

Terakhir diperbarui