3.1 Grundlagen des Maschinellen Lernens

Worum geht’s#

Die bisherigen Kapitel haben Wissen von Hand in den Rechner gebracht: Suchräume, Constraints, Spielregeln. Maschinelles Lernen kehrt diese Richtung um. Statt eine Funktion zu programmieren, geben wir dem System Beispiele — Paare aus Eingabe und gewünschter Ausgabe — und lassen es die Funktion selbst finden, die diese Beispiele erklärt und, das ist der eigentliche Punkt, auch auf neue Fälle passt.

Mir hat an diesem Kapitel geholfen, ML nicht als Zauberei, sondern als Funktionsapproximation zu lesen: Es gibt eine unbekannte wahre Funktion $f$, die die Welt erzeugt; wir sehen nur verrauschte Stichproben von ihr; und wir suchen aus einer Familie von Kandidatenfunktionen diejenige, die $f$ am besten nachbildet. Diese eine Brille — wahre Funktion, Daten, Hypothesenraum, Verlust — ordnet das ganze Feld. Regression, Klassifikation, sogar neuronale Netze sind dann nur unterschiedlich reichhaltige Familien von Kandidaten. Und die zentrale Schwierigkeit ist nicht, die Trainingsdaten gut zu treffen — das ist leicht —, sondern dabei nicht den Anschluss an die ungesehenen Daten zu verlieren. Genau dieser Spagat, Generalisierung, ist der rote Faden des Kapitels.

Kernkonzepte#

Die Lernparadigmen#

Lernverfahren unterscheiden sich zuerst darin, welche Art Rückmeldung sie bekommen. Die Vorlesung ordnet sie über die Lernsituation: ob ein „Lehrer” Beispiele vorgibt, ob der Lerner sich seine Lernsignale selbst erzeugt, oder ob er rein aus Feedback auf eigene Handlungen lernt.

Die Folien führen daneben noch das selbst-überwachte Lernen (self-supervised) als eigenes Prinzip: Der Lerner erzeugt sich seine positiven und negativen Trainingspaare selbst aus den Rohdaten. Das Schulbeispiel — und zugleich die Brücke zu Kapitel 7 — ist das Vervollständigen von Sätzen: Aus einem Textkorpus deckt man in einem Satz $S$ einzelne Wörter $w$ ab, bildet Paare $(S', w)$ und trainiert das Modell darauf, das verdeckte Wort zu erraten — prüfen kann es sich selbst, weil das ursprüngliche $w$ ja bekannt ist.

Diese Seite konzentriert sich auf das überwachte Lernen, weil es die Begriffsbildung am klarsten trägt; Clustering (unüberwacht) und Q-Learning (bestärkend) behandeln eigene Themen dieses Moduls.

Merkmale, Stichproben und der Split#

Die Rohdaten liegen als Matrix vor: Jede Zeile ist eine Stichprobe (sample), jede Spalte ein Merkmal (feature). Beim iris-Datensatz weiter unten etwa stehen 150 Blüten in den Zeilen und vier Maße — Kelch- und Blütenblattlänge und -breite — in den Spalten. Formal ist ein Datenpunkt eine Struktur $d = [d_1, \dots, d_n]$, deren Komponenten aus ganz unterschiedlichen Definitionsbereichen stammen können; lassen sie sich als Vektor $x \in \mathbb{R}^d$ auffassen, wird der Datensatz zur Menge $\{(x^{(i)}, y^{(i)})\}_{i=1}^{n}$. Die Vorlesung unterscheidet die Merkmale nach Skala — nominal (ungeordnet, z. B. Farbe, Geschlecht), ordinal (geordnet, z. B. Schulnoten) und numerisch (metrisch, z. B. Größe, Gewicht) — weil davon abhängt, welches Abstandsmaß überhaupt sinnvoll ist; iris ist durchweg numerisch, weshalb sich euklidische Distanz und damit kNN direkt anbieten.

Der vielleicht wichtigste methodische Reflex des ganzen Kapitels: Man trainiert und bewertet nie auf denselben Daten. Der Datensatz wird aufgeteilt in eine Trainingsmenge (das Modell passt seine Parameter an), eine Validierungsmenge (man wählt Hyperparameter und Modellklasse) und eine Testmenge (einmalig, zur ehrlichen Schätzung der Leistung auf Ungesehenem). Wer die Testmenge zur Modellwahl benutzt, belügt sich selbst — die Schätzung wird optimistisch verzerrt. Reicht das Datenmaterial nicht für drei Teile, übernimmt Kreuzvalidierung die Rolle der Validierungsmenge: Man rotiert den Validierungsblock über $k$ Faltungen und mittelt.

ML als Funktionsapproximation#

Sei $f\colon \mathcal{X} \to \mathcal{Y}$ die unbekannte Zielfunktion und $\mathcal{H}$ eine Familie von Kandidatenfunktionen (der Hypothesenraum). Lernen heißt, ein $h \in \mathcal{H}$ zu wählen, das den Verlust über die Daten minimiert. Für Regression ist der quadratische Verlust üblich:

Die Modellkapazität ist die Reichhaltigkeit von $\mathcal{H}$ — bei Polynomen schlicht der Grad. Ein Polynom vom Grad 1 (eine Gerade) ist arm an Kapazität, ein Polynom vom Grad 15 sehr reich.

Der Bias-Varianz-Kompromiss#

Diese beiden Übel lassen sich nicht gleichzeitig beliebig klein machen. Zerlegt man den erwarteten Testfehler eines Regressors, erhält man (für quadratischen Verlust)

Der Bias misst den systematischen Fehler einer zu starren Modellklasse, die Varianz die Empfindlichkeit gegenüber dem konkreten Trainingssatz. Mehr Kapazität senkt den Bias und hebt die Varianz; weniger Kapazität umgekehrt. Das $\sigma^2$ ist der irreduzible Rauschanteil — die Grenze, unter die kein Modell kommt. Das Optimum liegt dazwischen, und genau dieses Optimum macht die Praxis unten sichtbar.

Praxis#

Das Übungsblatt 8 verlangt, die Klassifikation einmal selbst in Python durchzuziehen. Ich habe den vollständigen scikit-learn-Workflow auf dem iris-Datensatz aufgebaut, vier Klassifikatoren verglichen und anschließend eine SVC per Gittersuche optimiert. Als Vertiefung über das Blatt hinaus folgt das Funktionsapproximations-Experiment, das Bias-Varianz greifbar macht.

Der Kern ist ein stratifizierter 70/30-Split und vier Modelle, die ich bewusst aus verschiedenen Familien gewählt habe: kNN (instanzbasiert, nicht-parametrisch), Entscheidungsbaum (regelbasiert, nicht-parametrisch), lineare SVM und logistische Regression (beide parametrisch, lineare Trennebenen). Jedes Modell steckt in einer Pipeline mit StandardScaler, damit die distanz- und margin-basierten Verfahren auf vergleichbaren Skalen rechnen.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression

X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.30, random_state=42, stratify=y)

models = {
    "kNN (k=5)":         make_pipeline(StandardScaler(), KNeighborsClassifier(5)),
    "Entscheidungsbaum": make_pipeline(StandardScaler(), DecisionTreeClassifier(max_depth=3, random_state=42)),
    "SVM (linear)":      make_pipeline(StandardScaler(), SVC(kernel="linear", C=1.0)),
    "Log. Regression":   make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
}
for name, m in models.items():
    m.fit(X_tr, y_tr)
    print(name, m.score(X_te, y_te))

GridSearchCV probiert jede Parameterkombination per 5-facher Kreuzvalidierung auf der Trainingsmenge durch — die Testmenge bleibt unberührt, bis die Wahl gefallen ist. Das Gitter ist nach Kernel getrennt, weil gamma für den linearen Kernel wirkungslos ist:

from sklearn.model_selection import GridSearchCV

grid = [
    {"svc__kernel": ["linear"], "svc__C": [0.1, 1, 10, 100]},
    {"svc__kernel": ["rbf"],    "svc__C": [0.1, 1, 10, 100],
     "svc__gamma": [0.01, 0.1, 1, "scale"]},
]
search = GridSearchCV(make_pipeline(StandardScaler(), SVC()),
                      grid, cv=5, scoring="accuracy")
search.fit(X_tr, y_tr)
print(search.best_params_, search.best_score_)

Das vollständige Skript liegt in python/src/eport_figures/praxis/p_3_1_ml_grundlagen.py. Seine echte Ausgabe:

Datensatz: iris — 150 Stichproben, 4 Merkmale, 3 Klassen
  Merkmale: sepal length (cm), sepal width (cm), petal length (cm), petal width (cm)
  Klassen:  setosa, versicolor, virginica
  Split: 105 Training / 45 Test (stratifiziert, random_state=42)

Aufgabe 1 — Klassifikatoren im Vergleich (Genauigkeit):
  Modell                 Train    Test
  ------------------------------------
  kNN (k=5)             98.1%   91.1%
  Entscheidungsbaum     98.1%   97.8%
  SVM (linear)          97.1%   91.1%
  Log. Regression       98.1%   91.1%

Aufgabe 2 — GridSearchCV für SVC (rbf vs. linear), 5-fach CV:
  bester Kernel: linear
  beste Parameter: C=100
  beste CV-Genauigkeit:  98.1%
  Test-Genauigkeit:      93.3%
  best linear: CV-Acc 98.1%
  best rbf   : CV-Acc 98.1%

Bemerkenswert ist, wie nah die Modelle beieinanderliegen: iris ist ein gutmütiger Datensatz, fast linear trennbar, mit klaren Klassen. Genau deshalb schlägt kein Verfahren dramatisch durch — eine nützliche Lehre gegen den Reflex, immer das „komplexeste” Modell zu wählen. Die GridSearchCV passt dazu: linear und rbf liegen in der CV-Genauigkeit gleichauf; der lineare Kernel wird hier ausgewählt, ohne dass eine gekrümmte Trennfläche erkennbar nötig wäre.

Funktionsapproximation: Bias und Varianz sichtbar#

Über das Blatt hinaus wollte ich den Bias-Varianz-Kompromiss nicht nur behaupten, sondern zeigen. Dazu fitte ich Polynome wachsenden Grades an 25 verrauschte Punkte einer bekannten Zielfunktion $f(x) = \cos(1{,}5\pi x) + 0{,}4x$ und messe den Fehler auf einem frischen Testsatz.

Funktionsapproximation — Polynome wachsenden Grades:
   Grad   Train-MSE    Test-MSE   Diagnose
  ------------------------------------------------
      1       0.230       0.248   Unteranpassung (hoher Bias)
      4       0.026       0.076   gute Balance
     15       0.007    1009.944   Überanpassung (hohe Varianz)

  Test-MSE minimal bei Grad 3 (MSE = 0.068) — das ist die Kapazität mit der besten Generalisierung.
  Grad 15: Train-MSE 0.007 (fast 0) vs. Test-MSE 1009.944 — klassische Überanpassung.

Die Zahlen erzählen die ganze Geschichte. Grad 1 hat in Training und Test einen ähnlich hohen Fehler — die Gerade ist zu starr, sie unterpasst. Grad 15 drückt den Trainingsfehler auf fast null, doch der Testfehler explodiert auf über 1000: Das Polynom schlängelt sich durch jeden Rauschpunkt und schwingt zwischen den Stützstellen wild aus. Grad 3-4 trifft die Balance.

Diese U-Kurve ist die vielleicht wichtigste Abbildung des Kapitels: Sie zeigt, dass „mehr Modell” eben nicht „besser” heißt, und dass die Wahl der Kapazität — über Validierung oder Kreuzvalidierung — das eigentliche Handwerk des maschinellen Lernens ist.

Aufgabe 3 (Blatt 8) — die Notebooks zum Buch#

Diese Aufgabe ist als freiwillige Lektüre-Empfehlung formuliert. Ich habe das zugehörige Repository DJCordhose/buch-machine-learning-notebooks (zu Zeigermann & Nguyen, Machine Learning – kurz & gut, O’Reilly) als konsultierte Literatur gesichtet, aber bewusst nicht hier ausgeführt: Die Notebooks setzen auf TensorFlow/Keras auf und gehören thematisch eher zu den neuronalen Netzen (Kapitel 7) als zu den hier behandelten Grundlagen. Inhaltlich deckt sich ihr roter Faden mit dieser Seite — train/test-Split, Über-/Unteranpassung, der Bias-Varianz-Kompromiss —, weshalb ich diese Begriffe lieber in meinem eigenen, vollständig reproduzierbaren scikit-learn-Workflow oben festgemacht habe, statt fremde Notebooks nachzufahren. Wer tiefer in die Keras-Praxis einsteigen will, findet im Repo gute, lauffähige Startpunkte; meine eigene neuronale Praxis liegt in 7.1.

Querbezüge#

• 3.2 (Klassifikation): Die hier verglichenen Verfahren — kNN, Entscheidungsbaum, SVM — werden dort einzeln vertieft. Der Bias-Varianz-Blick bleibt dabei der gemeinsame Maßstab: Ein tiefer, ungestutzter Baum ist das Paradebeispiel eines Überanpassers.
• 3.3 (ML mit Python) / 3.4 (Evaluation & XAI): Der train/test-Split und die Kreuzvalidierung von hier sind die Grundlage jeder ehrlichen Evaluation; Metriken jenseits der reinen Genauigkeit (Präzision, Recall, Konfusionsmatrix) schließen dort an.
• 7.1 (Neuronale Netze): Das Perzeptron ist ein parametrisches lineares Modell wie die logistische Regression hier; seine Lernregel ist ein Gradientenabstieg auf einer Verlustfunktion — exakt das Optimierungsprinzip, das oben den Polynom-Fit und die SVM-Trennebene bestimmt. Ein tiefes Netz ist schlicht ein Modell sehr hoher Kapazität, das entsprechend gegen Überanpassung reguliert werden muss.
• Stochastik/Statistik: Die Bias-Varianz-Zerlegung ist reine Statistik (Erwartungswert, Varianz eines Schätzers); ein verrauschtes $y = f(x) + \varepsilon$ ist ein klassisches Regressionsmodell, und Kreuzvalidierung ist Resampling.
• Numerik / Lineare Algebra: Den Polynom-Fit löst np.polyfit als lineares Ausgleichsproblem (Normalengleichung bzw. QR-Zerlegung) — Numerik über einer Designmatrix. Dass Grad 15 numerisch und statistisch instabil wird, ist beides zugleich: schlechte Kondition und hohe Varianz.

Quellen#

• Foliensätze _310_ML_Intro.pdf, _320_ML_Data.pdf, _330_ML_FuncApprox.pdf — Grundlage für die Begriffsbildung (Lernparadigmen, Merkmale/Stichproben, Funktionsapproximation). Die Folien führen die Funktionsapproximations-Sicht als verbindenden Rahmen ein, den ich hier übernommen und mit dem Bias-Varianz-Experiment unterfüttert habe.
• Übungsblatt 8 ki_ueb340_Learn.pdf — liefert die Aufgabenstellung (Klassifikations-Workflow und Hyperparameter-Optimierung mit GridSearchCV, Aufgaben 1–2; Aufgabe 3 als optionale Buch-Lektüre). Ich habe den Workflow konsequent in scikit-learn umgesetzt, was die einzelnen Schritte (Split, Training, Vergleich, Optimierung) explizit und reproduzierbar macht.
• Zeigermann & Nguyen, Machine Learning – kurz & gut (O’Reilly) mit dem zugehörigen Notebook-Repository — als optionale Vertiefung (Blatt 8, A3) gesichtet; thematisch eine Keras/TensorFlow-Praxis, die ich nach Kapitel 7 verorte und daher hier nur als Literatur einordne.
• Russell & Norvig, Artificial Intelligence: A Modern Approach, Kap. 19 („Learning from Examples”) — als Referenz für die saubere Formulierung von Hypothesenraum, Generalisierung und Bias-Varianz herangezogen.
• scikit-learn-Dokumentation — für die korrekten Signaturen von train_test_split, Pipeline und GridSearchCV konsultiert; die dortigen Beispiele zum Underfitting/Overfitting mit Polynomen haben mein Experiment inspiriert.