Scikit-learn (sklearn) Cheat Sheet
Zuletzt aktualisiert
Daten laden und splitten
Leg vor allem anderen ein Testset zurück und schau es dir erst ganz am Ende an.
| Aufgabe | Code |
|---|---|
| Splitter importieren | from sklearn.model_selection import train_test_split |
| Features und Ziel aus einem DataFrame | X = df.drop(columns="target")
y = df["target"] |
| Eingebauter Datensatz als pandas | from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True, as_frame=True) |
| Synthetische Daten zum Experimentieren | from sklearn.datasets import make_classification
X, y = make_classification(n_samples=500, n_features=8, random_state=0) |
| 80/20-Split in Training und Test | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
| Klassenanteile in beiden Teilen erhalten | train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) |
| Training, Validierung und Test (60/20/20) | X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, random_state=0) |
Features vorverarbeiten
Fitte einen Transformer nur auf den Trainingsdaten und transformiere dann beide Sets. Fitten auf Testdaten führt zu Data Leakage.
| Aufgabe | Code |
|---|---|
| Imports | from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, OrdinalEncoder |
| Auf Mittelwert 0 und Standardabweichung 1 skalieren | scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train[["age", "income"]])
X_test_s = scaler.transform(X_test[["age", "income"]]) |
| Auf den Bereich 0 bis 1 skalieren | MinMaxScaler().fit_transform(X_train[["age", "income"]]) |
| Kategorien One-Hot-kodieren | enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit_transform(X_train[["city"]]) |
| Geordnete Kategorien als Zahlen kodieren | OrdinalEncoder(categories=[["low", "mid", "high"]]).fit_transform([["mid"], ["high"]]) |
| Fehlende Werte füllen | from sklearn.impute import SimpleImputer
SimpleImputer(strategy="median").fit_transform(X_train[["age", "income"]]) |
| Polynom- und Interaktions-Features | from sklearn.preprocessing import PolynomialFeatures
PolynomialFeatures(degree=2, include_bias=False).fit_transform(X_train[["age", "income"]]) |
| DataFrames statt Arrays zurückbekommen | scaler.set_output(transform="pandas") |
| Text-Labels in Ganzzahlen | from sklearn.preprocessing import LabelEncoder
LabelEncoder().fit_transform(["cat", "dog", "cat"]) |
Modell wählen
Fang einfach an und behalte das einfache Modell als Score, den es zu schlagen gilt.
| Problem | Starte mit | Dann probiere |
|---|---|---|
| Zahl vorhersagen (Regression) | LinearRegression(), Ridge(alpha=1.0) | RandomForestRegressor(), HistGradientBoostingRegressor() |
| Klasse vorhersagen (Klassifikation) | LogisticRegression(max_iter=1000) | RandomForestClassifier(), HistGradientBoostingClassifier() |
| Wenig Daten, ähnliche Punkte teilen ein Label | KNeighborsClassifier(n_neighbors=5) | SVC(kernel="rbf") |
| Lesbare Regeln | DecisionTreeClassifier(max_depth=3) | RandomForestClassifier() |
| Zeilen ohne Labels gruppieren | KMeans(n_clusters=3) | DBSCAN(eps=0.5) |
| Weniger Features für Plots oder Tempo | PCA(n_components=2) | TSNE(n_components=2) |
| Ungewöhnliche Zeilen finden | IsolationForest(random_state=0) | LocalOutlierFactor() |
Modell fitten
Jeder Estimator folgt demselben Muster: mit seinen Einstellungen erstellen, dann fit aufrufen.
| Aufgabe | Code |
|---|---|
| Das Muster für jedes Modell | model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train) |
| Lineare Regression | from sklearn.linear_model import LinearRegression
LinearRegression() |
| Regularisierte lineare Regression | from sklearn.linear_model import Ridge, Lasso
Ridge(alpha=1.0), Lasso(alpha=0.1) |
| Logistische Regression (Klassifikation) | from sklearn.linear_model import LogisticRegression
LogisticRegression(C=1.0, max_iter=1000) |
| k nächste Nachbarn | from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5) |
| Entscheidungsbaum | from sklearn.tree import DecisionTreeClassifier
DecisionTreeClassifier(max_depth=3, random_state=0) |
| Random Forest | from sklearn.ensemble import RandomForestClassifier
RandomForestClassifier(n_estimators=200, random_state=0) |
| Gradient Boosting, schnell bei großen Daten | from sklearn.ensemble import HistGradientBoostingClassifier
HistGradientBoostingClassifier(random_state=0) |
| Support Vector Machine | from sklearn.svm import SVC
SVC(kernel="rbf", C=1.0) |
| Naive Bayes | from sklearn.naive_bayes import GaussianNB
GaussianNB() |
| Baseline, die immer die Mehrheit rät | from sklearn.dummy import DummyClassifier
DummyClassifier(strategy="most_frequent") |
Vorhersagen und untersuchen
| Aufgabe | Code |
|---|---|
| Klassen oder Werte vorhersagen | y_pred = model.predict(X_test) |
| Wahrscheinlichkeit der positiven Klasse | model.predict_proba(X_test)[:, 1] |
| Schneller Score: Accuracy oder R² | model.score(X_test, y_test) |
| Koeffizienten eines linearen Modells | model.coef_, model.intercept_ |
| Feature Importance eines Baummodells | pd.Series(forest.feature_importances_, index=X_train.columns).sort_values() |
| Importance durch Mischen jedes Features | from sklearn.inspection import permutation_importance
permutation_importance(model, X_test, y_test, random_state=0).importances_mean |
| Klassen-Labels, die das Modell kennt | model.classes_ |
| Einstellungen lesen und ändern | model.get_params(), model.set_params(C=0.5) |
| Entscheidungsbaum zeichnen | from sklearn.tree import plot_tree
plot_tree(tree, filled=True, feature_names=list(X_train.columns)) |
Metriken für Klassifikation
Accuracy allein verbirgt die Fehler bei einer seltenen Klasse. Prüf auch Precision, Recall und die Konfusionsmatrix.
| Aufgabe | Code |
|---|---|
| Imports | from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score |
| Accuracy | accuracy_score(y_test, y_pred) |
| Precision, Recall und F1 | precision_score(y_test, y_pred), recall_score(y_test, y_pred), f1_score(y_test, y_pred) |
| F1 für mehrere Klassen | f1_score(y_test, y_pred, average="macro") |
| Alle Metriken pro Klasse | from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred)) |
| Konfusionsmatrix | from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred) |
| Konfusionsmatrix plotten | from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test) |
| ROC AUC aus Wahrscheinlichkeiten | from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) |
| ROC-Kurve plotten | from sklearn.metrics import RocCurveDisplay
RocCurveDisplay.from_estimator(model, X_test, y_test) |
| Accuracy bei unausgewogenen Klassen | from sklearn.metrics import balanced_accuracy_score
balanced_accuracy_score(y_test, y_pred) |
| Eigener Entscheidungsschwellenwert | y_pred = (model.predict_proba(X_test)[:, 1] >= 0.3).astype(int) |
Metriken für Regression
Fehlermetriken haben die Einheit der Zielvariable (niedriger ist besser). R² ist der Anteil der erklärten Varianz (1 ist perfekt).
| Aufgabe | Code |
|---|---|
| Imports | from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score |
| Mittlerer absoluter Fehler | mean_absolute_error(y_test, y_pred) |
| Mittlerer quadratischer Fehler und seine Wurzel | mean_squared_error(y_test, y_pred), root_mean_squared_error(y_test, y_pred) |
| R²-Score | r2_score(y_test, y_pred) |
| Mittlerer absoluter prozentualer Fehler | from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred) |
| Vorhersage gegen Istwert plotten | from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_test, y_pred, kind="actual_vs_predicted") |
Pipelines
Eine Pipeline verkettet Preprocessing und ein Modell zu einem Estimator, sodass Kreuzvalidierung und Grid Search jeden Schritt nur auf den Trainings-Folds fitten.
| Aufgabe | Code |
|---|---|
| Imports | from sklearn.pipeline import make_pipeline, Pipeline |
| Skalieren, dann Modell fitten | pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train) |
| Schritte mit eigenen Namen | pipe = Pipeline([("scale", StandardScaler()), ("model", LogisticRegression(max_iter=1000))]) |
| Auf einen Schritt zugreifen | pipe.named_steps["model"], pipe[-1] |
| Unterschiedliche Schritte für verschiedene Spalten | from sklearn.compose import ColumnTransformer
pre = ColumnTransformer([
("num", StandardScaler(), ["age", "income"]),
("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
]) |
| Preprocessing und Modell in einem Objekt | model = make_pipeline(pre, RandomForestClassifier(random_state=0))
model.fit(X_train, y_train)
model.score(X_test, y_test) |
| Spalten nach Typ auswählen | from sklearn.compose import make_column_selector
make_column_selector(dtype_include="number")(X_train) |
| Imputieren, dann skalieren | make_pipeline(SimpleImputer(strategy="median"), StandardScaler()) |
| Namen der Ausgabe-Features | pre.get_feature_names_out() |
Kreuzvalidierung
Kreuzvalidierung trainiert und bewertet das Modell auf mehreren Splits, das liefert eine stabilere Schätzung als ein einzelnes Testset.
| Aufgabe | Code |
|---|---|
| Imports | from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold |
| Score auf 5 Folds | scores = cross_val_score(pipe, X, y, cv=5)
scores.mean(), scores.std() |
| Metrik wählen | cross_val_score(pipe, X, y, cv=5, scoring="f1_macro") |
| Gemischte Folds | cv = KFold(n_splits=5, shuffle=True, random_state=0) |
| Gleiche Klassenverteilung in jedem Fold | cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0) |
| Mehrere Metriken und Trainings-Scores | cross_validate(pipe, X, y, cv=cv, scoring=["accuracy", "f1"], return_train_score=True) |
| Out-of-Fold-Vorhersage für jede Zeile | from sklearn.model_selection import cross_val_predict
cross_val_predict(pipe, X, y, cv=5) |
| Folds nach Gruppe, Folds in zeitlicher Reihenfolge | from sklearn.model_selection import GroupKFold, TimeSeriesSplit
GroupKFold(n_splits=5), TimeSeriesSplit(n_splits=5) |
| Alle gültigen Scoring-Namen | from sklearn.metrics import get_scorer_names
get_scorer_names() |
Grid Search und Tuning
Eine Suche fittet das Modell für jede Einstellung mit Kreuzvalidierung, behält die beste und fittet sie neu auf allen Trainingsdaten.
| Aufgabe | Code |
|---|---|
| Imports | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV |
| Jede Kombination ausprobieren | grid = GridSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": [50, 100], "max_depth": [None, 5]}, cv=5)
grid.fit(X_train, y_train) |
| Beste Einstellungen und ihr Score | grid.best_params_, grid.best_score_ |
| Das beste Modell nutzen | grid.best_estimator_.predict(X_test), grid.score(X_test, y_test) |
| Schritt in einer Pipeline tunen | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1, 10]}, cv=5).fit(X_train, y_train) |
| Zufällige Einstellungen aus Verteilungen | from scipy.stats import randint
search = RandomizedSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": randint(50, 150)}, n_iter=5, cv=3, random_state=0)
search.fit(X_train, y_train) |
| Alle CPU-Kerne nutzen | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1]}, cv=5, n_jobs=-1) |
| Alle Ergebnisse als Tabelle | pd.DataFrame(grid.cv_results_).sort_values("rank_test_score") |
Clustering und Dimensionsreduktion
Unüberwachte Modelle lernen nur aus X. Skaliere die Features vorher, denn beide arbeiten mit Abständen.
| Aufgabe | Code |
|---|---|
| k-Means-Cluster | from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X) |
| Clusterzentren und Inertia | km.cluster_centers_, km.inertia_ |
| Wie gut die Cluster getrennt sind | from sklearn.metrics import silhouette_score
silhouette_score(X, labels) |
| Dichtebasierte Cluster, Rauschen ist -1 | from sklearn.cluster import DBSCAN
DBSCAN(eps=0.5, min_samples=5).fit_predict(X) |
| Auf 2 Komponenten projizieren | from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X) |
| Erklärte Varianz jeder Komponente | pca.explained_variance_ratio_ |
| 95 % der Varianz behalten | PCA(n_components=0.95).fit_transform(X) |
scikit-learn 1.9: alte Schreibweisen und was du jetzt schreibst
Code aus älteren Tutorials kann in scikit-learn 1.9 fehlschlagen oder Warnungen werfen. Schreib stattdessen die Varianten aus der Spalte scikit-learn 1.9.
| Aufgabe | scikit-learn 1.9 | Alte Schreibweise |
|---|---|---|
| Wurzel des mittleren quadratischen Fehlers | root_mean_squared_error(y_test, y_pred) | mean_squared_error(y_test, y_pred, squared=False) |
| Dichte One-Hot-Ausgabe | OneHotEncoder(sparse_output=False) | OneHotEncoder(sparse=False) |
| Logistische Regression mit L1 (Lasso) | LogisticRegression(l1_ratio=1, solver="liblinear") | LogisticRegression(penalty="l1", solver="liblinear") |
| Logistische Regression ohne Regularisierung | LogisticRegression(C=np.inf) | LogisticRegression(penalty=None) |
Speichern, laden und reproduzieren
| Aufgabe | Code |
|---|---|
| Gefittetes Modell oder Pipeline speichern | import joblib
joblib.dump(model, "model.joblib") |
| Wieder laden | model = joblib.load("model.joblib") |
| Gleiches Ergebnis bei jedem Lauf | random_state=0 |
| Welche Version installiert ist | import sklearn
sklearn.__version__ |
Der scikit-learn-Code hinter einem echten Machine-Learning-Workflow, in der Reihenfolge, in der du ihn schreibst: Daten laden und splitten, vorverarbeiten, ein Modell wählen, fitten und vorhersagen, das Ergebnis messen, die Schritte zu einer Pipeline verketten, kreuzvalidieren und per Grid Search tunen. Jede Zeile ist ein kurzes Snippet zum Einfügen, plus eine Zeile dazu, was es tut.
Jedes Modell in scikit-learn hat dieselbe API: fit lernt aus den Trainingsdaten, predict und transform wenden das Gelernte an. Alles hier ist für scikit-learn 1.9 geschrieben, die Version, die Coddy verwendet, mit X für die Features und y für die Zielvariable. scikit-learn arbeitet mit NumPy Arrays und pandas DataFrames, und der Matplotlib Spickzettel deckt die Plots ab. Neu in Python? Starte mit dem Python Spickzettel.
FAQ zum scikit-learn Spickzettel
Ist dieser scikit-learn Spickzettel kostenlos?
Ja. Dieser scikit-learn Spickzettel ist komplett kostenlos, ganz ohne Anmeldung. Setz ein Lesezeichen oder druck ihn im Browser als PDF, und schau wieder vorbei, wenn du den genauen Aufruf für eine Pipeline, eine Metrik oder eine Grid Search brauchst.
Ist sklearn dasselbe wie scikit-learn?
Ja. scikit-learn ist der Name der Bibliothek und des Pakets, das du installierst (
pip install scikit-learn), und sklearn ist der Name, den du im Code importierst (from sklearn.linear_model import LinearRegression). Ein sklearn Cheat Sheet und ein scikit-learn Cheat Sheet behandeln dasselbe.Was ist der Unterschied zwischen fit, transform und fit_transform?
fit lernt aus Daten: Ein Scaler lernt den Mittelwert jeder Spalte, ein Modell lernt seine Gewichte. transform wendet das Gelernte an, und fit_transform erledigt beides in einem Aufruf. Nutze fit_transform auf dem Trainingsset und nur transform auf dem Testset, sonst fließen die Testdaten ins Training ein. Eine Pipeline erledigt das für dich.Muss ich meine Features skalieren?
Bei Modellen, die mit Abständen oder Gradienten arbeiten, ja: k nächste Nachbarn, SVMs, k-Means, PCA sowie regularisierte lineare und logistische Regression funktionieren alle besser mit skalierten Daten. Baummodelle wie Entscheidungsbäume, Random Forests und Gradient Boosting brauchen keine Skalierung. Pack den Scaler in eine Pipeline, damit er nur auf den Trainingsdaten gefittet wird.
Mit welchem scikit-learn-Modell soll ich anfangen?
Starte mit einem einfachen, schnellen Modell als Baseline:
LinearRegression, um Zahlen vorherzusagen, LogisticRegression, um Klassen vorherzusagen. Probier dann RandomForestClassifier oder HistGradientBoostingClassifier (oder ihre Regressor-Varianten), vergleiche sie per Kreuzvalidierung und tune das beste mit GridSearchCV.Welche scikit-learn-Version deckt dieser Spickzettel ab?
scikit-learn 1.9, die Version, die Coddy verwendet, auf NumPy 2 und pandas 3. Ältere Aufrufe, die jetzt fehlschlagen oder warnen, etwa
squared=False in mean_squared_error, sparse=False in OneHotEncoder und das Argument penalty von LogisticRegression, stehen in der Tabelle mit alten Schreibweisen neben dem, was du stattdessen schreibst.Kann ich scikit-learn-Code online ausführen?
Ja. Der kostenlose Matplotlib Playground führt Python mit scikit-learn, pandas, NumPy und Matplotlib in deinem Browser aus, also kannst du jedes Snippet aus diesem Spickzettel einfügen und ohne Installation ausführen. Der Machine-Learning-Kurs von Coddy bringt dir den ganzen Workflow dieser Seite Schritt für Schritt bei, vom Splitten der Daten bis zum Tuning eines Modells.
Verwandte Ressourcen
Weitere Spickzettel
