Een volledige pipeline valideren en doorzoeken met grid search
Cursisten geven een Pipeline door aan cross_val_score en GridSearchCV en gebruiken de notatie met dubbele underscores om hyperparameters van afzonderlijke stappen op te geven.
Een volledige pipeline valideren en doorzoeken met grid 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.
Waarom een volledige pijplijn doorzoeken met rasterzoektocht?
Het afstemmen van hyperparameters moet altijd worden gecombineerd met kruisvalidatie om overfitting op de validatieverzameling te voorkomen. Wanneer je stappen voor voorbewerking hun eigen parameters hebben (bijvoorbeeld PCA's n_components en de drop van OneHotEncoder), moeten die tegelijkertijd met de parameters van het model worden afgestemd. Door alles in een Pipeline te verpakken en aan GridSearchCV door te geven, zorg je ervoor dat dit correct en zonder gegevenslekken gebeurt.
Een pijplijn doorgeven aan cross_val_score
De eenvoudigste manier om een Pipeline eerlijk te evalueren is cross_val_score(pipeline, X, y, cv=5). Bij elke vouw wordt de volledige pijplijn opnieuw gefit — inclusief scaler en classificatiemodel — op het trainingsgedeelte, waarna de pijplijn wordt geëvalueerd op de achtergehouden vouw. Het gemiddelde en de standaardafwijking van de geretourneerde array geven je een betrouwbare schatting van de generalisatie.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_wine
import numpy as np
X, y = load_wine(return_X_y=True)
pipe = Pipeline([
('sc', StandardScaler()),
('lr', LogisticRegression(C=1.0, max_iter=300))
])
scores = cross_val_score(pipe, X, y, cv=5, scoring='accuracy')
print(f'CV accuracy: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Notatie met dubbele underscores voor pijplijnparameters
Gebruik stepname__paramname om naar een parameter van een benoemde stap in de pijplijn te verwijzen. Voor geneste structuren, zoals een ColumnTransformer in een Pipeline, koppel je de namen aan elkaar: preprocessor__num__scaler__with_std. Deze conventie wordt zowel gebruikt in aanroepen van set_params als in het woordenboek param_grid dat aan GridSearchCV wordt doorgegeven.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
pipe = Pipeline([('sc', StandardScaler()), ('svm', SVC())])
# Print all tunable parameters
params = pipe.get_params()
for k, v in params.items():
print(f' {k}: {v}')Een param_grid definiëren voor GridSearchCV
Maak een woordenboek waarin de sleutels namen van pijplijnparameters zijn (met notatie met dubbele underscores) en de waarden lijsten met uit te proberen kandidaten zijn. GridSearchCV traint en evalueert de pijplijn voor elke combinatie in het cartesische product van alle lijsten. Het totale aantal fits is gelijk aan len(combinations) * cv_folds.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_wine
X, y = load_wine(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svm', SVC())])
param_grid = {
'svm__C': [0.1, 1.0, 10.0, 100.0],
'svm__kernel': ['rbf', 'linear'],
'svm__gamma': ['scale', 'auto']
}
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1, scoring='accuracy')
grid.fit(X, y)
print('Best params:', grid.best_params_)
print('Best CV score:', grid.best_score_.round(4))Ook parameters van de voorbewerker afstemmen
Je kunt parameters van de voorbewerker in hetzelfde raster opnemen. Stem bijvoorbeeld n_components van een PCA-stap af naast de regularisatie van de classificator. Zo vind je tegelijkertijd het optimale compressieniveau en de optimale complexiteit van het model. Dat is grondiger dan ze in afzonderlijke stappen af te stemmen.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True)
pipe = Pipeline([
('sc', StandardScaler()),
('pca', PCA()),
('lr', LogisticRegression(max_iter=500))
])
param_grid = {
'pca__n_components': [10, 20, 30, 40],
'lr__C': [0.1, 1.0, 10.0]
}
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X, y)
print('Best:', grid.best_params_)
print('Score:', grid.best_score_.round(4))Resultaten van GridSearchCV bekijken
Het attribuut cv_results_ is een woordenboek (dat je kunt omzetten in een DataFrame) met gemiddelde testscores, standaardafwijkingen en fittijden voor elke combinatie van hyperparameters. Door dit DataFrame te bekijken, krijg je inzicht in het prestatiebeeld en kun je bepalen of het beste resultaat duidelijk beter is dan het op één na beste, of dat veel parametercombinaties vergelijkbare prestaties leveren.
import pandas as pd
results = pd.DataFrame(grid.cv_results_)
results_sorted = results.sort_values('rank_test_score')
print(results_sorted[['param_pca__n_components', 'param_lr__C',
'mean_test_score', 'std_test_score']].head(6).to_string())RandomizedSearchCV voor grote parameterruimten
Wanneer de parameterruimte groot is, wordt GridSearchCV rekenkundig onhaalbaar. RandomizedSearchCV kiest een vast aantal combinaties willekeurig (bepaald door n_iter) en vindt vaak bijna optimale resultaten in een fractie van de tijd. Gebruik verdelingen uit scipy.stats voor continue parameters, zodat je uit een bereik kunt steekproeven in plaats van uit afzonderlijke waarden.
from sklearn.model_selection import RandomizedSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.datasets import load_wine
from scipy.stats import loguniform, uniform
X, y = load_wine(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svm', SVC())])
param_dist = {
'svm__C': loguniform(0.01, 100),
'svm__gamma': loguniform(1e-4, 1),
'svm__kernel': ['rbf', 'linear']
}
rs = RandomizedSearchCV(pipe, param_dist, n_iter=30, cv=5, random_state=42, n_jobs=-1)
rs.fit(X, y)
print('Best params:', rs.best_params_)
print('Best score:', rs.best_score_.round(4))Geneste kruisvalidatie: evaluatie en selectie gecombineerd
Een standaardrasterzoektocht met kruisvalidatie past zich enigszins aan de validatieverzameling aan: nadat je de beste hyperparameters hebt gekozen, heb je de validatiegegevens impliciet gebruikt. Geneste kruisvalidatie lost dit op: de buitenste lus evalueert de generalisatie van het afgestemde model en de binnenste lus selecteert de hyperparameters. De score van de buitenste lus is een onbevooroordeelde schatting van de werkelijke testprestatie van het uiteindelijke model.
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svm', SVC())])
param_grid = {'svm__C': [0.1, 1.0, 10.0], 'svm__gamma': ['scale', 'auto']}
inner_cv = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
# Outer CV evaluates the tuning procedure itself
outer_scores = cross_val_score(inner_cv, X, y, cv=5)
print(f'Nested CV score: {np.mean(outer_scores):.4f} +/- {np.std(outer_scores):.4f}')De beste schatter gebruiken
Na GridSearchCV.fit is het attribuut best_estimator_ de pijplijn die opnieuw is gefit op de volledige trainingsgegevens met de beste hyperparameters. Dit is het model dat je voor de uiteindelijke voorspellingen moet gebruiken. Je kunt er rechtstreeks predict, predict_proba of score op aanroepen.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.datasets import load_wine
X, y = load_wine(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('svm', SVC())])
param_grid = {'svm__C': [0.1, 1.0, 10.0], 'svm__kernel': ['rbf', 'linear']}
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)
best = grid.best_estimator_
print('Test accuracy:', best.score(X_test, y_test).round(4))Scoreopties in GridSearchCV
Standaard gebruikt GridSearchCV de standaards score van de schatter (nauwkeurigheid voor classificatiemodellen). Je kunt elke metriek opgeven met de parameter scoring: 'roc_auc', 'f1', 'neg_mean_squared_error' of een aangepaste scorer die je met make_scorer hebt gemaakt. Voor onevenwichtige gegevensverzamelingen zijn 'f1_macro' of 'roc_auc' betere keuzes dan alleen nauwkeurigheid.
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
param_grid = {'lr__C': [0.01, 0.1, 1.0, 10.0]}
grid = GridSearchCV(pipe, param_grid, cv=5, scoring='roc_auc', n_jobs=-1)
grid.fit(X, y)
print('Best C:', grid.best_params_)
print('Best ROC-AUC:', grid.best_score_.round(4))De beste pijplijn opslaan
Sla de beste pijplijn na de rasterzoektocht op schijf op. Dit ene bestand bevat de scaler (met de gefitte gemiddelden en varianties), de PCA (met de componenten) en de classificator (met de gewichten) — alles wat nodig is om voorspellingen op nieuwe gegevens te reproduceren. Laad de pijplijn in productie en roep rechtstreeks predict aan.
import joblib
# Save the best estimator
joblib.dump(grid.best_estimator_, '/tmp/best_pipeline.pkl')
# Load and verify
loaded = joblib.load('/tmp/best_pipeline.pkl')
print('Loaded pipeline test score:', loaded.score(X_test, y_test).round(4))Snelle controle
Test je begrip van het kruisvalideren en doorzoeken met rasterzoektocht van een volledige pijplijn uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat cross_val_score op een Pipeline alle stappen per vouw opnieuw fit en eerlijke schattingen van de generalisatie oplevert, dat notatie met dubbele underscores verwijst naar geneste hyperparameters in param_grid, en dat RandomizedSearchCV grote parameterruimten efficiënt verkent door een vast aantal willekeurige combinaties te selecteren. Hierna slaan we een volledige pijplijn met joblib op en laden we die voor implementatie in productie.
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 “Een volledige pipeline valideren en doorzoeken met grid search” gratis?
Ja — de volledige tekst van “Een volledige pipeline valideren en doorzoeken met grid 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 “Een volledige pipeline valideren en doorzoeken met grid search”?
Cursisten geven een Pipeline door aan cross_val_score en GridSearchCV en gebruiken de notatie met dubbele underscores om hyperparameters van afzonderlijke stappen op te geven. 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 “Een volledige pipeline valideren en doorzoeken met grid 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
- Uw eerste pipeline bouwen: scaler plus classifier
- ColumnTransformer in een pipeline
- Een volledige pipeline valideren en doorzoeken met grid search
- Een pipeline opslaan en laden met joblib