Machine Learning Academy · Pelajaran

Pencarian Grid vs Pencarian Acak

Pelajaran 3 dari 413 langkah

Pencarian Grid vs Pencarian Acak adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Masalah Pencarian Hiperparameter

Sebagian besar model pembelajaran mesin memiliki beberapa hiperparameter yang tidak dapat dipelajari dari data dan harus ditetapkan oleh praktisi. Menemukan kombinasi optimal secara manual tidak praktis — jumlah kombinasi bertambah secara eksponensial seiring bertambahnya jumlah hiperparameter. Dua pendekatan sistematis yang paling umum adalah: Pencarian Grid, yang mengevaluasi setiap kombinasi dalam grid yang telah ditentukan, dan Pencarian Acak, yang mengambil sampel kombinasi secara acak dari distribusi yang ditentukan. Memahami kapan harus menggunakan masing-masing pendekatan merupakan keterampilan praktis yang penting.

Pencarian Grid: Evaluasi Menyeluruh

GridSearchCV mengevaluasi setiap kombinasi nilai hiperparameter yang Anda tentukan. Untuk grid dengan 4 nilai C, 5 nilai gamma, dan 5 lipatan CV, proses ini melatih 4 × 5 × 5 = 100 model. Dengan demikian, Anda dijamin menemukan kombinasi terbaik dalam grid tersebut. Namun, biayanya bertambah secara multiplikatif: menambahkan hiperparameter ketiga dengan 4 nilai akan meningkatkan pencarian menjadi 400 model. Pencarian grid bekerja baik jika Anda memiliki 1–2 hiperparameter dan ukuran grid yang dapat dikelola.

from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_breast_cancer
import numpy as np

X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svc', SVC())])
param_grid = {'svc__C': [0.1, 1, 10], 'svc__gamma': [0.01, 0.1, 1]}
# 3 * 3 * 5 folds = 45 model fits
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X, y)
print('Best params:', grid.best_params_)
print('Best CV score:', round(grid.best_score_, 4))

Kutukan Dimensionalitas dalam Pencarian Grid

Pencarian grid mengalami peningkatan skala secara eksponensial. Model dengan 5 hiperparameter, masing-masing memiliki 5 nilai kandidat, memerlukan 5^5 = 3125 pelatihan model (dikalikan dengan jumlah lipatan CV). Dengan CV 5 lipatan, jumlahnya menjadi 15.625 proses pelatihan. Bahkan jika setiap proses memerlukan waktu 1 detik, totalnya lebih dari 4 jam. Praktisi sering membatasi pencarian grid pada 1–2 hiperparameter terpenting, menetapkan hiperparameter lainnya ke nilai bawaan yang masuk akal, dan menggunakan grid kasar terlebih dahulu. Heuristik ini efektif, tetapi berisiko melewatkan interaksi antara hiperparameter yang tidak dicari secara bersama-sama.

Pencarian Acak: Mengambil Sampel, Bukan Menggunakan Grid

RandomizedSearchCV mengambil sampel sejumlah tetap kombinasi hiperparameter (dikendalikan oleh n_iter) secara acak dari distribusi yang ditentukan, alih-alih menguji setiap titik dalam grid. Penelitian Bergstra dan Bengio (2012) menunjukkan bahwa dengan anggaran komputasi yang sama, pencarian acak menemukan hiperparameter yang lebih baik daripada pencarian grid ketika hanya beberapa hiperparameter yang sangat memengaruhi kinerja model — karena pencarian acak secara efektif menjelajahi lebih banyak nilai berbeda dari parameter penting.

from sklearn.svm import SVC
from sklearn.model_selection import RandomizedSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_breast_cancer
from scipy.stats import loguniform

X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svc', SVC())])
param_dist = {'svc__C': loguniform(0.01, 100), 'svc__gamma': loguniform(0.0001, 1)}
# 30 random combinations * 5 folds = 150 model fits (same as a 5*6 grid)
rnd = RandomizedSearchCV(pipe, param_dist, n_iter=30, cv=5, random_state=42, n_jobs=-1)
rnd.fit(X, y)
print('Best params:', {k: round(v, 5) for k, v in rnd.best_params_.items()})
print('Best CV score:', round(rnd.best_score_, 4))

Mengapa Pencarian Acak Unggul untuk Banyak Hiperparameter

Bayangkan terdapat 9 hiperparameter, dengan 3 di antaranya penting dan 6 lainnya tidak relevan. Grid dengan 3 nilai untuk setiap parameter menguji 3^9 = 19683 kombinasi, tetapi hanya menguji 3 nilai berbeda untuk setiap parameter penting. Dengan anggaran yang sama, yaitu 19.683 sampel acak, setiap parameter penting dieksplorasi menggunakan 19.683 nilai berbeda. Pemusatan sampel pada ruang parameter penting memberikan keunggulan besar bagi pencarian acak. Probabilitas bahwa setidaknya satu konfigurasi acak berada dalam 5% teratas ruang pencarian hanya dengan 60 iterasi adalah lebih dari 95%.

Distribusi untuk Pencarian Acak

Memilih distribusi probabilitas yang tepat untuk RandomizedSearchCV adalah hal penting. Gunakan scipy.stats.loguniform(a, b) untuk parameter yang mencakup beberapa orde magnitudo, seperti learning_rate atau C. Gunakan scipy.stats.uniform(a, b-a) untuk parameter dengan skala linear, seperti subsample (0.5 hingga 1.0). Gunakan scipy.stats.randint(low, high) untuk parameter bilangan bulat, seperti n_estimators atau max_depth. Parameter berupa daftar (misalnya, [3, 5, 7, 9]) mengambil sampel secara seragam dari opsi diskret tersebut.

from scipy.stats import loguniform, uniform, randint
import numpy as np

# Example distributions for RandomForestClassifier + LogisticRegression pipeline
param_dist = {
    'rf__n_estimators': randint(50, 500),          # integer, uniform
    'rf__max_depth': [3, 5, 7, None],              # discrete list
    'rf__min_samples_leaf': randint(1, 20),         # integer, uniform
    'rf__max_features': loguniform(0.1, 1.0)        # continuous, log-scale
}

# Show 5 sample combinations
np.random.seed(42)
for _ in range(3):
    sample = {k: v.rvs() if hasattr(v, 'rvs') else np.random.choice(v) for k, v in param_dist.items()}
    print(sample)

Membandingkan Pencarian Grid dan Acak Berdampingan

Perbandingan langsung: pencarian grid dengan 5 nilai untuk masing-masing dari 3 parameter memerlukan 125 pelatihan; pencarian acak dengan 125 iterasi menggunakan anggaran yang sama, tetapi mengeksplorasi distribusi kontinu, bukan 5 titik tetap untuk setiap parameter. Dalam praktiknya, untuk pencarian 2D sederhana (C dan gamma pada SVM), pencarian grid sudah lebih dari memadai. Untuk model kompleks seperti peningkatan gradien dengan 6 atau lebih hiperparameter, pencarian acak dengan 50–100 iterasi secara konsisten mengungguli grid dengan komputasi yang setara.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, cross_val_score
from sklearn.datasets import load_breast_cancer
from scipy.stats import randint
import time, numpy as np

X, y = load_breast_cancer(return_X_y=True)
# Grid search
start = time.time()
grid = GridSearchCV(RandomForestClassifier(random_state=42), {'n_estimators': [50,100,200], 'max_depth': [3,5,None]}, cv=3, n_jobs=-1)
grid.fit(X, y)
print(f'Grid search: {round(time.time()-start,1)}s, best={round(grid.best_score_,4)}')
# Random search
start = time.time()
rnd = RandomizedSearchCV(RandomForestClassifier(random_state=42), {'n_estimators': randint(10,300), 'max_depth': [3,5,7,None]}, n_iter=9, cv=3, random_state=42, n_jobs=-1)
rnd.fit(X, y)
print(f'Random search: {round(time.time()-start,1)}s, best={round(rnd.best_score_,4)}')

Pencarian Grid dengan Pengurangan Bertahap untuk Ruang yang Lebih Besar

scikit-learn 0.24+ memperkenalkan HalvingGridSearchCV dan HalvingRandomSearchCV yang didasarkan pada algoritme pengurangan bertahap: mulai dengan melatih semua kandidat menggunakan sebagian kecil data, singkirkan separuh kandidat terburuk, gandakan data, lalu ulangi hingga tersisa satu pemenang. Metode ini menemukan hiperparameter yang baik dengan komputasi yang jauh lebih sedikit daripada pencarian grid atau acak penuh, sehingga praktis untuk ruang pencarian yang lebih besar dengan model yang mahal.

from sklearn.experimental import enable_halving_search_cv  # noqa
from sklearn.model_selection import HalvingRandomSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from scipy.stats import randint

X, y = load_breast_cancer(return_X_y=True)
halving = HalvingRandomSearchCV(
    RandomForestClassifier(random_state=42),
    {'n_estimators': randint(10, 500), 'max_depth': [3, 5, 7, None], 'min_samples_leaf': randint(1, 20)},
    cv=3, factor=2, random_state=42, n_jobs=-1
)
halving.fit(X, y)
print('Best params:', halving.best_params_)
print('Best score:', round(halving.best_score_, 4))

Pengoptimalan Bayesian: Alternatif yang Cerdas

Pencarian kisi maupun acak bersifat tanpa panduan—keduanya tidak menggunakan hasil evaluasi sebelumnya untuk memandu pilihan berikutnya. Optimisasi Bayesian membangun model probabilistik dari fungsi sasaran (skor CV sebagai fungsi dari hyperparameter), lalu menggunakannya untuk memilih secara cerdas kombinasi paling menjanjikan yang akan dievaluasi berikutnya. Pustaka seperti Optuna, BayesSearchCV (scikit-optimize), dan HyperOpt menerapkan pendekatan ini dan biasanya menemukan hyperparameter yang lebih baik dengan evaluasi yang jauh lebih sedikit daripada pencarian acak.

Rekomendasi Strategi Pencarian Praktis

Panduan praktis: (1) mulai dengan pencarian acak selama 30–100 iterasi untuk mengidentifikasi wilayah hyperparameter yang menjanjikan; (2) jika memerlukan ketelitian lebih tinggi, jalankan pencarian kisi yang lebih terperinci di sekitar wilayah tersebut; (3) untuk model yang mahal (pelatihannya lambat), gunakan optimisasi Bayesian (Optuna) untuk meminimalkan jumlah evaluasi; (4) selalu gunakan alur kerja untuk mencegah kebocoran; (5) tetapkan n_jobs=-1 untuk pemrosesan paralel; (6) gunakan refit=True (bawaan) agar model terbaik dilatih ulang pada seluruh data pelatihan setelah pencarian selesai. Jangan pernah menggunakan set pengujian untuk memilih hyperparameter.

Mengakses Semua Hasil dari GridSearchCV

Setelah fitting, grid.cv_results_ adalah kamus yang berisi skor pengujian rata-rata, simpangan baku, waktu fitting, dan nilai parameter untuk setiap kombinasi yang dievaluasi. Mengonversinya menjadi DataFrame Pandas memudahkan Anda mengurutkan, memfilter, dan memvisualisasikan data. Hal ini berguna untuk memahami sensitivitas skor terhadap setiap parameter—jika semua nilai C menghasilkan skor yang serupa tetapi gamma memberikan pengaruh besar, Anda akan mengetahui bahwa penyesuaian berikutnya harus berfokus pada gamma.

import pandas as pd
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_breast_cancer
import numpy as np

X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svc', SVC(kernel='rbf'))])
grid = GridSearchCV(pipe, {'svc__C': np.logspace(-1, 2, 4), 'svc__gamma': np.logspace(-3, 0, 4)}, cv=5)
grid.fit(X, y)
df = pd.DataFrame(grid.cv_results_)[['param_svc__C', 'param_svc__gamma', 'mean_test_score', 'std_test_score']]
print(df.sort_values('mean_test_score', ascending=False).head(5).round(4))

Pemeriksaan Singkat

Uji pemahaman Anda tentang Pencarian Kisi dan Pencarian Acak dari pelajaran ini.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari: Pencarian Kisi mengevaluasi setiap kombinasi secara menyeluruh, tetapi skalanya bertambah secara eksponensial seiring jumlah hyperparameter, Pencarian Acak mengambil sampel secara kontinu dari distribusi dan unggul ketika hanya sedikit hyperparameter yang berpengaruh, serta Halving dan optimisasi Bayesian semakin mengurangi biaya evaluasi untuk model yang mahal. Selanjutnya, kita akan mempelajari Validasi Silang Bersarang untuk memilih dan mengevaluasi hyperparameter secara bersamaan tanpa bias.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pencarian Grid vs Pencarian Acak” gratis?

Ya — teks lengkap “Pencarian Grid vs Pencarian Acak” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pencarian Grid vs Pencarian Acak”?

Peserta akan mengonfigurasi GridSearchCV dan RandomizedSearchCV pada ruang hyperparameter yang sama, membandingkan cakupan serta biaya komputasinya, lalu memilih metode yang lebih cepat untuk ruang y… Kamu berlatih Machine Learning Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Machine Learning Academy?

Tidak diperlukan pengalaman sebelumnya. Machine Learning Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Pencarian Grid vs Pencarian Acak” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Validasi Silang K-Fold: Membagi Data Tanpa Kebocoran
Validasi Silang Terstratifikasi dan Deret Waktu
Pencarian Grid vs Pencarian Acak
Validasi Silang Bertingkat: Memilih dan Mengevaluasi Secara Bersamaan

← Kembali ke Machine Learning Academy