Machine Learning II — saubere Methodik

Lektion 10 hat dir den Workflow beigebracht: Split, fit/predict, Metriken. Diese Lektion macht aus dem Workflow eine Methodik, die du auch außerhalb des Bootcamps sauber anwenden kannst.

Vier neue Disziplinen kommen dazu:

1. Drei Sets statt zwei — Train und Validation und Test. Du wählst Hyperparameter auf Validation, berichtest auf Test.
2. Skalieren — Features auf vergleichbare Größenordnungen bringen. Pflicht bei Distanz-basierten Modellen, schadet aber nie.
3. Mehrere Klassifikatoren vergleichen — nicht den erstbesten nehmen, sondern systematisch.
4. Reproduzierbarkeit — random_state überall, sonst sind Vergleiche wertlos.

Die HSG-Klausur prüft genau diese Disziplinen — nicht nur ob du sklearn-Funktionsnamen kennst, sondern ob du verstehst, warum sie in dieser Reihenfolge mit diesen Parametern aufgerufen werden.

In Lektion 10 hattest du zwei Sets:

• Train zum Lernen
• Test zum Berichten

Das Problem: sobald du mehrere Modelle oder Hyperparameter ausprobierst und das beste auswählst, hast du das Testset indirekt zum Tunen benutzt. Information leckt vom Test ins Modell — die berichtete Performance ist optimistisch.

Die Lösung: drei Sets.

Set	Anteil	Wofür
Train	80 %	Modelle trainieren (fit)
Validation	10 %	Hyperparameter wählen, Modelle vergleichen
Test	10 %	Einmal am Ende Performance berichten

Goldene Regel: das Testset ist heilig. Du schaust es genau einmal an — wenn du das fertige, beste Modell ein letztes Mal bewerten willst. Keine zweite Runde, kein „lass mich nur noch mal mit anderem k probieren".

sklearn.model_selection.train_test_split macht einen Split. Für drei Sets rufst du es zweimal auf:

from sklearn.model_selection import train_test_split

# 1. Schritt: 80% Train, 20% Rest
X_train, X_rest, y_train, y_rest = train_test_split(
    X, y,
    train_size=0.8,
    stratify=y,
    random_state=13,
)

# 2. Schritt: Den Rest 50/50 in Validation und Test
X_val, X_test, y_val, y_test = train_test_split(
    X_rest, y_rest,
    train_size=0.5,
    stratify=y_rest,         # NEUER Stratify-Vektor — vom Rest!
    random_state=13,
)

Drei Details, die du nicht vergessen darfst:

• random_state an beiden Aufrufen — sonst ist der erste reproduzierbar, der zweite nicht. Im HSG-Assignment ist random_state=13 Pflicht.
• stratify=y und stratify=y_rest — du stratifizierst beim zweiten Split mit dem Rest-Vektor, nicht mit dem Original y. Vergessen heißt: ein Set hat eventuell nur Klassen A und B, ein anderes nur B und C.
• Reihenfolge der Rückgabewerte — immer X_train, X_test, y_train, y_test. Wer hier vertauscht, trainiert auf Labels und testet auf Features.

Ein Feature in [0, 1000] und eines in [0, 1] haben für viele Modelle sehr unterschiedliche Gewichte:

• Distanz-basierte Modelle (KNN, SVM, k-Means): die große Spalte dominiert die Distanzberechnung komplett. Eine 1.0 Veränderung im kleinen Feature ist „weiter" als 1000 im großen Feature gewichtsmäßig irrelevant.
• Gradient-basierte Modelle (Logistic Regression, neuronale Netze): die Lernrate ist für die große Spalte falsch dimensioniert, Konvergenz wird langsam oder bricht.
• Baumbasierte Modelle (DecisionTree, RandomForest, GradientBoosting): immun gegen Skalierung. Sie sind nur auf Reihenfolge angewiesen, nicht auf Beträge.

Konsequenz: du skalierst eigentlich immer. Schadet bei Bäumen nicht, hilft den anderen massiv.

Drei Standard-Scaler aus sklearn.preprocessing:

Scaler	Formel	Wann
StandardScaler	(x - mean) / std	Default. Mittelwert 0, Standardabweichung 1.
MinMaxScaler	(x - min) / (max - min)	Wertebereich [0, 1]. Wenn die Range bekannt sein soll.
RobustScaler	(x - median) / IQR	Robust gegen Ausreißer. Default im HSG-Assignment.

Der Unterschied wird wichtig, wenn deine Daten Ausreißer haben. StandardScaler benutzt mean und std, beide sehr empfindlich gegenüber Ausreißern. RobustScaler benutzt median und IQR (Interquartilsabstand) — beide unempfindlich.

Im HSG-Assignment trainierst du fünf oder mehr verschiedene Klassifikatoren, jeweils auf scaled und unscaled Daten, und bewertest sie mit vier Metriken — also ≥ 5 × 2 × 4 = 40+ Zahlen. Die saubere Lösung: eine Schleife + ein DataFrame.

from sklearn.neighbors      import KNeighborsClassifier
from sklearn.tree           import DecisionTreeClassifier
from sklearn.ensemble       import RandomForestClassifier
from sklearn.linear_model   import LogisticRegression
from sklearn.svm            import SVC
from sklearn.metrics        import (
    accuracy_score, precision_score, recall_score, f1_score,
)
import pandas as pd

MODELS = {
    'KNN':            KNeighborsClassifier(n_neighbors=5),
    'DecisionTree':   DecisionTreeClassifier(random_state=13),
    'RandomForest':   RandomForestClassifier(random_state=13),
    'LogReg':         LogisticRegression(max_iter=1000, random_state=13),
    'SVM':            SVC(random_state=13),
}

results = []
for name, model in MODELS.items():
    for scaled, X_tr, X_va in [
        ('unscaled', X_train,        X_val),
        ('scaled',   X_train_scaled, X_val_scaled),
    ]:
        model.fit(X_tr, y_train)
        y_pred = model.predict(X_va)
        results.append({
            'model':     name,
            'scaling':   scaled,
            'accuracy':  accuracy_score(y_val, y_pred),
            'precision': precision_score(y_val, y_pred, average='macro', zero_division=0),
            'recall':    recall_score(y_val, y_pred,    average='macro', zero_division=0),
            'f1':        f1_score(y_val, y_pred,        average='macro', zero_division=0),
        })

df = pd.DataFrame(results)

Am Ende hast du einen DataFrame mit ca. 10 Zeilen. Sortiere nach F1 — das Modell mit dem höchsten Wert auf Validation ist dein Gewinner.

Erwartbare Muster:

• Bäume und Random Forest: wenige Punkte Unterschied zwischen scaled und unscaled (sie sind skalierungsinvariant).
• KNN, SVM, LogReg: klare Verbesserung durch Skalierung — manchmal 10–20 Prozentpunkte.
• Random Forest schneidet auf vielen kleinen Datensätzen am besten ab — der Standard-Allrounder.

Sobald du auf der Validation deinen Gewinner gefunden hast, kommt der letzte Schritt: eine Bewertung auf dem Testset.

best_name = df.sort_values('f1', ascending=False).iloc[0]['model']
best_scaling = df.sort_values('f1', ascending=False).iloc[0]['scaling']

best_model = MODELS[best_name]
best_X_test = X_test_scaled if best_scaling == 'scaled' else X_test

# Re-fit auf vollständigen Trainingsdaten (optional, je nach Aufgabe)
best_model.fit(X_train, y_train)
y_pred_test = best_model.predict(best_X_test)

print(classification_report(y_test, y_pred_test))

Was du jetzt nicht mehr tust:

• Kein neues Modell ausprobieren, das auf Test besser aussieht.
• Keine neuen Hyperparameter probieren.
• Kein „aber wenn ich den Seed ändere…".

Die Test-Zahl ist deine eine ehrliche Schätzung. Sie wird wahrscheinlich etwas niedriger sein als die Validation-Zahl — das ist normal. Wenn sie deutlich niedriger ist (>10 Prozentpunkte), hast du auf der Validation overfittet (z. B. zu viele Modelle ausprobiert).

Quiz 11 hat zwei Fragen, die direkt eine Confusion Matrix zeigen. Du musst sie lesen können, ohne sklearn aufzurufen.

Welche Klasse schneidet am besten ab?

Die beste Klasse ist diejenige, deren Diagonal-Zelle relativ zum Zeilen-Total am höchsten ist — also wo der Recall am höchsten ist. Beispiel:

	pred A	pred B	pred C	Σ Zeile
A	18	1	1	20
B	3	14	3	20
C	2	4	14	20

• Recall(A) = 18 / 20 = 0.90
• Recall(B) = 14 / 20 = 0.70
• Recall(C) = 14 / 20 = 0.70

→ A schneidet am besten ab. Wenn die Zeilen-Totals unterschiedlich sind, immer auf den Anteil schauen, nicht auf die absolute Zahl.

Was bedeutet eine leere Diagonale?

Diagonale = alle korrekten Vorhersagen. Wenn die Diagonale komplett 0 ist:

• Nicht der Klassifikator lag immer falsch im naiven Sinn — das wäre trivial.
• Nicht der Klassifikator lag immer richtig — Accuracy wäre dann 0%, nicht 100%.
• Nicht unmöglich — passiert bei einem schlechten Modell auf neuen Daten.
• Ja: mindestens eine Vorhersage pro Klasse muss in einer Off-Diagonale liegen, sonst gäb's gar keine Datenpunkte. Heißt: jede Klasse wurde mindestens einmal vorhergesagt, aber nie für die richtige Klasse.

Das wirkt akademisch, ist aber genau die Quiz-Frage: zero-diagonal heißt accuracy=0, und jede Klasse hat mindestens eine (falsche) Vorhersage.