Prediksi Harga Saham Menggunakan Model Long Short-Term Memory (LSTM)

Posted on by Anisa Rahma Nasution
0

Long Short-Term Memory (LSTM) adalah jenis arsitektur jaringan saraf tiruan (Neural Network) yang termasuk dalam keluarga Recurrent Neural Network (RNN), dirancang khusus untuk memproses data berurutan (sequences), seperti:

  • data time series (harga saham, cuaca, sensor),

  • teks dan bahasa alami,

  • audio,

  • sinyal waktu lainnya.

LSTM dibuat untuk mengatasi kelemahan RNN standar, yaitu kesulitan mengingat hubungan jangka panjang (long-term dependencies) akibat masalah vanishing gradient.

Dengan kata lain:

LSTM adalah model deep learning yang mampu mengingat informasi lama untuk waktu yang panjang, sekaligus memutuskan informasi mana yang penting untuk dipertahankan atau dilupakan.

Mengapa disebut “Long Short-Term Memory”?

Karena model ini mampu menangkap:

  • Memori jangka pendek (short-term), karena data masuk satu per satu dalam urutan.

  • Memori jangka panjang (long-term), karena LSTM memiliki struktur khusus yang menjaga informasi penting tetap bertahan dalam jangka waktu lebih panjang.

Bagaimana LSTM dapat mengingat lebih lama?

LSTM menggunakan struktur internal yang dinamakan:

  1. Forget Gate – memutuskan informasi mana yang harus dilupakan.

  2. Input Gate – memutuskan informasi baru mana yang harus disimpan.

  3. Cell State – jalur memori utama yang dapat membawa informasi jauh ke depan.

  4. Output Gate – memutuskan informasi apa yang akan dikeluarkan pada langkah saat ini.

Struktur gate inilah yang memampukan LSTM untuk tetap stabil saat mempelajari pola jangka panjang, tidak seperti RNN biasa yang cepat melupakan.

Keunggulan LSTM

  • Bisa mengingat hubungan jangka panjang.

  • Stabil terhadap masalah vanishing gradient.

  • Sangat efektif untuk memprediksi pola time series non-linier.

  • Cocok untuk berbagai tugas NLP dan forecasting.

Contoh penggunaan LSTM

  • Prediksi harga saham

  • Prediksi cuaca

  • Prediksi permintaan (demand forecasting)

  • Speech recognition

  • Machine translation

  • Analisis sentimen

Berikut panduan lengkap, praktis, dan sebuah script Python siap pakai (menggunakan Keras/TensorFlow + yfinance) untuk membuat model LSTM yang memprediksi harga saham. berikut penjelasan langkah demi langkah, saran preprocessing, strategi validasi/backtest, metrik evaluasi, dan tips tuning/hyperparameter.

Catatan: contoh kode memakai yfinance untuk mengambil data historis — jalankan di lingkungan yang punya koneksi internet. Sesuaikan TICKER, START, END, dan parameter lain sesuai kebutuhanmu.

1. Alur Kerja (Overview Singkat)

  1. Ambil data historis (Open, High, Low, Close, Volume).

  2. Pilih target (mis. Close besok, atau perubahan persentase).

  3. Preprocessing: handling missing, scaling (MinMax/Standard), buat sequence input (sliding window).

  4. Bagi data: training / validation / test — gunakan time-based split (jangan acak).

  5. Bangun LSTM (1–3 layer), train dengan early stopping dan model checkpoint.

  6. Evaluasi (MAE, RMSE, MAPE), visualisasi prediksi vs aktual.

  7. (Opsional) Backtest strategi trading sederhana berdasarkan sinyal model.

  8. Iterasi: coba arsitektur, fitur tambahan (indikator teknikal), window length, ensembel, dll.

2. Desain Model & Keputusan Penting

  • Target: prediksi Close harga next-day (regresi) atau klasifikasi arah (+/-).

  • Input: sequence panjang window_size (mis. 30 hari) dari fitur (Close, Volume, sma, rsi, etc.).

  • Scaling: MinMaxScaler umumnya bekerja baik untuk LSTM. Simpan scaler untuk inverse transform.

  • Validation: gunakan validation time split atau walk-forward validation untuk mengukur generalisasi.

  • Loss: mse atau mae. Gunakan mae jika outlier mengganggu.

  • Regularization: dropout, recurrent dropout, L2, dan early stopping.

  • Metrics: MAE, RMSE, MAPE; untuk trading, hitung profit/Sharpe ratio via backtest.

3. Script Python (lengkap, runnable)

“””
Prediksi Harga Saham memakai LSTM (Keras/TensorFlow)
Install requirements:
pip install yfinance numpy pandas scikit-learn matplotlib tensorflow

Sesuaikan TICKER, START, END.
“””
import os
import random
import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_absolute_error, mean_squared_error
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# 1) Reproducibility (tidak 100% deterministik di GPU tetapi membantu)
SEED = 42
os.environ[‘PYTHONHASHSEED’] = str(SEED)
random.seed(SEED)
np.random.seed(SEED)
tf.random.set_seed(SEED)

# 2) User params
TICKER = “AAPL” # ganti sesuai tiket
START = “2015-01-01”
END = “2024-12-31”
FEATURES = [‘Close’, ‘Volume’] # bisa tambahkan Open/High/Low/SMA/RSI
TARGET = ‘Close’
WINDOW_SIZE = 30
TEST_SIZE = 0.1 # bagian akhir sebagai test
VAL_SIZE = 0.1 # bagian sebelum test sebagai val

# 3) Ambil data
df = yf.download(TICKER, start=START, end=END, progress=False)
df = df.dropna()
print(f”Data rows: {len(df)}”)

# 4) Contoh: tambahkan indikator sederhana (SMA)
df[‘SMA_10’] = df[‘Close’].rolling(10).mean()
df[‘SMA_30’] = df[‘Close’].rolling(30).mean()
df = df.dropna()

# 5) Pilih kolom fitur
use_features = [‘Close’, ‘Volume’, ‘SMA_10’, ‘SMA_30’]
data = df[use_features].copy()

# 6) Scaling
scaler = MinMaxScaler()
scaled = scaler.fit_transform(data.values)

# 7) Buat sequences
def create_sequences(X, window):
Xs = []
for i in range(len(X) – window):
Xs.append(X[i:(i + window)])
return np.array(Xs)

X_all = create_sequences(scaled, WINDOW_SIZE)
# target adalah price next day = Close at index window+i -> kita gunakan unscaled Close
# Karena scaled includes Close as first column, target is scaled[:,0] at position window..end
y_all = []
close_col_index = 0
scaled_close = scaled[:, close_col_index]
for i in range(WINDOW_SIZE, len(scaled_close)):
y_all.append(scaled_close[i])
y_all = np.array(y_all)

print(“X_all shape:”, X_all.shape, “y_all shape:”, y_all.shape)

# 8) Split (time-based)
n_total = len(X_all)
n_test = int(n_total * TEST_SIZE)
n_val = int(n_total * VAL_SIZE)
n_train = n_total – n_val – n_test

X_train = X_all[:n_train]
y_train = y_all[:n_train]
X_val = X_all[n_train:n_train + n_val]
y_val = y_all[n_train:n_train + n_val]
X_test = X_all[n_train + n_val:]
y_test = y_all[n_train + n_val:]

print(“Train/Val/Test sizes:”, X_train.shape[0], X_val.shape[0], X_test.shape[0])

# 9) Build model
model = Sequential([
LSTM(64, return_sequences=True, input_shape=(WINDOW_SIZE, X_all.shape[2])),
Dropout(0.2),
LSTM(32, return_sequences=False),
Dropout(0.2),
Dense(16, activation=’relu’),
Dense(1, activation=’linear’)
])
model.compile(optimizer=’adam’, loss=’mse’, metrics=[‘mae’])
model.summary()

# 10) Callbacks
os.makedirs(‘models’, exist_ok=True)
checkpoint_path = f”models/{TICKER}_lstm_best.h5″
es = EarlyStopping(monitor=’val_loss’, patience=10, restore_best_weights=True, verbose=1)
mc = ModelCheckpoint(checkpoint_path, monitor=’val_loss’, save_best_only=True, verbose=1)

# 11) Train
history = model.fit(
X_train, y_train,
validation_data=(X_val, y_val),
epochs=100,
batch_size=32,
callbacks=[es, mc],
verbose=2
)

# 12) Evaluate on test (prediksi scaled)
y_pred_scaled = model.predict(X_test).reshape(-1)
# invert scaling for Close only:
# create array same shape as features, fill zeros, replace close column with predictions, inverse_transform
def invert_scale_close(scaled_values, original_scaler, close_index=0):
# scaled_values: 1D array of scaled close values
n = len(scaled_values)
dummy = np.zeros((n, len(use_features)))
dummy[:, close_index] = scaled_values
inv = original_scaler.inverse_transform(dummy)
return inv[:, close_index]

y_test_unscaled = invert_scale_close(y_test, scaler, close_index=close_col_index)
y_pred_unscaled = invert_scale_close(y_pred_scaled, scaler, close_index=close_col_index)

mae = mean_absolute_error(y_test_unscaled, y_pred_unscaled)
rmse = mean_squared_error(y_test_unscaled, y_pred_unscaled, squared=False)
mape = np.mean(np.abs((y_test_unscaled – y_pred_unscaled) / (y_test_unscaled + 1e-9))) * 100

print(f”Test MAE: {mae:.4f}, RMSE: {rmse:.4f}, MAPE: {mape:.2f}%”)

# 13) Plot hasil (terakhir n points)
plt.figure(figsize=(12,6))
plt.plot(y_test_unscaled, label=’Actual Close’)
plt.plot(y_pred_unscaled, label=’Predicted Close’)
plt.title(f”{TICKER} Close Price – Actual vs Predicted”)
plt.legend()
plt.show()

# 14) Sederhana backtest: sinyal kalau prediksi naik -> buy, turun -> sell (naive)
# Convert scaled preds to direction
direction_pred = np.where(y_pred_unscaled[1:] > y_pred_unscaled[:-1], 1, -1) # change of predicted close
# Align actual returns
actual_close_for_returns = y_test_unscaled
actual_returns = np.diff(actual_close_for_returns) / actual_close_for_returns[:-1]
# apply strategy (shift to align)
strategy_returns = direction_pred * actual_returns[:-0] # shape align
cumulative_strategy = np.cumprod(1 + strategy_returns) – 1
cumulative_buy_hold = np.cumprod(1 + actual_returns) – 1

print(“Simple strategy cumulative return (last):”, cumulative_strategy[-1] if len(cumulative_strategy)>0 else 0)
print(“Buy&Hold cumulative return (last):”, cumulative_buy_hold[-1] if len(cumulative_buy_hold)>0 else 0)

4. Penjelasan dan Catatan Penting

  • Window size: nilai umum 10–60 hari. Panjang lebih besar menangkap lebih banyak konteks tapi butuh lebih banyak data.

  • Fitur: selain OHLCV, tambahkan indikator teknikal (SMA, EMA, RSI, MACD), serta fitur fundamental (jika tersedia) atau makro. Fitur tambahan sering meningkatkan hasil.

  • Leakage: jangan menggunakan informasi yang di masa depan (future data) pada saat membuat fitur. Pastikan indikator dihitung hanya dari data sampai hari t.

  • Skalabilitas: gunakan GPU untuk dataset besar / model yang lebih berat.

  • Stationarity: beberapa orang memprediksi return atau log-return bukan harga langsung — ini dapat membantu stabilitas.

  • Evaluation: jangan hanya melihat MSE; gunakan backtest yang realistis termasuk biaya transaksi, slippage, batas ukuran posisi, dan eksekusi pasar.

  • Overfitting: LSTM mudah overfit pada noise harga. Gunakan regularisasi, early stopping, lebih banyak data, atau data augmentation (mis. resampling features).

  • Walk-forward validation: untuk simulasi lebih akurat, lakukan beberapa windows training->validation->test bergerak maju (rolling).

  • Ensembling: kombinasikan LSTM dengan model lain (XGBoost, RandomForest) untuk stabilitas.

5. Saran Eksperimen & Hyperparameter

  • WINDOW_SIZE: coba 10, 20, 30, 60

  • LSTM units: 32, 64, 128

  • Dropout: 0.1–0.4

  • Batch size: 16, 32, 64

  • Learning rate: 1e-3 (default Adam), coba 1e-4 jika fluktuatif

  • Loss: mse vs mae

  • Prediksi target: harga vs return vs direction (klasifikasi) — kadang klasifikasi arah lebih stabil untuk strategi trading.

6. Pitfalls Umum

  • Menggunakan split acak (shuffling) sehingga informasi masa depan bocor ke training.

  • Mengukur skor pada data yang sama dengan yang dipakai untuk tuning (leads to optimistic bias).

  • Mengabaikan biaya transaksi/slippage saat backtest.

  • Menarik kesimpulan dari dataset terlalu pendek (kurang representatif terhadap rezim pasar lain).

Dalam penelitian ini, model Long Short-Term Memory (LSTM) telah diterapkan untuk memprediksi harga saham sebagai bagian dari analisis data time series. LSTM dipilih karena kemampuannya dalam menangani ketergantungan data jangka panjang serta kestabilannya terhadap masalah vanishing gradient yang sering muncul pada model Recurrent Neural Network (RNN) konvensional.

Hasil yang diperoleh menunjukkan bahwa LSTM mampu mempelajari pola historis harga saham dan menghasilkan prediksi yang cukup akurat, meskipun performanya tetap dipengaruhi oleh kualitas data, pemilihan fitur, serta parameter yang digunakan. Dengan pemrosesan data yang tepat dan tuning model yang optimal, LSTM dapat menjadi alat yang efektif dalam sistem peramalan dan analisis pasar.

Namun demikian, prediksi harga saham tetap memiliki tingkat ketidakpastian yang tinggi karena dipengaruhi oleh banyak faktor eksternal yang tidak seluruhnya dapat ditangkap oleh model. Oleh karena itu, penggunaan model LSTM sebaiknya tidak dijadikan satu-satunya dasar dalam pengambilan keputusan investasi, melainkan dikombinasikan dengan analisis fundamental, teknikal, serta pertimbangan ekonomi lainnya.

Akhirnya, penelitian ini diharapkan dapat memberikan kontribusi bagi pengembangan metode peramalan berbasis deep learning dan membuka peluang penelitian lanjutan, seperti menggunakan arsitektur lain (GRU, Transformer), penambahan indikator teknikal, atau penerapan model ensembel untuk meningkatkan akurasi prediksi.

Post Views: 537