Grid search versus random search
Cursisten configureren GridSearchCV en RandomizedSearchCV met dezelfde hyperparameterruimte, vergelijken hun dekking en rekenkosten en kiezen de snelste methode voor grote zoekruimten.
Grid search versus random search is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Het probleem van zoeken naar hyperparameters
De meeste machinelearningmodellen hebben meerdere hyperparameters die niet uit gegevens kunnen worden geleerd en door de gebruiker moeten worden ingesteld. De optimale combinatie handmatig vinden is onpraktisch — het aantal combinaties groeit exponentieel met het aantal hyperparameters. Twee systematische benaderingen zijn dominant: rasterzoeken, waarbij elke combinatie op een vooraf bepaald raster wordt geëvalueerd, en willekeurig zoeken, waarbij combinaties willekeurig uit opgegeven verdelingen worden genomen. Begrijpen wanneer je welke methode gebruikt, is een belangrijke praktische vaardigheid.
Rasterzoeken: uitputtende evaluatie
GridSearchCV evalueert elke combinatie van de hyperparameterwaarden die je opgeeft. Voor een raster met 4 waarden voor C, 5 waarden voor gamma en 5 kruisvalidatievouwen traint het 4 × 5 × 5 = 100 modellen. Zo weet je zeker dat je de beste combinatie binnen je raster vindt. De kosten groeien echter multiplicatief: als je een derde hyperparameter met 4 waarden toevoegt, groeit de zoekopdracht tot 400 modellen. Rasterzoeken werkt goed wanneer je 1–2 hyperparameters en een raster van beheersbare omvang hebt.
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))De vloek van dimensionaliteit bij rasterzoeken
Rasterzoeken schaalt exponentieel. Een model met 5 hyperparameters, elk met 5 kandidaatwaarden, vereist 5^5 = 3125 modeltrainingen (vermenigvuldigd met het aantal kruisvalidatievouwen). Met vijfvoudige kruisvalidatie zijn dat 15.625 trainingsrondes. Zelfs als elke ronde 1 seconde duurt, kost dat meer dan 4 uur. Gebruikers beperken rasterzoeken daarom vaak tot de belangrijkste 1–2 hyperparameters, zetten de overige op verstandige standaardwaarden en beginnen met grove rasters. Deze vuistregel werkt, maar het risico bestaat dat interacties tussen hyperparameters die niet gezamenlijk zijn onderzocht, worden gemist.
Willekeurig zoeken: steekproeven nemen in plaats van een raster gebruiken
RandomizedSearchCV neemt een vast aantal combinaties van hyperparameters (bepaald door n_iter) en trekt deze willekeurig uit opgegeven verdelingen, in plaats van elk rasterpunt te testen. Onderzoek van Bergstra en Bengio (2012) liet zien dat willekeurig zoeken bij hetzelfde rekenbudget betere hyperparameters vindt dan rasterzoeken wanneer slechts enkele hyperparameters de modelprestaties sterk beïnvloeden — omdat willekeurig zoeken effectief meer verschillende waarden van de belangrijke parameters onderzoekt.
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))Waarom willekeurig zoeken wint bij veel hyperparameters
Neem 9 hyperparameters, waarvan er 3 belangrijk zijn en 6 niet relevant. Een raster met 3 waarden per parameter test 3^9 = 19683 combinaties, maar test voor elke belangrijke parameter slechts 3 verschillende waarden. Met hetzelfde budget van 19.683 willekeurige steekproeven wordt elke belangrijke parameter met 19.683 verschillende waarden onderzocht. Doordat de steekproeven zich concentreren in de ruimte van de belangrijke parameters, heeft willekeurig zoeken een doorslaggevend voordeel. De kans dat bij slechts 60 iteraties ten minste één willekeurige configuratie in de beste 5% van de ruimte valt, is meer dan 95%.
Verdelingen voor willekeurig zoeken
Het is belangrijk om geschikte kansverdelingen voor RandomizedSearchCV te kiezen. Gebruik scipy.stats.loguniform(a, b) voor parameters die meerdere ordegroottes beslaan, zoals learning_rate of C. Gebruik scipy.stats.uniform(a, b-a) voor parameters met een lineaire schaal, zoals subsample (0.5 tot 1.0). Gebruik scipy.stats.randint(low, high) voor gehele parameters, zoals n_estimators of max_depth. Parameters als lijsten (bijvoorbeeld [3, 5, 7, 9]) leveren willekeurig een uniforme keuze uit die discrete opties.
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)Rasterzoeken en willekeurig zoeken naast elkaar vergelijken
Een directe vergelijking: rasterzoeken met 5 waarden voor elk van 3 parameters vereist 125 modeltrainingen; willekeurig zoeken met 125 iteraties gebruikt hetzelfde budget, maar onderzoekt continue verdelingen in plaats van 5 vaste punten per parameter. In de praktijk is rasterzoeken voor eenvoudige zoekopdrachten in 2 dimensies (C en gamma voor SVM) prima geschikt. Voor complexe modellen zoals gradient boosting met 6 of meer hyperparameters presteert willekeurig zoeken met 50–100 iteraties consequent beter dan een raster met vergelijkbare rekenkosten.
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)}')Halverend rasterzoeken voor grotere zoekruimten
scikit-learn 0.24+ introduceerde HalvingGridSearchCV en HalvingRandomSearchCV, gebaseerd op het algoritme voor opeenvolgende halvering: begin met alle kandidaten die op een kleine deelverzameling van de gegevens zijn getraind, verwijder de slechtste helft, verdubbel de hoeveelheid gegevens en herhaal dit totdat één winnaar overblijft. Zo vind je goede hyperparameters met veel minder rekenwerk dan met volledig rasterzoeken of willekeurig zoeken. Daardoor wordt het praktisch voor grotere zoekruimten met modellen die veel rekenkracht kosten.
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))Bayesiaanse optimalisatie: het slimme alternatief
Zowel zoeken op een raster als willekeurig zoeken is ongeïnformeerd: ze gebruiken geen resultaten van eerdere evaluaties om toekomstige keuzes te sturen. Bayesiaanse optimalisatie bouwt een probabilistisch model van de doelfunctie (de CV-score als functie van hyperparameters) en gebruikt dit om intelligent de meest veelbelovende combinatie te selecteren voor de volgende evaluatie. Bibliotheken zoals Optuna, BayesSearchCV (scikit-optimize) en HyperOpt implementeren dit en vinden doorgaans veel betere hyperparameters met veel minder evaluaties dan willekeurig zoeken.
Praktische aanbevelingen voor zoekstrategieën
Een praktische richtlijn: (1) begin met willekeurig zoeken gedurende 30-100 iteraties om het veelbelovende gebied van hyperparameters te identificeren; (2) als je meer precisie nodig hebt, voer je rond dat gebied een fijnmazige rasterzoektocht uit; (3) gebruik voor dure modellen (met een trage training) Bayesiaanse optimalisatie (Optuna) om het aantal evaluaties te beperken; (4) gebruik altijd een pijplijn om datalekken te voorkomen; (5) stel n_jobs=-1 in voor parallelle verwerking; (6) gebruik refit=True (de standaardwaarde), zodat het beste model na het zoeken opnieuw wordt getraind met alle trainingsgegevens. Gebruik de testset nooit om hyperparameters te kiezen.
Alle resultaten van GridSearchCV openen
Na het trainen is grid.cv_results_ een woordenboek met de gemiddelde testscore, standaardafwijking, trainingstijden en parameterwaarden voor elke geëvalueerde combinatie. Als je dit omzet naar een Pandas DataFrame, kun je de resultaten eenvoudig sorteren, filteren en visualiseren. Dit is nuttig om te begrijpen hoe gevoelig de score is voor elke parameter: als alle C-waarden vergelijkbare scores opleveren, maar gamma een groot effect heeft, weet je dat je toekomstige afstemming op gamma moet richten.
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))Snelle controle
Test je begrip van rasterzoeken versus willekeurig zoeken uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat rasterzoeken elke combinatie uitputtend evalueert, maar exponentieel schaalt met het aantal hyperparameters, dat willekeurig zoeken continu uit verdelingen steekproeven neemt en beter werkt wanneer slechts enkele hyperparameters belangrijk zijn, en dat halvering en Bayesiaanse optimalisatie de evaluatiekosten voor dure modellen verder verlagen. Hierna verkennen we geneste kruisvalidatie om hyperparameters gelijktijdig te selecteren en te evalueren zonder vertekening.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Grid search versus random search” gratis?
Ja — de volledige tekst van “Grid search versus random search” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “Grid search versus random search”?
Cursisten configureren GridSearchCV en RandomizedSearchCV met dezelfde hyperparameterruimte, vergelijken hun dekking en rekenkosten en kiezen de snelste methode voor grote zoekruimten. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Grid search versus random search”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- K-fold crossvalidatie: splitsen zonder datalekken
- Gestratificeerde crossvalidatie en crossvalidatie voor tijdreeksen
- Grid search versus random search
- Geneste crossvalidatie: selecteren en evalueren tegelijk