Lewati ke isi

Optimasi Hyperparameter

Gambaran singkat

Apa ini? Cara mencari pengaturan model (hyperparameter) terbaik secara sistematis dengan GridSearchCV dan RandomizedSearchCV.

Analogi

Mengatur resep kue: berapa gula, berapa lama dipanggang. Pengaturan itu tidak dipelajari kuenya, tetapi Anda yang menentukan. Anda mencoba beberapa kombinasi dan memilih yang paling enak.

Mengapa penting? Pengaturan yang tepat sering meningkatkan kinerja, tetapi mencoba banyak kombinasi pada data yang sama membuat skor terbaik terlalu optimis. Kita perlu cara menguji yang jujur.

Yang akan dipelajari, berurutan:

  1. Beda parameter dan hyperparameter.
  2. Grid search dan random search di dalam Pipeline.
  3. Mengapa skor terbaik pencarian terlalu optimis, dan nested cross-validation sebagai perbaikannya.

Istilah awal:

Istilah Arti sederhana
Hyperparameter Pengaturan yang kita tentukan sebelum pelatihan
Grid search Mencoba semua kombinasi dalam daftar
Random search Mencoba kombinasi acak
scoring Metrik yang dipakai untuk memilih yang terbaik

Tujuan pembelajaran

  • Membedakan parameter (dipelajari) dan hyperparameter (ditetapkan sebelum pelatihan).
  • Memakai GridSearchCV dan RandomizedSearchCV dengan Pipeline.
  • Menjelaskan mengapa skor terbaik dari pencarian bersifat optimis dan bagaimana nested cross-validation memperbaikinya.

Konsep dasar

Parameter (misalnya koefisien regresi logistik) dipelajari dari data. Hyperparameter (misalnya C, gamma, max_depth) ditetapkan sebelum pelatihan. Optimasi hyperparameter mencari kombinasi yang memberi skor validasi terbaik.

Metode Cara kerja Kapan dipakai
Grid Search Mencoba semua kombinasi pada kisi Sedikit hyperparameter, ruang kecil
Random Search Mencoba sampel acak kombinasi Ruang besar; sering lebih efisien per percobaan
Pencarian lanjutan (Bayesian, successive halving) Mengarahkan pencarian Model mahal; di luar cakupan lesson ini

Aturan penting:

  1. Pencarian hanya memakai data latih (validasi silang di dalamnya). Data uji tetap disimpan.
  2. Gunakan Pipeline, sehingga praproses ikut dilatih ulang per lipatan. Nama parameter memakai format <nama_langkah>__<parameter>, misalnya svc__C.
  3. Tentukan scoring sesuai tujuan (F1, recall, PR-AUC), bukan hanya accuracy.
  4. refit=True (bawaan) melatih ulang model terbaik pada seluruh data latih.

Implementasi langkah demi langkah

Dataset Breast Cancer; pemuatan dan pembagian data sama dengan pelajaran dasar. Program lengkap ada di akhir bagian ini.

Langkah 1: Grid Search untuk SVM

Tujuan. Mencari kombinasi C dan gamma terbaik dari kisi 4 × 4 = 16 kombinasi, dinilai dengan validasi silang pada data latih.

tuning.py
SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)
cv = StratifiedKFold(5, shuffle=True, random_state=SEED)

# 1. Grid Search untuk SVM. Nama parameter pipeline: <langkah>__<parameter>
svm = Pipeline([("scale", StandardScaler()), ("svc", SVC())])
grid = GridSearchCV(
    svm,
    param_grid={"svc__C": [0.1, 1, 10, 100], "svc__gamma": [0.001, 0.01, 0.1, "scale"]},
    scoring="f1", cv=cv,
)
grid.fit(X_train, y_train)  # pencarian hanya memakai data latih
Kode Penjelasan
Pipeline([("scale", StandardScaler()), ("svc", SVC())]) Pipeline dengan nama langkah scale dan svc. Nama dipakai untuk menunjuk parameter.
param_grid={"svc__C": [...], "svc__gamma": [...]} Kisi parameter. Format <nama_langkah>__<parameter> (dua garis bawah) menunjuk parameter C milik langkah svc. Semua kombinasi (16) dicoba.
scoring="f1" Metrik yang dioptimalkan. Pilih sesuai tujuan, bukan sekadar akurasi.
cv=cv Validasi silang 5 lipatan berstrata untuk setiap kombinasi (16 × 5 = 80 pelatihan).
grid.fit(X_train, y_train) Menjalankan pencarian. Hanya data latih yang dipakai; data uji tidak tersentuh. Setelah selesai, kombinasi terbaik dilatih ulang pada seluruh data latih (refit=True bawaan).
Grid Search SVM
  kombinasi dicoba : 16
  parameter terbaik: {'svc__C': 10, 'svc__gamma': 0.01}
  F1 CV terbaik    : 0.981

Langkah 2: membaca hasil pencarian

tuning.py
print("Grid Search SVM")
print("  kombinasi dicoba :", len(grid.cv_results_["params"]))
print("  parameter terbaik:", grid.best_params_)
print("  F1 CV terbaik    : %.3f" % grid.best_score_)
top = pd.DataFrame(grid.cv_results_).nsmallest(3, "rank_test_score")
print(top[["param_svc__C", "param_svc__gamma", "mean_test_score", "std_test_score"]].round(3).to_string(index=False))

default_cv = cross_val_score(svm, X_train, y_train, cv=cv, scoring="f1").mean()
print("  F1 CV SVM default: %.3f" % default_cv)

grid.best_params_ = kombinasi terbaik; grid.best_score_ = skor validasi silang rata-rata kombinasi itu; grid.cv_results_ = tabel hasil semua kombinasi, yang diubah menjadi DataFrame lalu nsmallest(3, "rank_test_score") mengambil tiga peringkat teratas (peringkat 1 = terbaik). Baris terakhir menghitung skor SVM bawaan (tanpa penyetelan) sebagai pembanding.

 param_svc__C param_svc__gamma  mean_test_score  std_test_score
         10.0             0.01            0.981           0.012
         10.0            0.001            0.978           0.015
          1.0             0.01            0.978           0.012
  F1 CV SVM default: 0.976

Interpretasi. Kombinasi terbaik C=10, gamma=0,01 dengan F1 CV 0,981, sedangkan SVM bawaan sudah memberi 0,976. Peningkatan 0,005 jauh lebih kecil daripada simpangan baku antar lipatan (0,012), jadi penyetelan di sini tidak memberi keuntungan yang meyakinkan. Tiga kombinasi teratas hanya berbeda 0,003.

Langkah 3: Random Search untuk Random Forest

Konsep. Bila ruang parameter besar, mencoba semua kombinasi tidak praktis. Random Search mengambil sejumlah kombinasi acak (n_iter) dari rentang yang ditentukan.

tuning.py
# 2. Random Search untuk Random Forest (ruang parameter lebih besar)
rf_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=SEED),
    param_distributions={
        "n_estimators": randint(100, 400),
        "max_depth": [None, 3, 5, 10],
        "min_samples_leaf": randint(1, 6),
        "max_features": ["sqrt", "log2", 0.5],
    },
    n_iter=15, scoring="f1", cv=cv, random_state=SEED,
)
rf_search.fit(X_train, y_train)
print("\nRandom Search Random Forest (15 percobaan)")
print("  parameter terbaik:", rf_search.best_params_)
print("  F1 CV terbaik    : %.3f" % rf_search.best_score_)
Kode Penjelasan
randint(100, 400) Distribusi bilangan bulat acak antara 100 dan 399 (dari scipy.stats). Daftar seperti [None, 3, 5, 10] berarti pilih acak salah satu.
n_iter=15 Hanya 15 kombinasi acak yang dicoba.
random_state=SEED Membuat pengambilan acaknya dapat diulang.
Random Search Random Forest (15 percobaan)
  parameter terbaik: {'max_depth': 10, 'max_features': 'sqrt', 'min_samples_leaf': 1, 'n_estimators': 121}
  F1 CV terbaik    : 0.973

Interpretasi. Skor terbaik 0,973 dengan max_depth=10, n_estimators=121; di bawah SVM pada data ini.

Langkah 4: estimasi jujur dengan nested cross-validation

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

tuning.py
# 3. Estimasi jujur: nested cross-validation (pencarian di dalam lipatan luar)
nested = cross_val_score(grid, X_train, y_train, cv=StratifiedKFold(5, shuffle=True, random_state=1), scoring="f1")
print("\nNested CV F1 untuk prosedur 'Grid Search SVM': %.3f (+/- %.3f)" % (nested.mean(), nested.std()))

cross_val_score(grid, ...) memperlakukan seluruh GridSearchCV sebagai satu model: untuk tiap lipatan luar, pencarian dijalankan pada lipatan latih luar, lalu hasilnya dinilai pada lipatan validasi luar. StratifiedKFold(..., random_state=1) memakai pembagian berbeda dari pencarian dalam.

Nested CV F1 untuk prosedur 'Grid Search SVM': 0.979 (+/- 0.007)

Interpretasi. Estimasi F1 0,979 (± 0,007) untuk prosedur "Grid Search SVM", sedikit di bawah skor terbaik grid (0,981) karena skor terbaik cenderung optimis.

Langkah 5: data uji sekali

tuning.py
# 4. Data uji dipakai SEKALI untuk model SVM terpilih
pred = grid.predict(X_test)
print("Data uji -> accuracy: %.3f | F1: %.3f" % (accuracy_score(y_test, pred), f1_score(y_test, pred)))

grid.predict(X_test) otomatis memakai model terbaik (best_estimator_) yang sudah dilatih ulang pada seluruh data latih.

Data uji -> accuracy: 0.982 | F1: 0.986

Interpretasi. Akurasi 0,982 dan F1 0,986 untuk model terpilih. Pesan utama: penyetelan berguna terutama bila model awal jauh dari optimal (seperti gamma ekstrem pada SVM); pada model yang sudah cukup baik, hasilnya sering marginal, dan waktu lebih baik dipakai memperbaiki data atau fitur.

Program lengkap (tuning.py)
tuning.py
import pandas as pd
from scipy.stats import randint
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score
from sklearn.model_selection import (
    GridSearchCV,
    RandomizedSearchCV,
    StratifiedKFold,
    cross_val_score,
    train_test_split,
)
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)
cv = StratifiedKFold(5, shuffle=True, random_state=SEED)

# 1. Grid Search untuk SVM. Nama parameter pipeline: <langkah>__<parameter>
svm = Pipeline([("scale", StandardScaler()), ("svc", SVC())])
grid = GridSearchCV(
    svm,
    param_grid={"svc__C": [0.1, 1, 10, 100], "svc__gamma": [0.001, 0.01, 0.1, "scale"]},
    scoring="f1", cv=cv,
)
grid.fit(X_train, y_train)  # pencarian hanya memakai data latih
print("Grid Search SVM")
print("  kombinasi dicoba :", len(grid.cv_results_["params"]))
print("  parameter terbaik:", grid.best_params_)
print("  F1 CV terbaik    : %.3f" % grid.best_score_)
top = pd.DataFrame(grid.cv_results_).nsmallest(3, "rank_test_score")
print(top[["param_svc__C", "param_svc__gamma", "mean_test_score", "std_test_score"]].round(3).to_string(index=False))

default_cv = cross_val_score(svm, X_train, y_train, cv=cv, scoring="f1").mean()
print("  F1 CV SVM default: %.3f" % default_cv)

# 2. Random Search untuk Random Forest (ruang parameter lebih besar)
rf_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=SEED),
    param_distributions={
        "n_estimators": randint(100, 400),
        "max_depth": [None, 3, 5, 10],
        "min_samples_leaf": randint(1, 6),
        "max_features": ["sqrt", "log2", 0.5],
    },
    n_iter=15, scoring="f1", cv=cv, random_state=SEED,
)
rf_search.fit(X_train, y_train)
print("\nRandom Search Random Forest (15 percobaan)")
print("  parameter terbaik:", rf_search.best_params_)
print("  F1 CV terbaik    : %.3f" % rf_search.best_score_)

# 3. Estimasi jujur: nested cross-validation (pencarian di dalam lipatan luar)
nested = cross_val_score(grid, X_train, y_train, cv=StratifiedKFold(5, shuffle=True, random_state=1), scoring="f1")
print("\nNested CV F1 untuk prosedur 'Grid Search SVM': %.3f (+/- %.3f)" % (nested.mean(), nested.std()))

# 4. Data uji dipakai SEKALI untuk model SVM terpilih
pred = grid.predict(X_test)
print("Data uji -> accuracy: %.3f | F1: %.3f" % (accuracy_score(y_test, pred), f1_score(y_test, pred)))

Kesalahan umum

Hindari

  • Menyetel hyperparameter dengan data uji.
  • Melaporkan best_score_ sebagai estimasi performa akhir.
  • Melakukan scaling sebelum pencarian sehingga bocor ke lipatan validasi.
  • Menyetel terlalu banyak kombinasi pada data kecil sehingga "overfit ke validasi".
  • Membandingkan model yang disetel dengan model lain yang tidak disetel secara adil.

Latihan

  1. Perluas grid C ke [0.01, 100, 1000]. Apakah kombinasi terbaik berubah?
  2. Ganti scoring menjadi recall untuk kelas ganas dengan make_scorer(recall_score, pos_label=0).
  3. Jalankan RandomizedSearchCV dengan n_iter=5 dan n_iter=40. Seberapa jauh skor terbaiknya berbeda?
  4. Jelaskan dengan kata-kata Anda mengapa best_score_ optimis.

Ringkasan

Hyperparameter disetel dengan pencarian bervalidasi silang pada data latih, di dalam Pipeline. Skor terbaik pencarian cenderung optimis; nested CV dan data uji (sekali) memberi gambaran lebih jujur. Peningkatan kecil dibanding ketidakpastian tidak perlu dianggap bermakna.

Berikutnya: Menyimpan Model, Deployment, dan Monitoring.