PROGRAM STUDI INFORMATIKA
UNIVERSITAS GUNADARMA
ALGORITMA
DEEP LEARNING
PERTEMUAN KE 8 – RECURRENT NEURAL NETWORKS (RNN)
GUNADARMA UNTUK INDONESIA 1 [Link]
PROGRAM STUDI INFORMATIKA
UNIVERSITAS GUNADARMA
R 1 • Konsep Dasar RNN
P 2 • Varian RNN (LSTM dan
GRU)
S 3 • Membangun Model RNN
GUNADARMA UNTUK INDONESIA 2 [Link]
PROGRAM STUDI INFORMATIKA
UNIVERSITAS GUNADARMA
01
Konsep Dasar RNN
GUNADARMA UNTUK INDONESIA 3 [Link]
Definisi RNN
Recurrent Neural Networks (RNN) adalah jenis jaringan saraf tiruan yang dirancang
khusus untuk memproses data sekuensial.
Tidak seperti jaringan saraf konvensional yang mengasumsikan bahwa input dan
output bersifat independen, RNN mampu mengingat informasi dari input
sebelumnya, sehingga sangat cocok untuk tugas-tugas seperti pemrosesan bahasa
alami, pengenalan ucapan, dan analisis deret waktu.
GUNADARMA UNTUK INDONESIA 4 [Link]
Konsep Dasar RNN
Unit Rekursif
• Unit dasar dalam RNN yang
menyimpan informasi dari input
sebelumnya.
Unfolding in Time
• Cara visualisasi RNN di mana
jaringan diulangi untuk setiap
elemen dalam urutan input.
Vanishing Gradient
Problem
• Masalah di mana gradien
menjadi sangat kecil selama
pelatihan, sehingga sulit untuk
melatih RNN untuk data
sekuensial yang panjang.
GUNADARMA UNTUK INDONESIA 5 [Link]
Cara Kerja RNN
(3) BACKPROPAGATION THROUGH
(1) INISIALISASI (2) ITERASI
TIME (BPTT)
• Bobot dan bias dalam RNN • Untuk setiap elemen dalam urutan • Setelah semua elemen dalam urutan
diinisialisasi secara acak. input: input diproses, gradien dihitung
• Hidden state (h) diinisialisasi dengan • Input: Elemen input saat ini (x_t) menggunakan BPTT untuk
nilai nol. diumpankan ke RNN. memperbarui bobot dan bias.
• Perhitungan Hidden State: Hidden • BPTT memungkinkan RNN untuk
state baru (h_t) dihitung belajar dari kesalahan yang terjadi di
menggunakan fungsi aktivasi non- langkah-langkah sebelumnya.
linear (misalnya, tanh) dan
kombinasi dari input saat ini dan
hidden state sebelumnya:
• h_t = tanh(Wx_t + Uh_{t-1} + b)
• di mana: * W: Matriks bobot
untuk input * U: Matriks bobot
untuk hidden state * b: Bias 3.
Output: Output (y_t) dihitung
menggunakan fungsi aktivasi
output (misalnya, softmax) dan
hidden state:
• y_t = softmax(Vx_t + Wh_t + c)
• di mana: * V: Matriks bobot
untuk input * W: Matriks bobot
untuk hidden state * c: Bias
GUNADARMA UNTUK INDONESIA 6 [Link]
PROGRAM STUDI INFORMATIKA
UNIVERSITAS GUNADARMA
02
Varian RNN (LSTM dan GRU)
GUNADARMA UNTUK INDONESIA 7 [Link]
Long Short-Term Memory (LSTM)
Long Short-Term Memory (LSTM) adalah varian dari Recurrent Neural Networks
(RNN) yang dirancang khusus untuk mengatasi masalah vanishing gradient yang
sering terjadi pada RNN biasa.
Masalah ini membuat RNN kesulitan dalam mengingat informasi dari input
yang jauh sebelumnya.
LSTM mengatasi masalah ini dengan menambahkan mekanisme gates yang
mengontrol aliran informasi dalam jaringan.
GUNADARMA UNTUK INDONESIA 8 [Link]
Struktur LSTM
Cell State
• Ini adalah semacam "jalan raya" yang
berjalan sepanjang seluruh rangkaian LSTM.
• Informasi mengalir di sepanjang jalur ini
dengan sedikit perubahan, membantu LSTM
mengingat informasi jangka panjang.
Gates
• Forget Gate: Mengontrol informasi mana
dari cell state yang akan dihapus.
• Input Gate: Mengontrol informasi baru
mana yang akan disimpan dalam cell state.
• Output Gate: Mengontrol informasi mana
dari cell state yang akan digunakan untuk
menghitung output.
GUNADARMA UNTUK INDONESIA 9 [Link]
Cara Kerja LSTM
Forget Gate: Input Gate:
• Memutuskan informasi mana dari cell state • Memutuskan informasi baru mana yang akan
sebelumnya yang tidak relevan lagi. ditambahkan ke cell state.
• Menggunakan fungsi sigmoid untuk • Menggunakan fungsi sigmoid untuk
menghasilkan nilai antara 0 dan 1 untuk setiap menentukan seberapa banyak informasi baru
elemen dalam cell state. Nilai mendekati 0 yang akan diperbarui, dan fungsi tanh untuk
berarti informasi tersebut akan dihapus, menghasilkan vektor kandidat baru.
sedangkan nilai mendekati 1 berarti informasi
tersebut akan dipertahankan.
Output Gate: Cell State Update:
• Memutuskan bagian mana dari cell state yang • Cell state yang lama diperbarui dengan
akan digunakan sebagai output. menggabungkan informasi dari forget gate,
• Menggunakan fungsi sigmoid untuk input gate, dan vektor kandidat baru.
menentukan seberapa banyak informasi dari
cell state yang akan dioutputkan, dan fungsi
tanh untuk menghasilkan output akhir.
GUNADARMA UNTUK INDONESIA 10 [Link]
Keunggulan dan Penerapan LSTM
Keunggulan LSTM Penerapan LSTM
• Memori Jangka Panjang • Pengenalan Ucapan
• LSTM sangat baik dalam mengingat • Mengubah sinyal audio menjadi teks.
informasi jangka panjang, sehingga • Terjemahan Mesin
cocok untuk tugas-tugas yang • Menerjemahkan teks dari satu
melibatkan urutan data yang bahasa ke bahasa lain.
panjang.
• Pembuatan Teks
• Gradien yang Lebih Stabil
• Menghasilkan teks baru, seperti
• Mekanisme gates membantu LSTM puisi, artikel, atau kode.
mengatasi masalah vanishing
gradient. • Analisis Sentimen
• Fleksibilitas • Menentukan sentimen (positif,
negatif, netral) dari sebuah teks.
• LSTM dapat digunakan untuk
berbagai tugas, seperti pengenalan • Prediksi Deret Waktu
ucapan, terjemahan mesin, dan • Memprediksi nilai masa depan
generasi teks. berdasarkan data historis.
GUNADARMA UNTUK INDONESIA 11 [Link]
Gated Recurrent Unit (GRU)
Gated Recurrent Unit (GRU) adalah varian dari Recurrent Neural
Networks (RNN) yang dirancang untuk mengatasi masalah vanishing
gradient seperti halnya LSTM.
Namun, GRU memiliki struktur yang lebih sederhana dibandingkan
LSTM, sehingga lebih mudah untuk dilatih dan diimplementasikan.
GUNADARMA UNTUK INDONESIA 12 [Link]
Struktur GRU
Update Gate
• Mengontrol seberapa banyak
informasi dari input saat ini akan
digunakan untuk memperbarui
hidden state.
Reset Gate
• Mengontrol seberapa banyak
informasi dari hidden state
sebelumnya akan "direset" atau
dilupakan.
GUNADARMA UNTUK INDONESIA 13 [Link]
Cara Kerja GRU
Reset Gate Update Gate
• Memutuskan seberapa banyak informasi dari • Memutuskan seberapa banyak informasi dari
hidden state sebelumnya yang akan diabaikan. hidden state sebelumnya akan dipertahankan
• Nilai yang dihasilkan oleh reset gate akan dan seberapa banyak informasi baru dari input
dikalikan dengan hidden state sebelumnya, saat ini akan ditambahkan.
sehingga informasi yang tidak relevan dapat • Nilai yang dihasilkan oleh update gate akan
dihilangkan. digunakan untuk mengontrol seberapa banyak
hidden state baru akan dipengaruhi oleh
hidden state sebelumnya dan input saat ini.
Hidden State Update Candidate Hidden State
• Menghitung hidden state baru dengan • Menghitung kandidat hidden state baru
menggabungkan hidden state sebelumnya dan berdasarkan input saat ini dan hidden state
kandidat hidden state baru, dengan bobot sebelumnya yang telah dimodifikasi oleh reset
yang ditentukan oleh update gate. gate.
GUNADARMA UNTUK INDONESIA 14 [Link]
Keunggulan dan Penerapan GRU
Keunggulan GRU Penerapan GRU
• Sederhana • Pengenalan Ucapan
• Struktur GRU lebih sederhana • Mengubah sinyal audio menjadi teks.
dibandingkan LSTM, sehingga lebih • Terjemahan Mesin
mudah untuk dipahami dan • Menerjemahkan teks dari satu bahasa
diimplementasikan. ke bahasa lain.
• Efisien • Pembuatan Teks
• Dengan jumlah parameter yang lebih • Menghasilkan teks baru, seperti puisi,
sedikit, GRU dapat dilatih lebih cepat. artikel, atau kode.
• Kinerja yang Baik • Analisis Sentimen
• Meskipun lebih sederhana, GRU • Menentukan sentimen (positif,
seringkali memberikan kinerja yang negatif, netral) dari sebuah teks.
setara dengan LSTM, terutama pada
dataset yang lebih kecil. • Prediksi Deret Waktu
• Memprediksi nilai masa depan
berdasarkan data historis.
GUNADARMA UNTUK INDONESIA 15 [Link]
Perbandingan GRU dan LSTM
FITUR GRU LSTM
Jumlah gerbang 2 (update, reset) 3 (input, forget, output)
Kompleksitas Lebih sederhana Lebih kompleks
Biasanya lebih baik untuk
Seringkali setara dengan
tugas yang membutuhkan
Kinerja LSTM, terutama pada dataset
penangkapan dependensi
yang lebih kecil
jangka panjang
Parameter Lebih sedikit Lebih banyak
GUNADARMA UNTUK INDONESIA 16 [Link]
Kesimpulan
GRU adalah alternatif yang baik untuk LSTM, terutama ketika kita menginginkan model yang
lebih sederhana dan efisien.
Meskipun LSTM memiliki beberapa keunggulan dalam kasus-kasus tertentu, GRU telah
terbukti sangat efektif dalam berbagai tugas pemrosesan bahasa alami dan analisis
sekuensial.
Pilihan antara GRU dan LSTM seringkali tergantung pada dataset dan tugas spesifik yang
sedang dikerjakan.
Dalam banyak kasus, disarankan untuk mencoba kedua model dan membandingkan
performanya.
GUNADARMA UNTUK INDONESIA 17 [Link]
PROGRAM STUDI INFORMATIKA
UNIVERSITAS GUNADARMA
03
Membangun Model RNN
GUNADARMA UNTUK INDONESIA 18 [Link]
Evaluasi Kinerja Analisis Sentimen
menggunakan RNN, LSTM, dan GRU
Berikut adalah contoh sederhana program pemrosesan bahasa alami
(Natural Language Processing / NLP) menggunakan tiga jenis jaringan
berulang (Recurrent Neural Networks / RNN), yaitu RNN klasik, LSTM (Long
Short-Term Memory), dan GRU (Gated Recurrent Unit).
Program ini akan melakukan tugas klasifikasi teks sederhana, misalnya
mendeteksi apakah teks tersebut memiliki sentimen positif atau negatif.
GUNADARMA UNTUK INDONESIA 19 [Link]
Langkah-langkah Algoritma
Persiapan Data: Preprocessing Teks:
• Dataset teks yang terdiri dari kalimat- • Tokenisasi teks menjadi urutan angka yang
kalimat dengan label (positif atau negatif). mewakili kata.
• Data akan diproses menggunakan • Padding agar semua urutan teks memiliki
tokenisasi dan padding agar dapat panjang yang sama.
dimasukkan ke dalam model RNN, LSTM,
dan GRU.
Pelatihan dan Evaluasi: Membangun Model:
• Melatih model menggunakan data latih. • RNN sederhana: Model pertama
• Mengevaluasi akurasi model dengan data menggunakan jaringan RNN klasik.
uji. • LSTM: Model kedua menggunakan
arsitektur LSTM.
• GRU: Model ketiga menggunakan
arsitektur GRU.
GUNADARMA UNTUK INDONESIA 20 [Link]
Langkah-langkah Pembuatan Program
1. Instalasi Pustaka yang Dibutuhkan
pip install tensorflow keras
GUNADARMA UNTUK INDONESIA 21 [Link]
Langkah-langkah Pembuatan Program
2. Mengimpor Modul dan Inisialisasi Model
import numpy as np
from [Link] import Tokenizer
from [Link] import pad_sequences
from [Link] import Sequential
from [Link] import Embedding, SimpleRNN, LSTM, GRU, Dense
from sklearn.model_selection import train_test_split
# Data contoh (sentimen teks sederhana)
texts = [
"I love this product", "This is the worst movie I have ever seen",
"Amazing experience, would love to come back", "Terrible service",
"I really enjoyed the dinner", "I hate waiting in line",
"The staff was very friendly", "Not worth the money"
]
labels = [1, 0, 1, 0, 1, 0, 1, 0] # 1: Positif, 0: Negatif
# Tokenisasi data
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
# Padding sequences
max_len = 10
X = pad_sequences(sequences, maxlen=max_len)
y = [Link](labels)
# Membagi data ke dalam training dan testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
GUNADARMA UNTUK INDONESIA 22 [Link]
Langkah-langkah Pembuatan Program
2. Mengimpor Modul dan Inisialisasi Model
import numpy as np
from [Link] import Tokenizer
from [Link] import pad_sequences
from [Link] import Sequential
from [Link] import Embedding, SimpleRNN, LSTM, GRU, Dense
from sklearn.model_selection import train_test_split
# Data contoh (sentimen teks sederhana)
texts = [
"I love this product", "This is the worst movie I have ever seen",
"Amazing experience, would love to come back", "Terrible service",
"I really enjoyed the dinner", "I hate waiting in line",
"The staff was very friendly", "Not worth the money"
]
labels = [1, 0, 1, 0, 1, 0, 1, 0] # 1: Positif, 0: Negatif
# Tokenisasi data
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
# Padding sequences
max_len = 10
X = pad_sequences(sequences, maxlen=max_len)
y = [Link](labels)
# Membagi data ke dalam training dan testing
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
GUNADARMA UNTUK INDONESIA 23 [Link]
Langkah-langkah Pembuatan Program
3. Membangun Model RNN
# Model RNN sederhana
def build_rnn_model():
model = Sequential([
Embedding(input_dim=1000, output_dim=64, input_length=max_len),
SimpleRNN(32),
Dense(1, activation='sigmoid')
])
[Link](optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
# Latih model RNN
rnn_model = build_rnn_model()
rnn_model.fit(X_train, y_train, epochs=5, batch_size=32, validation_data=(X_test,
y_test))
GUNADARMA UNTUK INDONESIA 24 [Link]
Langkah-langkah Pembuatan Program
4. Membangun Model LSTM
# Model LSTM
def build_lstm_model():
model = Sequential([
Embedding(input_dim=1000, output_dim=64, input_length=max_len),
LSTM(32),
Dense(1, activation='sigmoid')
])
[Link](optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
# Latih model LSTM
lstm_model = build_lstm_model()
lstm_model.fit(X_train, y_train, epochs=5, batch_size=32, validation_data=(X_test,
y_test))
GUNADARMA UNTUK INDONESIA 25 [Link]
Langkah-langkah Pembuatan Program
5. Membangun Model GRU
# Model GRU
def build_gru_model():
model = Sequential([
Embedding(input_dim=1000, output_dim=64, input_length=max_len),
GRU(32),
Dense(1, activation='sigmoid')
])
[Link](optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
# Latih model GRU
gru_model = build_gru_model()
gru_model.fit(X_train, y_train, epochs=5, batch_size=32, validation_data=(X_test,
y_test))
GUNADARMA UNTUK INDONESIA 26 [Link]
Langkah-langkah Pembuatan Program
6. Evaluasi Model
# Evaluasi RNN
rnn_loss, rnn_acc = rnn_model.evaluate(X_test, y_test)
print(f"RNN Accuracy: {rnn_acc}")
# Evaluasi LSTM
lstm_loss, lstm_acc = lstm_model.evaluate(X_test, y_test)
print(f"LSTM Accuracy: {lstm_acc}")
# Evaluasi GRU
gru_loss, gru_acc = gru_model.evaluate(X_test, y_test)
print(f"GRU Accuracy: {gru_acc}")
GUNADARMA UNTUK INDONESIA 27 [Link]
Penjelasan Algoritma
Tokenisasi dan Padding: Model RNN Sederhana: Model LSTM:
•Teks diubah menjadi urutan angka •RNN klasik digunakan sebagai baseline •LSTM (Long Short-Term Memory) adalah
menggunakan tokenisasi. Padding model. RNN sederhana dapat memproses varian RNN yang lebih canggih, dirancang
digunakan untuk memastikan semua urutan urutan data, tetapi kurang efisien dalam untuk menangani masalah "long-term
teks memiliki panjang yang sama sebelum menangani dependensi jangka panjang. dependencies". LSTM memiliki mekanisme
dimasukkan ke dalam model. "gating" yang memungkinkan model untuk
belajar kapan harus mempertahankan atau
melupakan informasi.
Evaluasi Model: Pelatihan Model: Model GRU:
•Model dievaluasi berdasarkan akurasi untuk •Ketiga model dilatih menggunakan data •GRU (Gated Recurrent Unit) adalah varian
menilai mana yang lebih efektif dalam latih, dan performanya dievaluasi dari LSTM yang lebih sederhana. GRU
melakukan tugas klasifikasi teks. menggunakan data uji. menggabungkan dua gerbang (update dan
reset gate) untuk mengendalikan aliran
informasi, yang membuatnya lebih ringan
dibanding LSTM.
GUNADARMA UNTUK INDONESIA 28 [Link]
PROGRAM STUDI INFORMATIKA
UNIVERSITAS GUNADARMA
TERIMA
KASIH
Tim Penyusun:
1. Dr. Winda Widya Ariestya
2. Dr. Reza Chandra
3. Wisnu Sukma Maulana, ST., MMSI
GUNADARMA UNTUK INDONESIA 29 [Link]