Scikit-Learn (sklearn) is de fundamentele opensourcebibliotheek in Python voor statistische modellering en traditionele machine learning, gebouwd op NumPy, SciPy en Matplotlib. De architectonische kracht berust op een strikt uniform ontwerppatroon met drie interfaces:
- Estimator (Schatteer): Leert modelparameters uit data via
fit(X, y). - Transformer (Transformator): Bewerkt en projecteert kenmerken via
transform(X)enfit_transform(X). - Predictor (Voorspeller): Doet voorspellingen op nieuwe steekproeven via
predict(X),predict_proba(X)enscore(X, y).
🔗 Gerelateerde spiekbrieven: NumPy Spiekbrief · Pandas Spiekbrief · Algoritmen voor begeleid leren · Data-analysemethoden · Python Spiekbrief
1. End-to-end snelstartvoorbeeld
Het volgende zelfstandige script doorloopt het laden van een dataset, gestratificeerd splitsen, schalen van kenmerken, trainen en evalueren:
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report
# 1. Data laden
iris = load_iris()
X, y = iris.data, iris.target
# 2. Gestratificeerde splitsing in trainings- en testset
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# 3. Kenmerkschaling (ALLEEN fitten op trainingsset om datalekken te voorkomen)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 4. Model trainen
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)
# 5. Voorspellen en evalueren
y_pred = knn.predict(X_test_scaled)
print(f"Nauwkeurigheid: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
2. Datavoorbereiding & Splitsing
Scikit-Learn vereist 2D numerieke structuren: een kenmerkenmatrix $X$ van vorm (n_samples, n_features) en een doelvector $y$ van vorm (n_samples,). Invoer kan bestaan uit NumPy-ndarrays, ijle SciPy-matrices (scipy.sparse) of Pandas DataFrames/Series.
2.1 Ingebouwde & Synthetische Datasets
from sklearn import datasets
# Kleine referentiedatasets (retourneert Bunch-object)
iris = datasets.load_iris() # Meervoudige classificatie
digits = datasets.load_digits() # 8x8 handgeschreven cijferafbeeldingen
diabetes = datasets.load_diabetes() # Regressie-benchmark
wine = datasets.load_wine() # Chemische analyse van wijn in 3 klassen
# Echte benchmarkdatasets (lokaal gecachet)
housing = datasets.fetch_california_housing()
# Synthetische datageneratie voor algoritmetests
X, y = datasets.make_classification(
n_samples=1000, n_features=20, n_informative=15, n_classes=2, random_state=42
)
X_reg, y_reg = datasets.make_regression(n_samples=500, n_features=10, noise=0.1, random_state=42)
X_blob, y_blob = datasets.make_blobs(n_samples=300, centers=3, n_features=2, random_state=42)
2.2 Dataset opsplitsen (train_test_split)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.25, # Verhouding van de testset (standaard: 0.25)
random_state=42, # Vaste seed voor reproduceerbaarheid
shuffle=True, # Steekproeven schudden voor het splitsen
stratify=y # Sterk aanbevolen bij classificatie: behoudt klasseverhoudingen
)
3. Feature Engineering & Datavoorbewerking (sklearn.preprocessing & sklearn.impute)
| Transformator | Toepassing | Wiskundige transformatie / Logica | Belangrijke parameters |
|---|---|---|---|
StandardScaler |
Z-score standaardisatie van numerieke kenmerken | $z = \frac{x - \mu}{\sigma}$ (gemiddelde 0, variantie 1) | with_mean=True, with_std=True |
MinMaxScaler |
Schalen van kenmerken naar een begrensd interval | $x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} \cdot (\max - \min) + \min$ | feature_range=(0, 1) |
RobustScaler |
Uitschieter-robuuste schaling van kenmerken | Schaling op basis van interkwartielafstand: $x' = \frac{x - Q_2}{Q_3 - Q_1}$ | quantile_range=(25.0, 75.0) |
Normalizer |
Rijgewijze normalisatie per steekproef | Schaalt elke steekproef naar een eenheidsnorm ($L_1$, $L_2$ of Max) | norm='l2' ('l1', 'max') |
Binarizer |
Drempelwaarde-binarisatie van continue waarden | $x > \text{threshold} \Rightarrow 1$, anders $0$ | threshold=0.0 |
SimpleImputer |
Vervanging van ontbrekende waarden (imputatie) | Vervangt ontbrekende waarden door gemiddelde, mediaan, modus of constante | missing_values=np.nan, strategy='mean' |
OneHotEncoder |
One-Hot codering voor nominale categorieën | Zet categorieën om in binaire dummy-kolommen | drop='first', handle_unknown='ignore' |
OrdinalEncoder |
Ordinale codering voor geordende categorieën | Codeert categorieën in geordende gehele getallen $0, \dots, K-1$ | categories='auto', encoded_missing_value |
LabelEncoder |
Labelcodering voor de doelvariabele $y$ | Zet tekstlabels om in getallen $0 \dots C-1$ | ALLEEN voor de doelvariabele $y$, NOOIT voor kenmerken $X$ |
PolynomialFeatures |
Genereren van polynoom- en interactietermen | Genereert termen van hogere orde $[1, a, b, a^2, ab, b^2]$ | degree=2, include_bias=False |
3.1 Voorbeelden van voorbewerkingscode
import numpy as np
from sklearn.preprocessing import (
StandardScaler, MinMaxScaler, RobustScaler, Normalizer,
Binarizer, OneHotEncoder, OrdinalEncoder, LabelEncoder, PolynomialFeatures
)
from sklearn.impute import SimpleImputer
# 1. Numerieke standaardisatie (nooit fitten op testdata!)
scaler = StandardScaler()
X_train_std = scaler.fit_transform(X_train)
X_test_std = scaler.transform(X_test)
# 2. Imputatie van ontbrekende waarden (mediaan-strategie)
imputer = SimpleImputer(missing_values=np.nan, strategy='median')
X_train_imp = imputer.fit_transform(X_train)
X_test_imp = imputer.transform(X_test)
# 3. One-Hot codering (verwerkt ongeziene testcategorieën veilig)
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
X_train_ohe = ohe.fit_transform(X_train_cat)
X_test_ohe = ohe.transform(X_test_cat)
# 4. Codering van de doelvariabele
le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)
# 5. Polynomiale kenmerkuitbreiding
poly = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly.fit_transform(X_train)
4. Hoofdindex van gangbare modellen (Estimators)
4.1 Begeleid leren: Classificatie
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier
# Logistische regressie (lineaire basisclassificatie)
clf_lr = LogisticRegression(C=1.0, max_iter=200, random_state=42)
# K-Dichtstbijzijnde buren (KNN)
clf_knn = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2)
# Support Vector Machine (RBF-kernel)
clf_svm = SVC(C=1.0, kernel='rbf', gamma='scale', probability=True, random_state=42)
# Gaussiaanse Naive Bayes
clf_gnb = GaussianNB()
# Random Forest (Bagging-ensemble)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=None, n_jobs=-1, random_state=42)
# Histogram-gebaseerde Gradient Boosting (snelle GBDT vergelijkbaar met LightGBM)
clf_hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100, random_state=42)
4.2 Begeleid leren: Regressie
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor
# Gewone kleinste-kwadraten regressie (OLS)
reg_lr = LinearRegression()
# Ridge-regressie (L2-regularisatie tegen multicollineariteit)
reg_ridge = Ridge(alpha=1.0)
# Lasso-regressie (L1-regularisatie voor kenmerkselectie)
reg_lasso = Lasso(alpha=0.1)
# Support Vector Regressie (SVR)
reg_svr = SVR(kernel='rbf', C=1.0, epsilon=0.1)
# Random Forest Regressor
reg_rf = RandomForestRegressor(n_estimators=100, n_jobs=-1, random_state=42)
4.3 Onbegeleid leren: Clustering & Dimensiereductie
from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA
# K-Means Clustering
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans.fit(X)
cluster_labels = kmeans.labels_ # Clustertoewijzingen
cluster_centers = kmeans.cluster_centers_
# Dichtheidsgebaseerde ruimtelijke clustering (DBSCAN: ruisbestendig)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X) # -1 geeft ruis / uitschieters aan
# Principale componentenanalyse (PCA): behoudt 95% variantie
pca = PCA(n_components=0.95)
X_pca = pca.fit_transform(X)
print("Behouden componenten:", pca.n_components_)
print("Verklaarde variantieverhouding:", pca.explained_variance_ratio_)
5. Samenvatting van uniforme API-bewerkingen
| Bewerking | Kanonieke methode | Doeltype | Semantiek & Retourwaarde |
|---|---|---|---|
| Fitten (Fit) | estimator.fit(X, y) |
Alle Estimators | Schat parameters uit trainingsdata; retourneert self |
| Voorspellen (Predict) | predictor.predict(X) |
Alle Predictors | Genereert discrete klasselabels of continue waarden |
| Waarschijnlijkheid | predictor.predict_proba(X) |
Classificatoren | Berekent a-posterioriklassekansenmatrix |
| Beslissingsafstand | predictor.decision_function(X) |
Lineaire modellen / SVM | Afstand met teken van steekproeven tot het scheidingshypervlak |
| Transformeren | transformer.transform(X) |
Alle Transformers | Projecteert kenmerken met behulp van geleerde parameters |
| Fitten & Transformeren | transformer.fit_transform(X) |
Alle Transformers | Berekent parameters en transformeert in één geoptimaliseerde stap |
| Standaardscore | estimator.score(X, y) |
Classificatoren / Regressors | Nauwkeurigheid voor classificatie; determinatiecoëfficiënt $R^2$ voor regressie |
6. Evaluatiemetrieken (sklearn.metrics)
6.1 Classificatiemetrieken
from sklearn.metrics import (
accuracy_score, precision_score, recall_score, f1_score,
roc_auc_score, confusion_matrix, classification_report,
ConfusionMatrixDisplay
)
# 1. Discrete labelmetrieken (specificeer average bij meervoudige klassen)
acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred, average='macro')
rec = recall_score(y_test, y_pred, average='macro')
f1 = f1_score(y_test, y_pred, average='macro')
# 2. Continue rankingmetrieken (ROC-AUC vereist voorspelde waarschijnlijkheden)
y_prob = clf.predict_proba(X_test)[:, 1] # Kansen van de positieve klasse
auc = roc_auc_score(y_test, y_prob)
# 3. Verwarringsmatrix en uitgebreid tekstueel classificatierapport
cm = confusion_matrix(y_test, y_pred)
print(classification_report(y_test, y_pred))
# 4. Grafische weergave van verwarringsmatrix
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
6.2 Regressiemetrieken
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False) # Wortel van de gemiddelde kwadratische fout (RMSE)
r2 = r2_score(y_test, y_pred) # Determinatiecoëfficiënt R²
6.3 Clusteringmetrieken
from sklearn.metrics import (
adjusted_rand_score, homogeneity_score, v_measure_score, silhouette_score
)
# Externe validatie (wanneer echte labels beschikbaar zijn)
ari = adjusted_rand_score(y_true, cluster_labels) # Bereik: [-1, 1], hoger is beter
homo = homogeneity_score(y_true, cluster_labels) # Bereik: [0, 1]
vm = v_measure_score(y_true, cluster_labels) # Harmonisch gemiddelde van homogeniteit en volledigheid
# Interne validatie (geometrisch, geen labels vereist)
sil = silhouette_score(X, cluster_labels) # Bereik: [-1, 1], dicht bij 1 duidt op duidelijke clusters
7. Kruisvalidatie & Hyperparameterafstemming (sklearn.model_selection)
7.1 Kruisvalidatie (Cross-Validation)
from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold
# Standaard K-Fold kruisvalidatie
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"5-Fold CV Nauwkeurigheid: {scores.mean():.4f} (±{scores.std():.4f})")
# Gestratificeerde K-Fold generator
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_skf = cross_val_score(clf, X, y, cv=skf, scoring='f1_macro')
# Gezamenlijke evaluatie van meerdere metrieken
multi_scores = cross_validate(
clf, X, y, cv=5,
scoring=['accuracy', 'roc_auc'],
return_train_score=False
)
print("Gemiddelde validatie-AUC:", multi_scores['test_roc_auc'].mean())
7.2 Grid Search en Random Search
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import randint
# 1. Uitputtende Grid Search (GridSearchCV)
param_grid = {
'n_neighbors': [3, 5, 7, 11],
'weights': ['uniform', 'distance'],
'metric': ['euclidean', 'manhattan']
}
grid = GridSearchCV(
estimator=KNeighborsClassifier(),
param_grid=param_grid,
cv=5,
scoring='accuracy',
n_jobs=-1
)
grid.fit(X_train, y_train)
print("Beste parameters:", grid.best_params_)
best_model = grid.best_estimator_
# 2. Willekeurig zoeken naar parameters (voor grote zoekruimtes)
param_dist = {
'n_estimators': randint(50, 300),
'max_depth': [None, 5, 10, 20],
'min_samples_split': randint(2, 11)
}
rand_search = RandomizedSearchCV(
estimator=RandomForestClassifier(random_state=42),
param_distributions=param_dist,
n_iter=20, # Aantal willekeurige combinaties
cv=5,
scoring='accuracy',
random_state=42,
n_jobs=-1
)
rand_search.fit(X_train, y_train)
print("Beste Random Search parameters:", rand_search.best_params_)
8. Beste praktijken voor productie: Pipeline & ColumnTransformer
8.1 Waarom Pipelines onmisbaar zijn
Het globaal toepassen van schaling of imputatie vóór het splitsen veroorzaakt Datalekkage (Data Leakage): gegevens uit de testpartities lekken door naar de training, wat leidt tot misleidend optimistische offline scores die in productie falen.
Pipeline bundelt transformatiestappen en modellen tot een ondeelbare lekvrije eenheid. Tijdens kruisvalidatie worden transformatoren uitsluitend gefit op de trainingspartities.
8.2 Productierecept met ColumnTransformer
Reële tabeldata combineren doorgaans continue numerieke kolommen en categorische variabelen:
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
# 1. Kenmerkkolommen expliciet scheiden
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['gender', 'occupation', 'city']
# 2. Numerieke sub-pipeline: mediaan-imputatie -> standaardisatie
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())
])
# 3. Categorische sub-pipeline: constante imputatie -> One-Hot codering
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
# 4. Kolommen koppelen in een uniforme ColumnTransformer
preprocessor = ColumnTransformer(transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)
])
# 5. Volledige modelpipeline samenstellen
full_pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])
# 6. Atomair trainen en voorspellen (geen lekken, veilige implementatie)
full_pipeline.fit(X_train_df, y_train)
y_pred = full_pipeline.predict(X_test_df)
print("Pipeline testnauwkeurigheid:", full_pipeline.score(X_test_df, y_test))