Lewati ke isi

Forecasting dengan Regresi dan Fitur Lag

Gambaran singkat

Apa ini? Meramal dengan model regresi (Ridge, Random Forest) memakai tabel fitur lag.

Analogi

Seperti meramal harga memakai "harga sebulan lalu, tiga bulan lalu, dan setahun lalu" sebagai bahan, lalu model regresi biasa menghitung hasilnya.

Mengapa penting? Ramalan jauh ke depan membutuhkan nilai bulan-bulan yang belum terjadi, sehingga kita memakai ramalan sendiri sebagai masukan. Cara ini punya risiko yang perlu dipahami.

Yang akan dipelajari, berurutan:

  1. Membangun model dari tabel fitur lag.
  2. Prediksi satu langkah vs rekursif multi-langkah.
  3. Mengapa model pohon perlu target selisih pada deret bertren.

Istilah awal:

Istilah Arti sederhana
Prediksi rekursif Hasil prediksi dimasukkan lagi sebagai masukan langkah berikutnya
Target selisih Memodelkan perubahan nilai, bukan nilai itu sendiri
Ekstrapolasi Menaksir di luar rentang data latih

Tujuan pembelajaran

  • Membangun model forecasting dari tabel fitur lag dengan Ridge dan Random Forest.
  • Membedakan prediksi satu langkah dan prediksi rekursif multi-langkah.
  • Menjelaskan mengapa model berbasis pohon memerlukan target selisih pada deret bertren.

Konsep

Setelah deret diubah menjadi tabel fitur (lesson fitur), model regresi apa pun dapat dipakai. Dua hal khusus forecasting:

  1. Prediksi multi-langkah. Fitur lag untuk bulan berikutnya memerlukan nilai bulan ini, yang pada saat prediksi belum diketahui. Pada prediksi rekursif, hasil prediksi dimasukkan kembali sebagai lag. Galat menumpuk seiring horizon. Alternatifnya, pendekatan langsung melatih satu model per horizon.
  2. Tren dan model pohon. Pohon dan hutan memprediksi rata-rata nilai target di daun, sehingga tidak dapat memprediksi di luar rentang target latih. Pada deret yang terus naik, cara umum adalah memprediksi selisih \(y_t - y_{t-1}\), lalu menambahkannya kembali ke level terakhir.

Implementasi langkah demi langkah

CO2 bulanan, fitur: lag 1, 2, 3, 12 dan sin/cos bulan. Model dilatih pada data sampai 1997-12 dan dievaluasi pada 24 bulan validasi dengan dua cara: 1-langkah (lag memakai data aktual) dan 24-langkah rekursif (realistis untuk peramalan). Program examples/forecasting/regression_forecasting.py; program lengkap ada di akhir bagian ini.

Langkah 1: fungsi pembuat fitur untuk satu bulan

Tujuan. Membuat satu baris fitur untuk bulan date yang hanya memakai data sebelum bulan itu.

regression_forecasting.py
y = load_co2_monthly()
test, valid, train = y.iloc[-24:], y.iloc[-48:-24], y.iloc[:-48]
LAGS = [1, 2, 3, 12]


def make_row(history, date):
    """Fitur untuk bulan `date` memakai HANYA data di `history` (sebelum date)."""
    v = history.to_numpy()
    row = [v[-k] for k in LAGS]
    row += [np.sin(2 * np.pi * date.month / 12), np.cos(2 * np.pi * date.month / 12)]
    return row
Kode Penjelasan
LAGS = [1, 2, 3, 12] Lag yang dipakai: 1, 2, 3, dan 12 bulan lalu.
v = history.to_numpy() Riwayat sebagai array; v[-k] adalah nilai k bulan sebelum bulan yang diprediksi (indeks negatif dari belakang).
row = [v[-k] for k in LAGS] Empat fitur lag.
row += [np.sin(...), np.cos(...)] Dua fitur kalender (bulan sebagai lingkaran). += menambahkan elemen ke daftar.

Karena make_row hanya menerima history, fiturnya tidak mungkin memuat masa depan.

Langkah 2: tabel fitur–target untuk pelatihan

Konsep. Untuk target selisih (use_diff=True), model memprediksi perubahan \(y_t - y_{t-1}\) lalu menambahkannya ke nilai terakhir. Untuk target level, model memprediksi \(y_t\) langsung.

regression_forecasting.py
def build_xy(series, use_diff):
    """Tabel fitur-target dari seluruh `series`. Target: level, atau selisih terhadap bulan lalu."""
    X, t = [], []
    for i in range(max(LAGS), len(series)):
        X.append(make_row(series.iloc[:i], series.index[i]))
        t.append(series.iloc[i] - series.iloc[i - 1] if use_diff else series.iloc[i])
    return np.array(X), np.array(t)

Perulangan berjalan untuk tiap bulan i (mulai dari max(LAGS) = 12, karena baris awal belum punya lag lengkap). series.iloc[:i] adalah riwayat sebelum bulan i, jadi fitur selalu berasal dari masa lalu. series.iloc[i] - series.iloc[i - 1] if use_diff else series.iloc[i] memilih target selisih atau level (ekspresi kondisional satu baris). Hasilnya diubah menjadi array NumPy X dan t.

Langkah 3: prediksi rekursif multi-langkah

Konsep. Untuk meramal 24 bulan, fitur bulan berikutnya memerlukan nilai bulan ini yang belum diketahui. Solusinya: hasil prediksi dimasukkan kembali sebagai riwayat untuk langkah berikutnya. Galat dapat menumpuk seiring horizon.

regression_forecasting.py
def recursive_forecast(model, history, horizon, use_diff):
    """Prediksi bertahap: hasil bulan ini dimasukkan sebagai lag bulan berikutnya."""
    hist = history.copy()
    out = []
    for _ in range(horizon):
        date = hist.index[-1] + pd.offsets.MonthBegin(1)
        x = np.array([make_row(hist, date)])
        p = model.predict(x)[0]
        value = hist.iloc[-1] + p if use_diff else p
        out.append(value)
        hist = pd.concat([hist, pd.Series([value], index=[date])])
    return np.array(out)
Kode Penjelasan
hist = history.copy() Salinan agar riwayat asli tidak berubah.
date = hist.index[-1] + pd.offsets.MonthBegin(1) Tanggal bulan berikutnya (satu awal-bulan setelah tanggal terakhir).
p = model.predict(x)[0] Prediksi satu langkah (satu angka).
value = hist.iloc[-1] + p if use_diff else p Bila target selisih, nilai = nilai terakhir + selisih terprediksi; bila level, nilai = prediksi.
hist = pd.concat([hist, pd.Series([value], index=[date])]) Menambahkan prediksi ke riwayat, sehingga menjadi lag untuk langkah berikutnya.

Langkah 4: mengevaluasi dua cara

regression_forecasting.py
def evaluate(name, model, use_diff):
    X, t = build_xy(train, use_diff)
    model.fit(X, t)
    one_step = []  # prediksi satu langkah: lag diambil dari data AKTUAL
    full = pd.concat([train, valid])
    for i in range(len(train), len(full)):
        x = np.array([make_row(full.iloc[:i], full.index[i])])
        p = model.predict(x)[0]
        one_step.append(full.iloc[i - 1] + p if use_diff else p)
    multi = recursive_forecast(model, train, len(valid), use_diff)
    print(f"{name:<34} 1-langkah MAE {mae(valid, one_step):5.2f} | 24-langkah rekursif MAE {mae(valid, multi):5.2f} "
          f"| MASE {mase(valid, multi, train):.2f}")
    return multi

evaluate melatih model pada train, lalu menghitung dua hal pada valid: prediksi 1-langkah (untuk tiap bulan validasi, lag diambil dari data aktual, jadi hanya memeriksa kemampuan meramal satu bulan ke depan) dan prediksi rekursif 24 langkah (lag memakai prediksi sebelumnya; ini sesuai kebutuhan peramalan nyata). MAE dan MASE dicetak.

Langkah 5: membandingkan empat konfigurasi

regression_forecasting.py
print("Validasi 24 bulan, metrik dalam ppm")
evaluate("Ridge, target level", make_pipeline(StandardScaler(), Ridge(alpha=1.0)), use_diff=False)
evaluate("Random Forest, target level", RandomForestRegressor(n_estimators=200, random_state=42), use_diff=False)
evaluate("Ridge, target selisih", make_pipeline(StandardScaler(), Ridge(alpha=1.0)), use_diff=True)
evaluate("Random Forest, target selisih", RandomForestRegressor(n_estimators=200, random_state=42), use_diff=True)

sn = seasonal_naive(train, 24)
print(f"{'Seasonal naive (pembanding)':<34} {'':<26}  24-langkah MAE {mae(valid, sn):5.2f} | MASE {mase(valid, sn, train):.2f}")
print("Rentang CO2 data latih: %.1f - %.1f | rentang validasi: %.1f - %.1f" % (
    train.min(), train.max(), valid.min(), valid.max()))

Empat konfigurasi: Ridge dan Random Forest, masing-masing pada target level dan target selisih. Baris terakhir mencetak rentang nilai CO2 pada data latih dan validasi, untuk menjelaskan hasil pohon.

Validasi 24 bulan, metrik dalam ppm
Ridge, target level                1-langkah MAE  0.50 | 24-langkah rekursif MAE  1.07 | MASE 0.86
Random Forest, target level        1-langkah MAE  2.17 | 24-langkah rekursif MAE  2.41 | MASE 1.93
Ridge, target selisih              1-langkah MAE  0.42 | 24-langkah rekursif MAE  0.97 | MASE 0.78
Random Forest, target selisih      1-langkah MAE  0.22 | 24-langkah rekursif MAE  0.64 | MASE 0.51
Seasonal naive (pembanding)                                    24-langkah MAE  3.72 | MASE 2.98
Rentang CO2 data latih: 313.4 - 366.7 | rentang validasi: 363.9 - 371.0

Interpretasi.

  • Random Forest pada target level gagal: MAE 1-langkah 2,17 dan rekursif 2,41 (MASE 1,93), bahkan lebih buruk dari Ridge. Rentang CO2 data latih berakhir di 366,7 ppm sedangkan validasi mencapai 371,0: hutan tidak dapat memprediksi di atas rentang latihnya.
  • Target selisih memperbaiki Random Forest secara dramatis: MAE 1-langkah 0,22 dan rekursif 0,64 (MASE 0,51), terbaik di antara semua model pada tabel ini. Tren ditangani oleh penjumlahan selisih, sedangkan hutan hanya mempelajari pola musiman dan perubahan.
  • Ridge (model linear) dapat mengekstrapolasi, sehingga baik pada level (rekursif MAE 1,07; MASE 0,86) dan sedikit lebih baik pada selisih (0,97; MASE 0,78).
  • Galat rekursif lebih besar dari galat 1-langkah pada semua model (misalnya 0,64 vs 0,22): kesalahan awal terbawa ke langkah berikutnya. Menilai model hanya dengan prediksi 1-langkah terlalu optimistis untuk peramalan 24 bulan.
  • Pembanding: seasonal naive memberi MAE 3,72 (MASE 2,98), dan Holt-Winters 1,37 pada validasi yang sama (lihat baseline). Namun hasil ini satu titik asal pada satu deret yang halus; belum cukup untuk menyatakan model pohon "terbaik" (lihat perbandingan).
Program lengkap (regression_forecasting.py)
regression_forecasting.py
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 forecast_utils import mae, mase, rmse, seasonal_naive, load_co2_monthly

y = load_co2_monthly()
test, valid, train = y.iloc[-24:], y.iloc[-48:-24], y.iloc[:-48]
LAGS = [1, 2, 3, 12]


def make_row(history, date):
    """Fitur untuk bulan `date` memakai HANYA data di `history` (sebelum date)."""
    v = history.to_numpy()
    row = [v[-k] for k in LAGS]
    row += [np.sin(2 * np.pi * date.month / 12), np.cos(2 * np.pi * date.month / 12)]
    return row


def build_xy(series, use_diff):
    """Tabel fitur-target dari seluruh `series`. Target: level, atau selisih terhadap bulan lalu."""
    X, t = [], []
    for i in range(max(LAGS), len(series)):
        X.append(make_row(series.iloc[:i], series.index[i]))
        t.append(series.iloc[i] - series.iloc[i - 1] if use_diff else series.iloc[i])
    return np.array(X), np.array(t)


def recursive_forecast(model, history, horizon, use_diff):
    """Prediksi bertahap: hasil bulan ini dimasukkan sebagai lag bulan berikutnya."""
    hist = history.copy()
    out = []
    for _ in range(horizon):
        date = hist.index[-1] + pd.offsets.MonthBegin(1)
        x = np.array([make_row(hist, date)])
        p = model.predict(x)[0]
        value = hist.iloc[-1] + p if use_diff else p
        out.append(value)
        hist = pd.concat([hist, pd.Series([value], index=[date])])
    return np.array(out)


def evaluate(name, model, use_diff):
    X, t = build_xy(train, use_diff)
    model.fit(X, t)
    one_step = []  # prediksi satu langkah: lag diambil dari data AKTUAL
    full = pd.concat([train, valid])
    for i in range(len(train), len(full)):
        x = np.array([make_row(full.iloc[:i], full.index[i])])
        p = model.predict(x)[0]
        one_step.append(full.iloc[i - 1] + p if use_diff else p)
    multi = recursive_forecast(model, train, len(valid), use_diff)
    print(f"{name:<34} 1-langkah MAE {mae(valid, one_step):5.2f} | 24-langkah rekursif MAE {mae(valid, multi):5.2f} "
          f"| MASE {mase(valid, multi, train):.2f}")
    return multi


print("Validasi 24 bulan, metrik dalam ppm")
evaluate("Ridge, target level", make_pipeline(StandardScaler(), Ridge(alpha=1.0)), use_diff=False)
evaluate("Random Forest, target level", RandomForestRegressor(n_estimators=200, random_state=42), use_diff=False)
evaluate("Ridge, target selisih", make_pipeline(StandardScaler(), Ridge(alpha=1.0)), use_diff=True)
evaluate("Random Forest, target selisih", RandomForestRegressor(n_estimators=200, random_state=42), use_diff=True)

sn = seasonal_naive(train, 24)
print(f"{'Seasonal naive (pembanding)':<34} {'':<26}  24-langkah MAE {mae(valid, sn):5.2f} | MASE {mase(valid, sn, train):.2f}")
print("Rentang CO2 data latih: %.1f - %.1f | rentang validasi: %.1f - %.1f" % (
    train.min(), train.max(), valid.min(), valid.max()))

Kesalahan umum

Hindari

  • Memakai model pohon pada level deret bertren tanpa menyadari batas ekstrapolasinya.
  • Mengevaluasi hanya dengan prediksi 1-langkah padahal kebutuhannya multi-langkah.
  • Memakai train_test_split acak untuk tabel fitur lag.
  • Menghitung fitur lag dari nilai prediksi yang bukan hasil rekursi sesungguhnya saat evaluasi multi-langkah.

Latihan

  1. Tambahkan lag_24 dan lihat pengaruhnya.
  2. Bandingkan GradientBoostingRegressor pada target selisih.
  3. Buat pendekatan langsung: satu model per horizon 1..12. Bandingkan dengan rekursif.

Ringkasan

Forecasting dengan regresi membutuhkan fitur yang hanya memakai masa lalu, strategi multi-langkah (rekursif atau langsung), dan penanganan tren (target selisih untuk model pohon). Nilai model dengan prediksi multi-langkah yang realistis.

Berikutnya: ARIMA dan SARIMA.