LSTM (Long Short-Term Memory) adalah salah satu arsitektur AI yang bisa mengingat informasi dalam jangka waktu yang lebih panjang dibandingkan arsitektur lainnya. Teknologi ini banyak digunakan untuk memahami bahasa manusia, menerjemahkan kalimat, mengenali suara, atau memprediksi sesuatu berdasarkan data sebelumnya..

Bayangkan LSTM sebagai seseorang yang membaca sebuah cerita panjang. Orang ini harus mengingat bagian bagian penting dari cerita tersebut agar bisa memahami keseluruhan isi ceritanya. Namun, tidak semua detail harus diingat. Ada hal hal tertentu yang boleh dilupakan, dan ada juga yang harus terus diingat agar cerita tersebut tetap bisa dipahami sampai selesai.

Dalam LSTM, ada beberapa bagian penting, yaitu:

Input: Informasi baru yang diterima di setiap langkah (seperti kalimat baru dalam cerita).

• Hidden state: Memori jangka pendek yang menyimpan informasi yang relevan saat ini.

• Cell state: Memori jangka panjang yang bisa menyimpan informasi penting dari jauh sebelumnya.

Supaya LSTM bisa mengingat dan melupakan informasi secara selektif, ada tiga 'gerbang' yang bekerja seperti filter:

Forget gate : Memutuskan informasi lama mana yang harus dilupakan atau tetap disimpan. Bayangkan gerbang ini seperti seseorang yang memilih mana informasi lama yang penting, mana yang sudah tidak relevan lagi.

• Input gate : Memilih informasi baru mana yang akan disimpan ke dalam memori jangka panjang (cell state). Ini seperti seseorang yang menentukan apakah informasi baru tersebut penting untuk diingat atau tidak.

• Output gate : Memutuskan bagian mana dari memori jangka panjang yang harus digunakan saat ini untuk menghasilkan suatu respon atau prediksi.

Setiap kali LSTM menerima informasi baru, ketiga gerbang ini bekerja bersama-sama untuk memperbarui ingatan sistem, menentukan apa yang perlu diingat, apa yang bisa dilupakan, serta apa yang akan digunakan sebagai output atau hasil.

Dengan kemampuan unik ini, LSTM sangat efektif digunakan dalam tugas-tugas yang membutuhkan pemahaman konteks atau hubungan informasi dalam waktu yang lama, seperti analisis sentimen, prediksi cuaca, atau menerjemahkan teks dalam bahasa yang berbeda.

Agar lebih jelas, kita akan langsung praktek melakukan prediksi menggunakan LSTM. Kita akan membuat prediksi angka berikutnya berdasarkan angka sebelumnya. Tolong siapkan vscode dan siapkan juga venv, apabila belum bisa membaca tutorial setup venv agungg.com/ilmu-mahal/Venv. Apabila sudah lakukan instalasi berikut ini:

pip install tensorflow
pip install numpy
pip install matplotlib

Setelah itu kita buat file notebook baru, misalnya lstm.ipynb. pastikan install juga ipykernel, cara installnya tinggal buat code cell baru dan lalu run cellnya maka vscode akan otomatis menyarankan untuk install ipykernel lalu pencet install. Barulah setelah terinstall kita isi lstm.ipynb dengan kode berikut :

#cell 1
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

Pada cell 1 kita mengimport library yang diperlukan untuk membuat model LSTM. selanjutnya isi cell 2 dengan kode berikut :

#cell 2
# Menyiapkan dataset sederhana (deret angka)
data = np.array([i for i in range(1, 101)])  # angka dari 1 hingga 100 (1, 2, 3, ..., 99, 100)

Pada cell 2 kita buat dataset sederhana yaitu deret angka dari 1 sampai 100. Selanjutnya isi cell 3 dengan kode berikut :

#cell 3
# Normalisasi data (0-1)
data = data / 100
#jadi dari 1,2,3...100 menjadi 0.01, 0.02, 0.03...1.00 ini memudahkan model untuk memahami

Pada cell 3 kita Kita melakukan normalisasi data untuk mengubah rentang nilai pada data yang semula beragam menjadi dalam rentang tertentu, di kode tersebut kita mengubahnya dari 1,2,3...100 menjadi 0.01, 0.02, 0.03...1.00. Selanjutnya isi cell 4 dengan kode berikut :

#cell 4
# Membuat dataset menjadi bentuk sekuens
def buat_dataset(dataset, timestep):
   X, y = [], [] #inisialisasi variabel X untuk input dan y untuk output 
   for i in range(len(dataset) - timestep): # Perulangan ini berjalan sebanyak jumlah data dikurangi timestep.
     X.append(dataset[i:i + timestep]) #Setiap iterasi, ambil angka sejumlah timestep (misalnya 5 angka berturut-turut) untuk menjadi satu sampel input (X).
     y.append(dataset[i + timestep])#Angka berikutnya setelah 5 angka tersebut menjadi output (y).
return np.array(X), np.array(y)

timestep = 5 
#dengan 5 timestep maka model akan belajar dengan cara berikut
#	[1, 2, 3, 4, 5] untuk output 	6 selanjutnya 	[2, 3, 4, 5, 6] untuk output 7 dan seterusnya... 
X, y = buat_dataset(data, timestep)

Pada cell 4 diisi fungsi buat_dataset yang mengubah data yang awalnya berupa deretan angka biasa menjadi bentuk pasangan input output (X, y) yang diperlukan untuk melatih model LSTM. Dimana tujuannya Untuk memprediksi satu angka berdasarkan beberapa angka sebelumnya (misalnya memprediksi angka ke 6 dari 5 angka sebelumnya). Selanjutnya isi cell 5 dengan kode berikut :

#cell 5
# Mengubah bentuk data agar cocok untuk LSTM (samples, timesteps, features)
X = X.reshape(X.shape[0], X.shape[1], 1)
#Contoh X.shape = (95, 5) diubah menjadi X = X.reshape(95, 5, 1) membuatnya menjadi 3 dimensi dengan nilai sample timestep dan feature.

#jika satu dimensi dia seperti ini arr_1d = np.array([1, 2, 3, 4, 5]) dapat ditulis arr_1d.shape = (5,)
#jika dua dimensi dia seperti ini arr_2d = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 10]]) dapat ditulis arr_2d.shape = (2, 5) 
#jika tiga dimensi dia seperti ini arr_3d = np.array([[[1, 2, 3, 4, 5],[6, 7, 8, 9, 10]],[[11, 12, 13, 14, 15],[16, 17, 18, 19, 20]]]) dapat ditulis arr_3d.shape = (2,2,5).

#Mengapa 1 feature karena setiap angka di dalam sekuens kita hanyalah satu nilai saja bukan vektor, bukan gambar, bukan data multi-atribut.

Pada cell 5 kita mengubah bentuk data agar cocok untuk LSTM. Kita mengubah data dari dua dimensi menjadi tiga dimensi dengan menambahkan dimensi baru untuk fitur. Dalam hal ini, kita hanya memiliki satu fitur yaitu angka itu sendiri. Selanjutnya isi cell 6 dengan kode berikut :

# Model LSTM sederhana
model = Sequential() #Ini artinya kita membuat model berlapis lapis (layer by layer) menggunakan arsitektur Sequential dari Keras ( input → LSTM → output ).
model.add(LSTM(50, activation='relu', input_shape=(timestep, 1))) # ini artinya kita menggunakan 50 unit neuron lstm
#kenapa 50? ga harus 50 bisa aja ditaruh 1000 contoh model.add(LSTM(1000,... 
#Tapi Semakin banyak unit = semakin berat komputasinya. 
#Fungsi aktivasi ReLU digunakan agar model bisa belajar hubungan non-linear. Dan input_shape sesuaikan dengan yang tadi

model.add(Dense(1)) #ini layer output
 #Dense(1) berarti kita ingin model mengeluarkan 1 angka saja sebagai prediksi

Pada cell 6 kita membuat model LSTM sederhana dengan satu layer LSTM dan satu layer Dense. Kita menggunakan 50 unit neuron LSTM dan fungsi aktivasi ReLU untuk menangkap hubungan non-linear dalam data. Selanjutnya isi cell 7 dengan kode berikut :

# Kompilasi model
model.compile(optimizer='adam', loss='mse')
#Optimizer → cara model belajar / menyesuaikan bobot. kita pakai adam (Adaptive Moment Estimation.) 
#Loss Function → cara model mengukur kesalahan prediksi

Pada cell 7 kita mengkompilasi model dengan optimizer Adam dan fungsi loss MSE (Mean Squared Error) untuk mengukur kesalahan prediksi. Selanjutnya isi cell 8 dengan kode berikut :

# Melatih model 
model.fit(X, y, epochs=100, verbose=1)
#epochs = 100 artinya kita melatih model sebanyak 100 kali.
#verbose = 1 artinya kita menampilkan progress training yang akan terlihat seperti dibawah ini.

#Epoch 1/100
#3/3 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - loss: 0.3672
#Epoch 2/100
#3/3 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - loss: 0.3568

Pada cell 8 kita melatih model dengan data yang telah kita siapkan sebelumnya. Kita menggunakan 100 epoch untuk melatih model. Selanjutnya isi cell 9 dengan kode berikut :

# Mencoba prediksi data baru
test_input = np.array([96, 97, 98, 99, 100]) / 100  # input angka
# angka bebas, jangan dibawah 100 itu namanya nebak dataset. ibarat prediksi yang sudah terjadi
test_input = test_input.reshape((1, timestep, 1))
prediction = model.predict(test_input)

# Hasil prediksi dikembalikan ke skala awal yang tadi 0.01,0.02...1.00 jadi 1,2...100 lagi
hasil_prediksi = prediction[0][0] * 100
print(f'Hasil prediksi berikutnya adalah: {hasil_prediksi:.2f}')

Pada cell 9 kita mencoba melakukan prediksi dengan model yang telah dilatih. Setelah di run saya mendapatkan output 'Hasil prediksi berikutnya adalah: 102.25' Mengapa demikian? bukannya harusnya 101. itu karena Model LSTM adalah model machine learning yang sifatnya memperkirakan (approximate). Model dilatih dengan asumsi bahwa pola angka akan terus meningkat dengan selisih yang konsisten (dalam kasus ini, pola naik +1 setiap kali). Namun, karena ini model machine learning sederhana dan jumlah data yang sangat terbatas (hanya 100 angka) serta epoch training yang terbatas pula, model bisa saja tidak sempurna memahami pola dengan tepat. Akibatnya, hasil prediksinya tidak persis angka 101, melainkan mendekati angka tersebut (102.25).

Oleh karena itu penting untuk memperhatikan kualitas dataset serta pendekatan yang akan dilakukan sebelum melakukan prediksi. Namun untuk kasus ini agar mendapat hasil yang akurat silahkan bereksperimen dengan menambah jumlah data, epoch ,dll. Dan perlu diingat semakin banyak data dan epoch yang digunakan maka semakin lama juga waktu yang dibutuhkan untuk melatih model. Anda bisa menggunakan GPU untuk mempercepat proses pelatihan model. Selain hal hal tersebut plot prediksi juga bisa dilakukan untuk melihat hasil prediksi dari model yang telah kita buat namun agar tidak terlalu panjang akan dibahas di tutorial selanjutnya yang akan membahas performa model, akurasi, resiko Overfitting. Untuk saat ini kita cukup melakukan prediksi angka berikutnya dari angka sebelumnya.

Pengembangan dari ilmu ini dapat kita aplikasikan dalam berbagai bidang, seperti prediksi saham, analisis sentimen, dan banyak lagi. Dengan memahami cara kerja LSTM, kita dapat mengembangkan model yang lebih kompleks dan akurat untuk memecahkan berbagai masalah dalam dunia nyata. Selain itu, kita juga bisa menggabungkan LSTM dengan teknik lain seperti CNN (Convolutional Neural Networks) untuk menangani data yang lebih kompleks seperti gambar atau video.

Mantap kita sudah berhasil membuat model LSTM sederhana yang dapat memprediksi angka berikutnya berdasarkan angka sebelumnya. Kurang lebih seperti itulah cara kerja dan arsitektur LSTM, semoga penjelasan ini dapat membantu Anda memahami konsep dasar LSTM dan bagaimana cara kerjanya. Jika ada pertanyaan atau ingin mendalami lebih lanjut tinggal email dibawah. Intinya Mantap.