<aside> 💡
Ini adalah tahap Pre-processing. Filosofi utamanya adalah: "Menjaga Urutan Waktu".
features = [..., "ISPU PM2.5"]. Perhatikan bahwa PM2.5 masuk sebagai feature (input) sekaligus target (output). Ini karena LSTM perlu melihat sejarah PM2.5 masa lalu untuk menebak PM2.5 masa depan.scaler.fit_transform. Semua data dipaksa masuk ke rentang 0 sampai 1.Konsep: DILARANG MENGACAK DATA (No Shuffling).
Dalam Time Series, kita tidak boleh menggunakan data masa depan untuk melatih masa lalu (data leakage).
Mekanisme: Potong kue secara urut.
Di Code: Menggunakan indeks slicing [:train_size], [train_size:train_size+val_size].
Ini adalah bagian paling krusial. LSTM tidak bisa makan data tabel biasa (Excel). Dia butuh data 3 Dimensi: (Samples, TimeSteps, Features).
Logika TimeseriesGenerator:
Bayangkan sebuah jendela kaca yang bergerak geser (Sliding Window) sepanjang data Anda.
Di Code: length=lookback menentukan lebar jendela, dan batch_size=4 artinya model belajar 4 jendela sekaligus dalam sekali jalan.
train_data[:, 6] merujuk pada kolom ke-6 (indeks mulai dari 0) yaitu ISPU PM2.5 sebagai target yang harus ditebak.Setelah data siap dalam bentuk "jendela-jendela" tadi, data masuk ke "Pabrik Pengolahan" (Model LSTM).
(30 hari, 7 fitur).Input(shape=input_shape).Anda menggunakan dua lapisan saringan memori.
return_sequences=True):
return_sequences=False):
val_loss. Jika 5 kali (patience=5) tidak turun-turun, stop! Ambil bobot terbaik (restore_best_weights=True).for epochs... for learning_rate....
Jika diminta menjelaskan alur data secara keseluruhan:
"Data mentah pertama-tama saya bersihkan dan dinormalisasi (0-1) agar kompatibel dengan fungsi aktivasi LSTM.
Kemudian, data dibagi secara sekuensial (70:15:15) tanpa pengacakan untuk menjaga integritas waktu. Data ini kemudian diubah menjadi format 3D menggunakan metode Sliding Window dengan lookback 30 hari; artinya model menggunakan data 30 hari terakhir untuk memprediksi hari esok.
Data 3D ini kemudian masuk ke arsitektur Stacked LSTM dua lapis. Layer pertama mengekstrak fitur urutan, dan layer kedua merangkumnya menjadi prediksi. Seluruh proses ini diawasi oleh Early Stopping untuk mencegah overfitting."
</aside>
High Level Explanation
<aside> 💡
Bagian ini menjelaskan "otak" dari sistem prediksi Anda.
LSTM(..., return_sequences=True): Menerima input urutan waktu dan meneruskan urutan data ke layer berikutnya.LSTM(..., return_sequences=False): Mengambil output dari layer 1 dan menghasilkan vektor fitur akhir.Dropout(0.2) setelah setiap lapisan LSTM. Ini berarti 20% neuron dimatikan secara acak selama pelatihan untuk mencegah Overfitting (model terlalu menghapal data latih).'tanh' yang merupakan standar emas untuk LSTM karena kemampuannya menangani gradient dengan baik dalam rentang -1 hingga 1.patience=5.
mape_score khusus yang menambahkan epsilon (nilai sangat kecil).
division by zero) jika ada data aktual bernilai 0.Bagian ini menjelaskan bagaimana Anda menemukan konfigurasi terbaik ("resep" terbaik).
adam, rmsprop, sgd, nadam) untuk melihat mana yang paling cepat konvergen.units) 16, 32, dan 64 untuk melihat apakah model perlu kapasitas memori kecil atau besar.Ini poin krusial untuk validitas data. Penguji sering bertanya: "Anda hitung error pakai data 0-1 atau data asli?"
scaler.inverse_transform menunjukkan bahwa Anda mengembalikan data ke satuan aslinya (µg/m³) sebelum menghitung error.Bagian ini adalah "bukti visual" performa model.
"Untuk implementasi teknis, saya membangun model Stacked LSTM menggunakan kerangka kerja TensorFlow/Keras. Model ini dilengkapi mekanisme Dropout 0.1 dan Early Stopping untuk menjaga generalisasi dan mencegah overfitting.
</aside>
Cell Code 0
df = df_cleaned
features = ["temp", "dew", "humidity", "precip", "windspeed", "AOD", "ISPU PM2.5"]
target = "ISPU PM2.5"
# Normalisasi data
scaler = MinMaxScaler()
df_scaled = scaler.fit_transform(df[features])
# Tentukan lookback (jumlah timestep sebelumnya digunakan untuk prediksi)
lookback = 30
# Bagi data menjadi training (70%), validasi (15%), dan testing (15%)
train_size = int(len(df_scaled) * 0.7)
val_size = int(len(df_scaled) * 0.15)
train_data = df_scaled[:train_size]
val_data = df_scaled[train_size:train_size+val_size]
test_data = df_scaled[train_size+val_size:]
# Gunakan TimeseriesGenerator untuk membentuk data dalam format sekuensial
train_gen = TimeseriesGenerator(train_data, train_data[:, 6], length=lookback, batch_size=4)
val_gen = TimeseriesGenerator(val_data, val_data[:, 6], length=lookback, batch_size=4)
test_gen = TimeseriesGenerator(test_data, test_data[:, 6], length=lookback, batch_size=4)
# Cek bentuk data generator
len(train_gen), len(val_gen), len(test_gen)
Cell Code 0
Cell Code 1
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.optimizers import Adam, RMSprop
from tensorflow.keras import Input
from sklearn.metrics import mean_squared_error, r2_score
from tensorflow.keras.callbacks import Callback, EarlyStopping
import numpy as np
# --- 1. FUNGSI BARU: MEAN ABSOLUTE PERCENTAGE ERROR (MAPE) ---
def mape_score(y_true, y_pred):
"""
Menghitung Mean Absolute Percentage Error (MAPE).
Mencegah pembagian dengan nol dengan menambahkan epsilon (np.finfo(float).eps).
"""
# Menghindari pembagian dengan nol
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / (y_true + np.finfo(float).eps))) * 100
# -------------------------------------------------------------
early_stopping = EarlyStopping(
monitor='val_loss',
patience=5,
restore_best_weights=True
)
def build_lstm_model(input_shape, lstm_units, optimizer, learning_rate):
model = Sequential([
Input(shape=input_shape),
LSTM(lstm_units, activation='tanh', return_sequences=True),
Dropout(0.1),
LSTM(lstm_units, activation='tanh', return_sequences=False),
Dropout(0.1),
Dense(25, activation='tanh'),
Dense(1)
])
opt = Adam(learning_rate=learning_rate) if optimizer == 'adam' else RMSprop(learning_rate=learning_rate)
model.compile(optimizer=opt, loss='mse')
return model
def evaluate_model(model, test_gen):
test_pred = model.predict(test_gen)
test_true_list = []
for i in range(len(test_gen)):
_, y = test_gen[i]
test_true_list.append(y)
test_true = np.hstack(test_true_list)
test_r2 = r2_score(test_true, test_pred)
test_rmse = np.sqrt(mean_squared_error(test_true, test_pred))
test_mbe = np.mean(test_true - test_pred)
test_nse = 1 - (np.sum((test_true - test_pred) ** 2) / np.sum((test_true - np.mean(test_true)) ** 2))
test_mape = mape_score(test_true, test_pred)
return {'R2': test_r2, 'RMSE': test_rmse, 'MBE': test_mbe, 'NSE': test_nse, 'MAPE': test_mape}
def grid_search_lstm(train_gen, val_gen, test_gen, input_shape, param_grid):
results = []
models = {}
all_history = {}
all_r2_callback = {}
# --- Callback kustom untuk R2, diperluas untuk MAPE (jika perlu, tapi kita fokus di evaluasi akhir) ---
class R2History(Callback):
def __init__(self, val_gen):
self.val_gen = val_gen
self.r2_scores = []
def on_epoch_end(self, epoch, logs=None):
val_pred = self.model.predict(self.val_gen, verbose=0)
val_true_list = []
for i in range(len(val_gen)):
_, y = val_gen[i]
val_true_list.append(y)
val_true = np.hstack(val_true_list)
r2 = r2_score(val_true, val_pred)
self.r2_scores.append(r2)
# ------------------------------------------------------------------------------------------------------
for epochs in param_grid['epochs']:
for learning_rate in param_grid['learning_rate']:
for optimizer in param_grid['optimizer']:
for lstm_units in param_grid['lstm_units']:
r2_callback = R2History(val_gen)
config_name = f"epochs_{epochs}_lr_{learning_rate}_opt_{optimizer}_units_{lstm_units}"
print(f"\nTraining model dengan {config_name}")
model = build_lstm_model(input_shape, lstm_units, optimizer, learning_rate)
# Run 1 epoch warmup (optional but helpful before main loop)
model.fit(train_gen, validation_data=val_gen, epochs=1, verbose=0, callbacks=[r2_callback])
# Main training loop
history = model.fit(train_gen, validation_data=val_gen, epochs=epochs, verbose=0, callbacks=[r2_callback, early_stopping])
metrics = evaluate_model(model, test_gen)
print(metrics)
results.append({
'epochs': epochs,
'learning_rate': learning_rate,
'optimizer': optimizer,
'lstm_units': lstm_units,
'R2': metrics['R2'],
'RMSE': metrics['RMSE'],
'MBE': metrics['MBE'],
'NSE': metrics['NSE'],
'MAPE': metrics['MAPE'] # --- PENAMBAHAN MAPE KE HASIL AKHIR ---
})
models[config_name] = model
all_history[config_name] = history
all_r2_callback[config_name] = r2_callback
return results, models, all_history, all_r2_callback
Cell Code 1
Cell Code 2
param_grid = {
'epochs': [1000],
'learning_rate': [0.0001, 0.001, 0.01, 0.1],
'optimizer': ['adam', 'rmsprop', 'sgd', 'nadam'],
'lstm_units': [16, 32, 64]
}
grid_results, models, all_history, all_r2_callback = grid_search_lstm(train_gen, val_gen, test_gen, (lookback, len(features)), param_grid)
df_results = pd.DataFrame(grid_results)
Cell Code 2
Cell Code 3