Panduan LSTM Time Series Python Membangun Model Prediksi

Panduan praktis ini akan memandu Anda langkah demi langkah dalam membangun model prediksi time series menggunakan LSTM (Long Short-Term Memory) di Python. LSTM adalah jenis Recurrent Neural Network (RNN) yang sangat efektif dalam memproses data sekuensial seperti time series. Kita akan menggunakan library TensorFlow/Keras yang populer untuk membangun dan melatih model LSTM.

Konsep Time Series dan LSTM

Data time series adalah serangkaian data yang diurutkan berdasarkan waktu. Contoh umum data time series meliputi harga saham harian, data suhu bulanan, data penjualan tahunan, dan data sensor dari perangkat IoT. Analisis time series python menjadi penting karena memberikan wawasan berharga dan memungkinkan kita untuk membuat prediksi tentang perilaku masa depan berdasarkan pola historis. Misalnya, dalam bisnis, prediksi time series dapat digunakan untuk memperkirakan permintaan produk, mengoptimalkan inventaris, dan merencanakan strategi pemasaran.

Baca juga: AI Prediksi Penjualan Tingkatkan Akurasi dan Efisiensi Bisnis

LSTM (Long Short-Term Memory) adalah jenis arsitektur jaringan saraf tiruan yang dirancang khusus untuk mengatasi masalah vanishing gradient yang sering terjadi pada RNN tradisional. LSTM memiliki kemampuan untuk “mengingat” informasi jangka panjang, yang membuatnya sangat cocok untuk menganalisis data time series yang memiliki dependensi jangka panjang. Dengan kata lain, model lstm python dapat mempelajari pola kompleks dalam data time series dan membuat prediksi yang akurat. Dalam konteks deep learning time series python, LSTM telah terbukti menjadi salah satu pendekatan yang paling efektif.

Dalam tutorial ini, kita akan menggunakan beberapa library python untuk time series yang powerful, terutama:

TensorFlow/Keras: Framework deep learning yang menyediakan API tingkat tinggi untuk membangun dan melatih model LSTM.
Pandas: Untuk manipulasi dan analisis data, terutama untuk memuat dan memproses data time series.
NumPy: Untuk operasi numerik dan komputasi array.
Scikit-learn: Untuk preprocessing data (seperti normalisasi) dan membagi data menjadi set pelatihan dan pengujian.

Tujuan utama dari time series python tutorial ini adalah untuk memberikan panduan praktis dan komprehensif yang dapat Anda ikuti langkah demi langkah, mulai dari persiapan data hingga evaluasi model.

Persiapan Data Time Series

Mengumpulkan Data

Data time series dapat diperoleh dari berbagai sumber, seperti:

API Publik: Banyak penyedia data menyediakan API yang memungkinkan Anda mengunduh data secara terprogram. Contohnya, Yahoo Finance API untuk data harga saham, atau API dari penyedia data cuaca.
File CSV: Data time series sering kali disimpan dalam format CSV, yang mudah dibaca dengan Pandas.
Database: Data juga dapat disimpan dalam database SQL atau NoSQL.

Untuk tutorial ini, kita akan menggunakan data time series sederhana yang kita buat sendiri, yaitu data sinusoidal dengan sedikit noise. Ini akan memudahkan kita untuk fokus pada langkah-langkah membangun model LSTM.

import numpy as np
import pandas as pd

# Generate data sinusoidal
time = np.arange(0, 100, 0.1)
amplitude = np.sin(time) + np.random.normal(scale=0.2, size=len(time))  # Add noise

# Create Pandas DataFrame
data = pd.DataFrame({'Time': time, 'Value': amplitude})

print(data.head())

Kode di atas menghasilkan data sinusoidal dengan menambahkan noise acak. Data ini kemudian disimpan dalam DataFrame Pandas.

Membersihkan Data

Pembersihan data adalah langkah penting untuk memastikan kualitas model. Beberapa langkah pembersihan data yang umum meliputi:

Menangani Missing Values: Jika ada nilai yang hilang dalam data, kita perlu memutuskan apakah akan menghapus baris tersebut, atau mengisi nilai yang hilang dengan teknik imputasi (misalnya, mengisi dengan nilai rata-rata atau median).
Menangani Outliers: Outliers adalah nilai ekstrem yang dapat mengganggu model. Kita bisa menghapus outliers atau menggunakan teknik transformasi seperti winsorizing.
Memeriksa Format Data: Pastikan kolom waktu memiliki tipe data yang benar (misalnya, datetime di Pandas).

Dalam contoh data sinusoidal yang kita buat, kita tidak memiliki missing values atau outliers, jadi kita bisa langsung ke langkah berikutnya.

Memformat Data

Sebelum memasukkan data ke model LSTM, kita perlu melakukan beberapa transformasi:

Scaling/Normalisasi: LSTM, seperti kebanyakan model deep learning, bekerja lebih baik jika data berada dalam skala yang sama. Kita dapat menggunakan MinMaxScaler dari Scikit-learn untuk menskalakan data ke rentang [0, 1].

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))
data['Value'] = scaler.fit_transform(data['Value'].values.reshape(-1, 1))

print(data.head())

Membagi Data: Data dibagi menjadi set pelatihan (training) dan set pengujian (testing). Rasio yang umum digunakan adalah 80% untuk pelatihan dan 20% untuk pengujian.

train_size = int(len(data) * 0.8)
train_data = data[:train_size]
test_data = data[train_size:]

print(f"Train size: {len(train_data)}, Test size: {len(test_data)}")

Time Series Windowing: LSTM memerlukan input berupa sekuens data. Kita perlu mengubah data time series menjadi format sekuens input dan output. Misalnya, jika kita ingin menggunakan 10 data sebelumnya untuk memprediksi data berikutnya, kita akan membuat sekuens input dengan panjang 10, dan outputnya adalah nilai pada waktu ke-11. Ini adalah inti dari pemodelan time series python.

def create_sequences(data, seq_length):
    X = []
    y = []
    for i in range(len(data) - seq_length):
        X.append(data['Value'].iloc[i:(i + seq_length)].values)
        y.append(data['Value'].iloc[i + seq_length])
    return np.array(X), np.array(y)

seq_length = 10  # Sequence length
X_train, y_train = create_sequences(train_data, seq_length)
X_test, y_test = create_sequences(test_data, seq_length)

print(f"X_train shape: {X_train.shape}, y_train shape: {y_train.shape}")
print(f"X_test shape: {X_test.shape}, y_test shape: {y_test.shape}")

Kode di atas mendefinisikan fungsi create_sequences yang mengubah data menjadi format yang sesuai untuk LSTM.

Membangun Model LSTM

Arsitektur Model LSTM

Arsitektur LSTM yang akan kita gunakan terdiri dari:

Input Layer: Menerima sekuens data time series dengan panjang yang telah ditentukan (seq_length).
LSTM Layer(s): Satu atau lebih layer LSTM. Setiap layer LSTM terdiri dari sejumlah unit (atau neuron). Jumlah unit ini adalah hyperparameter yang dapat kita tuning.
Dense Layer: Layer fully connected yang menghasilkan output prediksi.
Fungsi Aktivasi: Kita akan menggunakan fungsi aktivasi ‘relu’ untuk layer LSTM dan tidak ada fungsi aktivasi (linear) untuk layer Dense karena ini adalah masalah regresi.

Alasan pemilihan arsitektur ini adalah karena LSTM dirancang khusus untuk memproses data sekuensial, dan layer Dense memberikan output yang sesuai untuk masalah prediksi time series. Kita akan mulai dengan arsitektur sederhana (satu layer LSTM) dan kemudian dapat bereksperimen dengan menambahkan lebih banyak layer atau unit. Pemilihan ini sangat umum dalam implementasi lstm time series python.

Implementasi dengan TensorFlow/Keras

Berikut adalah kode Python untuk membangun model LSTM menggunakan TensorFlow/Keras. Kode ini adalah contoh kode lstm time series yang lengkap dan tutorial lstm python yang detail.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Build the LSTM model
model = Sequential()
model.add(LSTM(units=50, activation='relu', input_shape=(X_train.shape[1], 1))) #input_shape, pastikan sesuai dengan inputan sequence
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mse')

model.summary()

Penjelasan kode:

Sequential(): Membuat model sekuensial, di mana layer ditambahkan secara berurutan.
model.add(LSTM(...)): Menambahkan layer LSTM.
- units=50: Menentukan jumlah unit LSTM (hyperparameter).
- activation='relu': Menggunakan fungsi aktivasi ReLU.
- input_shape=(X_train.shape[1], 1): Menentukan bentuk input. X_train.shape[1] adalah panjang sekuens, dan 1 adalah jumlah fitur (karena kita hanya memiliki satu fitur, yaitu ‘Value’).
model.add(Dense(units=1)): Menambahkan layer Dense dengan satu unit, yang akan menghasilkan output prediksi.
model.compile(...): Mengompilasi model.
- optimizer='adam': Menggunakan optimizer Adam, yang merupakan algoritma optimasi yang populer.
- loss='mse': Menggunakan Mean Squared Error (MSE) sebagai loss function, yang umum digunakan untuk masalah regresi seperti prediksi deret waktu python.

Pelatihan Model LSTM

Proses pelatihan melibatkan pemberian data latih ke model dan membiarkannya belajar menyesuaikan bobotnya.

history = model.fit(X_train, y_train, epochs=20, batch_size=32, validation_data=(X_test, y_test), verbose=1)

Penjelasan kode:

model.fit(...): Melatih model.
- X_train, y_train: Data latih (input dan output).
- epochs=20: Jumlah iterasi pelatihan (hyperparameter).
- batch_size=32: Jumlah sampel yang digunakan dalam setiap iterasi (hyperparameter).
- validation_data=(X_test, y_test): Data uji digunakan untuk memvalidasi model selama pelatihan.
- verbose=1: Menampilkan output pelatihan.
history menyimpan history pelatihan

Berikut contoh output dan visualisasi untuk memonitor overfitting atau underfitting:

import matplotlib.pyplot as plt

# Plot training & validation loss values
plt.figure(figsize=(10, 6))
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(loc='upper right')
plt.show()

Jika validation loss mulai meningkat sementara training loss terus menurun, ini bisa menjadi indikasi overfitting. Dalam kasus tersebut, kita bisa mencoba mengurangi kompleksitas model (misalnya, mengurangi jumlah unit LSTM), menggunakan teknik regularisasi seperti dropout, atau menggunakan early stopping. Early stopping menghentikan pelatihan jika validation loss tidak membaik setelah sejumlah iterasi tertentu.

Contoh Implementasi Early Stopping:

from tensorflow.keras.callbacks import EarlyStopping

early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)

history = model.fit(X_train, y_train, epochs=100, batch_size=32, validation_data=(X_test, y_test), verbose=1, callbacks=[early_stopping])

EarlyStopping akan memantau val_loss dan menghentikan pelatihan jika tidak ada peningkatan setelah 5 epochs (patience=5). restore_best_weights=True akan memuat kembali bobot model terbaik.

Evaluasi Model

Evaluasi model dilakukan dengan menggunakan data uji. Metrik yang umum digunakan untuk time series adalah:

Root Mean Squared Error (RMSE): Akar kuadrat dari rata-rata selisih kuadrat antara prediksi dan nilai sebenarnya.
Mean Absolute Error (MAE): Rata-rata selisih absolut antara prediksi dan nilai sebenarnya.

Interpretasi: Semakin kecil nilai RMSE dan MAE, semakin baik performa model.

from sklearn.metrics import mean_squared_error, mean_absolute_error

# Make predictions
y_pred = model.predict(X_test)

# Inverse transform the predictions and actual values
y_pred = scaler.inverse_transform(y_pred)
y_test_inv = scaler.inverse_transform(y_test.reshape(-1, 1))

# Calculate RMSE and MAE
rmse = np.sqrt(mean_squared_error(y_test_inv, y_pred))
mae = mean_absolute_error(y_test_inv, y_pred)

print(f"RMSE: {rmse:.4f}")
print(f"MAE: {mae:.4f}")

# Visualize the predictions
plt.figure(figsize=(12, 6))
plt.plot(y_test_inv, label='Actual')
plt.plot(y_pred, label='Predicted')
plt.title('Actual vs. Predicted Values')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.show()

Kode di atas menghitung RMSE dan MAE, dan kemudian memvisualisasikan hasil prediksi dibandingkan dengan data aktual.

Prediksi dengan Model

Setelah model dilatih dan dievaluasi, kita dapat menggunakannya untuk membuat prediksi pada data baru. Kodenya mirip dengan yang digunakan untuk evaluasi, tetapi kita akan menggunakan data yang belum pernah dilihat oleh model sebelumnya. Forecasting time series python menjadi lebih mudah dengan model yang sudah terlatih.

# Assume we have new data in 'new_data' DataFrame
# Preprocess the new data (scaling, create sequences)
new_data['Value'] = scaler.transform(new_data['Value'].values.reshape(-1, 1))
X_new, y_new = create_sequences(new_data, seq_length)

# Make predictions
y_new_pred = model.predict(X_new)

# Inverse transform the predictions
y_new_pred = scaler.inverse_transform(y_new_pred)

# Print or visualize the predictions
print(y_new_pred)

Kesimpulan

Dalam panduan ini, kita telah membahas langkah-langkah membangun model prediksi time series dengan LSTM di Python, mulai dari persiapan data, pembangunan model, pelatihan, evaluasi, hingga prediksi. Langkah-langkah utama meliputi:

Persiapan Data: Mengumpulkan, membersihkan, dan memformat data time series.
Pembangunan Model: Membuat arsitektur LSTM menggunakan TensorFlow/Keras.
Pelatihan Model: Melatih model dengan data latih dan memonitor overfitting.
Evaluasi Model: Mengukur performa model dengan metrik RMSE dan MAE.
Prediksi: Menggunakan model terlatih untuk membuat prediksi baru.

Untuk pengembangan lebih lanjut, Anda dapat mencoba:

Arsitektur LSTM yang berbeda (misalnya, stacked LSTM, bidirectional LSTM).
Teknik regularisasi seperti dropout.
Optimasi hyperparameter menggunakan teknik seperti grid search atau random search.
Menerapkannya untuk studi kasus prediksi harga saham dan data real

Baca juga: AI dalam Prediksi Harga Saham Akuratkah atau Hanya Hype?

Dengan memahami konsep dan langkah-langkah yang telah diuraikan, Anda sekarang memiliki dasar yang kuat untuk membangun model time series Anda sendiri dan bereksperimen dengan berbagai teknik untuk meningkatkan akurasi prediksi. Untuk memperdalam pemahaman tentang time series machine learning python, Anda bisa mengeksplorasi lebih jauh library dan teknik-teknik lainnya.

Baca juga: Panduan Lengkap Skill Machine Learning Engineer untuk Pemula

Kirim.ai adalah platform yang menyediakan berbagai solusi berbasis AI, termasuk alat untuk pemrosesan teks, audio, gambar, dan video. Jika Anda tertarik untuk mengembangkan solusi prediksi time series atau aplikasi berbasis AI lainnya, pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu Anda.

Kode Sumber Lengkap

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
from sklearn.metrics import mean_squared_error, mean_absolute_error
import matplotlib.pyplot as plt
from tensorflow.keras.callbacks import EarlyStopping

# --- Generate Data ---
time = np.arange(0, 100, 0.1)
amplitude = np.sin(time) + np.random.normal(scale=0.2, size=len(time))
data = pd.DataFrame({'Time': time, 'Value': amplitude})

# --- Data Preprocessing ---
scaler = MinMaxScaler(feature_range=(0, 1))
data['Value'] = scaler.fit_transform(data['Value'].values.reshape(-1, 1))

train_size = int(len(data) * 0.8)
train_data = data[:train_size]
test_data = data[train_size:]

def create_sequences(data, seq_length):
    X = []
    y = []
    for i in range(len(data) - seq_length):
        X.append(data['Value'].iloc[i:(i + seq_length)].values)
        y.append(data['Value'].iloc[i + seq_length])
    return np.array(X), np.array(y)

seq_length = 10
X_train, y_train = create_sequences(train_data, seq_length)
X_test, y_test = create_sequences(test_data, seq_length)

# --- Build LSTM Model ---
model = Sequential()
model.add(LSTM(units=50, activation='relu', input_shape=(X_train.shape[1], 1)))
model.add(Dense(units=1))
model.compile(optimizer='adam', loss='mse')

# --- Train Model with Early Stopping ---
early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
history = model.fit(X_train, y_train, epochs=100, batch_size=32, validation_data=(X_test, y_test), verbose=1, callbacks=[early_stopping])

# --- Evaluate Model ---
y_pred = model.predict(X_test)
y_pred = scaler.inverse_transform(y_pred)
y_test_inv = scaler.inverse_transform(y_test.reshape(-1, 1))

rmse = np.sqrt(mean_squared_error(y_test_inv, y_pred))
mae = mean_absolute_error(y_test_inv, y_pred)
print(f"RMSE: {rmse:.4f}")
print(f"MAE: {mae:.4f}")

# --- Visualize Predictions ---
plt.figure(figsize=(12, 6))
plt.plot(y_test_inv, label='Actual')
plt.plot(y_pred, label='Predicted')
plt.title('Actual vs. Predicted Values')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.show()

# --- Prediction on New Data (Example) ---
# Assume we have new data
new_time = np.arange(100, 110, 0.1)  # Example new time points
new_amplitude = np.sin(new_time) + np.random.normal(scale=0.2, size=len(new_time)) # with noise
new_data = pd.DataFrame({'Time': new_time, 'Value': new_amplitude})

# Preprocess
new_data['Value'] = scaler.transform(new_data['Value'].values.reshape(-1, 1))
X_new, y_new = create_sequences(new_data, seq_length)

# Predict
y_new_pred = model.predict(X_new)
y_new_pred = scaler.inverse_transform(y_new_pred)

# Print
print("\nPredictions on New Data:")
print(y_new_pred)