Lewati ke isi

Perbandingan Model Regresi

Gambaran singkat

Apa ini? Membandingkan beberapa model regresi dengan data, lipatan, dan metrik yang sama.

Analogi

Seperti uji coba beberapa mobil di jalur yang sama dan kondisi yang sama sebelum memilih.

Mengapa penting? Tidak ada model terbaik untuk semua data. Perbandingan hanya adil jika kondisi uji sama, dan pemilihan juga mempertimbangkan kestabilan serta kemudahan dijelaskan.

Yang akan dipelajari, berurutan:

  1. Sifat umum tiap model dalam satu tabel.
  2. Prosedur perbandingan yang adil.
  3. Membaca MAE, RMSE, R² bersama sebaran antar-lipatan.
  4. Memilih model.

Istilah awal:

Istilah Arti sederhana
Lipatan (fold) Satu potongan data pada validasi silang
Stabilitas Skor tidak berubah-ubah antar-lipatan
Interpretabilitas Seberapa mudah model dijelaskan

Tujuan pembelajaran

  • Membandingkan model regresi dengan lipatan dan metrik yang sama.
  • Menafsirkan MAE, RMSE, dan R² bersama sebaran antar-lipatan.
  • Memilih model dengan mempertimbangkan akurasi, stabilitas, dan kebutuhan interpretasi.

Ringkasan sifat model

Aspek Linear Ridge / Lasso KNN Decision Tree Random Forest
Bentuk hubungan Linear Linear (teregularisasi) Lokal Tangga Tangga (rata-rata)
Perlu scaling Disarankan Wajib Wajib Tidak Tidak
Ekstrapolasi Ya (linear) Ya Tidak Tidak Tidak
Interpretabilitas Tinggi Tinggi Rendah Tinggi (kecil) Rendah
Risiko overfitting Naik dengan jumlah fitur Dikendalikan alpha Tinggi bila k kecil Tinggi bila dalam Sedang
Hyperparameter kunci — alpha n_neighbors max_depth, min_samples_leaf n_estimators, min_samples_leaf

Sifat ini bersifat umum; performa sebenarnya bergantung pada data.

Prosedur

Data uji dipisahkan lebih dulu. Semua model dievaluasi pada data latih dengan RepeatedKFold (5 lipatan × 3 pengulangan = 15 skor per model) dan metrik yang sama (MAE, RMSE, R²). Data uji dipakai sekali untuk model terpilih.

Implementasi langkah demi langkah

Dataset Diabetes; pemuatan dan pembagian data sama dengan pelajaran regresi linear. Program examples/estimation/model_comparison.py; program lengkap ada di akhir bagian ini.

Langkah 1: mendefinisikan kandidat model

Konsep. Semua model disimpan dalam kamus (nama → model) agar dapat dinilai dengan perulangan yang sama. Model yang sensitif pada skala (linear teregularisasi, KNN) dimasukkan ke Pipeline dengan StandardScaler; pohon dan hutan tidak memerlukannya.

model_comparison.py
X, y = load_diabetes(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=SEED)

models = {
    "Baseline (rata-rata)": DummyRegressor(strategy="mean"),
    "Linear Regression": make_pipeline(StandardScaler(), LinearRegression()),
    "Ridge (alpha=10)": make_pipeline(StandardScaler(), Ridge(alpha=10)),
    "Lasso (alpha=0.5)": make_pipeline(StandardScaler(), Lasso(alpha=0.5)),
    "KNN (k=20)": make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=20)),
    "Decision Tree (depth=3)": DecisionTreeRegressor(max_depth=3, min_samples_leaf=5, random_state=SEED),
    "Random Forest": RandomForestRegressor(n_estimators=200, min_samples_leaf=5, random_state=SEED),
}

Daftar ini mencakup baseline rata-rata, tiga model linear, dan tiga model non-linear. Nilai hyperparameter (alpha, k, max_depth) dipilih dari pelajaran sebelumnya; semua model baru diinisialisasi, belum dilatih.

Langkah 2: validasi silang berulang dan beberapa metrik

model_comparison.py
# Lipatan yang sama untuk semua model: 5 lipatan x 3 pengulangan = 15 skor per model
cv = RepeatedKFold(n_splits=5, n_repeats=3, random_state=SEED)
scoring = {"mae": "neg_mean_absolute_error", "rmse": "neg_root_mean_squared_error", "r2": "r2"}
Kode Penjelasan
RepeatedKFold(n_splits=5, n_repeats=3, random_state=SEED) Validasi silang 5 lipatan diulang 3 kali dengan pengacakan berbeda = 15 skor per model; objek cv yang sama dipakai untuk semua model sehingga lipatannya identik.
scoring = {...} Kamus tiga metrik: neg_mean_absolute_error (MAE negatif), neg_root_mean_squared_error (RMSE negatif), dan r2.

Langkah 3: menjalankan perbandingan

model_comparison.py
rows = []
for name, model in models.items():
    s = cross_validate(model, X_train, y_train, cv=cv, scoring=scoring)
    rows.append({"Model": name, "MAE": -s["test_mae"].mean(), "RMSE": -s["test_rmse"].mean(),
                 "R2": s["test_r2"].mean(), "Std RMSE": s["test_rmse"].std()})
results = pd.DataFrame(rows).set_index("Model")
print(results.round(2).to_string())

cross_validate mengembalikan kamus skor per lipatan dengan kunci test_mae, test_rmse, test_r2. Tanda minus pada -s["test_mae"] mengembalikan skor negatif menjadi galat positif. Std RMSE adalah simpangan baku RMSE antar 15 lipatan, yaitu ukuran kestabilan.

                           MAE   RMSE    R2  Std RMSE
Model                                                
Baseline (rata-rata)     66.84  78.31 -0.04      4.75
Linear Regression        44.93  55.23  0.47      3.53
Ridge (alpha=10)         44.97  55.30  0.47      3.38
Lasso (alpha=0.5)        44.95  55.29  0.47      3.39
KNN (k=20)               48.61  59.04  0.41      4.08
Decision Tree (depth=3)  52.81  65.43  0.26      3.80
Random Forest            47.89  58.48  0.41      3.93

Interpretasi.

  • Semua model mengalahkan baseline (RMSE 78,31; R² -0,04).
  • Keluarga linear imbang: Linear (55,23), Ridge (55,30), dan Lasso (55,29) berbeda jauh lebih kecil daripada simpangan baku antar-lipatan (3,4–3,5). Regularisasi ringan tidak mengubah apa-apa pada 10 fitur ini.
  • KNN (59,04) dan Random Forest (58,48) sedikit di bawah model linear; Decision Tree kedalaman 3 paling lemah (RMSE 65,43; R² 0,26): dengan 8 daun, prediksinya hanya 8 nilai berbeda, kasar untuk target kontinu, sedangkan pohon yang lebih dalam bervarians tinggi.
  • Bacaan bersama metrik: MAE sekitar 45 berarti galat rata-rata 45 satuan target (yang simpangan bakunya 77); RMSE selalu ≥ MAE, dan selisih besar menandakan adanya galat besar yang sesekali.

Langkah 4: memilih model dan menguji sekali

model_comparison.py
# Model terpilih: RMSE CV terendah; data uji dipakai satu kali
best = results["RMSE"].idxmin()
pred = models[best].fit(X_train, y_train).predict(X_test)
print("\nModel terpilih:", best)
print("Uji -> MAE %.2f | RMSE %.2f | R2 %.3f" % (
    mean_absolute_error(y_test, pred), mean_squared_error(y_test, pred) ** 0.5, r2_score(y_test, pred)))

results["RMSE"].idxmin() mengembalikan nama model dengan RMSE terendah; model itu dilatih pada seluruh data latih dan diuji pada data uji sekali saja.

Model terpilih: Linear Regression
Uji -> MAE 42.79 | RMSE 53.85 | R2 0.453

Interpretasi. Linear Regression terpilih; pada data uji MAE 42,79, RMSE 53,85, R² 0,453. Karena Ridge dan Lasso nyaris sama, memilih yang paling sederhana pun masuk akal. Mengapa model linear cukup baik di sini? Kemungkinan hubungan fitur–target pada dataset ini mendekati linear dengan derau besar, dan 353 data latih terlalu sedikit bagi model fleksibel untuk memanfaatkan non-linearitas. Ini kesimpulan untuk dataset ini; bukan aturan umum.

Program lengkap (model_comparison.py)
model_comparison.py
import pandas as pd
from sklearn.datasets import load_diabetes
from sklearn.dummy import DummyRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import Lasso, LinearRegression, Ridge
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import RepeatedKFold, cross_validate, train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeRegressor

SEED = 42
X, y = load_diabetes(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=SEED)

models = {
    "Baseline (rata-rata)": DummyRegressor(strategy="mean"),
    "Linear Regression": make_pipeline(StandardScaler(), LinearRegression()),
    "Ridge (alpha=10)": make_pipeline(StandardScaler(), Ridge(alpha=10)),
    "Lasso (alpha=0.5)": make_pipeline(StandardScaler(), Lasso(alpha=0.5)),
    "KNN (k=20)": make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=20)),
    "Decision Tree (depth=3)": DecisionTreeRegressor(max_depth=3, min_samples_leaf=5, random_state=SEED),
    "Random Forest": RandomForestRegressor(n_estimators=200, min_samples_leaf=5, random_state=SEED),
}

# Lipatan yang sama untuk semua model: 5 lipatan x 3 pengulangan = 15 skor per model
cv = RepeatedKFold(n_splits=5, n_repeats=3, random_state=SEED)
scoring = {"mae": "neg_mean_absolute_error", "rmse": "neg_root_mean_squared_error", "r2": "r2"}

rows = []
for name, model in models.items():
    s = cross_validate(model, X_train, y_train, cv=cv, scoring=scoring)
    rows.append({"Model": name, "MAE": -s["test_mae"].mean(), "RMSE": -s["test_rmse"].mean(),
                 "R2": s["test_r2"].mean(), "Std RMSE": s["test_rmse"].std()})
results = pd.DataFrame(rows).set_index("Model")
print(results.round(2).to_string())

# Model terpilih: RMSE CV terendah; data uji dipakai satu kali
best = results["RMSE"].idxmin()
pred = models[best].fit(X_train, y_train).predict(X_test)
print("\nModel terpilih:", best)
print("Uji -> MAE %.2f | RMSE %.2f | R2 %.3f" % (
    mean_absolute_error(y_test, pred), mean_squared_error(y_test, pred) ** 0.5, r2_score(y_test, pred)))

Kesalahan umum

Hindari

  • Membandingkan model dengan pembagian data atau metrik berbeda.
  • Mengabaikan sebaran antar-lipatan (Std RMSE) saat selisih kecil.
  • Menyimpulkan model fleksibel selalu lebih baik.
  • Memilih model berdasarkan data uji berulang.

Latihan

  1. Tambahkan RandomForestRegressor(min_samples_leaf=10) dan Ridge(alpha=100) ke daftar. Apakah kesimpulan berubah?
  2. Ganti SEED. Apakah urutan model dengan RMSE terendah tetap sama?
  3. Bandingkan hasil ketika target diubah menjadi log(target) untuk semua model (gunakan TransformedTargetRegressor).

Ringkasan

Bandingkan model dengan lipatan dan metrik yang sama; baca selisih skor relatif terhadap sebarannya. Pada data ini keluarga linear sudah memadai; model fleksibel belum tentu lebih baik.

Berikutnya: Metrik Regresi dan Analisis Residual.