Kurzreferenz

Scikit-Learn API & Machine Learning Workflow Spickzettel

Ein praxisorientierter Referenzleitfaden für Scikit-Learn: einheitliches API-Design (Estimator, Transformer, Predictor), Datenvorbereitung, Feature-Engineering, überwachte und unüberwachte Modelle, Kreuzvalidierung, Evaluierungsmetriken und leckagefreie Pipelines.

· Veröffentlicht · Aktualisiert

Scikit-Learn (sklearn) ist die grundlegende Open-Source-Bibliothek für maschinelles Lernen und statistische Modellierung in Python, aufgebaut auf NumPy, SciPy und Matplotlib. Ihre architektonische Stärke basiert auf einem streng einheitlichen Drei-Schnittstellen-Entwurfsmuster:

  • Estimator (Schätzer): Lernt Modellparameter aus Daten über fit(X, y).
  • Transformer (Transformator): Bereitet Features vor und projiziert sie über transform(X) und fit_transform(X).
  • Predictor (Prädiktor): Erstellt Vorhersagen für ungesehene Stichproben über predict(X), predict_proba(X) und score(X, y).

🔗 Verwandte Spickzettel: NumPy Spickzettel · Pandas Spickzettel · Überwachte Lernalgorithmen · Datenanalysemethoden · Python Spickzettel


1. Durchgängiges Schnellstart-Beispiel

Das folgende in sich geschlossene Skript zeigt das Laden eines Datensatzes, die stratifizierte Aufteilung, Feature-Skalierung, Modellanpassung und Auswertung:

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. Daten laden
iris = load_iris()
X, y = iris.data, iris.target

# 2. Stratifizierte Aufteilung in Trainings- und Testdaten
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 3. Feature-Skalierung (NUR auf dem Trainingssatz fitten, um Datenlecks zu vermeiden)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Schätzer anpassen
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)

# 5. Vorhersagen und Auswerten
y_pred = knn.predict(X_test_scaled)
print(f"Genauigkeit: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

2. Datenvorbereitung & Aufteilung

Scikit-Learn erwartet 2D-numerische Strukturen: Merkmalsmatrix $X$ der Form (n_samples, n_features) und Zielvektor $y$ der Form (n_samples,). Als Eingaben werden NumPy-ndarrays, dünnbesetzte SciPy-Matrizen (scipy.sparse) sowie Pandas-DataFrames/Series unterstützt.

2.1 Integrierte Datensätze & Synthetische Datengenerierung

from sklearn import datasets

# Kleine Baseline-Datensätze (gibt Bunch-Objekt zurück)
iris = datasets.load_iris()               # Mehrklassen-Klassifikation
digits = datasets.load_digits()           # 8x8 handgeschriebene Ziffernbilder
diabetes = datasets.load_diabetes()       # Regressions-Benchmark
wine = datasets.load_wine()               # 3-Klassen-Wein-Chemikalienanalyse

# Reale Benchmark-Datensätze (lokal gecacht)
housing = datasets.fetch_california_housing()

# Synthetische Datenerzeugung für Algorithmustests
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 Datenaufteilung (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,        # Anteil des Testdatensatzes (Standard: 0.25)
    random_state=42,       # Fester Seed für Reproduzierbarkeit
    shuffle=True,          # Stichproben vor der Aufteilung mischen
    stratify=y             # Sehr empfohlen für Klassifikation: behält Klassenverhältnisse bei
)

3. Feature-Engineering & Vorverarbeitung (sklearn.preprocessing & sklearn.impute)

Transformator Anwendungsfall Mathematische Transformation / Logik Wichtige Parameter
StandardScaler Z-Score-Standardisierung numerischer Merkmale $z = \frac{x - \mu}{\sigma}$ (Mittelwert 0, Varianz 1) with_mean=True, with_std=True
MinMaxScaler Begrenzung von Features auf ein geschlossenes Intervall $x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} \cdot (\max - \min) + \min$ feature_range=(0, 1)
RobustScaler Gegen Ausreißer robuste Merkmalsskalierung Skalierung über Interquartilabstand: $x' = \frac{x - Q_2}{Q_3 - Q_1}$ quantile_range=(25.0, 75.0)
Normalizer Zeilenweise Normalisierung pro Stichprobe Skaliert jede Stichprobe auf Einheitsnorm ($L_1$, $L_2$ oder Max) norm='l2' ('l1', 'max')
Binarizer Schwellenwert-Binarisierung kontinuierlicher Werte $x > \text{threshold} \Rightarrow 1$, sonst $0$ threshold=0.0
SimpleImputer Ersetzung fehlender Werte (Imputation) Ersetzt fehlende Werte durch Mittelwert, Median, Modus oder Konstante missing_values=np.nan, strategy='mean'
OneHotEncoder One-Hot-Codierung nominaler kategorialer Merkmale Konvertiert Kategorien in binäre Dummy-Spalten drop='first', handle_unknown='ignore'
OrdinalEncoder Ordinale Codierung geordneter Kategorien Codiert Kategorien in ganzzahlige Ränge $0, \dots, K-1$ categories='auto', encoded_missing_value
LabelEncoder Label-Codierung für Zielvariable $y$ Codiert String-Klassenlabels in Ganzzahlen $0 \dots C-1$ NUR für Zielvariable $y$, NIEMALS für Merkmale $X$ verwenden
PolynomialFeatures Erzeugung von Polynom- und Interaktionsmerkmalen Erzeugt Terme höherer Ordnung $[1, a, b, a^2, ab, b^2]$ degree=2, include_bias=False

3.1 Vorverarbeitungs-Codebeispiele

import numpy as np
from sklearn.preprocessing import (
    StandardScaler, MinMaxScaler, RobustScaler, Normalizer,
    Binarizer, OneHotEncoder, OrdinalEncoder, LabelEncoder, PolynomialFeatures
)
from sklearn.impute import SimpleImputer

# 1. Numerische Standardisierung (niemals auf Testdaten fitten!)
scaler = StandardScaler()
X_train_std = scaler.fit_transform(X_train)
X_test_std = scaler.transform(X_test)

# 2. Imputation fehlender Werte (Median-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-Codierung kategorialer Spalten (behandelt ungesehene Testkategorien sicher)
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. Label-Codierung der Zielvariablen
le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)

# 5. Polynomielle Feature-Erweiterung
poly = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly.fit_transform(X_train)

4. Master-Index gängiger Schätzer

4.1 Überwachtes Lernen: Klassifikation

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 Regression (linearer Klassifikations-Baseline)
clf_lr = LogisticRegression(C=1.0, max_iter=200, random_state=42)

# K-Nächste Nachbarn (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)

# Gaußscher Naive Bayes
clf_gnb = GaussianNB()

# Random Forest (Bagging-Ensemble)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=None, n_jobs=-1, random_state=42)

# Histogramm-basiertes Gradient Boosting (schnelles GBDT analog LightGBM)
clf_hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100, random_state=42)

4.2 Überwachtes Lernen: Regression

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor

# Gewöhnliche lineare Regression der kleinsten Quadrate (OLS)
reg_lr = LinearRegression()

# Ridge-Regression (L2-Regularisierung gegen Multikollinearität)
reg_ridge = Ridge(alpha=1.0)

# Lasso-Regression (L1-Regularisierung für Merkmalsselektion)
reg_lasso = Lasso(alpha=0.1)

# Support Vector Regression (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 Unüberwachtes Lernen: Clustering & Dimensionsreduktion

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_        # Cluster-Zuweisungen
cluster_centers = kmeans.cluster_centers_

# Dichtebasiertes räumliches Clustering (DBSCAN: rauschresistent)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X)      # -1 kennzeichnet Rausch-Ausreißer

# Hauptkomponentenanalyse (PCA): 95% erklärte Varianz beibehalten
pca = PCA(n_components=0.95)
X_pca = pca.fit_transform(X)
print("Beibehaltene Komponenten:", pca.n_components_)
print("Erklärte Varianzrate:", pca.explained_variance_ratio_)

5. Einheitliche API-Operationen im Überblick

Operation Kanonische Methode Zielobjekttyp Semantik & Rückgabewert
Anpassen (Fit) estimator.fit(X, y) Alle Schätzer Schätzt Parameter aus Trainingsdaten; gibt self zurück
Vorhersagen (Predict) predictor.predict(X) Alle Prädiktoren Generiert diskrete Klassenlabels oder kontinuierliche Zielwerte
Wahrscheinlichkeit predictor.predict_proba(X) Klassifikatoren Gibt Matrix der A-posteriori-Klassenwahrscheinlichkeiten aus
Entscheidungsabstand predictor.decision_function(X) Lineare Modelle / SVM Vorzeichenbehafteter Abstand der Stichproben zur Trennhyperebene
Transformieren transformer.transform(X) Alle Transformatoren Projiziert Eingabemerkmale anhand gelernter Parameter
Anpassen & Transformieren transformer.fit_transform(X) Alle Transformatoren Berechnet Parameter und transformiert in einem optimierten Schritt
Standard-Score estimator.score(X, y) Klassifikatoren / Regressoren Genauigkeit (Accuracy) für Klassifikation; $R^2$-Bestimmtheitsmaß für Regression

6. Bewertungsmetriken (sklearn.metrics)

6.1 Klassifikationsmetriken

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix, classification_report,
    ConfusionMatrixDisplay
)

# 1. Diskrete Klassifikationsmetriken (average für Mehrklassen angeben)
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. Kontinuierliche Ranking-Metriken (ROC-AUC erfordert vorhergesagte Wahrscheinlichkeiten)
y_prob = clf.predict_proba(X_test)[:, 1]   # Wahrscheinlichkeiten der positiven Klasse
auc = roc_auc_score(y_test, y_prob)

# 3. Konfusionsmatrix & umfassender Textbericht
cm = confusion_matrix(y_test, y_pred)
print(classification_report(y_test, y_pred))

# 4. Visualisierung der Konfusionsmatrix
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()

6.2 Regressionsmetriken

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)  # Wurzel der mittleren quadrierten Fehler (RMSE)
r2 = r2_score(y_test, y_pred)                            # R²-Bestimmtheitsmaß

6.3 Clustering-Metriken

from sklearn.metrics import (
    adjusted_rand_score, homogeneity_score, v_measure_score, silhouette_score
)

# Externe Validierung (wenn Ground-Truth-Labels vorliegen)
ari = adjusted_rand_score(y_true, cluster_labels)       # Bereich: [-1, 1], höher ist besser
homo = homogeneity_score(y_true, cluster_labels)        # Bereich: [0, 1]
vm = v_measure_score(y_true, cluster_labels)           # Harmonisches Mittel aus Homogenität und Vollständigkeit

# Interne Validierung (geometriebasiert, keine Ground Truth erforderlich)
sil = silhouette_score(X, cluster_labels)              # Bereich: [-1, 1], nahe 1 deutet auf klar getrennte Cluster hin

7. Kreuzvalidierung & Hyperparameter-Tuning (sklearn.model_selection)

7.1 Kreuzvalidierung (Cross-Validation)

from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold

# Standard K-Fold Kreuzvalidierung
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"5-Fold CV Genauigkeit: {scores.mean():.4f} (±{scores.std():.4f})")

# Stratifizierter 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')

# Gemeinsame Auswertung mehrerer Metriken
multi_scores = cross_validate(
    clf, X, y, cv=5,
    scoring=['accuracy', 'roc_auc'],
    return_train_score=False
)
print("Mittlere Validierungs-AUC:", multi_scores['test_roc_auc'].mean())

7.2 Rastersuche & Randomisierte Suche

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import randint

# 1. Erschöpfende Rastersuche (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 Parameter:", grid.best_params_)
best_model = grid.best_estimator_

# 2. Randomisierte Suche (für große Parameterräume)
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,             # Anzahl der zufälligen Parameterkombinationen
    cv=5,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1
)
rand_search.fit(X_train, y_train)
print("Beste Random-Search-Parameter:", rand_search.best_params_)

8. Best Practice für die Produktion: Pipeline & ColumnTransformer

8.1 Warum Pipelines unerlässlich sind

Werden Feature-Skalierung oder Imputation vor dem Splitten oder der Kreuzvalidierung global auf dem gesamten Datensatz ausgeführt, führt dies zu Datenlecks (Data Leakage): Informationen aus den Testfalten fließen in die Trainingsstatistiken ein, was zu trügerisch optimistischen Offline-Metriken führt, die im Produktiveinsatz versagen.

Pipeline bündelt Vorverarbeitungsschritte und Schätzer zu einer unteilbaren, leckagefreien Einheit. Bei der Kreuzvalidierung werden Transformatoren strikt nur auf den jeweiligen Trainingsfalten angepasst.

8.2 Produktionsrezept für ColumnTransformer

Reale tabellarische Daten enthalten sowohl kontinuierliche numerische Spalten als auch kategoriale Variablen:

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. Feature-Spaltennamen explizit aufteilen
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['gender', 'occupation', 'city']

# 2. Numerische Sub-Pipeline: Median-Imputation -> Standard-Skalierung
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# 3. Kategoriale Sub-Pipeline: Konstante Imputation -> One-Hot-Codierung
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# 4. Spalten in einen einheitlichen ColumnTransformer binden
preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_transformer, numeric_features),
    ('cat', categorical_transformer, categorical_features)
])

# 5. Vollständige Modell-Pipeline zusammenstellen
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# 6. Atomares Fitten und Inferenz (null Leckage, sicheres Deployment)
full_pipeline.fit(X_train_df, y_train)
y_pred = full_pipeline.predict(X_test_df)
print("Pipeline Test-Genauigkeit:", full_pipeline.score(X_test_df, y_test))

Verwandte Themen