C en gamma afstemmen met een grid search
U voert een GridSearchCV uit voor C en gamma, interpreteert de validatieheatmap en selecteert de beste hyperparameters voor een SVM-classifier.
C en gamma afstemmen met een grid search is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 4 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 C en gamma samen moeten worden afgestemd
Voor een RBF-SVM moeten zowel C als gamma gelijktijdig worden afgestemd, omdat hun effecten elkaar beïnvloeden. Een hoge C met een kleine gamma kan een goede grens opleveren, maar een lage C met een hoge gamma kan dat ook doen. Als je ze onafhankelijk zoekt — door één parameter vast te zetten terwijl je de andere optimaliseert — mis je deze interactie en kom je vaak uit op een suboptimale combinatie. De standaardaanpak is een 2D-rasterzoekopdracht die elke combinatie van C- en gammawaarden beoordeelt en het paar met de beste score bij kruisvalidatie kiest.
De rasterzoekopdracht instellen
Gebruik GridSearchCV uit scikit-learn om elke combinatie van hyperparameters te beoordelen. Verpak je schaler en SVM in een Pipeline, zodat GridSearchCV de schaler opnieuw aanpast op elke trainingsvouw zonder statistieken uit de testgegevens te laten lekken. Geef het raster van hyperparameters op met de notatie met dubbele underscores svc__C en svc__gamma om de benoemde stap in de pijplijn te selecteren.
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([('scaler', StandardScaler()), ('svc', SVC(kernel='rbf'))])
param_grid = {'svc__C': np.logspace(-2, 3, 6), 'svc__gamma': np.logspace(-4, 0, 5)}
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))Logaritmische schaal voor C en gamma
Zowel C als gamma moeten op een logaritmische schaal worden doorzocht (machten van 10 of machten van 2). De reden is dat het gedrag van het model sterk verandert wanneer deze parameters van 0,001 naar 0,01 gaan (een verandering met factor 10), maar nauwelijks verandert van 10 naar 11 (een verandering van 10%). Een typisch grof raster omvat: C in [0.01, 0.1, 1, 10, 100, 1000] en gamma in [0.0001, 0.001, 0.01, 0.1, 1]. Nadat je het beste gebied hebt gevonden, kun je verfijnen met een fijner raster rond die waarden.
import numpy as np
# Generate logarithmically spaced values
C_range = np.logspace(-2, 3, 6) # [0.01, 0.1, 1, 10, 100, 1000]
gamma_range = np.logspace(-4, 0, 5) # [0.0001, 0.001, 0.01, 0.1, 1.0]
print('C values:', np.round(C_range, 4))
print('gamma values:', np.round(gamma_range, 5))
print('Total combinations:', len(C_range) * len(gamma_range))De validatie-heatmap interpreteren
Na een rasterzoekopdracht kun je de resultaten visualiseren als een 2D-heatmap met C op de ene as en gamma op de andere, ingekleurd op basis van de kruisvalidatiescore. Hiermee zie je: (1) een optimaal gebied waar de scores pieken; (2) underfitting bij lage C en lage gamma (te glad); (3) overfitting bij hoge C en hoge gamma (te complex). Als je de vorm van het optimale gebied herkent, krijg je inzicht in de gevoeligheid van het model en kun je beslissen of je een fijnere zoekopdracht wilt uitvoeren.
import numpy as np
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
X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('svc', SVC(kernel='rbf'))])
param_grid = {'svc__C': np.logspace(-1, 2, 4), 'svc__gamma': np.logspace(-3, 0, 4)}
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X, y)
results = pd.DataFrame(grid.cv_results_)
pivot = results.pivot_table(index='param_svc__C', columns='param_svc__gamma', values='mean_test_score')
print(pivot.round(3))Rasterzoekopdracht van grof naar fijn
Een praktische strategie is zoeken van grof naar fijn: voer eerst een grof raster uit over een breed bereik om het veelbelovende gebied te vinden en voer daarna een fijn raster uit dat zich op dat gebied richt. Als C=10 en gamma=0.01 bijvoorbeeld het beste lijken op het grove raster, zoek je voor het fijne raster naar C in [5, 8, 10, 15, 20] en gamma in [0.005, 0.008, 0.01, 0.015, 0.02]. Dit vermindert de totale rekentijd ten opzichte van meteen een fijn raster over de volledige ruimte uitvoeren.
RandomizedSearchCV als alternatief
Bij grotere rasters of wanneer het optimale gebied onbekend is, neemt RandomizedSearchCV willekeurige combinaties uit continue verdelingen in plaats van elk rasterpunt te testen. Dit schaalt veel beter: 50 willekeurige combinaties uit een raster van 10×10 (100 punten) vinden het optimum bijna even betrouwbaar als alle 100 punten testen, terwijl ze de helft van de rekenkracht gebruiken. Gebruik scipy.stats.loguniform voor de verdelingen van C en gamma om het logaritmische steekproefgedrag te behouden.
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(kernel='rbf'))])
param_dist = {'svc__C': loguniform(0.01, 1000), 'svc__gamma': loguniform(0.0001, 1)}
rnd = RandomizedSearchCV(pipe, param_dist, n_iter=50, 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))Het beste model op de testset beoordelen
Na de rasterzoekopdracht wordt GridSearchCV.best_estimator_ automatisch opnieuw getraind op de volledige trainingsset met de beste hyperparameters. Beoordeel het model op de achtergehouden testset met grid.score(X_test, y_test) — roep dit slechts één keer aan, helemaal aan het einde. Als je de testscore gebruikt om verder af te stemmen, laat je in feite informatie uit de testset lekken naar het modelselectieproces en krijg je een te optimistische schatting van de prestaties.
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, train_test_split
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)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
pipe = Pipeline([('sc', StandardScaler()), ('svc', SVC(kernel='rbf'))])
param_grid = {'svc__C': np.logspace(-1, 2, 4), 'svc__gamma': np.logspace(-3, 0, 4)}
grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)
print('CV score:', round(grid.best_score_, 4))
print('Test score:', round(grid.score(X_test, y_test), 4))Rekenkosten van een rasterzoekopdracht
Een rasterzoekopdracht met k vouwen, m C-waarden en n gammwaarden traint k × m × n modellen. Een zoekopdracht met 5 vouwen over een raster van 6×5 vereist 150 modelaanpassingen. Elke aanpassing op een gegevensverzameling met 1.000 voorbeelden en een RBF-SVM duurt een fractie van een seconde, maar met 100.000 voorbeelden kan elke aanpassing minuten duren. Beperk de kosten als volgt: gebruik n_jobs=-1 voor parallellisatie, begin met grove rasters en overweeg RandomizedSearchCV met minder iteraties voor grote gegevensverzamelingen of dure modellen.
Geneste kruisvalidatie voor onbevooroordeelde schattingen
Hyperparameters selecteren op basis van validatiescores en het model vervolgens beoordelen op een afzonderlijke testset kan nog steeds licht optimistische schattingen opleveren door het aantal geteste combinaties van hyperparameters. Bij geneste kruisvalidatie wordt een buitenste CV-lus gebruikt voor de beoordeling en een binnenste CV-lus (rasterzoekopdracht) voor de selectie. De testset van de buitenste vouw wordt nooit gebruikt voor het trainen van een model of het selecteren van hyperparameters, waardoor je een werkelijk onbevooroordeelde schatting van de generalisatie krijgt. Dit is de gouden standaard voor kleine gegevensverzamelingen waarbij je geen afzonderlijke testset kunt gebruiken.
Praktische tips voor het afstemmen van SVM's
Praktisch advies voor een SVM-grid search: (1) neem je scaler altijd op in de pijplijn om datalekken te voorkomen; (2) gebruik gamma='scale' als startpunt voordat je vaste waarden onderzoekt; (3) als de beste score aan de rand van je grid ligt (bijvoorbeeld als C=1000 het beste is), breid je het grid verder uit; (4) vergelijk de CV-score met de testscore — een groot verschil wijst op overfitting tijdens het selecteren van hyperparameters; (5) voor problemen met meerdere klassen breidt SVM zich automatisch uit met onderliggende one-vs-one- of one-vs-rest-strategieën.
SVM Predict_proba met Platt-schaling
Standaard produceert SVC geen waarschijnlijkheidsschattingen — alleen harde klasselabels of ruwe scores van de beslisfunctie. Door probability=True in te stellen schakel je Platt-schaling in: boven op de scores van de beslisfunctie van de SVM wordt met kruisvalidatie een aanvullend logistisch regressiemodel getraind om de uitvoer naar waarschijnlijkheden te kalibreren. Hierdoor duurt het trainen van de SVM 5 tot 10 keer langer en verandert de beslissingsgrens enigszins. Gebruik waarschijnlijkheidsschattingen alleen wanneer je ze nodig hebt (soft voting, ROC-AUC, kalibratie) en gebruik anders harde voorspellingen.
from sklearn.svm import SVC
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = make_pipeline(StandardScaler(), SVC(kernel='rbf', C=10, gamma=0.01, probability=True))
model.fit(X_train, y_train)
probs = model.predict_proba(X_test)
print('Probability shape:', probs.shape)
print('First 3 predicted probs (class 0, class 1):'); print(probs[:3].round(3))Korte controle
Toets je begrip van Grid Search voor SVM-hyperparameters uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat C en gamma samen moeten worden afgestemd met een 2D-grid search, dat je beide op een logaritmische schaal moet onderzoeken om relevante grootheden te bestrijken, en dat je de scaler altijd in de pijplijn moet opnemen om datalekken tijdens kruisvalidatie te voorkomen. Hierna onderzoeken we Gradient Boosting en hoe opeenvolgende foutcorrectie krachtige ensembles opbouwt.
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 “C en gamma afstemmen met een grid search” gratis?
Ja — de volledige tekst van “C en gamma afstemmen met een 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 “C en gamma afstemmen met een grid search”?
U voert een GridSearchCV uit voor C en gamma, interpreteert de validatieheatmap en selecteert de beste hyperparameters voor een SVM-classifier. 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 4 van 4.
Hoe lang duurt de les “C en gamma afstemmen met een 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
- Classifier met maximale marge: supportvectors en hypervlak
- SVM met soft margin en de parameter C
- De kerneltruc: RBF-, polynomiale en sigmoidkernels
- C en gamma afstemmen met een grid search