Snelle referentie

Scikit-Learn API & Machine Learning Workflow Spiekbrief

Productiericht naslagwerk voor Scikit-Learn: uniform API-ontwerp (Estimator, Transformer, Predictor), datavoorbereiding, feature engineering, modellen met en zonder toezicht, kruisvalidatie, evaluatiemetrieken en lekvrije Pipelines.

· Gepubliceerd · Bijgewerkt

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) en fit_transform(X).
  • Predictor (Voorspeller): Doet voorspellingen op nieuwe steekproeven via predict(X), predict_proba(X) en score(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())
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))

Verwante onderwerpen