Lewati ke isi

Validasi Silang dan Optimasi Hyperparameter

Gambaran singkat

Apa ini? Menguji dan menyetel model regresi dengan validasi silang yang tepat.

Analogi

Satu ujian tidak cukup menilai murid; beberapa ujian dengan soal berbeda lebih adil. Validasi silang mengulang pengujian pada potongan data berbeda.

Mengapa penting? Skor dari satu pembagian data bisa kebetulan. Validasi silang memberi gambaran lebih stabil, dan pencarian pengaturan terbaik harus dihitung dengan jujur.

Yang akan dipelajari, berurutan:

  1. Validasi silang untuk regresi (tanpa stratifikasi kelas).
  2. Menyetel alpha Ridge dan Random Forest.
  3. Membedakan skor terbaik pencarian dan estimasi jujur (nested CV).

Istilah awal:

Istilah Arti sederhana
KFold Membagi data menjadi lipatan untuk validasi silang
Skor negatif Konvensi scikit-learn: galat ditulis negatif agar makin besar makin baik
Nested CV Validasi silang bersarang untuk estimasi yang tidak optimis

Tujuan pembelajaran

  • Memakai validasi silang yang sesuai untuk regresi.
  • Menyetel Ridge (alpha) dan Random Forest dengan pencarian bervalidasi silang.
  • Membedakan skor terbaik pencarian dan estimasi jujur (nested CV).

Prasyarat

Konsep Grid/Random Search dan nested CV dijelaskan di Optimasi Hyperparameter (Klasifikasi). Di sini fokus pada hal yang spesifik regresi.

Validasi silang untuk regresi

  • Gunakan KFold(shuffle=True, random_state=...) atau RepeatedKFold; tidak ada stratifikasi kelas. Untuk target yang sangat miring, dapat distratifikasi pada kelompok (bin) target.
  • Skor scikit-learn dibuat "makin besar makin baik", sehingga galat dinyatakan negatif: neg_root_mean_squared_error, neg_mean_absolute_error. Ubah tanda saat melaporkan.
  • Pilih metrik pencarian sesuai tujuan (RMSE bila galat besar mahal, MAE bila galat tipikal).
  • Data berurutan waktu tidak boleh memakai KFold acak (lihat bab Forecasting).

Implementasi langkah demi langkah

Dataset Diabetes. Pencarian pertama menyetel alpha Ridge pada fitur polinomial derajat 2 (65 fitur); pencarian kedua menyetel Random Forest. Program examples/estimation/tuning.py; program lengkap ada di akhir bagian ini.

Langkah 1: patokan sebelum penyetelan

Tujuan. Mengetahui skor model dengan hyperparameter bawaan agar hasil penyetelan dapat dinilai.

tuning.py
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)
cv = KFold(5, shuffle=True, random_state=SEED)
scoring = "neg_root_mean_squared_error"

# 1. Validasi silang tunggal: estimasi tanpa penyetelan
ridge = Pipeline([("poly", PolynomialFeatures(2, include_bias=False)),
                  ("scale", StandardScaler()), ("ridge", Ridge())])
base = -cross_val_score(ridge, X_train, y_train, cv=cv, scoring=scoring).mean()
print("Ridge + polinomial, alpha=1 (bawaan): RMSE CV %.2f" % base)
Kode Penjelasan
scoring = "neg_root_mean_squared_error" Skor scikit-learn selalu "lebih besar lebih baik", sehingga galat dinyatakan negatif. Metrik ini dipakai di semua pencarian.
Pipeline([("poly", ...), ("scale", ...), ("ridge", Ridge())]) Fitur polinomial derajat 2, standardisasi, lalu Ridge (bawaan alpha=1). Nama langkah dipakai untuk menunjuk parameter.
-cross_val_score(...).mean() RMSE rata-rata validasi silang; minus mengembalikannya menjadi positif.
Ridge + polinomial, alpha=1 (bawaan): RMSE CV 60.47

Hasil. RMSE CV 60,47 dengan alpha=1.

Langkah 2: Grid Search untuk alpha

tuning.py
# 2. Grid Search untuk alpha (skala logaritmik)
grid = GridSearchCV(ridge, {"ridge__alpha": np.logspace(-1, 4, 11)}, scoring=scoring, cv=cv)
grid.fit(X_train, y_train)
print("\nGrid Search Ridge (11 nilai alpha)")
print("  alpha terbaik: %.1f | RMSE CV: %.2f" % (grid.best_params_["ridge__alpha"], -grid.best_score_))

np.logspace(-1, 4, 11) menghasilkan 11 nilai yang berjarak sama pada skala logaritmik dari \(10^{-1}\) sampai \(10^{4}\) (0,1; 0,32; 1; ...; 10.000). Skala logaritmik dipakai karena alpha bekerja secara multiplikatif. "ridge__alpha" menunjuk parameter alpha milik langkah ridge. grid.best_params_["ridge__alpha"] adalah alpha terbaik dan -grid.best_score_ RMSE CV-nya.

Grid Search Ridge (11 nilai alpha)
  alpha terbaik: 100.0 | RMSE CV: 56.92

Hasil. alpha terbaik 100 dengan RMSE CV 56,92, turun dari 60,47.

Langkah 3: Random Search untuk Random Forest

tuning.py
# 3. Random Search untuk Random Forest
rf_search = RandomizedSearchCV(
    RandomForestRegressor(random_state=SEED),
    {"n_estimators": randint(100, 400), "max_depth": [None, 3, 5, 8],
     "min_samples_leaf": randint(2, 20), "max_features": [0.3, 0.6, 1.0]},
    n_iter=15, scoring=scoring, cv=cv, random_state=SEED,
).fit(X_train, y_train)
print("\nRandom Search Random Forest (15 percobaan)")
print("  parameter terbaik:", rf_search.best_params_)
print("  RMSE CV: %.2f" % -rf_search.best_score_)

RandomizedSearchCV mencoba 15 kombinasi acak dari ruang yang ditentukan: randint(100, 400) memilih bilangan bulat acak, sedangkan daftar seperti [None, 3, 5, 8] memilih salah satu elemennya. max_features=[0.3, 0.6, 1.0] berarti proporsi fitur yang dipertimbangkan pada tiap pembagian. .fit(X_train, y_train) dipanggil langsung di akhir rangkaian.

Random Search Random Forest (15 percobaan)
  parameter terbaik: {'max_depth': 8, 'max_features': 0.6, 'min_samples_leaf': 9, 'n_estimators': 101}
  RMSE CV: 57.36

Hasil. Terbaik: max_depth=8, max_features=0,6, min_samples_leaf=9, n_estimators=101, RMSE CV 57,36, hampir sama dengan Ridge yang disetel.

Langkah 4: nested cross-validation

Konsep. best_score_ dipilih dari banyak kandidat pada lipatan yang sama, sehingga cenderung optimis. Nested CV menilai prosedur pencarian: pencarian diulang di dalam tiap lipatan luar yang tidak dilihat pencarian.

tuning.py
# 4. Nested CV: estimasi jujur untuk prosedur 'Grid Search Ridge'
nested = -cross_val_score(grid, X_train, y_train, cv=KFold(5, shuffle=True, random_state=1), scoring=scoring)
print("\nNested CV RMSE: %.2f (+/- %.2f)" % (nested.mean(), nested.std()))
Nested CV RMSE: 57.20 (+/- 3.30)

Hasil. RMSE 57,20 (± 3,30), sedikit lebih buruk daripada best_score_ 56,92: skor terbaik yang dipilih dari banyak kandidat cenderung optimis.

Langkah 5: data uji dan tiga alpha teratas

tuning.py
# 5. Data uji, satu kali, untuk kedua model terpilih
for name, search in [("Ridge", grid), ("Random Forest", rf_search)]:
    pred = search.predict(X_test)
    print(f"Uji {name:<14} MAE {mean_absolute_error(y_test, pred):.2f} | RMSE {mean_squared_error(y_test, pred) ** 0.5:.2f}")

top = pd.DataFrame(grid.cv_results_).nsmallest(3, "rank_test_score")[["param_ridge__alpha", "mean_test_score"]]
print("\nTiga alpha teratas (RMSE CV):")
print(top.assign(rmse=-top["mean_test_score"].round(2)).drop(columns="mean_test_score").to_string(index=False))

Data uji dipakai sekali untuk dua model terpilih (search.predict otomatis memakai model terbaik hasil refit). Baris terakhir menampilkan tiga alpha dengan RMSE CV terkecil dari grid.cv_results_ untuk melihat seberapa landai kurvanya.

Uji Ridge          MAE 41.57 | RMSE 51.57
Uji Random Forest  MAE 42.89 | RMSE 52.80

Tiga alpha teratas (RMSE CV):
 param_ridge__alpha  rmse
         100.000000 56.92
          31.622777 57.43
          10.000000 58.60

Interpretasi keseluruhan

  • Penyetelan Ridge: dengan alpha=1 (bawaan), RMSE CV 60,47; Grid Search memilih alpha=100 dengan RMSE CV 56,92. Tiga teratas: 100 (56,92), 31,6 (57,43), dan 10 (58,60): kurva cukup landai di sekitar optimum.
  • Random Forest: RMSE CV 57,36, hampir sama dengan Ridge yang disetel.
  • Nested CV untuk prosedur "Grid Search Ridge": 57,20 (± 3,30), sedikit lebih buruk daripada best_score_ 56,92.
  • Data uji, sekali: Ridge MAE 41,57 dan RMSE 51,57; Random Forest MAE 42,89 dan RMSE 52,80. Selisihnya kecil dan tidak cukup untuk menyatakan pemenang.
  • Konteks: regresi linear biasa pada 10 fitur asli sudah memberi RMSE CV sekitar 55–56. Penyetelan memperbaiki model polinomial yang berlebihan dari 60,47 ke 56,92, tetapi tidak mengalahkan model sederhana. Menyetel model yang kurang cocok tidak menggantikan pemilihan model dan fitur yang baik.
Program lengkap (tuning.py)
tuning.py
import numpy as np
import pandas as pd
from scipy.stats import randint
from sklearn.datasets import load_diabetes
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import (
    GridSearchCV,
    KFold,
    RandomizedSearchCV,
    cross_val_score,
    train_test_split,
)
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler

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)
cv = KFold(5, shuffle=True, random_state=SEED)
scoring = "neg_root_mean_squared_error"

# 1. Validasi silang tunggal: estimasi tanpa penyetelan
ridge = Pipeline([("poly", PolynomialFeatures(2, include_bias=False)),
                  ("scale", StandardScaler()), ("ridge", Ridge())])
base = -cross_val_score(ridge, X_train, y_train, cv=cv, scoring=scoring).mean()
print("Ridge + polinomial, alpha=1 (bawaan): RMSE CV %.2f" % base)

# 2. Grid Search untuk alpha (skala logaritmik)
grid = GridSearchCV(ridge, {"ridge__alpha": np.logspace(-1, 4, 11)}, scoring=scoring, cv=cv)
grid.fit(X_train, y_train)
print("\nGrid Search Ridge (11 nilai alpha)")
print("  alpha terbaik: %.1f | RMSE CV: %.2f" % (grid.best_params_["ridge__alpha"], -grid.best_score_))

# 3. Random Search untuk Random Forest
rf_search = RandomizedSearchCV(
    RandomForestRegressor(random_state=SEED),
    {"n_estimators": randint(100, 400), "max_depth": [None, 3, 5, 8],
     "min_samples_leaf": randint(2, 20), "max_features": [0.3, 0.6, 1.0]},
    n_iter=15, scoring=scoring, cv=cv, random_state=SEED,
).fit(X_train, y_train)
print("\nRandom Search Random Forest (15 percobaan)")
print("  parameter terbaik:", rf_search.best_params_)
print("  RMSE CV: %.2f" % -rf_search.best_score_)

# 4. Nested CV: estimasi jujur untuk prosedur 'Grid Search Ridge'
nested = -cross_val_score(grid, X_train, y_train, cv=KFold(5, shuffle=True, random_state=1), scoring=scoring)
print("\nNested CV RMSE: %.2f (+/- %.2f)" % (nested.mean(), nested.std()))

# 5. Data uji, satu kali, untuk kedua model terpilih
for name, search in [("Ridge", grid), ("Random Forest", rf_search)]:
    pred = search.predict(X_test)
    print(f"Uji {name:<14} MAE {mean_absolute_error(y_test, pred):.2f} | RMSE {mean_squared_error(y_test, pred) ** 0.5:.2f}")

top = pd.DataFrame(grid.cv_results_).nsmallest(3, "rank_test_score")[["param_ridge__alpha", "mean_test_score"]]
print("\nTiga alpha teratas (RMSE CV):")
print(top.assign(rmse=-top["mean_test_score"].round(2)).drop(columns="mean_test_score").to_string(index=False))

Kesalahan umum

Hindari

  • Mencari alpha pada skala linear (gunakan np.logspace).
  • Melaporkan best_score_ sebagai performa akhir.
  • Lupa mengubah tanda skor negatif.
  • Menyetel dengan data uji.
  • Menyetel banyak parameter pada data kecil sehingga overfit ke lipatan validasi.

Latihan

  1. Perluas grid alpha ke np.logspace(-2, 5, 15). Apakah optimum bergeser?
  2. Ganti metrik pencarian menjadi neg_mean_absolute_error.
  3. Ulangi Random Search dengan random_state berbeda. Seberapa stabil parameter terbaiknya?

Ringkasan

Gunakan KFold acak, metrik negatif untuk galat, skala logaritmik untuk alpha, dan nested CV atau data uji untuk estimasi jujur. Penyetelan membantu tetapi tidak menggantikan pemilihan model yang tepat.

Berikutnya: Menyimpan Model, Deployment, dan Monitoring.