Lewati ke isi

Perbandingan dan Optimasi Model Forecasting

Gambaran singkat

Apa ini? Membandingkan beberapa metode peramalan secara adil dan menyetel pengaturannya tanpa memakai data uji.

Analogi

Beberapa pelari dites di lintasan dan waktu yang sama, bukan satu kali lari saja, sebelum memilih yang terbaik.

Mengapa penting? Skor dari satu titik asal bisa kebetulan. Perbandingan yang adil memakai banyak titik asal dan memperhatikan sebarannya.

Yang akan dipelajari, berurutan:

  1. Ringkasan kekuatan dan batas tiap metode.
  2. Perbandingan dengan rolling origin yang sama.
  3. Menyetel varian model tanpa menyentuh data uji.
  4. Memutuskan model terpilih.

Istilah awal:

Istilah Arti sederhana
Rolling origin Menguji berulang dengan titik awal yang bergeser
Holt-Winters Exponential smoothing dengan tren dan musiman
Sebaran antar titik asal Seberapa bervariasi galat antar-pengujian

Tujuan pembelajaran

  • Membandingkan banyak metode forecasting dengan rolling origin yang sama.
  • Mengoptimasi varian model tanpa memakai data uji.
  • Memutuskan model terpilih dengan mempertimbangkan sebaran antar titik asal.

Ringkasan metode

Metode Prinsip Kekuatan Keterbatasan
Seasonal naive Salin musim yang sama tahun lalu Sederhana, baseline wajib Tidak menangkap tren
Drift Ekstrapolasi garis lurus Menangkap tren Tanpa musiman
Holt-Winters Tingkat, tren, musiman yang dihaluskan Cepat, sedikit parameter Perlu pilihan aditif/multiplikatif dan peredaman tren
SARIMA Autoregresi dan rata-rata bergerak pada deret terdiferensiasi Interval prediksi, teori matang Penyetelan orde, asumsi linear
Regresi + fitur lag Tabel lag dan kalender dengan Ridge/Random Forest Fleksibel, fitur eksternal Perlu strategi multi-langkah dan penanganan tren

Prosedur

  1. Sisihkan 24 bulan terakhir sebagai data uji dan jangan dipakai selama pemilihan.
  2. Evaluasi semua kandidat pada 6 titik asal (data latih berakhir 1993-12 sampai 1998-12), masing-masing horizon 12 bulan, yang prediksinya tidak menyentuh data uji.
  3. Bandingkan MAE rata-rata dan sebarannya antar-asal.
  4. Pilih satu metode, lalu evaluasi sekali pada data uji bersama baseline seasonal naive.

Optimasi dilakukan dengan membandingkan varian pada titik asal yang sama: Holt-Winters aditif vs multiplikatif vs tren teredam, dan Ridge dengan alpha 0,1 vs 10. (Untuk penyetelan fitur ML secara lebih luas, gunakan TimeSeriesSplit agar validasi tetap kronologis.)

Implementasi langkah demi langkah

Program examples/forecasting/comparison_optimization.py. Sembilan metode dibandingkan pada titik asal yang sama. Program lengkap ada di akhir bagian ini.

Langkah 1: fungsi prediksi berbasis regresi (selisih bulanan)

Tujuan. Membungkus model ML (Ridge, Random Forest) menjadi fungsi ml_forecast(model, history, horizon) yang bentuknya sama dengan metode statistik, sehingga semua metode dapat dinilai dalam satu perulangan. Idenya sama dengan pelajaran regresi untuk forecasting: fitur lag dari selisih bulanan dan prediksi rekursif.

comparison_optimization.py
y = load_co2_monthly()
LAGS = [1, 2, 3, 12]


def ml_forecast(make_model, history, horizon):
    """Prediksi rekursif dengan fitur lag dari selisih bulanan + bulan (hanya masa lalu)."""
    d = history.diff()
    X = pd.DataFrame({f"lag_{k}": d.shift(k) for k in LAGS})
    X["sin"], X["cos"] = np.sin(2 * np.pi * X.index.month / 12), np.cos(2 * np.pi * X.index.month / 12)
    ok = X.notna().all(axis=1) & d.notna()
    model = make_model().fit(X[ok], d[ok])
    diffs, level, date, out = list(d.dropna()), history.iloc[-1], history.index[-1], []
    for _ in range(horizon):
        date = date + pd.offsets.MonthBegin(1)
        row = [diffs[-k] for k in LAGS] + [np.sin(2 * np.pi * date.month / 12), np.cos(2 * np.pi * date.month / 12)]
        step = model.predict(pd.DataFrame([row], columns=X.columns))[0]
        diffs.append(step)
        level += step
        out.append(level)
    return np.array(out)
Kode Penjelasan
d = history.diff() Selisih bulanan; ini target.
X = pd.DataFrame({f"lag_{k}": d.shift(k) for k in LAGS}) Fitur lag dari selisih, hanya memakai masa lalu.
ok = X.notna().all(axis=1) & d.notna() Baris yang fitur dan targetnya lengkap (membuang baris awal yang kosong).
model = make_model().fit(X[ok], d[ok]) make_model adalah fungsi pembuat model (misalnya lambda: Ridge(alpha=10)); dipanggil () untuk membuat model baru lalu dilatih.
for _ in range(horizon): ... Prediksi rekursif: tiap langkah memakai selisih terakhir (termasuk prediksi sebelumnya) sebagai lag, lalu level += step mengakumulasi selisih menjadi level.

Langkah 2: pabrik Holt-Winters dan daftar metode

comparison_optimization.py
def hw(trend, damped, seasonal):
    return lambda tr, h: ExponentialSmoothing(tr, trend=trend, damped_trend=damped, seasonal=seasonal, seasonal_periods=12,
                                              initialization_method="estimated").fit().forecast(h).to_numpy()


methods = {
    "Seasonal naive": lambda tr, h: seasonal_naive(tr, h),
    "Drift": lambda tr, h: tr.iloc[-1] + (tr.iloc[-1] - tr.iloc[0]) / (len(tr) - 1) * np.arange(1, h + 1),
    "HW aditif": hw("add", False, "add"),
    "HW aditif, tren teredam": hw("add", True, "add"),
    "HW musiman multiplikatif": hw("add", False, "mul"),
    "SARIMA (1,1,1)(0,1,1,12)": lambda tr, h: SARIMAX(tr, order=(1, 1, 1), seasonal_order=(0, 1, 1, 12)).fit(disp=False).forecast(h).to_numpy(),
    "Ridge alpha=0.1 (selisih)": lambda tr, h: ml_forecast(lambda: make_pipeline(StandardScaler(), Ridge(alpha=0.1)), tr, h),
    "Ridge alpha=10 (selisih)": lambda tr, h: ml_forecast(lambda: make_pipeline(StandardScaler(), Ridge(alpha=10)), tr, h),
    "Random Forest (selisih)": lambda tr, h: ml_forecast(lambda: RandomForestRegressor(n_estimators=100, random_state=42), tr, h),
}

hw(trend, damped, seasonal) mengembalikan sebuah fungsi lambda tr, h: ... yang melatih Holt-Winters dengan pengaturan tersebut; dengan begitu varian aditif, teredam, dan multiplikatif dibuat dari satu definisi. methods adalah kamus nama → fungsi(riwayat, horizon): setiap metode, apa pun jenisnya, dipanggil dengan cara yang sama. Varian yang dibandingkan di sini sekaligus menjadi bentuk sederhana optimasi model: Holt-Winters aditif vs teredam vs musiman multiplikatif, dan Ridge alpha 0,1 vs 10.

Langkah 3: titik asal pengembangan

Konsep. Data uji (24 bulan terakhir) tidak boleh disentuh selama pemilihan. Titik asal dipilih sehingga prediksi 12 bulannya berakhir paling lambat di akhir data pengembangan.

comparison_optimization.py
# Data uji: 24 bulan terakhir (disimpan). Pemilihan memakai titik asal yang prediksinya TIDAK menyentuh data uji.
n_dev_end = len(y) - 24
dev_origins = [n_dev_end - 12 - 12 * k for k in range(5, -1, -1)]  # 6 titik asal, horizon 12
print("titik asal pengembangan:", y.index[dev_origins[0] - 1].strftime("%Y-%m"), "...", y.index[dev_origins[-1] - 1].strftime("%Y-%m"))
titik asal pengembangan: 1993-12 ... 1998-12

Enam titik asal dari 1993-12 sampai 1998-12; prediksinya paling jauh sampai 1999-12, sebelum data uji (2000–2001).

Langkah 4: menilai semua metode pada semua titik asal

comparison_optimization.py
rows = []
for name, fn in methods.items():
    maes, rmses, mases = [], [], []
    for end in dev_origins:
        tr, actual = y.iloc[:end], y.iloc[end:end + 12]
        pred = fn(tr, 12)
        maes.append(mae(actual, pred)); rmses.append(rmse(actual, pred)); mases.append(mase(actual, pred, tr))
    rows.append({"Metode": name, "MAE": np.mean(maes), "Std MAE": np.std(maes), "RMSE": np.mean(rmses), "MASE": np.mean(mases)})
table = pd.DataFrame(rows).set_index("Metode").sort_values("MAE")
print(table.round(2).to_string())

Perulangan luar melewati metode, perulangan dalam melewati titik asal. Pada tiap titik asal, fn(tr, 12) memprediksi 12 bulan memakai hanya tr (data sampai titik asal). MAE, RMSE, dan MASE dikumpulkan; tabel meringkas rata-rata dan simpangan baku MAE antar titik asal (Std MAE), lalu diurutkan menurut MAE.

                            MAE  Std MAE  RMSE  MASE
Metode                                              
HW musiman multiplikatif   0.49     0.24  0.57  0.39
SARIMA (1,1,1)(0,1,1,12)   0.51     0.27  0.58  0.41
Random Forest (selisih)    0.52     0.36  0.59  0.42
HW aditif                  0.57     0.30  0.64  0.46
Ridge alpha=10 (selisih)   0.59     0.32  0.67  0.47
HW aditif, tren teredam    0.59     0.30  0.67  0.48
Ridge alpha=0.1 (selisih)  0.60     0.33  0.67  0.48
Seasonal naive             1.87     0.54  1.93  1.51
Drift                      2.06     0.07  2.39  1.66

Interpretasi.

  • Seasonal naive (MAE 1,87) dan drift (2,06) jauh tertinggal. Semua metode lain berada di kisaran 0,49–0,60 (MASE 0,39–0,48).
  • Tujuh metode teratas tidak dapat dibedakan. Selisih MAE rata-rata antar mereka (0,49 sampai 0,60) lebih kecil dari simpangan baku antar-asal (0,24–0,36). Urutan bisa berubah bila titik asal diganti.
  • Pemilihan: Holt-Winters musiman multiplikatif memiliki MAE rata-rata terendah (0,49 ± 0,24; MASE 0,39), disusul SARIMA (0,51 ± 0,27) dan Random Forest berbasis selisih (0,52 ± 0,36). Random Forest memiliki sebaran terbesar, tanda hasilnya kurang stabil antar-asal.
  • Optimasi varian memberi perubahan kecil: HW aditif 0,57, tren teredam 0,59, multiplikatif 0,49; Ridge alpha=10 0,59 vs alpha=0,1 0,60. Dengan hanya 6 titik asal, selisih seperti ini belum bermakna.

Langkah 5: evaluasi akhir sekali pada data uji

comparison_optimization.py
# Evaluasi akhir: SATU kali pada 24 bulan terakhir untuk metode terpilih dan seasonal naive
best = table.index[0]
train, test = y.iloc[:n_dev_end], y.iloc[n_dev_end:]
print("\nMetode terpilih (MAE pengembangan terendah):", best)
for name in [best, "Seasonal naive"]:
    pred = methods[name](train, 24)
    print(f"Uji 24 bulan  {name:<26} MAE {mae(test, pred):.2f} | RMSE {rmse(test, pred):.2f} | MASE {mase(test, pred, train):.2f}")

table.index[0] adalah nama metode dengan MAE terendah. Metode itu dan seasonal naive dilatih pada seluruh data sebelum 2000 (train) lalu dinilai pada 24 bulan uji sekali; :<26 meratakan nama ke kiri selebar 26 karakter.

Metode terpilih (MAE pengembangan terendah): HW musiman multiplikatif
Uji 24 bulan  HW musiman multiplikatif   MAE 0.44 | RMSE 0.54 | MASE 0.34
Uji 24 bulan  Seasonal naive             MAE 1.88 | RMSE 2.07 | MASE 1.45

Interpretasi. Holt-Winters multiplikatif: MAE 0,44; RMSE 0,54; MASE 0,34, dibanding seasonal naive MAE 1,88; MASE 1,45. Keunggulan atas baseline jelas; keunggulan atas model lain tidak dapat diklaim. Rekomendasi praktis: bila beberapa metode setara, pilih yang paling sederhana, paling cepat, atau yang menyediakan interval prediksi.

Program lengkap (comparison_optimization.py)
comparison_optimization.py
import warnings

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from statsmodels.tsa.holtwinters import ExponentialSmoothing
from statsmodels.tsa.statespace.sarimax import SARIMAX

from forecast_utils import mae, mase, rmse, seasonal_naive, load_co2_monthly

warnings.filterwarnings("ignore")

y = load_co2_monthly()
LAGS = [1, 2, 3, 12]


def ml_forecast(make_model, history, horizon):
    """Prediksi rekursif dengan fitur lag dari selisih bulanan + bulan (hanya masa lalu)."""
    d = history.diff()
    X = pd.DataFrame({f"lag_{k}": d.shift(k) for k in LAGS})
    X["sin"], X["cos"] = np.sin(2 * np.pi * X.index.month / 12), np.cos(2 * np.pi * X.index.month / 12)
    ok = X.notna().all(axis=1) & d.notna()
    model = make_model().fit(X[ok], d[ok])
    diffs, level, date, out = list(d.dropna()), history.iloc[-1], history.index[-1], []
    for _ in range(horizon):
        date = date + pd.offsets.MonthBegin(1)
        row = [diffs[-k] for k in LAGS] + [np.sin(2 * np.pi * date.month / 12), np.cos(2 * np.pi * date.month / 12)]
        step = model.predict(pd.DataFrame([row], columns=X.columns))[0]
        diffs.append(step)
        level += step
        out.append(level)
    return np.array(out)


def hw(trend, damped, seasonal):
    return lambda tr, h: ExponentialSmoothing(tr, trend=trend, damped_trend=damped, seasonal=seasonal, seasonal_periods=12,
                                              initialization_method="estimated").fit().forecast(h).to_numpy()


methods = {
    "Seasonal naive": lambda tr, h: seasonal_naive(tr, h),
    "Drift": lambda tr, h: tr.iloc[-1] + (tr.iloc[-1] - tr.iloc[0]) / (len(tr) - 1) * np.arange(1, h + 1),
    "HW aditif": hw("add", False, "add"),
    "HW aditif, tren teredam": hw("add", True, "add"),
    "HW musiman multiplikatif": hw("add", False, "mul"),
    "SARIMA (1,1,1)(0,1,1,12)": lambda tr, h: SARIMAX(tr, order=(1, 1, 1), seasonal_order=(0, 1, 1, 12)).fit(disp=False).forecast(h).to_numpy(),
    "Ridge alpha=0.1 (selisih)": lambda tr, h: ml_forecast(lambda: make_pipeline(StandardScaler(), Ridge(alpha=0.1)), tr, h),
    "Ridge alpha=10 (selisih)": lambda tr, h: ml_forecast(lambda: make_pipeline(StandardScaler(), Ridge(alpha=10)), tr, h),
    "Random Forest (selisih)": lambda tr, h: ml_forecast(lambda: RandomForestRegressor(n_estimators=100, random_state=42), tr, h),
}

# Data uji: 24 bulan terakhir (disimpan). Pemilihan memakai titik asal yang prediksinya TIDAK menyentuh data uji.
n_dev_end = len(y) - 24
dev_origins = [n_dev_end - 12 - 12 * k for k in range(5, -1, -1)]  # 6 titik asal, horizon 12
print("titik asal pengembangan:", y.index[dev_origins[0] - 1].strftime("%Y-%m"), "...", y.index[dev_origins[-1] - 1].strftime("%Y-%m"))

rows = []
for name, fn in methods.items():
    maes, rmses, mases = [], [], []
    for end in dev_origins:
        tr, actual = y.iloc[:end], y.iloc[end:end + 12]
        pred = fn(tr, 12)
        maes.append(mae(actual, pred)); rmses.append(rmse(actual, pred)); mases.append(mase(actual, pred, tr))
    rows.append({"Metode": name, "MAE": np.mean(maes), "Std MAE": np.std(maes), "RMSE": np.mean(rmses), "MASE": np.mean(mases)})
table = pd.DataFrame(rows).set_index("Metode").sort_values("MAE")
print(table.round(2).to_string())

# Evaluasi akhir: SATU kali pada 24 bulan terakhir untuk metode terpilih dan seasonal naive
best = table.index[0]
train, test = y.iloc[:n_dev_end], y.iloc[n_dev_end:]
print("\nMetode terpilih (MAE pengembangan terendah):", best)
for name in [best, "Seasonal naive"]:
    pred = methods[name](train, 24)
    print(f"Uji 24 bulan  {name:<26} MAE {mae(test, pred):.2f} | RMSE {rmse(test, pred):.2f} | MASE {mase(test, pred, train):.2f}")

Kesalahan umum

Hindari

  • Memilih berdasarkan satu titik asal atau selisih yang lebih kecil dari sebaran.
  • Menyetel parameter dengan titik asal yang menyentuh data uji.
  • Membandingkan metode pada horizon dan data latih yang berbeda.
  • Melaporkan hanya rata-rata tanpa sebaran.

Latihan

  1. Tambahkan SARIMA (0,1,1)(0,1,1,12) dan Holt-Winters dengan seasonal_periods=6. Bagaimana peringkatnya?
  2. Perbanyak titik asal menjadi 10. Apakah urutan kandidat berubah?
  3. Tambahkan model ensambel: rata-rata prediksi HW dan SARIMA. Apakah galatnya lebih kecil?

Ringkasan

Bandingkan metode dengan titik asal yang sama, perhatikan sebaran, dan jaga data uji tetap utuh. Banyak metode yang layak sering setara; keunggulan atas baseline sederhana adalah yang paling penting dibuktikan.

Berikutnya: Menyimpan Model, Deployment, dan Monitoring.