Wie bewerten wir ein Machine Learning Modell?

Trainings Loss:

• Mean Squared Error
• (Log-) Likelihood

Regressionsmodelle

Wir sagen reellwertige Zahlen voraus

Mean Squared Error: \[ \frac{1}{m} \sum_{(x,y) \in \mathcal{D}} (h(x) - y)^2 \]

Mean Absolute Error: \[ \frac{1}{m} \sum_{(x,y) \in \mathcal{D}} |h(x) - y| \]

Max Error: \[ \max_{(x,y) \in \mathcal{D}} |h(x) - y| \]

R2 Score
Coefficient of determination

Gibt an, wie viel besser wir sind, als einfach den Mittelwert vorherzusagen

• $\text{R2} = 1$: Alle Punkte perfekt getroffen.
• $\text{R2} > 0$: Besser als Durchschnitt vorhersagen.
• $\text{R2} = 0$: Könnten auch $h(x) = \bar y$ verwenden.
• $\text{R2} < 0$: Schlechter als Durchschnitt vorhersagen.

\[ \text{R2} = 1 - \frac{\color{blue} \text{SS}_\text{res}}{\color{red} \text{SS}_\text{tot}} \]

https://en.wikipedia.org/wiki/File:Coefficient_of_Determination.svg

Es macht Sinn, immer mehrere Metriken zu tracken um potentielle Probleme zu finden.

Classification

Wir haben Positive und Negative Beispiele

Confusion Matrix

Accuracy

\[ \frac{\text{TP+TN}}{\text{TP} + \text{TN} + \text{FP} + \text{FN}} \]

Welcher Anteil der Vorhersagen waren korrekt?

Recall
(True Positive Rate)

\[ \frac{\text{TP}}{\text{TP} + \text{FN}} \]

Welchen Anteil der echt positiven Beispiele haben wir gefunden?

Specificity
(True Negative Rate)

\[ \frac{\text{TN}}{\text{TN} + \text{FP}} \]

Welchen Anteil der echt negativen Beispiele haben wir gefunden?

Fall-out
(False Positive Rate)

\[ \frac{\text{FP}}{\text{TN} + \text{FP}} \]

Welchen Anteil der echt negativen Beispiele haben wir falsch vorhergesagt?

Precision

\[ \frac{\text{TP}}{\text{TP} + \text{FP}} \]

Welcher Anteil der positiven Vorhersagen waren korrekt?

Eine Metrik alleine kann täuschen

• Wir sagen immer "positiv" voraus: Recall ist 100%
• Wir sagen immer "negativ" voraus: Specificity ist 100% (und Precision ist undefiniert)
• Wenn 98% der Beispiele negativ sind, bekommen wir 98% Accuracy wenn wir immer "negativ" vorhersagen

Metriken brauchen Kontext: ELISA HIV Test

Test mit 99.9% Accuracy, 99.9% Recall und 99.9% Specificity.

https://de.wikipedia.org/w/index.php?title=Beurteilung_eines_bin%C3%A4ren_Klassifikators&oldid=223284084

Tradeoff zwischen

• Recall ($\frac{\text{TP}}{\text{TP} + \text{FN}}$)
• Specificity ($\frac{\text{TN}}{\text{TN} + \text{FP}}$) / Precision ($\frac{\text{TP}}{\text{TP} + \text{FP}}$)

$\text{F}_1$ Score

\[ \frac{2 \cdot \text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}} \]

Harmonisches Mittel aus Precision und Recall

Oft haben wir den Trade-off selber in der Hand.

Logistischen Regression: $h_w(x)$ nicht binär, sondern eine Wahrscheinlichkeit von 0 bis 1.

Wir müssen den Threshold bestimmen, ab dem wir "positiv" vorhersagen wollen.

• Hoher Threshold → Bessere Specificity
• Kleiner Threshold → Besserer Recall

Was wir wollen hängt vom Problem ab.

Beispiel: Spam Filter

Wenn eine Spam Email im Posteingang landet ist das weniger schlimm, als wenn eine richtige Email als Spam klassifiziert wird.

Specificity wichtiger als Recall

Receiver operating characteristic (ROC)

Für alle Thresholds plotte Recall gegen Fall-out.

https://commons.wikimedia.org/wiki/File:Roc_curve.svg

Beispiel (Wikipedia):

https://commons.wikimedia.org/wiki/File:Roccurves.png

AUROC
(Area under operating characteristic)

Berechne Fläche unter der ROC Kurve

• 1: Perfekter Classifier
• 0.5: Münzwurf
• 0: Jedes einzelne Beispiel falsch.

In sklearn: Metrics

Wahl von Modell Parametern

Beispiel: Polynomielle Features

Welchen maximalen Grad $d$ nehmen wir?

Underfitting (High Bias):
Unser Modell hat starke Annahmen, die (zu) falsch sind.

Overfitting (High Variance):
Mit leicht anderen Daten bekommen wir ein komplett anderes Modell

Ein Modell kann viel Bias und Varianz haben

Analog für Classification

Jeder Parameter, den das Modell lernt ist ein Freiheitsgrad.

Wenn Freiheitsgerade $\geq m$, dann besteht die Möglichkeit, dass das Modell die Daten "auswendig" lernt.

Regularisierung

Idee: Bestrafe große Gewichte in $w$

Beispiel Lineare Regression: \[ \min_w \sum_{(x,y) \in \mathcal{D}_\text{train}} ( h_w(x) - y )^2 {\color{red} + \lambda ||w||^2} \]

Extremfälle:

• $\lambda = 0$: Keine Regularisierung, overfitting
• $\lambda \to \infty$: $w=0$, underfitting

Die Feature sollten ordentlich skaliert sein (gleiche Größenordnung), damit Regularisierung nicht große Feature bevorzugt.

Durch Regularisierung ist es nicht mehr so schlimm, wenn wir mehr Feature als Daten haben.

Wahrscheinlichkeitsinterpretation von Regularisierung

Wenn wir annehmen, dass \[ P(w) \sim \mathcal{N}(0, \frac{1}{\lambda}) \] dann ist Regularisierung Maximum Likelihood Estimation.

• Frequentist: Es gibt ein wahres $w$, dass die Daten generiert und wir wollen es schätzen.
• Bayesian: Wir haben schon eine Idee, wie $w$ aussieht und wollen dieses Wissen mit zusätzlichen Daten updaten.

$\lambda$ nennen wir einen Hyperparameter

Parameter, die nicht direkt vom Modell gelernt werden sind Hyperparameter.

Hyperparameter

• $\lambda$ (Regularisierung)
• Grad an polynomiellen Features
• Größe des Dictionaries bei Bag of words Modellen
• $N$ bei $N$-Grammen
• Logistische Regression oder Naive Bayes?
• Standard vs Robust Scaler
• ...

Wie stellen wir die Hyperparameter ein?

Was für uns am Ende zählt ist nicht, wie gut das Modell auf den Trainingsdaten ist, sondern wie gut es in Produktion läuft.

Generalization Error: Fehler des Modells auf neuen Daten

Wie kommen wir an den Generalization Error?

Wir brauchen ein separates Testset $\mathcal{D}_\text{test}$, das nicht zum trainieren der Daten verwendet wird.

Vorgehen: Teile alle Daten auf in $\mathcal{D}_\text{train}$ und $\mathcal{D}_\text{test}$

Wie groß sollte das Testset sein?

Faustregel: 20%

Wenn wir sehr viele Daten haben, reicht auch ein kleinerer Anteil

Wie optimieren wir die Hyperparameter?

• Minimaler Error auf Trainingsdaten: Dann maximieren wir die Modell Komplexität
• Minimaler Error auf Testdaten: Dann trainieren wir das Modell auf den Testdaten

Wir brauchen noch ein Datenset (Validation- oder Developmentset): $\mathcal{D}_\text{val}$

Hold-out Cross Validation

• Teile Daten in 3 Teile: $\mathcal{D}_\text{train}$, $\mathcal{D}_\text{val}$, $\mathcal{D}_\text{test}$
• Für verschiedene Kombinationen an Hyperparametern:
  • Trainiere auf $\mathcal{D}_\text{train}$
  • Evaluiere auf $\mathcal{D}_\text{val}$
• Wähle Hyperparameter mit kleinstem Error auf $\mathcal{D}_\text{val}$
• Evaluiere auf $\mathcal{D}_\text{test}$

Nachdem wir die Hyperparameter bestimmt haben, macht es Sinn, nochmal auf $\mathcal{D}_\text{train} \bigcup \mathcal{D}_\text{val}$ zu trainieren, um keine Daten zu verschwenden.

Aus Versehen doch das Testset verwenden kann leicht passieren.

Beispiel: Kaggle-Challenge
Es machen 1000 Teams mit und das beste (auf dem Testset) gewinnt.

Best practice

Testset direkt am Anfang herausschneiden und in eigener Datei speichern.

Best practice

Bei einem produktiven ML System sollten wir versuchen die Modell Performance auf neuen Daten zu messen.

Vorsicht mit Time Series Data:

Können wir da einfach zufällig ein Testset rausholen?

Die einzelnen Daten sind nicht unabhängig!

Besser: Mehrere zusammenhängende Zeiträume als Testset verwenden.

Wenn wir sehr wenige Daten haben können wir das Validierungsset ökonomischer machen:

k-fold Cross Validation

• Teile Trainingsdaten in $k$ Teile $\mathcal{D}_\text{val}^i$
• Für $i = 1, \ldots, k$:
  • Trainiere auf Daten $\mathcal{D}_\text{train} \setminus \mathcal{D}_\text{val}^i$
• Nimm Mittelwert über alle $k$ Errors

Vorteil:

• Wir kommen mit weniger Daten aus

Nachteil:

• Mehr Rechenaufwand

Wenn wir wenige Daten haben gilt generell:
Wir sollten möglichst viele Hyperparameter durch Domänen-Wissen festlegen.

In sklearn: KFold

Anderer Ansatz: Reduziere Anzahl an Features um Overfitting zu vermeiden.

Sequential Feature Selection

• Starte mit $F = \emptyset$
• Wiederhole:
  • Für alle Feature $f$ noch nicht in $F$:
    • Evaluiere Modell mit Features $F \bigcup \{f\}$
  • Füge bestes $f$ zu $F$ hinzu.

Stoppe wenn

• sich der Error nicht mehr verbessert.
• nach einer Obergrenze an Iterationen.

In sklearn: SequentialFeatureSelector