Übungen: Maschinelles Lernen - Klassifikation

Korrekt ist b).

Die Folien definieren ML als "Erzeugen eines Modells, basierend auf Eingaben ('Training') und die Nutzung des Modells für Vorhersagen ('produktive Anwendung')". Der zentrale Punkt: Das Modell wird gelernt, nicht von Hand programmiert.

Warum die anderen falsch sind:

• a) beschreibt klassische, explizit programmierte Software - das Gegenteil von ML.
• c) und d) sind reine Datenhaltung/-verarbeitung ohne gelerntes Modell.

Tipp: Zwei Phasen immer parat haben: Training (Modell erzeugen, "Fitting") und produktive Anwendung (Vorhersagen für neue, unbekannte Daten).

Siehe EKI02.

Klassifikation sagt eine Kategorie (Klasse) voraus.

• Gegeben: Datensätze, die in zwei oder mehr Klassen eingeteilt sind.
• Ziel: neue, unbekannte Datensätze einer Klasse zuordnen.
• Beispiele: Spam-Filter, Fraud-Detection, Titanic (überlebt/gestorben).

Regression sagt einen numerischen Wert voraus.

• Gegeben: Datensätze mit einem numerischen Ausgabewert.
• Ziel: für neue Datensätze den Ausgabewert vorhersagen.
• Beispiel: Aktienkurs-Vorhersage.

Lösungsweg: Die entscheidende Frage lautet: Ist die Ausgabe eine Kategorie (dann Klassifikation) oder eine kontinuierliche Zahl (dann Regression)? Beide gehören zum Supervised Learning.

Falle: "Zahl als Ausgabe" heißt nicht automatisch Regression. Bei Titanic ist die Ausgabe 0/1 - das sind kodierte Kategorien (gestorben/überlebt), also Klassifikation, keine Regression.

Siehe EKI02.

(a) Das Label ist Survived (ML-Ausgabe: 0 = Gestorben, 1 = Überlebt) - binäre Klassifikation.

(b) PassengerId ist eine eindeutige ID ohne inhaltlichen Zusammenhang zum Überleben. Sie trägt keine Information, die die Klassifikation stützt, und wird daher nicht als Feature benutzt.

(c) Sex, Age und Pclass sind alle Features (ML-Eingaben).

Lösungsweg: Features sind die Eingaben (X), aus denen das Modell lernt; das Label ist die Zielgröße (y), die vorhergesagt wird. Eine reine Identifikationsnummer wie PassengerId ist beides nicht - sie ist nur ein Schlüssel.

Tipp: Namenskonvention aus der Mathematik: Features als Matrix X (Großbuchstabe), Label als Vektor y (Kleinbuchstabe). Ein Spaltenname liefert einen Vektor, eine Liste von Spaltennamen eine Matrix.

Siehe EKI02.

Formel: $H(M) = \sum_{i=1}^{n} -c_i \cdot \log_2(c_i)$ mit den relativen Klassenanteilen $c_i$.

Schritt 1 - Anteile: $c_A = \tfrac{6}{8} = 0{,}75$, $c_B = \tfrac{2}{8} = 0{,}25$.

Schritt 2 - einsetzen:

Schritt 3 - Logarithmen: $\log_2(0{,}75) = -0{,}415$, $\log_2(0{,}25) = -2$.

Schritt 4 - ausrechnen:

Ergebnis: $H \approx 0{,}811$. Die Menge ist eher gemischt (Wert deutlich über 0), aber nicht maximal gemischt: Bei 50/50 wäre $H = 1$, bei einer reinen Klasse $H = 0$.

Tipp: $\log_2(x)$ ist für $0 < x < 1$ immer negativ, das Minuszeichen in der Formel macht $H$ positiv. Wer keinen Taschenrechner hat (Klausur!): $\log_2(0{,}25) = \log_2(1/4) = -2$ und $\log_2(0{,}5) = -1$ auswendig kennen.

Siehe EKI02.

Richtige Reihenfolge:

1. (2) Daten laden - pd.read_csv('data/train.csv')
2. (5) Vorverarbeiten - Spalten wählen (X = train_data[features]), fehlende Werte auffüllen (fillna / SimpleImputer)
3. (3) Modell erzeugen - model = DecisionTreeClassifier()
4. (1) Trainieren - model.fit(X, y)
5. (4) Vorhersagen - predictions = model.predict(X_test)
6. (6) Einreichung schreiben - output.to_csv('data/submission.csv', index=False)

(Dazwischen gehört das Analysieren des Datensatzes - Features, Label, Datentypen, NaN erkennen - vor der Vorverarbeitung.)

Lösungsweg: Der Ablauf folgt der Logik laden -> verstehen -> aufbereiten -> Modell bauen -> anlernen -> anwenden -> ausgeben. Ohne Vorverarbeitung kein sinnvolles Training; ohne Training keine Vorhersage.

Falle: Der Testdatensatz muss genau so vorverarbeitet werden wie der Trainingsdatensatz (gleiche Spaltenauswahl, gleiches Auffüllen). Sonst passen Eingabeformat und Modell nicht zusammen.

Siehe EKI02.

(a) Zwei Strategien:

1. Fester Wert mit fillna:

data['Embarked'] = data['Embarked'].fillna('S')

2. Mittelwert mit SimpleImputer (scikit-learn):

import numpy as np
from sklearn.impute import SimpleImputer

imp = SimpleImputer(missing_values=np.nan, strategy='mean')
data['Age'] = imp.fit_transform(data[['Age']])

(b) Warum Zuweisung? DataFrame.fillna liefert einen modifizierten (neuen) DataFrame zurück und verändert das Original nicht. Ohne Zuweisung (data['Embarked'].fillna('S') allein) würde das Ergebnis verworfen und die fehlenden Werte blieben bestehen. Die Zuweisung überschreibt die Spalte mit dem aufgefüllten Ergebnis.

Lösungsweg: fillna eignet sich für kategoriale Spalten mit einem sinnvollen Standardwert (Embarked -> 'S'), SimpleImputer(strategy='mean') für numerische Spalten wie Age. Beides verhindert, dass NaN-Werte das Training stören.

Tipp: SimpleImputer erwartet eine 2D-Struktur, daher data[['Age']] mit doppelten eckigen Klammern (Liste von Spalten -> Matrix), nicht data['Age'] (ein Name -> Vektor).

Siehe EKI02.

Formel: $\text{Gewinn} = H(T) - \frac{|T_{lower}|}{|T|}H(T_{lower}) - \frac{|T_{upper}|}{|T|}H(T_{upper})$

Split S1: Beide Teilmengen haben $H = 0{,}722$ (Verteilung 4:1 bzw. 1:4 ist symmetrisch).

Split S2: $H(T_{lower}) = H(5{:}1) = 0{,}650$; $H(T_{upper}) = 0$ (reine Klasse A).

Entscheidung: $0{,}610 > 0{,}278$ - es wird Split S2 gewählt, weil er den größeren Entropieverlust liefert.

Lösungsweg: Man gewichtet die Teilmengen-Entropien mit ihrem Anteil an der Gesamtmenge und zieht sie von $H(T)$ ab. S2 punktet, weil er eine reine Teilmenge ($H = 0$) erzeugt - ein Zweig wird sofort zum Blatt.

Tipp: Eine reine Teilmenge ($H = 0$) ist immer wertvoll, weil sie den gewichteten Restterm verkleinert. Splits, die eine Klasse sauber abtrennen, gewinnen meist.

Siehe EKI02.

(a) Weiblich, 30 Jahre: "is sex male?" -> no -> Blatt survived (0.73, 36%). Vorhersage: überlebt.

(b) Männlich, 40 Jahre: "is sex male?" -> yes -> "is age > 9.5?" -> yes -> Blatt died (0.17, 61%). Vorhersage: gestorben.

(c) Männlich, 5 Jahre, SibSp = 1: "is sex male?" -> yes -> "is age > 9.5?" -> no (5 < 9.5) -> "is sibsp > 2.5?" -> no (1 < 2.5) -> Blatt survived (0.89, 2%). Vorhersage: überlebt.

Lösungsweg: Man startet an der Wurzel und folgt bei jedem inneren Knoten der Kante, deren Bedingung zutrifft, bis man ein Blatt (Klasse) erreicht. Die Klassen stehen in den Blättern, die Entscheidungen in den inneren Knoten, die Werte (yes/no) an den Kanten.

Tipp: Die Zahlen im Blatt bedeuten (vorhergesagte Überlebenswahrscheinlichkeit, Anteil der Fälle). "survived (0.89, 2%)" heißt: dieses Blatt sagt "überlebt" mit hoher Sicherheit, betrifft aber nur 2 % der Fälle. Das Muster spiegelt "Frauen und Kinder zuerst" wider.

Siehe EKI02.

(a) ML ist sinnvoll. Spam-Erkennung ist ein Klassifikationsproblem mit vielen Beispielen und sich ständig ändernden Mustern. Eine feste Regelmenge von Hand wäre kaum wartbar; ein Modell lernt aus manuell klassifizierten Beispielen und verbessert sich über Nutzerkorrekturen (Rückkopplungskreislauf: Training input -> Klassifikation -> Corrections -> zurück ins Training). Genau dieser Fall wird in der Vorlesung als ML-Anwendung gezeigt.

(b) ML ist nicht sinnvoll. Die Regel ist exakt bekannt und trivial: $\text{Brutto} = \text{Netto} \cdot 1{,}19$. Hier braucht man kein gelerntes Modell - eine explizit programmierte Formel ist exakt, schneller und fehlerfrei. ML lohnt sich nur, wenn die Regel unbekannt/komplex ist und genügend Daten vorliegen.

Lösungsweg: Faustregel aus der ML-Definition: ML einsetzen, wenn das Modell aus Daten gelernt werden muss, weil es nicht praktikabel explizit programmierbar ist. Ist die Lösung eine bekannte, exakte Regel, ist klassische Programmierung besser.

Falle: ML ist kein Selbstzweck. Für deterministische, exakt beschreibbare Aufgaben ist es überflüssig und sogar schlechter (ungenau, aufwändig, Datenbedarf).

Siehe EKI02.

Formel: $\text{Gewinn} = H(T) - \frac{|T_{lower}|}{|T|}H(T_{lower}) - \frac{|T_{upper}|}{|T|}H(T_{upper})$, mit $H(T)=1{,}0$ und $|T|=12$.

S1: beide Teilmengen $H=0{,}650$

S2: $H(T_{lower})=0$ (rein), $H(T_{upper})=0{,}811$

S3: $H(T_{lower})=0$ (rein), $H(T_{upper})=0{,}918$

Entscheidung: Der größte Entropieverlust gehört zu S2 (0,459). Dieser Split wird als erster gewählt.

Lösungsweg: Beim Aufbau wählt man an jedem Knoten das Feature/Wert-Paar mit dem maximalen Entropieverlust. Obwohl S3 ebenfalls eine reine Teilmenge liefert, ist diese sehr klein (3 Sätze) und der große Restzweig bleibt stark gemischt ($H=0{,}918$). S2 trennt mehr sauber ab und senkt die Restentropie stärker.

Falle: Nicht nur schauen, ob eine reine Teilmenge entsteht - die Gewichtung mit der Teilmengengröße entscheidet. Eine kleine reine Teilmenge (S3) bringt weniger als eine größere, die den Rest deutlicher entmischt (S2).

Alternative Betrachtung: Man könnte auch das Verfahren aus der Folie 2.38-2.43 heranziehen, wo genauso f4 < 809.1 als Gewinner mit 0,334 aus fünf Kandidaten hervorging - dasselbe Prinzip "größter Entropieverlust gewinnt".

Siehe EKI02.

Musterantwort:

1. Struktur: Ein Entscheidungsbaum hat die Klassen als Blätter (z.B. überlebt/gestorben), Entscheidungen in den inneren Knoten (z.B. "männlich?") und die Werte an den Kanten (z.B. Ja/Nein).

2. Ziel jedes Splits: An jedem Knoten wird ein Feature und ein Wert gewählt, so dass ein möglichst großer Entropieverlust entsteht. Ein Split "Feature < Wert" teilt die Menge $T$ in $T_{lower}$ (Bedingung erfüllt) und $T_{upper}$ (nicht erfüllt).

3. Entropie misst, wie "gemischt" eine Menge bezüglich der Klassen ist:

Sie ist maximal bei ausgeglichener Verteilung (50/50) und 0, wenn alle Elemente derselben Klasse angehören.

4. Entropieverlust (Information Gain) bewertet einen Split:

Man testet mehrere Feature/Wert-Kandidaten und wählt den mit dem größten Gewinn.

5. Rekursion + Abbruch: Teilmengen, die noch gemischt sind ($H > 0$), werden rekursiv nach demselben Verfahren weiter aufgeteilt. Erreicht eine Teilmenge Entropie 0 (nur noch eine Klasse), wird sie zum Blatt dieser Klasse. Beispiel aus der Folie: Nach dem ersten Split hat $T_{upper}$ mit 6 Fällen $H=0$ (alle "A") und wird Blatt "A"; $T_{lower}$ mit $H=0{,}94$ wird weiter aufgeteilt.

Lösungsweg: Der Algorithmus ist greedy und top-down: an jedem Knoten lokal den besten Split (max. Entropieverlust) wählen, dann für die entstandenen Teilmengen rekursiv wiederholen, bis die Blätter rein sind.

Tipp: In scikit-learn erledigt das der DecisionTreeClassifier(); model.fit(X, y) baut den Baum automatisch aus Features und Labels auf.

Siehe EKI02.

(a) Kaggle ist eine Community-Plattform mit Datensätzen, Wettbewerben etc. Für Titanic lädt man:

• train.csv - Trainingsdaten mit bekanntem Label Survived.
• test.csv - der Einreichungs-Datensatz ohne Labels; für ihn werden die Vorhersagen erzeugt und eingereicht.

Der Unterschied: nur train.csv enthält das Label zum Lernen; test.csv ist unbeschriftet. Es ist kein lokal beschrifteter Hold-out-Testsatz - die Bewertung erfolgt extern über das Kaggle-Leaderboard.

(b) Ablauf:

# Vorhersagen für den (gleich vorverarbeiteten) Testdatensatz
predictions = model.predict(X_test)

# Einreichung mit zwei Spalten erzeugen
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('data/submission.csv', index=False)

Danach submission.csv bei Kaggle einreichen und Position im Leaderboard prüfen.

(c) Achtung: Der Testdatensatz muss genau so wie der Trainingsdatensatz vorverarbeitet werden - gleiche Spaltenauswahl, gleiches Auffüllen fehlender Werte etc. Sonst passt das Eingabeformat nicht zum trainierten Modell.

Lösungsweg: model.predict(X_test) wendet das im Training gelernte Modell auf neue, unbekannte Fälle an. Die Ausgabe wird zusammen mit PassengerId in die von Kaggle geforderte CSV geschrieben.

Falle: Da test.csv kein Label hat, kann man mit ihm lokal keine Genauigkeit messen. Eine lokale Gütemessung (Accuracy, Train/Validation/Test-Split, Kreuzvalidierung) zeigt das Deck nicht - die Bewertung läuft nur über das Leaderboard.

Siehe EKI02.