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)undfit_transform(X). - Predictor (Prädiktor): Erstellt Vorhersagen für ungesehene Stichproben über
predict(X),predict_proba(X)undscore(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))