EKI03 - Maschinelles Lernen: Regression

Überwachtes Lernen im Detail: Der Unterschied zwischen Klassifikation und Regression, wie man ML-Modelle validiert (Konfusionsmatrix, Accuracy, Precision, Recall, F-Score fuer Klassifikation; MAE, MSE, RMSE fuer Regression), k-fache Kreuzvalidierung und ein vollstaendiger scikit-learn-Workflow am Beispiel der TMDB Box-Office-Vorhersage.

Überblick

Dieser Foliensatz (EKI03) ordnet die Regression in die Landschaft des maschinellen Lernens ein und legt den Schwerpunkt auf die Validierung von ML-Modellen. Der rote Faden der Vorlesung (Folie "Aufbau"):

1. Überblick (Einordnung, Klassifikation vs. Regression)
2. ML Validierung (Guetemasse fuer Klassifikation und Regression, Kreuzvalidierung)
3. Beispiel zu Regression: Ticketverkauf-Vorhersage mit TMDB
4. Cheat sheets
5. Mini-Test

Hinweis: Trotz des Titels "ML Regression" enthaelt der Foliensatz KEINE mathematische Herleitung der linearen Regression (kein Modell $y = w x + b$, kein Least-Squares-Verfahren), KEINEN Gradient Descent, KEINE polynomiale Regression und KEINE formale Definition von Over-/Underfitting oder Regularisierung. Diese Themen werden nur am Rande beruehrt (siehe Abschnitte unten und die Flags). Der inhaltliche Kern der Vorlesung ist die Validierung von ML-Modellen sowie ein praktischer scikit-learn-Workflow. Dieses Kapitel bildet ausschliesslich den tatsaechlichen Folieninhalt ab.

Die KI-Landkarte

Die Folie "Die KI-Landkarte" (nach B. Humm, "Applied Artificial Intelligence") teilt KI in zwei grosse Bereiche: Non-symbolic AI / Machine learning und Symbolic AI / Knowledge-based AI. Rund um diese liegen die Faehigkeiten Perceiving (Computer vision, Sensorik), Communicating (NLP), Reasoning, Acting (Planning, Robotics), Learning und Knowing.

Dem Bereich Learning / Machine learning sind u.a. folgende Verfahren zugeordnet - hier steht auch die Regression:

• Artificial neural networks
• Support vector machines
• Linear / logistic regression
• Random forest
• Gradient boosting tree
• K-Nearest neighbors
• K-means
• Naive Bayes

Hinweis: "Linear / logistic regression" erscheint hier nur als Name in einer Aufzaehlung. Eine Erklaerung des linearen Regressionsmodells selbst wird auf den Folien nicht gegeben.

Kategorien von ML-Aufgaben

graph TD
    ML["Machine Learning"] --> SL["Supervised Learning (Area)"]
    ML --> UL["Unsupervised Learning (Area)"]
    ML --> RL["Reinforcement Learning (Area)"]
    SL --> C["Classification (Task)"]
    SL --> R["Regression (Task)"]
    UL --> CL["Clustering (Task)"]
    UL --> FS["Feature selection / extraction (Task)"]
    UL --> TM["Topic modeling (Task)"]

Der Foliensatz konzentriert sich auf das ueberwachte Lernen (supervised learning) und darin auf die Aufgabe Regression (hervorgehoben werden Classification und Regression gemeinsam).

Aufgaben des überwachten Lernens (supervised learning)

Beim ueberwachten Lernen gibt es zwei Grundaufgaben. Der Unterschied liegt in der Art des Ausgabewerts (kategorisch vs. numerisch).

Aspekt	Klassifikation (classification)	Regression
Gegeben	Datensaetze fuer das Training, die in zwei oder mehr Klassen ("Kategorien") eingeteilt sind	Datensaetze fuer das Training, die einen numerischen Ausgabewert besitzen
Ziel	Ein Modell erzeugen, das neue, bisher unbekannte Datensaetze klassifizieren kann	Ein Modell erzeugen, das fuer neue, bisher unbekannte Datensaetze den Ausgabewert vorhersagen kann
Ausgabe	diskrete Kategorie	kontinuierlicher / numerischer Wert
Beispiele	Spam-Filter, Fraud-Detection	Aktienkurs-Vorhersage

Merksatz: Klassifikation sagt eine Kategorie voraus, Regression sagt eine Zahl voraus.

ML Validierung

Woher weiss man, ob das ML-Modell gut genug ist?

Ein trainiertes Modell muss vor dem produktiven Einsatz validiert werden. Nur so laesst sich beurteilen, ob es "gut genug" ist.

Der ML-Entwicklungsprozess: Training und Validierung vor dem produktiven Einsatz

Der Entwicklungsprozess (nach B. Humm) gliedert sich in eine Trainingsphase und eine Produktionsphase:

graph TD
    Start(("Start")) --> Config["Configuration"]
    TrainData["Training data"] -.-> Train["Training"]
    ModelConfig["Model configuration"] -.-> Config
    Config --> Train
    Train --> Model["Trained model"]
    TestData["Test data"] -.-> Val["Validation"]
    Model -.-> Val
    Train --> Val
    Val --> Decision{"Gut genug?"}
    Decision -->|"not good enough"| Config
    Decision -->|"good enough"| Pred["Prediction"]
    LiveData["Live data"] -.-> Pred
    Model -.-> Pred
    Pred -.-> Result["Prediction result"]

    subgraph Trainingsphase
        Config
        Train
        Val
        Decision
    end
    subgraph Produktionsphase
        Pred
    end

Ablauf: Man konfiguriert das Modell, trainiert es mit den Trainingsdaten, validiert es mit Testdaten und entscheidet. Ist das Ergebnis not good enough, geht es zurueck zur Konfiguration (Iteration). Ist es good enough, wird das trainierte Modell in der Produktionsphase auf Live-Daten angewendet, um Vorhersagen (prediction result) zu erzeugen.

Validierung der Klassifikation: Konfusionsmatrix (confusion matrix)

Beispiel: Klassifikation von medizinischen Daten, ob eine bestimmte Krankheit vorliegt oder nicht. In der Konfusionsmatrix stehen die Vorhersagen in den Zeilen und der tatsaechliche Zustand in den Spalten.

	Krankheit liegt tatsaechlich vor (krank)	Krankheit liegt nicht vor (gesund)
Vorhersage: KRANK	TP - True positive	FP - False positive (Type I Error)
Vorhersage: GESUND	FN - False negative (Type II Error)	TN - True negative

• TP (True positive): korrekt als krank erkannt
• TN (True negative): korrekt als gesund erkannt
• FP (False positive, Type I Error): faelschlich als krank klassifiziert (ist gesund)
• FN (False negative, Type II Error): faelschlich als gesund klassifiziert (ist krank)

Durchgehendes Zahlenbeispiel (Tumorbilder als boesartig = positiv, gutartig = negativ):

$$\text{TP}=1 \qquad \text{FP}=1 \qquad \text{FN}=8 \qquad \text{TN}=90$$

Treffergenauigkeit (accuracy)

Definition:

$$\text{Treffergenauigkeit} = \frac{\text{Anzahl der korrekten Vorhersagen}}{\text{Gesamtanzahl der Vorhersagen}}$$

Bei binaerer Klassifikation (2 Klassen) ergibt sich:

$$\text{Treffergenauigkeit} = \frac{TP + TN}{TP + TN + FP + FN}$$

Worked example (aus den Folien):

$$\text{Treffergenauigkeit} = \frac{TP + TN}{TP + TN + FP + FN} = \frac{1 + 90}{1 + 90 + 1 + 8} = \frac{91}{100} = 0.91$$

Positiver Vorhersagewert (precision, positive predictive value, PPV)

Anteil der Personen, die als krank klassifiziert wurden und auch tatsaechlich krank sind.

$$\text{precision} = \frac{TP}{TP + FP}$$

Worked example:

$$\text{precision} = \frac{TP}{TP + FP} = \frac{1}{1 + 1} = 0.5$$

D.h. nur jede zweite als krank klassifizierte Person ist tatsaechlich krank. (Konsequenz = ?)

Trefferquote (recall, true positive rate, TPR)

Mit welcher Wahrscheinlichkeit wird ein Kranker auch erkannt?

$$\text{recall} = \frac{TP}{TP + FN}$$

Worked example:

$$\text{recall} = \frac{TP}{TP + FN} = \frac{1}{1 + 8} = \frac{1}{9} = 0.111$$

D.h. nur jede(r) neunte Kranke wird auch als krank klassifiziert. (Konsequenz = ?)

F-Score (F1 Score)

Der F-Score (manchmal auch: F1 Score) verbindet precision und recall durch das harmonische Mittel:

$$F\text{ Score} = \frac{2}{\left(\dfrac{1}{\text{precision}}\right) + \left(\dfrac{1}{\text{recall}}\right)} = 2 \cdot \frac{\text{precision} \cdot \text{recall}}{\text{precision} + \text{recall}}$$

Worked example:

$$F\text{ Score} = 2 \cdot \frac{\text{precision} \cdot \text{recall}}{\text{precision} + \text{recall}} = 2 \cdot \frac{0.5 \cdot 0.111}{0.5 + 0.111} = 0.181$$

Der niedrige F-Score (0.18) reflektiert in diesem Fall die schlechte Qualitaet des Klassifikators weitaus besser als seine gute Treffergenauigkeit (0.91).

Weitere Masse: NPV und Specificity

$$\text{Negative Predictive Value } NPV = \frac{TN}{FN + TN} \qquad\qquad \text{specificity} = \frac{TN}{FP + TN}$$

Hinweis: Fuer NPV und Specificity werden auf den Folien nur die Formeln gezeigt, kein Zahlenergebnis berechnet. Mit den Beispielwerten ergaeben sich $NPV = 90/98 \approx 0.918$ und $\text{specificity} = 90/91 \approx 0.989$ (eigene Rechnung zur Veranschaulichung, nicht auf den Folien).

Achtung: Accuracy nur bei ausgewogenen Datensaetzen

• Tumor-Klassifikations-Beispiel: Treffergenauigkeit = 0.91.
• Das sieht auf den ersten Blick gut aus, aber 8 von 9 Faellen werden falsch klassifiziert - das ist also sehr schlecht!
• Der F-Score (F1 Score) ist fuer nicht ausgewogene (imbalanced) Datensaetze besser geeignet.
• Je nach Anwendung gibt es weitere Scores (siehe Wikipedia-Artikel "Confusion matrix").

Kernaussage: Bei unausgewogenen Datensaetzen ist die Treffergenauigkeit irrefuehrend; man verwendet stattdessen den F-Score.

Validierung der Regression: MAE, MSE, RMSE

Die Validierung der Regression erfolgt mit Hilfe der vorhergesagten Werte $\hat{f}_i$ und der tatsaechlichen (erwarteten) Werte $y_i$. Grafisch entspricht jeder Fehler dem vertikalen Abstand eines Datenpunkts von der Regressionskurve.

Mean Absolute Error (MAE) - Durchschnitt der Betraege der Abweichungen:

$$MAE = \frac{1}{n} \sum_{i=1}^{n} \left| \hat{f}_i - y_i \right|$$

Mean Squared Error (MSE) - Durchschnitt der quadrierten Abweichungen (bestraft grosse Fehler staerker):

$$MSE = \frac{1}{n} \sum_{i=1}^{n} \left( \hat{f}_i - y_i \right)^2$$

Rooted MSE (RMSE) - Wurzel des MSE (gleiche Einheit wie die Zielgroesse):

$$RMSE = \sqrt{\frac{1}{n} \sum_{i=1}^{n} \left( \hat{f}_i - y_i \right)^2}$$

Illustratives Rechenbeispiel (die Zahlen sind ein eigenes Beispiel zur Anwendung der Folienformeln; die Folien geben hierfuer keine Datenpunkte an):

Angenommen $n = 3$ mit Vorhersagen $\hat{f} = (2, 4, 6)$ und wahren Werten $y = (3, 4, 8)$. Die Abweichungen sind $-1, 0, -2$.

$$MAE = \frac{|-1| + |0| + |-2|}{3} = \frac{3}{3} = 1.0$$ $$MSE = \frac{(-1)^2 + 0^2 + (-2)^2}{3} = \frac{1 + 0 + 4}{3} = \frac{5}{3} \approx 1.667$$ $$RMSE = \sqrt{1.667} \approx 1.29$$

Achtung: Regressionen muessen einen Sinn ergeben

Eine gute Validierung allein ist nicht ausreichend! Die Folie zeigt das beruehmte Beispiel "Overfitting the S & P 500" ("Stupid Data Miner Tricks"): Der S&P-500-Index laesst sich mit $R^2 = 0.99$ durch voellig unsinnige Variablen "erklaeren" (Butterproduktion in Bangladesch und den USA, US-Kaeseproduktion, Schafpopulation). Trotz nahezu perfekter Kennzahl ist das Modell wertlos - es handelt sich um eine Scheinkorrelation (spurious correlation) bzw. Overfitting.

Hinweis: $R^2$ (Bestimmtheitsmass) taucht auf den Folien ausschliesslich in dieser Karikatur als Wert "$R^2 = .99$" auf. Eine Definition oder Formel des Bestimmtheitsmasses wird nicht gegeben. Ebenso wird Overfitting nur an diesem Beispiel illustriert, aber nicht formal definiert; Underfitting kommt nicht vor.

K-fache Kreuzvalidierung (k fold cross validation)

Verfahren zur robusteren Validierung:

1. Spalte den Datensatz in $k$ Teildatensaetze auf, z.B. $k = 5$.
2. Fuehre das Training mit $k-1$ Teildatensaetzen durch und benutze 1 Teildatensatz fuer die Validierung.
3. Iteriere $k$-mal mit jeweils einem anderen Teildatensatz fuer die Validierung.
4. Berechne das durchschnittliche Ergebnis von allen Iterationen.

graph TD
    D["Datensatz"] --> Split["Aufteilen in k = 5 Folds"]
    Split --> I1["Iteration 1: Fold 1 = Test, Rest = Training -> Performance(1)"]
    Split --> I2["Iteration 2: Fold 2 = Test, Rest = Training -> Performance(2)"]
    Split --> I3["Iteration 3: Fold 3 = Test, Rest = Training -> Performance(3)"]
    Split --> I4["Iteration 4: Fold 4 = Test, Rest = Training -> Performance(4)"]
    Split --> I5["Iteration 5: Fold 5 = Test, Rest = Training -> Performance(5)"]
    I1 --> Avg["Mittelwert bilden"]
    I2 --> Avg
    I3 --> Avg
    I4 --> Avg
    I5 --> Avg

Das Gesamtergebnis ist der Mittelwert ueber alle $k$ Iterationen:

$$\text{Performance} = \frac{1}{k} \sum_{i=1}^{k} \text{Performance}_i$$

Kreuzvalidierung mit scikit-learn

from sklearn.model_selection import cross_val_score

# Evaluiere das Modell
scores = cross_val_score(model, X, y)
print(f'Accuracy: {scores.mean()}')

cross_val_score fuehrt eine Kreuzvalidierung mit dem Modell, dem Datensatz X und den Labels y durch.

• Default: scoring='accuracy', k = 5
• Viele andere Optionen moeglich
• Formatierte Ausgabe: gibt den Mittelwert (mean) der resultierenden Scores aus

Beispiel zu Regression: Ticketverkauf-Vorhersage mit TMDB

Anhand des Kaggle-Wettbewerbs TMDB Box Office Prediction ("Can you predict a movie's worldwide box office revenue?") wird ein kompletter Regressions-Workflow gezeigt. Gegeben sind Metadaten zu ueber 7.000 Filmen aus der The Movie Database; vorherzusagen ist der weltweite Umsatz (revenue).

Trainingsdaten: Merkmale (features) und Ziel (target)

Die Trainingsdaten enthalten heterogene Spaltentypen:

Typ	Beispiel-Spalten
Numerisch	id, budget, popularity, runtime
Text	overview, tagline, title
Strukturiert (JSON)	genres, production_companies, cast, crew, Keywords, spoken_languages
Kategorisch	original_language, status
Ziel (target)	revenue

Fehlende Werte

Vor dem Training muss man fehlende Werte betrachten. Die Folie zeigt die "Missing Value count By Features" - einige Spalten haben sehr viele Fehlwerte:

Feature	Fehlende Werte
belongs_to_collection	2396
homepage	2054
tagline	597
Keywords	276
production_companies	156
production_countries	55
spoken_languages	20
crew	16
cast	13
overview	8
genres	7
runtime	2
poster_path	1
id, budget, revenue, ...	0

Auffaellig: belongs_to_collection und homepage fehlen in ueber 2000 Faellen, waehrend das Ziel revenue vollstaendig vorhanden ist.

Format der Einreichung

Die Kaggle-Einreichung (sample_submission) ist eine CSV mit genau zwei Spalten: id und revenue (der vorhergesagte Umsatz je Film-ID).

Schritt 1: DataFrame aus einer CSV-Datei laden

import pandas as pd

train_data = pd.read_csv('data/train.csv')
test_data = pd.read_csv('data/test.csv')

pd.read_csv liest eine CSV-Datei (relativer Pfad zum Notebook) und speichert sie in einem pd.DataFrame. Viele optionale Parameter sind moeglich, z.B. encoding, delimiter, quotechar.

Schritt 2: Datenvorverarbeitung - relevante Spalten extrahieren

# Labels extrahieren (Regressionsziel)
y = train_data["revenue"]

# Relevante Spalten (features) extrahieren (wird spaeter erweitert...)
features = ["budget"]
X = train_data[features]

Zu Beginn wird nur ein einziges Feature (budget) verwendet; die Featureauswahl kann spaeter erweitert werden. (Die Folie fragt offen: "Andere Ideen fuer die Datenvorverarbeitung?")

Schritt 3: ML-Training

from sklearn.svm import SVR

# Erzeuge mittels ML ein Regressionsmodell
model = SVR()
# Trainiere das Regressionsmodell
model.fit(X, y)

Gewaehlter ML-Ansatz: Support Vector Regression (SVR). Das Training ("fitting") erfolgt mit den Merkmalen X und den Zielen y ueber model.fit(X, y).

Ideen fuer weitere ML-Ansaetze: Das scikit-learn algorithm cheat sheet

Zur Modellauswahl dient die "scikit-learn algorithm cheat-sheet"-Karte. Im Regressions-Ast werden u.a. genannt:

• SGD Regressor (bei > 100K samples)
• Lasso, ElasticNet (wenige Features sollten wichtig sein)
• RidgeRegression, SVR(kernel='linear')
• SVR(kernel='rbf'), EnsembleRegressors

Hinweis: Regularisierungsverfahren (Lasso, Ridge, ElasticNet) erscheinen nur als Namen auf dieser Cheat-Sheet-Grafik. Der Foliensatz erklaert die zugehoerige Mathematik (L1-/L2-Regularisierung) nicht.

Schritt 4: Validierung mit RMSE

# Evaluiere das Modell
scores = cross_val_score(model, X, y, scoring='neg_root_mean_squared_error')
print(f'RMSE: {scores.mean()}')

Fuer die Regression wird als Score der RMSE verwendet. In scikit-learn heisst die Option scoring='neg_root_mean_squared_error' (negativ, da scikit-learn Scores maximiert - je hoeher, desto besser; ein negativer RMSE ist umso besser, je naeher er an 0 liegt).

Schritt 5: Einreichungsdatei fuer Kaggle erzeugen

# Vorhersage der Labels fuer den Test-Datensatz
predictions = model.predict(X_test)

# Bereite die Einreichung vor
output = pd.DataFrame({'id': test_data.id, 'revenue': predictions})
output.to_csv('data/submission.csv', index=False)

• model.predict(X_test) sagt den Umsatz des (vorverarbeiteten) Kaggle-Testdatensatzes voraus.
• Es entsteht ein DataFrame mit zwei Spalten (id, revenue).
• to_csv(..., index=False) schreibt den DataFrame als CSV.

Zusammenfassung des scikit-learn-Workflows

graph LR
    A["read_csv: Daten laden"] --> B["Preprocessing: X, y extrahieren"]
    B --> C["model = SVR()"]
    C --> D["model.fit(X, y): Training"]
    D --> E["cross_val_score (RMSE): Validierung"]
    E --> F["model.predict(X_test): Vorhersage"]
    F --> G["to_csv: submission.csv"]

Cheat Sheets

Der Foliensatz verweist am Ende auf eine Sammlung von "Python For Data Science"-Cheat-Sheets als Nachschlagehilfe: Python Basics, NumPy Basics, Pandas Basics, Data Wrangling with Pandas (2 Teile), Scikit-Learn und Matplotlib. Diese dienen der praktischen Umsetzung des oben gezeigten Workflows.

Prüfungsrelevanz

• Klassifikation vs. Regression sicher abgrenzen koennen: Kategorie (diskret) vs. numerischer Wert (kontinuierlich), jeweils mit Beispiel (Spam-Filter/Fraud-Detection bzw. Aktienkurs-Vorhersage).
• Konfusionsmatrix zeichnen und TP/FP/FN/TN inkl. Type I Error (FP) und Type II Error (FN) einordnen koennen.
• Die vier Klassifikationsmasse aus dem TP=1, FP=1, FN=8, TN=90-Beispiel rechnen koennen: Accuracy = 0.91, Precision = 0.5, Recall = 0.111, F-Score = 0.181.
• Accuracy-Formel: $\frac{TP+TN}{TP+TN+FP+FN}$; Precision: $\frac{TP}{TP+FP}$; Recall: $\frac{TP}{TP+FN}$; F-Score: harmonisches Mittel von precision und recall.
• Wissen, wann Accuracy versagt (unausgewogene Datensaetze) und dass dann der F-Score genommen wird.
• Die drei Regressionsmasse MAE, MSE, RMSE mit Formel hinschreiben und den Unterschied benennen koennen (MSE bestraft grosse Fehler; RMSE hat die Einheit der Zielgroesse).
• Warnung "Regressionen muessen Sinn ergeben": gute Kennzahl (z.B. $R^2 = 0.99$) allein reicht nicht - Scheinkorrelation/Overfitting.
• k-fache Kreuzvalidierung in vier Schritten erklaeren und die Mittelung ueber $k$ Iterationen kennen.
• Den scikit-learn-Workflow beschreiben koennen: read_csv -> Features/Target -> SVR() -> fit -> cross_val_score -> predict -> to_csv. cross_val_score-Default: accuracy, k=5; fuer Regression scoring='neg_root_mean_squared_error'.
• Nennen koennen, welche Modelle fuer Regression geeignet sind (SVR, SGD Regressor, Ridge/Lasso/ElasticNet, Ensemble Regressors) - Auswahl via scikit-learn cheat sheet.

Mini-Test

Mini-Test "ML Regression":

• Erklaeren Sie die ML-Aufgabe Regression
• Erklaeren Sie den ML-Entwicklungsprozess
• Warum ist es wichtig, ein ML-Modell zu validieren?
• Erklaeren Sie die Konfusionsmatrix
• Erklaeren Sie Treffergenauigkeit
• Wann ist es sinnvoll, Treffergenauigkeit zu benutzen, wann nicht?
• Welcher Score sollte bei unausgewogenen Datensaetzen verwendet werden?
• Welche Scores existieren fuer die Validierung von Regressionen?
• Erklaeren Sie die k-fache Kreuzvalidierung
• Welche ML-Modelle koennen fuer Regression verwendet werden? Wie werden Sie trainiert? Wie werden Sie fuer die Vorhersage benutzt?