23 · Einführung in das maschinelle Lernen

Klinischer Aufhänger

Kann ein Algorithmus vorhersagen, welche Patient:innen innerhalb von 30 Tagen sterben werden? Die Frage ist berechtigt, und die ehrliche Antwort ist komplizierter, als ein AUC von 0,85 vermuten lässt. In diesem Modul bauen wir einen ersten Klassifikator, messen ihn sorgfältig und halten fest, was er nicht kann. Das legt das Fundament für Modul 24, wo Vorhersage zum eigentlichen Ziel wird.

1 Warum maschinelles Lernen? Erklären vs. Vorhersagen

Klassische Regressionsmodelle (Modul 12) dienen primär der Erklärung: Wir schätzen Effekte (OR, HR) unter Adjustierung für Confounder, um kausale Hypothesen zu testen. Die Koeffizienten sind das Ergebnis.

Maschinelles Lernen zielt primär auf Vorhersage: Wir optimieren eine Verlustfunktion, damit das Modell bei neuen Patient:innen möglichst genau prognostiziert. Die Koeffizienten sind Mittel zum Zweck, nicht das Ergebnis.

Auch ein ML-Modell mit hervorragender Vorhersagegüte beweist keine Kausalität, und ein erklärendes Regressionsmodell kann schlechte Vorhersagen liefern. Modul 24 vertieft den Prädiktions-Workflow; dieses Modul legt das handwerkliche Fundament.

2 Train/Test-Split und Stratifizierung

Das Grundproblem: Ein Modell, das auf denselben Daten evaluiert wird, mit denen es trainiert wurde, wirkt immer gut, es hat die Antworten schon gesehen.

Lösung: Daten aufteilen, bevor du irgendetwas am Modell tust.

Bei einem Mortalitäts-Outcome von ~16 % kann ein zufälliger Split dazu führen, dass das Testset kaum Ereignisse enthält. Deshalb stratifizieren wir: Der Split erhält die Ereignisrate in beiden Mengen.

Hinweis — die Codeblöcke unten sind Auszüge. Sie zeigen die entscheidenden Schritte, nicht jede Import-Zeile. Das vollständige, am Stück lauffähige Skript ist code/python.py (im Browser über den Python-Reiter oben). In Colab führst du das ganze Modul mit einer Zeile aus: !python module/23-machine-learning/code/python.py — siehe das in Colab öffnen.

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED)

3 Das Modell: Logistische Regression als transparente Baseline

Für einen ersten Klassifikator ist die logistische Regression ideal: Sie ist linear, ihre Koeffizienten sind interpretierbar, und ohne Klassengewichtung liefert sie kalibrierte Wahrscheinlichkeiten, ohne Blackbox-Charakter. Sobald wir gleich class_weight="balanced" einschalten, gilt der Kalibrierungsteil nicht mehr automatisch, siehe Abschnitt 5.

Um Data Leakage zu verhindern, kapseln wir Skalierung und Modell in einer Pipeline. Der StandardScaler wird dann nur auf den Trainingsdaten gefittet und anschließend auf die Testdaten angewendet, nie umgekehrt. Modul 24 macht Leakage zum zentralen Thema; hier führen wir das Prinzip ein.

pipeline = Pipeline([
    ("scale", StandardScaler()),
    ("model", LogisticRegression(max_iter=1000, class_weight="balanced",
                                  random_state=SEED)),
])
pipeline.fit(X_train, y_train)
auc = roc_auc_score(y_test, pipeline.predict_proba(X_test)[:, 1])

class_weight="balanced" gewichtet die Minderheitsklasse (Verstorbene) höher, damit das Modell sie nicht systematisch ignoriert, wichtig bei ~16 % Basisrate.

4 Kreuzvalidierung

Ein einzelner Train/Test-Split ist zufallsabhängig. Bei ~16 Ereignissen im Testset (16 % von 100) kann der AUC zwischen zwei Splits um 0,05–0,10 schwanken, rein durch Zufall. Kreuzvalidierung teilt die Trainingsdaten in k Blöcke, trainiert k-mal auf k–1 Blöcken, prüft auf dem übrigen und mittelt die Ergebnisse.

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
auc_scores = cross_val_score(pipeline, X_train, y_train, cv=cv, scoring="roc_auc")
print(f"CV-AUC: {auc_scores.mean():.3f} ± {auc_scores.std():.3f}")

Kreuzvalidierung berührt das Testset nicht, es bleibt der unabhängige, abschließende Prüfstein.

5 Kalibrierung

Ein Modell mit hoher AUC kann trotzdem schlecht kalibriert sein: Sagt es für eine Gruppe 40 % Mortalität vorher, sollten tatsächlich ~40 % sterben. Ist das nicht der Fall, sind absolute Risikoschätzungen irreführend, und klinisch gefährlich.

Die Kalibrierungskurve trägt vorhergesagte Wahrscheinlichkeiten (x-Achse) gegen beobachtete Ereignisraten (y-Achse) auf. Eine perfekt kalibrierte Kurve liegt auf der Diagonale.

from sklearn.calibration import calibration_curve
frac_pos, mean_probs = calibration_curve(y_test, probs, n_bins=5, strategy="quantile")

Rufst du das auf unserem pipeline (mit class_weight="balanced") auf, zeigt sich die Verzerrung aus Abschnitt 3 direkt: die Kurve liegt weit unterhalb der Diagonale (Überschätzung), weil die vorhergesagten Wahrscheinlichkeiten systematisch zu hoch sind. Rekalibrierung mit CalibratedClassifierCV bringt sie zurück in die Nähe der Diagonale:

from sklearn.calibration import CalibratedClassifierCV

calibrated = CalibratedClassifierCV(pipeline, method="sigmoid", cv=5)
calibrated.fit(X_train, y_train)
probs_cal = calibrated.predict_proba(X_test)[:, 1]

6 Klassenungleichgewicht und Gütekriterien

Unsere Kohorte hat ~16 % Mortalität. Ein Modell, das immer „lebt" vorhersagt, erreicht 84 % Accuracy, und ist klinisch wertlos. Das ist das Genauigkeitsparadox: Accuracy täuscht, wenn die Klassen stark unbalanciert sind.

Deshalb verwenden wir als Hauptgütemaß den ROC-AUC: Er misst, ob das Modell Sterbende höher einstuft als Überlebende, schwellenunabhängig.

class_weight="balanced" legt automatisch mehr Gewicht auf die Minderheitsklasse, eine einfache und effektive Gegenmaßnahme.

SEED = 42
import pandas as pd
from sklearn.calibration import calibration_curve
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, classification_report
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

df = pd.read_csv("https://schradern.github.io/data-science-coach/data/kohorte.csv")
df["is_sepsis"] = (df["aufnahmegrund"] == "Sepsis").astype(int)
df["is_smoker"] = (df["raucherstatus"] == "aktiv").astype(int)
X = df[["alter", "sofa_score", "crp_mg_l", "diabetes", "is_sepsis", "is_smoker"]]
y = df["verstorben_30d"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED)

pipeline = Pipeline([
    ("scale", StandardScaler()),
    ("model", LogisticRegression(max_iter=1000, class_weight="balanced",
                                  random_state=SEED)),
])
pipeline.fit(X_train, y_train)
auc = roc_auc_score(y_test, pipeline.predict_proba(X_test)[:, 1])
print(f"ROC-AUC (Test): {auc:.3f}")

SEED <- 42
suppressPackageStartupMessages(library(tidyverse))
set.seed(SEED)

cohort <- read_csv("https://schradern.github.io/data-science-coach/data/kohorte.csv", show_col_types = FALSE) |>
  mutate(
    is_sepsis = as.integer(aufnahmegrund == "Sepsis"),
    is_smoker = as.integer(raucherstatus == "aktiv")
  )

# Stratifizierter Split
idx_pos   <- which(cohort$verstorben_30d == 1)
idx_neg   <- which(cohort$verstorben_30d == 0)
train_idx <- c(sample(idx_pos, floor(0.8 * length(idx_pos))),
               sample(idx_neg, floor(0.8 * length(idx_neg))))
train_df  <- cohort[train_idx, ]
test_df   <- cohort[-train_idx, ]

# Case weights == scikit-learn's class_weight="balanced" (base R glm() has no
# built-in class_weight argument). Without this, glm() silently reproduces
# the accuracy paradox — see code/r.R for the unweighted-vs-weighted comparison.
n_tr  <- nrow(train_df)
w_pos <- n_tr / (2 * sum(train_df$verstorben_30d == 1))
w_neg <- n_tr / (2 * sum(train_df$verstorben_30d == 0))
case_wts <- ifelse(train_df$verstorben_30d == 1, w_pos, w_neg)

fit <- glm(
  verstorben_30d ~ alter + sofa_score + crp_mg_l + diabetes + is_sepsis + is_smoker,
  data = train_df, weights = case_wts, family = binomial
)
probs <- predict(fit, newdata = test_df, type = "response")

# AUC via Wilcoxon-Statistik (kein pROC erforderlich)
u_stat <- wilcox.test(probs[test_df$verstorben_30d == 1],
                       probs[test_df$verstorben_30d == 0])$statistic
n1 <- sum(test_df$verstorben_30d == 1)
n0 <- sum(test_df$verstorben_30d == 0)
auc <- as.numeric(u_stat) / (n1 * n0)
cat("ROC-AUC (Test):", round(auc, 3), "\n")

Fallstricke und Merksätze

• Erst splitten, dann alles andere. Kein Preprocessing auf den Gesamtdaten vor dem Split.
• Stratifizieren bei seltenen Outcomes, ohne Stratifizierung kann ein Fold keine Ereignisse enthalten.
• AUC statt Accuracy bei unbalancierten Klassen: 84 % Accuracy für ein Modell, das immer „lebt" sagt, ist kein Erfolg.
• Pipeline = Schutz vor Leakage. Der Scaler kennt nur die Trainingsdaten, nie die Testdaten.
• class_weight="balanced" rettet die Rangordnung, nicht die Wahrscheinlichkeiten. Für Kalibrierung immer vorher rekalibrieren (CalibratedClassifierCV, Modul 25).
• AUC > 0,9 ist ein Warnsignal, kein Erfolgsbeweis. Externe Validierung ist Pflicht vor jedem klinischen Einsatz.
• Assoziation ≠ Kausalität. Das gilt auch für ML-Modelle, drei Mal, weil es das Wichtigste ist.

Selbstcheck