Machine Learning I — Klassifikation und KNN

Bisher hast du Daten geladen, gefiltert, aggregiert und geplottet. Diese Lektion ist der Sprung in Machine Learning: aus den Daten ein Modell lernen, das Vorhersagen für neue Beispiele macht.

Wir bleiben bei einer der einfachsten Familien — Klassifikation — und arbeiten den ganzen sklearn-Workflow einmal durch:

1. Daten anschauen und in Train/Test splitten.
2. Einen Klassifikator wählen, mit fit trainieren.
3. Mit predict für die Test-Daten Vorhersagen machen.
4. Mit Metriken bewerten, wie gut das Modell ist.

Im zweiten Teil bauen wir K-Nearest Neighbors einmal selbst — damit du verstehst, was im KNeighborsClassifier von sklearn passiert.

Lektion 11 setzt darauf auf: dort wird aus funktioniert ein funktioniert sauber (Validation-Set, Skalierung, Modellvergleich).

Supervised Machine Learning heißt: du gibst dem Modell Eingabe-Beispiele plus die richtige Antwort. Das Modell lernt aus diesen Paaren, Eingabe → Antwort, einen Zusammenhang. Bei IRIS:

• Eingabe (Features X): vier Zahlen pro Blume — sepal_length, sepal_width, petal_length, petal_width.
• Ausgabe (Label y): die Spezies — setosa, versicolor oder virginica.
• Trainingsbeispiele: viele Zeilen, jede mit ihren vier Features und ihrer bekannten Spezies.

Nach dem Training kannst du dem Modell die vier Features einer neuen Blume geben (deren Spezies es nie gesehen hat), und es sagt dir die wahrscheinlichste Spezies.

Zwei Hauptaufgaben:

Aufgabe	y ist…	Beispiel
Klassifikation	eine Kategorie	Spezies, Spam/Ham, Buy/Hold/Sell
Regression	eine Zahl	Hauspreis, Temperatur morgen

Lektion 10 ist Klassifikation. Regression kommt in Lektion 11 zur Sprache.

Abgrenzung zu Unsupervised Learning: unsupervised heißt ohne Labels. Du gibst dem Modell nur X und es findet selbst Strukturen (Clustering, PCA).

Und das dritte Paradigma — Reinforcement Learning: weder Labels noch reine Strukturanalyse, sondern ein Agent, der mit einer Umgebung interagiert und über Belohnungen (Reward) lernt. Statt „hier ist die richtige Antwort" gibt es nur „diese Aktion war gut, jene war schlecht" — und das Modell muss selbst herausfinden, welche Strategie langfristig den höchsten Gesamt-Reward liefert. Klassische Beispiele: Schach- und Go-Engines (AlphaGo), Robotersteuerung, automatisches Trading. Anders als bei Supervised Learning gibt es kein fixes Trainingsset — die Daten entstehen durch das Handeln des Agenten selbst. RL kommt im Bootcamp nicht vor; aber den Begriff solltest du kennen, wenn er im Quiz als Distraktor auftaucht.

Wir bleiben in dieser Lektion bei supervised.

Erste Goldene Regel der ML: Du darfst dein Modell niemals auf denselben Daten testen, auf denen es trainiert wurde. Sonst bewertet du auswendig-Lernen, nicht Generalisierung.

Deshalb teilst du den Datensatz in zwei disjunkte Teile:

• Trainingsset (typisch 70–80 %): zeigt dem Modell die Wahrheit, daraus lernt es.
• Testset (typisch 20–30 %): nach dem Training einmal angeschaut, um die Performance zu messen. Das Modell hat diese Beispiele nie gesehen.

from sklearn.model_selection import train_test_split

X = IRIS[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']]
y = IRIS['species']

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,        # 20% für den Test
    random_state=42,      # reproduzierbar
    stratify=y,           # gleiche Klassenverteilung in beiden Teilen
)

Drei Parameter, die du immer setzt:

• test_size — Anteil oder absolute Zahl der Test-Zeilen.
• random_state — Seed für den Random Generator. Pflicht für Reproduzierbarkeit. Ohne kriegst du jedes Mal andere Splits, jedes Mal andere Metriken — das ist nicht messbar.
• stratify=y — sorgt dafür, dass beide Teile dieselbe Klassenverteilung haben. Bei IRIS (3 Klassen × 50 Zeilen) sehr wichtig — sonst landet eventuell nur eine Klasse im Testset.

Jeder Klassifikator in sklearn hat dieselben drei Methoden:

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(random_state=42)   # 1. Modell-Objekt
model.fit(X_train, y_train)                       # 2. Trainieren
y_pred = model.predict(X_test)                    # 3. Vorhersagen

• fit(X, y) — schaut sich Trainings-Features und -Labels an und passt die internen Parameter an. Verändert das Modell-Objekt in-place.
• predict(X) — wendet das gelernte Modell auf neue Features an, gibt einen 1D-Array von Labels zurück.
• predict_proba(X) (optional) — gibt Wahrscheinlichkeiten pro Klasse zurück, statt nur die wahrscheinlichste.

Der Trick: alle Klassifikatoren in sklearn folgen exakt diesem Interface. Du kannst DecisionTreeClassifier durch KNeighborsClassifier, LogisticRegression, RandomForestClassifier, SVC ersetzen, ohne den Rest des Codes zu ändern. Das ist ein Hauptgrund, warum sklearn so populär ist.

KNN ist der am einfachsten zu erklärende Klassifikator. Idee in einem Satz:

„Schau dir die k ähnlichsten Trainings-Beispiele an. Welche Klasse haben die meisten? Das ist deine Vorhersage.“

Kein Lernen im klassischen Sinne — KNN speichert einfach alle Trainingsdaten und schaut bei jeder Vorhersage neu nach. Das macht KNN zu einer lazy learning-Methode: viel Arbeit zum predict-Zeitpunkt, fast keine zum fit-Zeitpunkt.

Der Algorithmus in vier Schritten

Für eine neue Beobachtung q:

1. Distanz zu jedem Trainingspunkt berechnen.
2. Die k Punkte mit der kleinsten Distanz nehmen.
3. Unter diesen k Nachbarn die Klassen zählen.
4. Die häufigste Klasse zurückgeben (Mehrheitsvotum).

Was KNN braucht (für Quiz 10 wichtig!)

KNN ist vollständig definiert durch drei Komponenten:

• k — wie viele Nachbarn schaue ich an? (1, 3, 5, 7, …)
• Eine Distanzfunktion — meistens Euklidisch: $d(p,q)=\sqrt{{\sum }_i(p_i-q_i{)}^2}$.
• Die Trainingsdaten — ohne sie kann KNN nichts vorhersagen.

Was KNN nicht braucht: keine Lernrate, keine Verlustfunktion, keine Anzahl Epochen, keine Schichten. KNN gehört nicht zu den Modellen, die trainiert werden — es erinnert sich einfach.

Implementierung in Python — gerade so viel Code, dass du das sklearn-KNeighborsClassifier als „genau das, plus Optimierungen“ lesen kannst:

import numpy as np
from collections import Counter

def knn_predict(query, X_train, y_train, k=5):
    # 1. Distanzen zu allen Trainingspunkten
    distances = np.linalg.norm(X_train - query, axis=1)
    # 2. Indizes der k kleinsten
    nearest_idx = np.argsort(distances)[:k]
    # 3. Klassen dieser k Punkte
    nearest_labels = y_train[nearest_idx]
    # 4. Mehrheitsvotum
    return Counter(nearest_labels).most_common(1)[0][0]

Wichtige Details:

• np.linalg.norm(X - q, axis=1) rechnet die Euklidische Distanz zeilenweise — schnell, weil vektorisiert. Ein Python-for-Loop wäre 100× langsamer.
• np.argsort(distances)[:k] gibt die Positionen der k kleinsten Distanzen zurück (sortiert aufsteigend).
• Counter(...).most_common(1) ist die idiomatische Art, das häufigste Element zu finden — viel knapper als max() mit key=.

Das ist alles, was im sklearn-KNeighborsClassifier konzeptionell passiert. Sklearn hat dazu noch KD-Trees und Ball-Trees für schnellere Nachbarsuchen, aber das Verhalten ist gleich.

Mit sklearn bleibt der Code symmetrisch zu jedem anderen Klassifikator:

from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

Wichtigste Hyperparameter:

• n_neighbors=k — wie oben.
• weights='uniform' (Default) oder 'distance' — bei 'distance' wiegen näherliegende Nachbarn mehr.
• metric='minkowski' mit p=2 (= Euklidisch) ist der Default. p=1 wäre Manhattan-Distanz.

Achtung Skalierung: KNN basiert auf Distanzen — wenn eine Spalte in 1000ern und eine in 0.01ern misst, dominiert die große Spalte komplett. Standardisieren (StandardScaler oder RobustScaler) ist Pflicht. Bei IRIS sind alle Features im selben Bereich, deshalb fällt es nicht auf — bei echten Daten passiert hier oft der erste Bug.

Lektion 11 macht das Skalieren explizit.

Accuracy (Genauigkeit) ist die intuitivste Metrik:

$\text{accuracy}=\frac{\text{korrekte Vorhersagen}}{\text{Gesamtanzahl Vorhersagen}}$

Problem: Bei unbalancierten Klassen ist sie irreführend. Wenn 95 % der Mails Ham sind, kriegst du 95 % Accuracy, indem du alles als Ham klassifizierst — und erkennst keinen einzigen Spam.

Drei Metriken, die du pro Klasse berechnest:

• Precision = von allen, die das Modell als Klasse X vorhersagt, wie viele waren wirklich X?
• Recall = von allen, die wirklich X sind, wie viele hat das Modell als X erkannt?
• F1 = harmonisches Mittel aus Precision und Recall. Eine einzige Zahl, die beide ausbalanciert.

Für mehrere Klassen aggregierst du auf eine Gesamt-Zahl mit:

• average='macro' — Durchschnitt der Pro-Klassen-Werte. Behandelt jede Klasse gleich, unabhängig von ihrer Häufigkeit. Standard im HSG-Assignment.
• average='micro' — global über alle Vorhersagen aggregiert. Bei Single-Label-Klassifikation fallen Precision, Recall und F1 hier auf denselben Wert wie die Accuracy zusammen — also keine zusätzliche Information.
• average='weighted' — Pro-Klasse, gewichtet mit der Häufigkeit.

Ein häufiges Stolperproblem: Precision, Recall und F1 hängen davon ab, welche Klasse du als „positiv" betrachtest. Dieselbe Confusion Matrix liefert zwei komplett verschiedene Wertesätze, je nach Perspektive.

Konkretes Beispiel

Ein Spam-Filter wertet 1000 Mails aus:

	pred spam	pred ham
true spam	40	10
true ham	20	930

Aus Sicht der Klasse spam (positiv)

• TP = 40 (Spam korrekt erkannt), FN = 10 (Spam übersehen), FP = 20 (Ham als Spam markiert), TN = 930
• Precision(spam) = 40 / (40 + 20) = 0.667 — „Wenn der Filter Spam sagt, in welchen Fällen stimmt's?"
• Recall(spam) = 40 / (40 + 10) = 0.800 — „Wieviel echtes Spam erwischt er?"

Aus Sicht der Klasse ham (positiv)

• TP = 930, FN = 20, FP = 10, TN = 40
• Precision(ham) = 930 / (930 + 10) = 0.989
• Recall(ham) = 930 / (930 + 20) = 0.979

Gleicher Klassifikator, gleicher Datensatz — aber die Spam-Erkennung sieht solide-mittelmäßig aus, die Ham-Erkennung sieht herausragend aus. Der Grund ist die Klassenungleichheit: 950 Hams gegen 50 Spams. In so einem Setting verzerrt jede Spam-Verwechslung die Spam-Metriken stark, beeinflusst aber kaum die Ham-Metriken.

Welche Klasse ist eigentlich „positiv"?

Konvention: das, was dir wichtig ist und/oder selten ist.

• Spam-Filter: spam ist positiv (du willst sie erkennen).
• Krebsdiagnose: krebs-Diagnose ist positiv (False Negatives wären fatal).
• Bei IRIS gibt's keine natürliche „positive" Klasse — alle drei Spezies sind gleichberechtigt. Deshalb berichtet man dort gerne macro avg (Durchschnitt über alle Klassen) statt einer einzelnen.

TP/FN/FP/TN sind perspektiv-abhängig

Dieselbe Zelle in der Matrix bekommt unterschiedliche Labels, je nachdem, welche Klasse du gerade als positiv ansiehst:

Zelle (true → pred)	aus Sicht spam	aus Sicht ham
spam → spam	TP	TN
spam → ham	FN	FP
ham → spam	FP	FN
ham → ham	TN	TP

Accuracy ist die einzige Metrik, die nicht von der Perspektive abhängt — sie zählt nur die Diagonale (alles korrekt klassifizierte) und teilt durch die Gesamtanzahl. Deshalb steht sie in classification_report auch nicht in einer Pro-Klassen-Zeile, sondern einmal global.

Im Rechner unten kannst du das ausprobieren: schalte zwischen für positiv und für negativ um — Precision, Recall und F1 ändern sich, Accuracy bleibt konstant.

sklearn liefert dir alles auf einmal:

from sklearn.metrics import classification_report

print(classification_report(y_test, y_pred))

Ausgabe:

              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       0.91      1.00      0.95        10
   virginica       1.00      0.90      0.95        10

    accuracy                           0.97        30
   macro avg       0.97      0.97      0.97        30
weighted avg       0.97      0.97      0.97        30

Lies das so:

• Pro-Klassen-Zeilen zeigen, ob das Modell bei einer bestimmten Spezies häufiger Fehler macht. Hier: versicolor hat nur 91 % Precision — heißt, manchmal werden andere Spezies fälschlich als versicolor erkannt.
• support ist die Anzahl Test-Beispiele dieser Klasse.
• accuracy ist eine globale Zahl — die einzige, die nicht pro Klasse berechnet wird.
• macro avg mittelt über die drei Pro-Klassen-Zeilen, jede Klasse zählt gleich.
• weighted avg mittelt mit Gewichtung nach support.

k-fold Cross-Validation ist eine Methode, die Modell-Bewertung robuster zu machen, ohne dafür mehr Daten zu brauchen.

Die Idee in fünf Schritten (für k=5)

1. Trainings-Daten in 5 gleich große, disjunkte Teile (Folds) zerlegen.
2. Für jeden Fold:
   • Trainiere auf den anderen 4 Folds.
   • Bewerte auf diesem 1 Fold.
3. Du hast 5 Performance-Werte.
4. Mittelwert der 5 Werte ist deine geschätzte Modell-Performance.
5. Standardabweichung sagt dir, wie stabil das Modell ist.

Was es löst

• Mehr Daten zum Trainieren: jeder Datenpunkt wird einmal validiert und mehrfach trainiert. (Kein Datenpunkt geht „verloren“.)
• Robustere Schätzung: ein einzelner Train/Val-Split kann durch Zufall gut oder schlecht ausgehen. 5 Splits → 5 Schätzungen, weniger Varianz.
• Stabilitäts-Indikator: wenn die 5 Werte stark schwanken, ist das Modell empfindlich gegen die Datenwahl.

Was es nicht tut

• k-fold ist nicht zwingend stratifiziert. Bei unbalancierten Klassen brauchst du StratifiedKFold (oder cross_val_score(..., cv=StratifiedKFold(...))).
• k-fold ersetzt das Testset nicht. Du tunst auf den Folds, der echte Test wartet daneben.
• k-fold trainiert nicht k Modelle, die du danach behältst. Es gibt dir eine Schätzung der Performance — fürs finale Modell trainierst du noch einmal auf allen Trainingsdaten.

Quiz 10 hat eine Frage zu k-fold-CV: typische Distraktoren sind „splittet die Test-Daten in k Teile“ (falsch — Train) oder „liefert ein einzelnes finales Modell“ (auch falsch).