<aside> 💡


BAGIAN 1: Cell Code 0 (Penyiapan & Pembagian Data)

Ini adalah tahap Pre-processing. Filosofi utamanya adalah: "Menjaga Urutan Waktu".

1. Seleksi Fitur & Target (Multivariate)

2. Normalisasi (MinMaxScaler)

3. Pembagian Data (Sequential Splitting)

4. The sliding Window (TimeseriesGenerator) - PENTING!

Ini adalah bagian paling krusial. LSTM tidak bisa makan data tabel biasa (Excel). Dia butuh data 3 Dimensi: (Samples, TimeSteps, Features).


BAGIAN 2: Cell Code 1 (Arsitektur & Pelatihan)

Setelah data siap dalam bentuk "jendela-jendela" tadi, data masuk ke "Pabrik Pengolahan" (Model LSTM).

1. Input Layer

2. Stacked LSTM (LSTM Bertumpuk)

Anda menggunakan dua lapisan saringan memori.

3. Regularisasi (Dropout & Early Stopping)

4. Grid Search (Looping Eksperimen)

Kesimpulan Alur Data

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> 💡

1. Arsitektur Model & Mekanisme Pelatihan (Cell 1)

Bagian ini menjelaskan "otak" dari sistem prediksi Anda.

2. Skenario Hyperparameter Tuning (Cell 2)

Bagian ini menjelaskan bagaimana Anda menemukan konfigurasi terbaik ("resep" terbaik).

3. Evaluasi pada Skala Asli (Cell 3)

Ini poin krusial untuk validitas data. Penguji sering bertanya: "Anda hitung error pakai data 0-1 atau data asli?"

4. Visualisasi & Diagnostik Model (Cell 4)

Bagian ini adalah "bukti visual" performa model.


Naskah Penjelasan Singkat

"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