3.4. Metriken und Scoring: Quantifizierung der Qualität von Vorhersagen#

3.4.1. Welche Scoring-Funktion sollte ich verwenden?#

Bevor wir uns die Details der vielen Scores und Evaluierungsmetriken genauer ansehen, möchten wir einige, von der statistischen Entscheidungstheorie inspirierte, Ratschläge zur Wahl von Scoring-Funktionen für das überwachte Lernen geben, siehe [Gneiting2009]

Welche Scoring-Funktion sollte ich verwenden?
Welche Scoring-Funktion ist gut für meine Aufgabe?

Kurz gesagt, wenn die Scoring-Funktion vorgegeben ist, z. B. in einem Kaggle-Wettbewerb oder in einem geschäftlichen Kontext, verwenden Sie diese. Wenn Sie die Wahl haben, beginnt es damit, das Endziel und die Anwendung der Vorhersage zu berücksichtigen. Es ist nützlich, zwei Schritte zu unterscheiden:

Vorhersage
Entscheidungsfindung

Vorhersage: Normalerweise ist die Antwortvariable \(Y\) eine Zufallsvariable, im Sinne, dass es keine deterministische Funktion \(Y = g(X)\) der Merkmale \(X\) gibt. Stattdessen gibt es eine Wahrscheinlichkeitsverteilung \(F\) von \(Y\). Man kann versuchen, die gesamte Verteilung vorherzusagen, bekannt als probabilistische Vorhersage, oder – mehr der Fokus von scikit-learn – eine Punktvorhersage (oder Punktprognose) auszugeben, indem man eine Eigenschaft oder ein Funktional dieser Verteilung \(F\) wählt. Typische Beispiele sind der Mittelwert (Erwartungswert), der Median oder ein Quantil der Antwortvariablen \(Y\) (bedingt auf \(X\)).

Sobald dies geklärt ist, verwenden Sie eine strikt konsistente Scoring-Funktion für dieses (Ziel-)Funktional, siehe [Gneiting2009]. Das bedeutet die Verwendung einer Scoring-Funktion, die auf die Messung des Abstands zwischen Vorhersagen y_pred und dem wahren Ziel-Funktional anhand von Beobachtungen von \(Y\), d. h. y_true, abgestimmt ist. Für die Klassifizierung fallen strikt richtige Scoring-Regeln, siehe Wikipedia-Eintrag für Scoring rule und [Gneiting2007], mit strikt konsistenten Scoring-Funktionen zusammen. Die weiter unten stehende Tabelle liefert Beispiele. Man könnte sagen, dass konsistente Scoring-Funktionen als Wahrheitsserum fungieren, da sie garantieren, dass „wahrheitsgemäßes Reden [...] im Erwartungswert eine optimale Strategie ist“ [Gneiting2014].

Sobald eine strikt konsistente Scoring-Funktion gewählt wurde, wird sie am besten für beides verwendet: als Verlustfunktion für das Modelltraining und als Metrik/Score in der Modellevaluierung und im Modellvergleich.

Beachten Sie, dass bei Regressoren die Vorhersage mit predict erfolgt, während bei Klassifikatoren normalerweise predict_proba verwendet wird.

Entscheidungsfindung: Die häufigsten Entscheidungen werden bei binären Klassifizierungsaufgaben getroffen, bei denen das Ergebnis von predict_proba in ein einziges Ergebnis umgewandelt wird, z. B. aus der vorhergesagten Regenwahrscheinlichkeit wird eine Entscheidung getroffen, wie zu handeln ist (ob mildernde Maßnahmen wie ein Regenschirm ergriffen werden sollen oder nicht). Für Klassifikatoren ist dies das, was predict zurückgibt. Siehe auch Anpassen des Entscheidungsschwellenwerts für Klassen-Vorhersagen. Es gibt viele Scoring-Funktionen, die verschiedene Aspekte einer solchen Entscheidung messen, die meisten davon sind durch die metrics.confusion_matrix abgedeckt oder daraus abgeleitet.

Liste der strikt konsistenten Scoring-Funktionen: Hier listen wir einige der relevantesten statistischen Funktionalen und entsprechenden strikt konsistenten Scoring-Funktionen für praktische Aufgaben auf. Beachten Sie, dass die Liste nicht vollständig ist und es noch weitere gibt. Weitere Kriterien zur Auswahl einer bestimmten Funktion finden Sie unter [Fissler2022].

Funktional	Scoring- oder Verlustfunktion	Antwort `y`	Vorhersage
Klassifikation
Mittelwert	Brier-Score ¹	Mehrklassen	`predict_proba`
Mittelwert	Log-Verlust	Mehrklassen	`predict_proba`
Modus	Null-Eins-Verlust ²	Mehrklassen	`predict`, kategorisch
Regression
Mittelwert	Quadratischer Fehler ³	Alle reellen Zahlen	`predict`, alle reellen Zahlen
Mittelwert	Poisson-Devianz	Nicht-negativ	`predict`, strikt positiv
Mittelwert	Gamma-Devianz	Striktiv positiv	`predict`, strikt positiv
Mittelwert	Tweedie-Devianz	abhängig von `power`	`predict`, abhängig von `power`
Median	Absoluter Fehler	Alle reellen Zahlen	`predict`, alle reellen Zahlen
Quantil	Pinball-Verlust	Alle reellen Zahlen	`predict`, alle reellen Zahlen
Modus	Kein konsistenter existiert	Reelle Zahlen

¹ Der Brier-Score ist lediglich ein anderer Name für den quadratischen Fehler bei Klassifizierung mit One-Hot-kodierten Zielen.

² Der Null-Eins-Verlust ist nur konsistent, aber nicht strikt konsistent für den Modus. Der Null-Eins-Verlust entspricht eins minus der Genauigkeits-Score, was bedeutet, dass er unterschiedliche Score-Werte, aber das gleiche Ranking liefert.

³ R² liefert das gleiche Ranking wie der quadratische Fehler.

Fiktives Beispiel: Machen wir die obigen Argumente greifbarer. Betrachten Sie eine Situation im Bereich der Netzwerkinfrastruktur, wie z. B. die Aufrechterhaltung stabiler Internet- oder Wi-Fi-Verbindungen. Als Anbieter des Netzwerks haben Sie Zugriff auf den Datensatz von Protokolleinträgen von Netzwerkverbindungen, der die Netzwerklast im Laufe der Zeit und viele interessante Merkmale enthält. Ihr Ziel ist es, die Zuverlässigkeit der Verbindungen zu verbessern. Tatsächlich versprechen Sie Ihren Kunden, dass an mindestens 99 % aller Tage keine Verbindungsunterbrechungen von mehr als 1 Minute auftreten. Daher sind Sie an einer Vorhersage des 99%-Quantils (der längsten Verbindungsunterbrechungsdauer pro Tag) interessiert, um im Voraus zu wissen, wann Sie mehr Bandbreite hinzufügen und dadurch Ihre Kunden zufriedenstellen müssen. Das Ziel-Funktional ist also das 99%-Quantil. Aus der obigen Tabelle wählen Sie den Pinball-Verlust als Scoring-Funktion (fairerweise wenig Auswahl gegeben), sowohl für das Modelltraining (z. B. HistGradientBoostingRegressor(loss="quantile", quantile=0.99)) als auch für die Modellevaluierung (mean_pinball_loss(..., alpha=0.99) – wir entschuldigen uns für die unterschiedlichen Argumentnamen, quantile und alpha), sei es in einer Grid-Suche zur Ermittlung von Hyperparametern oder im Vergleich zu anderen Modellen wie QuantileRegressor(quantile=0.99).

Referenzen

[Gneiting2007]

T. Gneiting und A. E. Raftery. Strictly Proper Scoring Rules, Prediction, and Estimation In: Journal of the American Statistical Association 102 (2007), pp. 359– 378. Link zu PDF

[Gneiting2009] (1,2)

T. Gneiting. Making and Evaluating Point Forecasts Journal of the American Statistical Association 106 (2009): 746 - 762.

[Gneiting2014]

T. Gneiting und M. Katzfuss. Probabilistic Forecasting. In: Annual Review of Statistics and Its Application 1.1 (2014), pp. 125–151.

[Fissler2022]

T. Fissler, C. Lorentzen und M. Mayer. Model Comparison and Calibration Assessment: User Guide for Consistent Scoring Functions in Machine Learning and Actuarial Practice.

3.4.2. Überblick über die Scoring-API#

Es gibt 3 verschiedene APIs zur Bewertung der Qualität der Vorhersagen eines Modells

Score-Methode des Schätzers: Schätzer (Estimators) verfügen über eine score-Methode, die ein Standard-Bewertungskriterium für das Problem liefert, für das sie konzipiert wurden. Am häufigsten ist dies die Genauigkeit für Klassifikatoren und der Bestimmtheitskoeffizient (\(R^2\)) für Regressoren. Details für jeden Schätzer finden Sie in seiner Dokumentation.
Scoring-Parameter: Werkzeuge zur Modellevaluierung, die Kreuzvalidierung verwenden (wie model_selection.GridSearchCV, model_selection.validation_curve und linear_model.LogisticRegressionCV), verlassen sich auf eine interne Scoring-Strategie. Diese kann über den scoring-Parameter dieses Werkzeugs angegeben werden und wird im Abschnitt Der Scoring-Parameter: Regeln für die Modellevaluierung definieren erläutert.
Metrikfunktionen: Das Modul sklearn.metrics implementiert Funktionen zur Bewertung des Vorhersagefehlers für spezifische Zwecke. Diese Metriken werden in den Abschnitten Klassifikationsmetriken, Multilabel-Ranking-Metriken, Regressionsmetriken und Clustering-Metriken detailliert.

Schließlich sind Dummy-Schätzer nützlich, um einen Basiswert dieser Metriken für zufällige Vorhersagen zu erhalten.

Siehe auch

Für „Paarweise“ Metriken, zwischen Stichproben und nicht zwischen Schätzern oder Vorhersagen, siehe den Abschnitt Paarweise Metriken, Affinitäten und Kernel.

3.4.3. Der `scoring`-Parameter: Regeln für die Modellevaluierung definieren#

Werkzeuge zur Modellauswahl und -evaluierung, die intern Kreuzvalidierung verwenden (wie model_selection.GridSearchCV, model_selection.validation_curve und linear_model.LogisticRegressionCV) nehmen einen scoring-Parameter entgegen, der steuert, welche Metrik auf die evaluierten Schätzer angewendet wird.

Sie können auf verschiedene Arten angegeben werden:

None: das Standard-Bewertungskriterium des Schätzers (d. h. die im score-Methode des Schätzers verwendete Metrik) wird verwendet.
Zeichenkettenname: Häufige Metriken können über einen Zeichenkettennamen übergeben werden.
Aufrufbare Funktion: komplexere Metriken können über eine benutzerdefinierte Metrik-Aufrufbare übergeben werden (z. B. eine Funktion).

Einige Werkzeuge akzeptieren auch mehrere Metriken. Siehe Verwendung von Mehrfachmetrik-Evaluierung für Details.

3.4.3.1. Zeichenkettennamen-Scorer#

Für die häufigsten Anwendungsfälle können Sie ein Scorer-Objekt mit dem scoring-Parameter über einen Zeichenkettennamen bezeichnen; die folgende Tabelle zeigt alle möglichen Werte. Alle Scorer-Objekte folgen der Konvention, dass höhere Rückgabewerte besser sind als niedrigere. Daher sind Metriken, die den Abstand zwischen dem Modell und den Daten messen, wie z. B. metrics.mean_squared_error, als „neg_mean_squared_error“ verfügbar, was den negierten Wert der Metrik zurückgibt.

Scoring-Zeichenkettenname	Funktion	Kommentar
Klassifikation
‘accuracy’	`metrics.accuracy_score`
‘balanced_accuracy’	`metrics.balanced_accuracy_score`
‘top_k_accuracy’	`metrics.top_k_accuracy_score`
‘average_precision’	`metrics.average_precision_score`
‘neg_brier_score’	`metrics.brier_score_loss`	erfordert Unterstützung für `predict_proba`
‘f1’	`metrics.f1_score`	für binäre Ziele
‘f1_micro’	`metrics.f1_score`	mikro-gemittelt
‘f1_macro’	`metrics.f1_score`	makro-gemittelt
‘f1_weighted’	`metrics.f1_score`	gewichtete Mittelung
‘f1_samples’	`metrics.f1_score`	pro Multilabel-Stichprobe
‘neg_log_loss’	`metrics.log_loss`	erfordert Unterstützung für `predict_proba`
‘precision’ usw.	`metrics.precision_score`	Suffixe gelten wie bei ‘f1’
‘recall’ usw.	`metrics.recall_score`	Suffixe gelten wie bei ‘f1’
‘jaccard’ usw.	`metrics.jaccard_score`	Suffixe gelten wie bei ‘f1’
‘roc_auc’	`metrics.roc_auc_score`
‘roc_auc_ovr’	`metrics.roc_auc_score`
‘roc_auc_ovo’	`metrics.roc_auc_score`
‘roc_auc_ovr_weighted’	`metrics.roc_auc_score`
‘roc_auc_ovo_weighted’	`metrics.roc_auc_score`
‘d2_log_loss_score’	`metrics.d2_log_loss_score`	erfordert Unterstützung für `predict_proba`
‘d2_brier_score’	`metrics.d2_brier_score`	erfordert Unterstützung für `predict_proba`
Clustering
‘adjusted_mutual_info_score’	`metrics.adjusted_mutual_info_score`
‘adjusted_rand_score’	`metrics.adjusted_rand_score`
‘completeness_score’	`metrics.completeness_score`
‘fowlkes_mallows_score’	`metrics.fowlkes_mallows_score`
‘homogeneity_score’	`metrics.homogeneity_score`
‘mutual_info_score’	`metrics.mutual_info_score`
‘normalized_mutual_info_score’	`metrics.normalized_mutual_info_score`
‘rand_score’	`metrics.rand_score`
‘v_measure_score’	`metrics.v_measure_score`
Regression
‘explained_variance’	`metrics.explained_variance_score`
‘neg_max_error’	`metrics.max_error`
‘neg_mean_absolute_error’	`metrics.mean_absolute_error`
‘neg_mean_squared_error’	`metrics.mean_squared_error`
‘neg_root_mean_squared_error’	`metrics.root_mean_squared_error`
‘neg_mean_squared_log_error’	`metrics.mean_squared_log_error`
‘neg_root_mean_squared_log_error’	`metrics.root_mean_squared_log_error`
‘neg_median_absolute_error’	`metrics.median_absolute_error`
‘r2’	`metrics.r2_score`
‘neg_mean_poisson_deviance’	`metrics.mean_poisson_deviance`
‘neg_mean_gamma_deviance’	`metrics.mean_gamma_deviance`
‘neg_mean_absolute_percentage_error’	`metrics.mean_absolute_percentage_error`
‘d2_absolute_error_score’	`metrics.d2_absolute_error_score`

Anwendungsbeispiele

>>> from sklearn import svm, datasets
>>> from sklearn.model_selection import cross_val_score
>>> X, y = datasets.load_iris(return_X_y=True)
>>> clf = svm.SVC(random_state=0)
>>> cross_val_score(clf, X, y, cv=5, scoring='recall_macro')
array([0.96, 0.96, 0.96, 0.93, 1.        ])

Hinweis

Wenn ein falscher Scoring-Name übergeben wird, wird ein InvalidParameterError ausgelöst. Sie können die Namen aller verfügbaren Scorer abrufen, indem Sie get_scorer_names aufrufen.

3.4.3.2. Aufrufbare Scorer#

Für komplexere Anwendungsfälle und mehr Flexibilität können Sie eine aufrufbare Funktion an den scoring-Parameter übergeben. Dies kann geschehen durch:

Anpassen vordefinierter Metriken über make_scorer
Erstellen eines benutzerdefinierten Scorer-Objekts (am flexibelsten)

3.4.3.2.1. Anpassen vordefinierter Metriken über `make_scorer`#

Die folgenden Metrikfunktionen sind nicht als benannte Scorer implementiert, manchmal weil sie zusätzliche Parameter erfordern, wie z. B. fbeta_score. Sie können nicht an die scoring-Parameter übergeben werden; stattdessen muss ihre aufrufbare Funktion zusammen mit dem Wert der benutzersetzbaren Parameter an make_scorer übergeben werden.

Funktion	Parameter	Beispielverwendung
Klassifikation
`metrics.fbeta_score`	`beta`	`make_scorer(fbeta_score, beta=2)`
Regression
`metrics.mean_tweedie_deviance`	`power`	`make_scorer(mean_tweedie_deviance, power=1.5)`
`metrics.mean_pinball_loss`	`alpha`	`make_scorer(mean_pinball_loss, alpha=0.95)`
`metrics.d2_tweedie_score`	`power`	`make_scorer(d2_tweedie_score, power=1.5)`
`metrics.d2_pinball_score`	`alpha`	`make_scorer(d2_pinball_score, alpha=0.95)`

Ein typischer Anwendungsfall ist das Umwickeln einer bestehenden Metrikfunktion aus der Bibliothek mit nicht standardmäßigen Werten für ihre Parameter, wie z. B. dem beta-Parameter für die Funktion fbeta_score

>>> from sklearn.metrics import fbeta_score, make_scorer
>>> ftwo_scorer = make_scorer(fbeta_score, beta=2)
>>> from sklearn.model_selection import GridSearchCV
>>> from sklearn.svm import LinearSVC
>>> grid = GridSearchCV(LinearSVC(), param_grid={'C': [1, 10]},
...                     scoring=ftwo_scorer, cv=5)

Das Modul sklearn.metrics stellt auch eine Reihe einfacher Funktionen zur Verfügung, die einen Vorhersagefehler anhand von Ground Truth und Vorhersage messen

Funktionen, die mit _score enden, geben einen zu maximierenden Wert zurück, je höher desto besser.
Funktionen, die mit _error, _loss oder _deviance enden, geben einen zu minimierenden Wert zurück, je niedriger desto besser. Beim Konvertieren in ein Scorer-Objekt mit make_scorer setzen Sie den Parameter greater_is_better auf False (True standardmäßig; siehe die Parameterbeschreibung unten).

3.4.3.2.2. Erstellen eines benutzerdefinierten Scorer-Objekts#

Sie können Ihr eigenes benutzerdefiniertes Scorer-Objekt mit make_scorer erstellen.

3.4.3.3. Verwendung von Mehrfachmetrik-Evaluierung#

Scikit-learn ermöglicht auch die Evaluierung mehrerer Metriken in GridSearchCV, RandomizedSearchCV und cross_validate.

Es gibt drei Möglichkeiten, mehrere Scoring-Metriken für den scoring-Parameter anzugeben:

Als Iterable von Zeichenketten-Metriken

>>> scoring = ['accuracy', 'precision']

Als dict, die den Scorer-Namen der Scoring-Funktion zuordnet

>>> from sklearn.metrics import accuracy_score
>>> from sklearn.metrics import make_scorer
>>> scoring = {'accuracy': make_scorer(accuracy_score),
...            'prec': 'precision'}

Beachten Sie, dass die Wörterbuchwerte entweder Scorer-Funktionen oder eine der vordefinierten Metrik-Zeichenketten sein können.

Als aufrufbare Funktion, die ein Wörterbuch von Scores zurückgibt

>>> from sklearn.model_selection import cross_validate
>>> from sklearn.metrics import confusion_matrix
>>> # A sample toy binary classification dataset
>>> X, y = datasets.make_classification(n_classes=2, random_state=0)
>>> svm = LinearSVC(random_state=0)
>>> def confusion_matrix_scorer(clf, X, y):
...      y_pred = clf.predict(X)
...      cm = confusion_matrix(y, y_pred)
...      return {'tn': cm[0, 0], 'fp': cm[0, 1],
...              'fn': cm[1, 0], 'tp': cm[1, 1]}
>>> cv_results = cross_validate(svm, X, y, cv=5,
...                             scoring=confusion_matrix_scorer)
>>> # Getting the test set true positive scores
>>> print(cv_results['test_tp'])
[10  9  8  7  8]
>>> # Getting the test set false negative scores
>>> print(cv_results['test_fn'])
[0 1 2 3 2]

3.4.4. Klassifikationsmetriken#

Das Modul sklearn.metrics implementiert mehrere Verlust-, Score- und Hilfsfunktionen zur Messung der Klassifikationsleistung. Einige Metriken erfordern möglicherweise Wahrscheinlichkeitsschätzungen der positiven Klasse, Konfidenzwerte oder binäre Entscheidungswerte. Die meisten Implementierungen erlauben es jeder Stichprobe, über den Parameter sample_weight einen gewichteten Beitrag zur Gesamtbewertung zu leisten.

Einige davon sind auf den binären Klassifizierungsfall beschränkt:

`precision_recall_curve`(y_true, y_score, *[, ...])	Berechne Präzisions-Recall-Paare für verschiedene Wahrscheinlichkeitsschwellen.
`roc_curve`(y_true, y_score, *[, pos_label, ...])	Berechne die Receiver operating characteristic (ROC).
`class_likelihood_ratios`(y_true, y_pred, *[, ...])	Berechnet die positiven und negativen Likelihood-Verhältnisse für die binäre Klassifikation.
`det_curve`(y_true, y_score[, pos_label, ...])	Berechne Detection Error Tradeoff (DET) für verschiedene Wahrscheinlichkeitsschwellen.
`confusion_matrix_at_thresholds`(y_true, y_score)	Berechne Terme der binären Konfusionsmatrix pro Klassifizierungsschwelle.

Andere funktionieren auch im Multiklassenfall:

`balanced_accuracy_score`(y_true, y_pred, *[, ...])	Berechnet die ausgewogene Genauigkeit.
`cohen_kappa_score`(y1, y2, *[, labels, ...])	Berechnet den Cohen's Kappa: eine Statistik, die die Übereinstimmung zwischen Annotatoren misst.
`confusion_matrix`(y_true, y_pred, *[, ...])	Berechnet die Konfusionsmatrix zur Bewertung der Genauigkeit einer Klassifikation.
`hinge_loss`(y_true, pred_decision, *[, ...])	Durchschnittlicher Hinge-Verlust (nicht regularisiert).
`matthews_corrcoef`(y_true, y_pred, *[, ...])	Berechne den Matthews-Korrelationskoeffizienten (MCC).
`roc_auc_score`(y_true, y_score, *[, average, ...])	Berechne die Fläche unter der Receiver Operating Characteristic Curve (ROC AUC) aus den Vorhersagescores.
`top_k_accuracy_score`(y_true, y_score, *[, ...])	Top-k Genauigkeitsklassifikations-Score.

Einige funktionieren auch im Multilabel-Fall:

`accuracy_score`(y_true, y_pred, *[, ...])	Genauigkeits-Klassifikationsergebnis.
`classification_report`(y_true, y_pred, *[, ...])	Erstellt einen Textbericht, der die wichtigsten Klassifikationsmetriken zeigt.
`f1_score`(y_true, y_pred, *[, labels, ...])	Berechne den F1-Score, auch bekannt als Balanced F-Score oder F-Maß.
`fbeta_score`(y_true, y_pred, *, beta[, ...])	Berechne den F-beta-Score.
`hamming_loss`(y_true, y_pred, *[, sample_weight])	Berechne den durchschnittlichen Hamming-Verlust.
`jaccard_score`(y_true, y_pred, *[, labels, ...])	Jaccard-Ähnlichkeitskoeffizient-Score.
`log_loss`(y_true, y_pred, *[, normalize, ...])	Log-Loss, auch bekannt als logistischer Verlust oder Kreuzentropieverlust.
`multilabel_confusion_matrix`(y_true, y_pred, *)	Berechne eine Konfusionsmatrix für jede Klasse oder Stichprobe.
`precision_recall_fscore_support`(y_true, ...)	Berechne Präzision, Recall, F-Maß und Support für jede Klasse.
`precision_score`(y_true, y_pred, *[, labels, ...])	Berechne die Präzision.
`recall_score`(y_true, y_pred, *[, labels, ...])	Berechne den Recall.
`roc_auc_score`(y_true, y_score, *[, average, ...])	Berechne die Fläche unter der Receiver Operating Characteristic Curve (ROC AUC) aus den Vorhersagescores.
`zero_one_loss`(y_true, y_pred, *[, ...])	Null-Eins-Klassifikationsverlust.
`d2_log_loss_score`(y_true, y_pred, *[, ...])	D² Score-Funktion, Bruchteil des erklärten Log-Loss.

Und einige arbeiten mit binären und Multilabel-Problemen (aber nicht Multiclass-Problemen)

average_precision_score(y_true, y_score, *)

Berechnet die durchschnittliche Präzision (AP) aus Vorhersageergebnissen.

In den folgenden Unterabschnitten werden wir jede dieser Funktionen beschreiben, vorangestellt mit einigen Hinweisen zu gängigen APIs und Metrikdefinitionen.

3.4.4.1. Von binär zu Multiclass und Multilabel#

Einige Metriken sind im Wesentlichen für binäre Klassifizierungsaufgaben definiert (z. B. f1_score, roc_auc_score). In diesen Fällen wird standardmäßig nur das positive Label ausgewertet, wobei angenommen wird, dass die positive Klasse standardmäßig mit 1 bezeichnet wird (obwohl dies über den Parameter pos_label konfigurierbar ist).

Bei der Erweiterung einer binären Metrik auf Multiclass- oder Multilabel-Probleme werden die Daten als eine Sammlung von binären Problemen behandelt, eines für jede Klasse. Es gibt dann eine Reihe von Möglichkeiten, binäre Metrikberechnungen über die Menge der Klassen zu mitteln, von denen jede in einem bestimmten Szenario nützlich sein kann. Wo verfügbar, sollten Sie unter diesen mit dem Parameter average auswählen.

"macro" berechnet einfach den Mittelwert der binären Metriken und weist jeder Klasse die gleiche Gewichtung zu. Bei Problemen, bei denen seltene Klassen dennoch wichtig sind, kann die Makromittelung ein Mittel sein, um ihre Leistung hervorzuheben. Andererseits ist die Annahme, dass alle Klassen gleich wichtig sind, oft nicht zutreffend, so dass die Makromittelung die typischerweise geringe Leistung bei einer seltenen Klasse überbewertet.
"weighted" berücksichtigt Klassenungleichgewichte, indem der Durchschnitt binärer Metriken berechnet wird, bei denen die Punktzahl jeder Klasse nach ihrer Präsenz in der tatsächlichen Datenstichprobe gewichtet wird.
"micro" gibt jedem Stichproben-Klassen-Paar einen gleichen Beitrag zur Gesamtmetrik (außer aufgrund von Stichprobengewichten). Anstatt die Metrik pro Klasse zu summieren, werden hier die Dividenden und Divisoren summiert, die die Metriken pro Klasse bilden, um einen Gesamtquotienten zu berechnen. Die Mikromittelung kann in Multilabel-Szenarien bevorzugt werden, einschließlich Multiclass-Klassifizierung, bei der eine Mehrheitsklasse ignoriert werden soll.
"samples" gilt nur für Multilabel-Probleme. Es wird keine Metrik pro Klasse berechnet, sondern stattdessen die Metrik über die tatsächlichen und vorhergesagten Klassen für jede Stichprobe in den Auswertungsdaten berechnet und deren (mit sample_weight gewichteter) Durchschnitt zurückgegeben.
Wenn average=None ausgewählt wird, wird ein Array mit der Punktzahl für jede Klasse zurückgegeben.

Während Multiclass-Daten wie binäre Ziele als Array von Klassenbezeichnungen an die Metrik übergeben werden, werden Multilabel-Daten als Indikatormatrix angegeben, bei der die Zelle [i, j] den Wert 1 hat, wenn die Stichprobe i das Label j hat, und ansonsten den Wert 0.

3.4.4.2. Genauigkeitspunktzahl#

Die Funktion accuracy_score berechnet die Genauigkeit, entweder den Bruchteil (standardmäßig) oder die Anzahl (normalize=False) korrekter Vorhersagen.

Bei der Multilabel-Klassifizierung gibt die Funktion die Subset-Genauigkeit zurück. Wenn die gesamte Menge der vorhergesagten Labels für eine Stichprobe exakt mit der wahren Menge der Labels übereinstimmt, dann ist die Subset-Genauigkeit 1,0; andernfalls ist sie 0,0.

Wenn \(\hat{y}_i\) der vorhergesagte Wert für die \(i\)-te Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der Anteil der korrekten Vorhersagen über \(n_\text{samples}\) definiert als

\[\texttt{accuracy}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples}-1} 1(\hat{y}_i = y_i)\]

wobei \(1(x)\) die Indikatorfunktion ist.

>>> import numpy as np
>>> from sklearn.metrics import accuracy_score
>>> y_pred = [0, 2, 1, 3]
>>> y_true = [0, 1, 2, 3]
>>> accuracy_score(y_true, y_pred)
0.5
>>> accuracy_score(y_true, y_pred, normalize=False)
2.0

Im Multilabel-Fall mit binären Label-Indikatoren

>>> accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

Beispiele

Siehe Testen der Signifikanz einer Klassifizierungsmetrik mit Permutationen für ein Beispiel zur Verwendung der Genauigkeitspunktzahl mit Permutationen des Datensatzes.

3.4.4.3. Top-k Genauigkeitspunktzahl#

Die Funktion top_k_accuracy_score ist eine Verallgemeinerung von accuracy_score. Der Unterschied besteht darin, dass eine Vorhersage als korrekt gilt, solange das wahre Label mit einem der k höchsten vorhergesagten Punktzahlen verbunden ist. accuracy_score ist der Sonderfall von k = 1.

Die Funktion deckt binäre und Multiclass-Klassifizierungsfälle ab, aber nicht den Multilabel-Fall.

Wenn \(\hat{f}_{i,j}\) die vorhergesagte Klasse für die \(i\)-te Stichprobe ist, die der \(j\)-ten höchsten vorhergesagten Punktzahl entspricht, und \(y_i\) der entsprechende wahre Wert ist, dann ist der Anteil der korrekten Vorhersagen über \(n_\text{samples}\) definiert als

\[\texttt{top-k accuracy}(y, \hat{f}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples}-1} \sum_{j=1}^{k} 1(\hat{f}_{i,j} = y_i)\]

wobei \(k\) die Anzahl der zulässigen Vermutungen und \(1(x)\) die Indikatorfunktion ist.

>>> import numpy as np
>>> from sklearn.metrics import top_k_accuracy_score
>>> y_true = np.array([0, 1, 2, 2])
>>> y_score = np.array([[0.5, 0.2, 0.2],
...                     [0.3, 0.4, 0.2],
...                     [0.2, 0.4, 0.3],
...                     [0.7, 0.2, 0.1]])
>>> top_k_accuracy_score(y_true, y_score, k=2)
0.75
>>> # Not normalizing gives the number of "correctly" classified samples
>>> top_k_accuracy_score(y_true, y_score, k=2, normalize=False)
3.0

3.4.4.4. Ausbalancierte Genauigkeitspunktzahl#

Die Funktion balanced_accuracy_score berechnet die ausbalancierte Genauigkeit, die überhöhte Leistungsindikatoren auf unausgeglichenen Datensätzen vermeidet. Sie ist die Makromittelung von Recall-Punktzahlen pro Klasse oder, gleichwertig, die Rohgenauigkeit, bei der jede Stichprobe entsprechend der inversen Prävalenz ihrer wahren Klasse gewichtet wird. Bei ausgeglichenen Datensätzen ist die Punktzahl daher gleich der Genauigkeit.

Im binären Fall entspricht die ausbalancierte Genauigkeit dem arithmetischen Mittel von Sensitivität (True Positive Rate) und Spezifität (True Negative Rate) oder der Fläche unter der ROC-Kurve mit binären Vorhersagen anstelle von Punktzahlen

\[\texttt{balanced-accuracy} = \frac{1}{2}\left( \frac{TP}{TP + FN} + \frac{TN}{TN + FP}\right )\]

Wenn der Klassifikator auf beiden Klassen gleichermaßen gut abschneidet, reduziert sich dieser Term auf die konventionelle Genauigkeit (d. h. die Anzahl der korrekten Vorhersagen geteilt durch die Gesamtzahl der Vorhersagen).

Wenn die konventionelle Genauigkeit nur oberhalb des Zufalls liegt, weil der Klassifikator einen unausgeglichenen Testdatensatz ausnutzt, dann fällt die ausbalancierte Genauigkeit, wie angemessen, auf \(\frac{1}{n\_classes}\).

Die Punktzahl reicht von 0 bis 1, oder wenn adjusted=True verwendet wird, wird sie auf den Bereich \(\frac{1}{1 - n\_classes}\) bis 1 skaliert, wobei eine Leistung bei zufälliger Punktzahl von 0 bewertet wird.

Wenn \(y_i\) der wahre Wert der \(i\)-ten Stichprobe und \(w_i\) das entsprechende Stichprobengewicht ist, dann passen wir das Stichprobengewicht an

\[\hat{w}_i = \frac{w_i}{\sum_j{1(y_j = y_i) w_j}}\]

wobei \(1(x)\) die Indikatorfunktion ist. Gegeben die vorhergesagten \(\hat{y}_i\) für Stichprobe \(i\), ist die ausbalancierte Genauigkeit definiert als

\[\texttt{balanced-accuracy}(y, \hat{y}, w) = \frac{1}{\sum{\hat{w}_i}} \sum_i 1(\hat{y}_i = y_i) \hat{w}_i\]

Mit adjusted=True berichtet die ausbalancierte Genauigkeit die relative Zunahme von \(\texttt{balanced-accuracy}(y, \mathbf{0}, w) = \frac{1}{n\_classes}\). Im binären Fall ist dies auch als Youden’s J-Statistik oder *Informedness* bekannt.

Hinweis

Die Multiclass-Definition hier scheint die sinnvollste Erweiterung der in der binären Klassifizierung verwendeten Metrik zu sein, obwohl es keinen eindeutigen Konsens in der Literatur gibt.

Unsere Definition: [Mosley2013], [Kelleher2015] und [Guyon2015], wobei [Guyon2015] die angepasste Version übernimmt, um sicherzustellen, dass zufällige Vorhersagen eine Punktzahl von \(0\) und perfekte Vorhersagen eine Punktzahl von \(1\) haben.
Klassen-ausbalancierte Genauigkeit, wie beschrieben in [Mosley2013]: das Minimum zwischen Präzision und Recall für jede Klasse wird berechnet. Diese Werte werden dann über die Gesamtzahl der Klassen gemittelt, um die ausbalancierte Genauigkeit zu erhalten.
Ausbalancierte Genauigkeit, wie beschrieben in [Urbanowicz2015]: der Durchschnitt aus Sensitivität und Spezifität wird für jede Klasse berechnet und dann über die Gesamtzahl der Klassen gemittelt.

Referenzen

[Guyon2015] (1,2)

I. Guyon, K. Bennett, G. Cawley, H.J. Escalante, S. Escalera, T.K. Ho, N. Macià, B. Ray, M. Saeed, A.R. Statnikov, E. Viegas, Design of the 2015 ChaLearn AutoML Challenge, IJCNN 2015.

[Mosley2013] (1,2)

L. Mosley, A balanced approach to the multi-class imbalance problem, IJCV 2010.

[Kelleher2015]

John. D. Kelleher, Brian Mac Namee, Aoife D’Arcy, Fundamentals of Machine Learning for Predictive Data Analytics: Algorithms, Worked Examples, and Case Studies, 2015.

[Urbanowicz2015]

Urbanowicz R.J., Moore, J.H. ExSTraCS 2.0: description and evaluation of a scalable learning classifier system, Evol. Intel. (2015) 8: 89.

3.4.4.5. Cohens Kappa#

Die Funktion cohen_kappa_score berechnet die Cohen’s Kappa-Statistik. Diese Maßnahme soll die Labels verschiedener menschlicher Annotatoren vergleichen, nicht einen Klassifikator mit einer Grundwahrheit.

Die Kappa-Punktzahl ist eine Zahl zwischen -1 und 1. Punktzahlen über 0,8 werden im Allgemeinen als gute Übereinstimmung betrachtet; null oder niedriger bedeutet keine Übereinstimmung (praktisch zufällige Labels).

Kappa-Punktzahlen können für binäre oder Multiclass-Probleme berechnet werden, aber nicht für Multilabel-Probleme (außer durch manuelle Berechnung einer Punktzahl pro Label) und nicht für mehr als zwei Annotatoren.

>>> from sklearn.metrics import cohen_kappa_score
>>> labeling1 = [2, 0, 2, 2, 0, 1]
>>> labeling2 = [0, 0, 2, 2, 0, 2]
>>> cohen_kappa_score(labeling1, labeling2)
0.4285714285714286

3.4.4.6. Konfusionsmatrix#

Die Funktion confusion_matrix wertet die Klassifizierungsgenauigkeit aus, indem sie die Konfusionsmatrix berechnet, wobei jede Zeile der wahren Klasse entspricht (Wikipedia und andere Referenzen können unterschiedliche Konventionen für Achsen verwenden).

Per Definition ist der Eintrag \(i, j\) in einer Konfusionsmatrix die Anzahl der Beobachtungen, die tatsächlich in Gruppe \(i\) sind, aber als Gruppe \(j\) vorhergesagt wurden. Hier ist ein Beispiel

>>> from sklearn.metrics import confusion_matrix
>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> confusion_matrix(y_true, y_pred)
array([[2, 0, 0],
       [0, 0, 1],
       [1, 0, 2]])

ConfusionMatrixDisplay kann verwendet werden, um eine Konfusionsmatrix visuell darzustellen, wie im Beispiel Bewertung der Leistung eines Klassifikators mit Konfusionsmatrix gezeigt, das die folgende Abbildung erstellt

../_images/sphx_glr_plot_confusion_matrix_001.png

Der Parameter normalize ermöglicht die Berichterstattung von Verhältnissen anstelle von Zählungen. Die Konfusionsmatrix kann auf 3 verschiedene Arten normalisiert werden: 'pred', 'true' und 'all', die die Zählungen durch die Summe jeder Spalte, Zeile oder der gesamten Matrix teilen.

>>> y_true = [0, 0, 0, 1, 1, 1, 1, 1]
>>> y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
>>> confusion_matrix(y_true, y_pred, normalize='all')
array([[0.25 , 0.125],
       [0.25 , 0.375]])

Für binäre Probleme können wir die Zählungen von True Negatives, False Positives, False Negatives und True Positives wie folgt erhalten

>>> y_true = [0, 0, 0, 1, 1, 1, 1, 1]
>>> y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
>>> tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel().tolist()
>>> tn, fp, fn, tp
(2, 1, 2, 3)

Mit confusion_matrix_at_thresholds können wir True Negatives, False Positives, False Negatives und True Positives für verschiedene Schwellenwerte erhalten.

>>> from sklearn.metrics import confusion_matrix_at_thresholds
>>> y_true = np.array([0., 0., 1., 1.])
>>> y_score = np.array([0.1, 0.4, 0.35, 0.8])
>>> tns, fps, fns, tps, thresholds = confusion_matrix_at_thresholds(y_true, y_score)
>>> tns
array([2., 1., 1., 0.])
>>> fps
array([0., 1., 1., 2.])
>>> fns
array([1., 1., 0., 0.])
>>> tps
array([1., 1., 2., 2.])
>>> thresholds
array([0.8, 0.4, 0.35, 0.1])

Beachten Sie, dass die Schwellenwerte aus eindeutigen y_score-Werten in absteigender Reihenfolge bestehen.

Beispiele

Siehe Bewertung der Leistung eines Klassifikators mit Konfusionsmatrix für ein Beispiel zur Verwendung einer Konfusionsmatrix zur Bewertung der Qualität von Klassifikatorausgaben.
Siehe Erkennung handgeschriebener Ziffern für ein Beispiel zur Verwendung einer Konfusionsmatrix zur Klassifizierung handgeschriebener Ziffern.
Siehe Klassifizierung von Textdokumenten mit spärlichen Merkmalen für ein Beispiel zur Verwendung einer Konfusionsmatrix zur Klassifizierung von Textdokumenten.

3.4.4.7. Klassifizierungsbericht#

Die Funktion classification_report erstellt einen Textbericht, der die wichtigsten Klassifizierungsmetriken anzeigt. Hier ist ein kleines Beispiel mit benutzerdefinierten target_names und abgeleiteten Labels

>>> from sklearn.metrics import classification_report
>>> y_true = [0, 1, 2, 2, 0]
>>> y_pred = [0, 0, 2, 1, 0]
>>> target_names = ['class 0', 'class 1', 'class 2']
>>> print(classification_report(y_true, y_pred, target_names=target_names))
              precision    recall  f1-score   support

     class 0       0.67      1.00      0.80         2
     class 1       0.00      0.00      0.00         1
     class 2       1.00      0.50      0.67         2

    accuracy                           0.60         5
   macro avg       0.56      0.50      0.49         5
weighted avg       0.67      0.60      0.59         5

Beispiele

Siehe Erkennung handgeschriebener Ziffern für ein Beispiel zur Verwendung des Klassifizierungsberichts für handgeschriebene Ziffern.
Siehe Benutzerdefinierte Refit-Strategie einer Grid-Suche mit Kreuzvalidierung für ein Beispiel zur Verwendung des Klassifizierungsberichts für die Grid-Suche mit verschachtelter Kreuzvalidierung.

3.4.4.8. Hamming-Verlust#

Die Funktion hamming_loss berechnet den durchschnittlichen Hamming-Verlust oder die Hamming-Distanz zwischen zwei Stichprobenmengen.

Wenn \(\hat{y}_{i,j}\) der vorhergesagte Wert für das \(j\)-te Label einer gegebenen Stichprobe \(i\) ist, \(y_{i,j}\) der entsprechende wahre Wert ist, \(n_\text{samples}\) die Anzahl der Stichproben und \(n_\text{labels}\) die Anzahl der Labels ist, dann ist der Hamming-Verlust \(L_{Hamming}\) definiert als

\[L_{Hamming}(y, \hat{y}) = \frac{1}{n_\text{samples} * n_\text{labels}} \sum_{i=0}^{n_\text{samples}-1} \sum_{j=0}^{n_\text{labels} - 1} 1(\hat{y}_{i,j} \not= y_{i,j})\]

wobei \(1(x)\) die Indikatorfunktion ist.

Die obige Gleichung gilt nicht im Fall der Multiclass-Klassifizierung. Bitte beachten Sie die folgende Notiz für weitere Informationen.

>>> from sklearn.metrics import hamming_loss
>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> hamming_loss(y_true, y_pred)
0.25

Im Multilabel-Fall mit binären Label-Indikatoren

>>> hamming_loss(np.array([[0, 1], [1, 1]]), np.zeros((2, 2)))
0.75

Hinweis

Bei der Multiclass-Klassifizierung entspricht der Hamming-Verlust der Hamming-Distanz zwischen y_true und y_pred, was der Funktion Zero-One-Verlust ähnelt. Während der Zero-One-Verlust Vorhersagesätze bestraft, die nicht exakt mit wahren Sätzen übereinstimmen, bestraft der Hamming-Verlust einzelne Labels. Somit ist der Hamming-Verlust, der durch den Zero-One-Verlust nach oben begrenzt ist, immer zwischen Null und Eins, einschließlich; und die Vorhersage eines echten Teilmengens oder Obermenge der wahren Labels ergibt einen Hamming-Verlust zwischen Null und Eins, exklusiv.

3.4.4.9. Präzision, Recall und F-Maße#

Intuitiv ist Präzision die Fähigkeit des Klassifikators, eine Stichprobe nicht als positiv zu kennzeichnen, die negativ ist, und Recall ist die Fähigkeit des Klassifikators, alle positiven Stichproben zu finden.

Das F-Maß (\(\text{F}_\beta\) und \(\text{F}_1\)-Maße) kann als gewichteter harmonischer Mittelwert aus Präzision und Recall interpretiert werden. Ein \(\text{F}_\beta\)-Maß erreicht seinen besten Wert bei 1 und seine schlechteste Punktzahl bei 0. Mit \(\beta = 1\) sind \(\text{F}_\beta\) und \(\text{F}_1\) gleichwertig, und Recall und Präzision sind gleich wichtig.

Die Funktion precision_recall_curve berechnet eine Präzisions-Recall-Kurve aus der Grundwahrheit und einer vom Klassifikator gegebenen Punktzahl durch Variieren eines Entscheidungsschwellenwerts.

Die Funktion average_precision_score berechnet die durchschnittliche Präzision (AP) aus Vorhersagepunktzahlen. Der Wert liegt zwischen 0 und 1, und höher ist besser. AP ist definiert als

\[\text{AP} = \sum_n (R_n - R_{n-1}) P_n\]

wobei \(P_n\) und \(R_n\) die Präzision und der Recall beim n-ten Schwellenwert sind. Bei zufälligen Vorhersagen ist die AP der Anteil der positiven Stichproben.

Referenzen [Manning2008] und [Everingham2010] stellen alternative Varianten von AP vor, die die Präzisions-Recall-Kurve interpolieren. Derzeit implementiert average_precision_score keine interpolierten Varianten. Referenzen [Davis2006] und [Flach2015] beschreiben, warum eine lineare Interpolation von Punkten auf der Präzisions-Recall-Kurve eine überoptimistische Messung der Klassifikatorleistung liefert. Diese lineare Interpolation wird bei der Berechnung der Fläche unter der Kurve mit der Trapezregel in auc verwendet. [Chen2024] vergleicht verschiedene Interpolationsstrategien, um die Effekte zu demonstrieren.

Mehrere Funktionen ermöglichen es Ihnen, die Präzisions-, Recall- und F-Maße-Punktzahl zu analysieren.

`average_precision_score`(y_true, y_score, *)	Berechnet die durchschnittliche Präzision (AP) aus Vorhersageergebnissen.
`f1_score`(y_true, y_pred, *[, labels, ...])	Berechne den F1-Score, auch bekannt als Balanced F-Score oder F-Maß.
`fbeta_score`(y_true, y_pred, *, beta[, ...])	Berechne den F-beta-Score.
`precision_recall_curve`(y_true, y_score, *[, ...])	Berechne Präzisions-Recall-Paare für verschiedene Wahrscheinlichkeitsschwellen.
`precision_recall_fscore_support`(y_true, ...)	Berechne Präzision, Recall, F-Maß und Support für jede Klasse.
`precision_score`(y_true, y_pred, *[, labels, ...])	Berechne die Präzision.
`recall_score`(y_true, y_pred, *[, labels, ...])	Berechne den Recall.

Beachten Sie, dass die Funktion precision_recall_curve auf den binären Fall beschränkt ist. Die Funktion average_precision_score unterstützt Multiclass- und Multilabel-Formate, indem sie die Punktzahl jeder Klasse im One-vs-the-rest (OvR)-Verfahren berechnet und diese je nach Wert des Arguments average mittelt oder nicht.

Die Funktionen PrecisionRecallDisplay.from_estimator und PrecisionRecallDisplay.from_predictions zeichnen die Präzisions-Recall-Kurve wie folgt.

../_images/sphx_glr_plot_precision_recall_001.png

Beispiele

Siehe Benutzerdefinierte Refit-Strategie einer Grid-Suche mit Kreuzvalidierung für ein Beispiel zur Verwendung von precision_score und recall_score zur Parameterschätzung mittels Grid-Suche mit verschachtelter Kreuzvalidierung.
Siehe Präzision-Recall für ein Beispiel zur Verwendung von precision_recall_curve zur Bewertung der Qualität von Klassifikatorausgaben.

Referenzen

[Manning2008]

C.D. Manning, P. Raghavan, H. Schütze, Introduction to Information Retrieval, 2008.

[Everingham2010]

M. Everingham, L. Van Gool, C.K.I. Williams, J. Winn, A. Zisserman, The Pascal Visual Object Classes (VOC) Challenge, IJCV 2010.

[Davis2006]

J. Davis, M. Goadrich, The Relationship Between Precision-Recall and ROC Curves, ICML 2006.

[Flach2015]

P.A. Flach, M. Kull, Precision-Recall-Gain Curves: PR Analysis Done Right, NIPS 2015.

[Chen2024]

W. Chen, C. Miao, Z. Zhang, C.S. Fung, R. Wang, Y. Chen, Y. Qian, L. Cheng, K.Y. Yip, S.K Tsui, Q. Cao, Commonly used software tools produce conflicting and overly-optimistic AUPRC values, Genome Biology 2024.

3.4.4.9.1. Binäre Klassifizierung#

Bei einer binären Klassifizierungsaufgabe beziehen sich die Begriffe „positiv“ und „negativ“ auf die Vorhersage des Klassifikators, und die Begriffe „wahr“ und „falsch“ beziehen sich darauf, ob diese Vorhersage mit dem externen Urteil (manchmal auch als „Beobachtung“ bezeichnet) übereinstimmt. Mit diesen Definitionen können wir die folgende Tabelle formulieren

	Tatsächliche Klasse (Beobachtung)
Vorhergesagte Klasse (Erwartung)	tp (true positive) Korrektes Ergebnis	fp (false positive) Unerwartetes Ergebnis
Vorhergesagte Klasse (Erwartung)	fn (false negative) Fehlendes Ergebnis	tn (true negative) Korrektes Fehlen eines Ergebnisses

In diesem Zusammenhang können wir die Begriffe Präzision und Recall definieren

\[\text{precision} = \frac{\text{tp}}{\text{tp} + \text{fp}},\]

\[\text{recall} = \frac{\text{tp}}{\text{tp} + \text{fn}},\]

(Manchmal wird Recall auch als „Sensitivität“ bezeichnet)

Das F-Maß ist das gewichtete harmonische Mittel aus Präzision und Recall, wobei der Beitrag der Präzision zum Mittel mit einem Parameter \(\beta\) gewichtet wird.

\[F_\beta = (1 + \beta^2) \frac{\text{precision} \times \text{recall}}{\beta^2 \text{precision} + \text{recall}}\]

Um eine Division durch Null zu vermeiden, wenn Präzision und Recall null sind, berechnet Scikit-Learn das F-Maß mit dieser ansonsten äquivalenten Formel

\[F_\beta = \frac{(1 + \beta^2) \text{tp}}{(1 + \beta^2) \text{tp} + \text{fp} + \beta^2 \text{fn}}\]

Beachten Sie, dass diese Formel immer noch undefiniert ist, wenn keine True Positives, False Positives oder False Negatives vorhanden sind. Standardmäßig wird F-1 für eine Menge ausschließlich von True Negatives als 0 berechnet. Dieses Verhalten kann jedoch mit dem Parameter zero_division geändert werden. Hier sind einige kleine Beispiele zur binären Klassifizierung.

>>> from sklearn import metrics
>>> y_pred = [0, 1, 0, 0]
>>> y_true = [0, 1, 0, 1]
>>> metrics.precision_score(y_true, y_pred)
1.0
>>> metrics.recall_score(y_true, y_pred)
0.5
>>> metrics.f1_score(y_true, y_pred)
0.66
>>> metrics.fbeta_score(y_true, y_pred, beta=0.5)
0.83
>>> metrics.fbeta_score(y_true, y_pred, beta=1)
0.66
>>> metrics.fbeta_score(y_true, y_pred, beta=2)
0.55
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5)
(array([0.66, 1.        ]), array([1. , 0.5]), array([0.71, 0.83]), array([2, 2]))


>>> import numpy as np
>>> from sklearn.metrics import precision_recall_curve
>>> from sklearn.metrics import average_precision_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> precision, recall, threshold = precision_recall_curve(y_true, y_scores)
>>> precision
array([0.5       , 0.66, 0.5       , 1.        , 1.        ])
>>> recall
array([1. , 1. , 0.5, 0.5, 0. ])
>>> threshold
array([0.1 , 0.35, 0.4 , 0.8 ])
>>> average_precision_score(y_true, y_scores)
0.83

3.4.4.9.2. Multiclass- und Multilabel-Klassifizierung#

Bei Multiclass- und Multilabel-Klassifizierungsaufgaben können die Begriffe Präzision, Recall und F-Maße für jedes Label einzeln angewendet werden. Es gibt mehrere Möglichkeiten, die Ergebnisse über Labels hinweg zu kombinieren, die durch das Argument average in den Funktionen average_precision_score, f1_score, fbeta_score, precision_recall_fscore_support, precision_score und recall_score beschrieben werden, wie oben beschrieben.

Beachten Sie die folgenden Verhaltensweisen bei der Mittelung

Wenn alle Labels einbezogen werden, ergibt die „Mikro“-Mittelung in einem Multiclass-Szenario Präzision, Recall und \(\text{F}\), die alle identisch mit der Genauigkeit sind.
„weighted“ averaging kann einen F-Score ergeben, der nicht zwischen Präzision und Recall liegt.
„macro“-Mittelung für F-Maße wird als das arithmetische Mittel über die F-Maße pro Label/Klasse berechnet, nicht als das harmonische Mittel über die arithmetischen Mittel von Präzision und Recall. Beide Berechnungen sind in der Literatur zu finden, aber nicht äquivalent, siehe [OB2019] für Details.

Um dies deutlicher zu machen, betrachten Sie die folgende Notation

\(y\) die Menge der wahren \((Stichprobe, Label)\)-Paare
\(\hat{y}\) die Menge der vorhergesagten \((Stichprobe, Label)\)-Paare
\(L\) die Menge der Labels
\(S\) die Menge der Stichproben
\(y_s\) die Teilmenge von \(y\) mit der Stichprobe \(s\), d.h. \(y_s := \left\{(s', l) \in y | s' = s\right\}\)
\(y_l\) die Teilmenge von \(y\) mit dem Label \(l\)
ähnlich sind \(\hat{y}_s\) und \(\hat{y}_l\) Teilmengen von \(\hat{y}\)
\(P(A, B) := \frac{\left| A \cap B \right|}{\left|B\right|}\) für einige Mengen \(A\) und \(B\)
\(R(A, B) := \frac{\left| A \cap B \right|}{\left|A\right|}\) (Konventionen variieren bei der Behandlung von \(A = \emptyset\); diese Implementierung verwendet \(R(A, B):=0\), und ähnliches für \(P\).)
\(F_\beta(A, B) := \left(1 + \beta^2\right) \frac{P(A, B) \times R(A, B)}{\beta^2 P(A, B) + R(A, B)}\)

Dann sind die Metriken definiert als

`Mittelung`	Präzision	Recall	F_beta
`"micro"`	\(P(y, \hat{y})\)	\(R(y, \hat{y})\)	\(F_\beta(y, \hat{y})\)
`"samples"`	\(\frac{1}{\left\|S\right\|} \sum_{s \in S} P(y_s, \hat{y}_s)\)	\(\frac{1}{\left\|S\right\|} \sum_{s \in S} R(y_s, \hat{y}_s)\)	\(\frac{1}{\left\|S\right\|} \sum_{s \in S} F_\beta(y_s, \hat{y}_s)\)
`"macro"`	\(\frac{1}{\left\|L\right\|} \sum_{l \in L} P(y_l, \hat{y}_l)\)	\(\frac{1}{\left\|L\right\|} \sum_{l \in L} R(y_l, \hat{y}_l)\)	\(\frac{1}{\left\|L\right\|} \sum_{l \in L} F_\beta(y_l, \hat{y}_l)\)
`"weighted"`	\(\frac{1}{\sum_{l \in L} \left\|y_l\right\|} \sum_{l \in L} \left\|y_l\right\| P(y_l, \hat{y}_l)\)	\(\frac{1}{\sum_{l \in L} \left\|y_l\right\|} \sum_{l \in L} \left\|y_l\right\| R(y_l, \hat{y}_l)\)	\(\frac{1}{\sum_{l \in L} \left\|y_l\right\|} \sum_{l \in L} \left\|y_l\right\| F_\beta(y_l, \hat{y}_l)\)
`None`	\(\langle P(y_l, \hat{y}_l) \| l \in L \rangle\)	\(\langle R(y_l, \hat{y}_l) \| l \in L \rangle\)	\(\langle F_\beta(y_l, \hat{y}_l) \| l \in L \rangle\)

>>> from sklearn import metrics
>>> y_true = [0, 1, 2, 0, 1, 2]
>>> y_pred = [0, 2, 1, 0, 0, 1]
>>> metrics.precision_score(y_true, y_pred, average='macro')
0.22
>>> metrics.recall_score(y_true, y_pred, average='micro')
0.33
>>> metrics.f1_score(y_true, y_pred, average='weighted')
0.267
>>> metrics.fbeta_score(y_true, y_pred, average='macro', beta=0.5)
0.238
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5, average=None)
(array([0.667, 0., 0.]), array([1., 0., 0.]), array([0.714, 0., 0.]), array([2, 2, 2]))

Bei der Klassifizierung von Multiklassen mit einer „negativen Klasse“ ist es möglich, einige Labels auszuschließen

>>> metrics.recall_score(y_true, y_pred, labels=[1, 2], average='micro')
... # excluding 0, no labels were correctly recalled
0.0

Ähnlich können Labels, die in der Datenprobe nicht vorhanden sind, bei der Makro-Mittelung berücksichtigt werden.

>>> metrics.precision_score(y_true, y_pred, labels=[0, 1, 2, 3], average='macro')
0.166

Referenzen

[OB2019]

Opitz, J., & Burst, S. (2019). „Macro f1 and macro f1.“

3.4.4.10. Jaccard-Ähnlichkeitskoeffizient-Score#

Die Funktion jaccard_score berechnet das Mittel der Jaccard-Ähnlichkeitskoeffizienten, auch bekannt als Jaccard-Index, zwischen Paaren von Label-Mengen.

Der Jaccard-Ähnlichkeitskoeffizient mit einer wahren Label-Menge \(y\) und einer vorhergesagten Label-Menge \(\hat{y}\) ist definiert als

\[J(y, \hat{y}) = \frac{|y \cap \hat{y}|}{|y \cup \hat{y}|}.\]

Der jaccard_score (wie precision_recall_fscore_support) ist nativ für binäre Ziele anwendbar. Durch die paarweise Berechnung kann er auf Multilabel und Multiklassen mittels average (siehe oben) erweitert werden.

Im binären Fall

>>> import numpy as np
>>> from sklearn.metrics import jaccard_score
>>> y_true = np.array([[0, 1, 1],
...                    [1, 1, 0]])
>>> y_pred = np.array([[1, 1, 1],
...                    [1, 0, 0]])
>>> jaccard_score(y_true[0], y_pred[0])
0.6666

Im 2D-Vergleichsfall (z.B. Bildähnlichkeit)

>>> jaccard_score(y_true, y_pred, average="micro")
0.6

Im Multilabel-Fall mit binären Label-Indikatoren

>>> jaccard_score(y_true, y_pred, average='samples')
0.5833
>>> jaccard_score(y_true, y_pred, average='macro')
0.6666
>>> jaccard_score(y_true, y_pred, average=None)
array([0.5, 0.5, 1. ])

Multiklassenprobleme werden binarisiert und wie entsprechende Multilabel-Probleme behandelt

>>> y_pred = [0, 2, 1, 2]
>>> y_true = [0, 1, 2, 2]
>>> jaccard_score(y_true, y_pred, average=None)
array([1. , 0. , 0.33])
>>> jaccard_score(y_true, y_pred, average='macro')
0.44
>>> jaccard_score(y_true, y_pred, average='micro')
0.33

3.4.4.11. Hinge Loss#

Die Funktion hinge_loss berechnet den durchschnittlichen Abstand zwischen dem Modell und den Daten unter Verwendung des Hinge Loss, einer einseitigen Metrik, die nur Vorhersagefehler berücksichtigt. (Hinge Loss wird in maximalen Randklassifizierern wie Support Vector Machines verwendet.)

Wenn das wahre Label \(y_i\) einer binären Klassifikationsaufgabe für jede Stichprobe \(i\) als \(y_i=\left\{-1, +1\right\}\) kodiert ist; und \(w_i\) die entsprechende vorhergesagte Entscheidung ist (ein Array der Form (n_samples,) wie es von der Methode decision_function ausgegeben wird), dann ist der Hinge Loss definiert als

\[L_\text{Hinge}(y, w) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples}-1} \max\left\{1 - w_i y_i, 0\right\}\]

Wenn es mehr als zwei Labels gibt, verwendet hinge_loss eine Multiklassenvariante nach Crammer & Singer. Hier ist die Arbeit, die sie beschreibt.

In diesem Fall ist die vorhergesagte Entscheidung ein Array der Form (n_samples, n_labels). Wenn \(w_{i, y_i}\) die vorhergesagte Entscheidung für das wahre Label \(y_i\) der \(i\)-ten Stichprobe ist; und \(\hat{w}_{i, y_i} = \max\left\{w_{i, y_j}~|~y_j \ne y_i \right\}\) das Maximum der vorhergesagten Entscheidungen für alle anderen Labels ist, dann ist der Multiklassen-Hinge-Loss definiert durch

\[L_\text{Hinge}(y, w) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples}-1} \max\left\{1 + \hat{w}_{i, y_i} - w_{i, y_i}, 0\right\}\]

Hier ist ein kleines Beispiel, das die Verwendung der Funktion hinge_loss mit einem SVM-Klassifizierer in einem binären Klassenproblem demonstriert

>>> from sklearn import svm
>>> from sklearn.metrics import hinge_loss
>>> X = [[0], [1]]
>>> y = [-1, 1]
>>> est = svm.LinearSVC(random_state=0)
>>> est.fit(X, y)
LinearSVC(random_state=0)
>>> pred_decision = est.decision_function([[-2], [3], [0.5]])
>>> pred_decision
array([-2.18,  2.36,  0.09])
>>> hinge_loss([-1, 1, 1], pred_decision)
0.3

Hier ist ein Beispiel, das die Verwendung der Funktion hinge_loss mit einem SVM-Klassifizierer in einem Multiklassenproblem demonstriert

>>> X = np.array([[0], [1], [2], [3]])
>>> Y = np.array([0, 1, 2, 3])
>>> labels = np.array([0, 1, 2, 3])
>>> est = svm.LinearSVC()
>>> est.fit(X, Y)
LinearSVC()
>>> pred_decision = est.decision_function([[-1], [2], [3]])
>>> y_true = [0, 2, 3]
>>> hinge_loss(y_true, pred_decision, labels=labels)
0.56

3.4.4.12. Log Loss#

Log Loss, auch bekannt als logistische Regressionsverlust oder Kreuzentropieverlust, wird auf Wahrscheinlichkeitsschätzungen angewendet. Er wird häufig in der (multinomialen) logistischen Regression und in neuronalen Netzen verwendet, sowie in einigen Varianten des Erwartungsmaximierungsalgorithmus, und kann zur Auswertung der Wahrscheinlichkeitsausgaben (predict_proba) eines Klassifizierers anstelle seiner diskreten Vorhersagen verwendet werden.

Für die binäre Klassifizierung mit einem wahren Label \(y \in \{0,1\}\) und einer Wahrscheinlichkeitsschätzung \(\hat{p} \approx \operatorname{Pr}(y = 1)\) ist der Log Loss pro Stichprobe die negative logarithmische Likelihood des Klassifizierers gegeben das wahre Label

\[L_{\log}(y, \hat{p}) = -\log \operatorname{Pr}(y|\hat{p}) = -(y \log (\hat{p}) + (1 - y) \log (1 - \hat{p}))\]

Dies erweitert sich auf den Multiklassenfall wie folgt. Sei die wahren Labels für eine Menge von Stichproben als 1-von-K-Binärindikatormatrix \(Y\) kodiert, d.h. \(y_{i,k} = 1\), wenn Stichprobe \(i\) das Label \(k\) aus einer Menge von \(K\) Labels hat. Sei \(\hat{P}\) eine Matrix von Wahrscheinlichkeitsschätzungen mit Elementen \(\hat{p}_{i,k} \approx \operatorname{Pr}(y_{i,k} = 1)\). Dann ist der Log Loss der gesamten Menge

\[L_{\log}(Y, \hat{P}) = -\log \operatorname{Pr}(Y|\hat{P}) = - \frac{1}{N} \sum_{i=0}^{N-1} \sum_{k=0}^{K-1} y_{i,k} \log \hat{p}_{i,k}\]

Um zu sehen, wie dies den binären Log Loss verallgemeinert, beachten Sie, dass im binären Fall \(\hat{p}_{i,0} = 1 - \hat{p}_{i,1}\) und \(y_{i,0} = 1 - y_{i,1}\) gilt, so dass die Erweiterung der inneren Summe über \(y_{i,k} \in \{0,1\}\) den binären Log Loss ergibt.

Die Funktion log_loss berechnet den Log Loss gegeben eine Liste von wahren Labels und eine Wahrscheinlichkeitsmatrix, wie sie von der Methode predict_proba eines Schätzers zurückgegeben wird.

>>> from sklearn.metrics import log_loss
>>> y_true = [0, 0, 1, 1]
>>> y_pred = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]]
>>> log_loss(y_true, y_pred)
0.1738

Das erste [.9, .1] in y_pred bedeutet eine 90%ige Wahrscheinlichkeit, dass die erste Stichprobe Label 0 hat. Der Log Loss ist nicht negativ.

3.4.4.13. Matthews-Korrelationskoeffizient#

Die Funktion matthews_corrcoef berechnet den Matthew’s Correlation Coefficient (MCC) für binäre Klassen. Zitiert aus Wikipedia

„Der Matthews-Korrelationskoeffizient wird im maschinellen Lernen als Maß für die Qualität binärer (Zwei-Klassen-)Klassifizierungen verwendet. Er berücksichtigt wahre und falsche positive und negative Ergebnisse und wird generell als ausgewogenes Maß angesehen, das auch bei Klassen mit sehr unterschiedlichen Größen verwendet werden kann. Der MCC ist im Wesentlichen ein Korrelationskoeffizient zwischen -1 und +1. Ein Koeffizient von +1 bedeutet eine perfekte Vorhersage, 0 eine durchschnittliche zufällige Vorhersage und -1 eine inverse Vorhersage. Die Statistik ist auch als Phi-Koeffizient bekannt.“

Im binären (Zwei-Klassen-)Fall sind \(tp\), \(tn\), \(fp\) und \(fn\) die Anzahlen von True Positives, True Negatives, False Positives und False Negatives, der MCC ist definiert als

\[MCC = \frac{tp \times tn - fp \times fn}{\sqrt{(tp + fp)(tp + fn)(tn + fp)(tn + fn)}}.\]

Im Multiklassenfall kann der Matthews-Korrelationskoeffizient anhand einer confusion_matrix \(C\) für \(K\) Klassen definiert werden. Zur Vereinfachung der Definition betrachten wir die folgenden Zwischenvariablen

\(t_k=\sum_{i}^{K} C_{ik}\) die Anzahl der Male, die Klasse \(k\) tatsächlich aufgetreten ist,
\(p_k=\sum_{i}^{K} C_{ki}\) die Anzahl der Male, die Klasse \(k\) vorhergesagt wurde,
\(c=\sum_{k}^{K} C_{kk}\) die Gesamtzahl der korrekt vorhergesagten Stichproben,
\(s=\sum_{i}^{K} \sum_{j}^{K} C_{ij}\) die Gesamtzahl der Stichproben.

Dann ist der Multiklassen-MCC definiert als

\[MCC = \frac{ c \times s - \sum_{k}^{K} p_k \times t_k }{\sqrt{ (s^2 - \sum_{k}^{K} p_k^2) \times (s^2 - \sum_{k}^{K} t_k^2) }}\]

Wenn es mehr als zwei Labels gibt, reicht der Wert des MCC nicht mehr von -1 bis +1. Stattdessen liegt der Minimalwert je nach Anzahl und Verteilung der wahren Labels irgendwo zwischen -1 und 0. Der Maximalwert ist immer +1. Weitere Informationen finden Sie unter [WikipediaMCC2021].

Hier ist ein kleines Beispiel, das die Verwendung der Funktion matthews_corrcoef illustriert

>>> from sklearn.metrics import matthews_corrcoef
>>> y_true = [+1, +1, +1, -1]
>>> y_pred = [+1, -1, +1, +1]
>>> matthews_corrcoef(y_true, y_pred)
-0.33

Referenzen

[WikipediaMCC2021]

Wikipedia-Autoren. Phi coefficient. Wikipedia, The Free Encyclopedia. 21. April 2021, 12:21 CEST. Verfügbar unter: https://en.wikipedia.org/wiki/Phi_coefficient Zugegriffen am 21. April 2021.

3.4.4.14. Multilabel-Konfusionsmatrix#

Die Funktion multilabel_confusion_matrix berechnet eine klassenweise (Standard) oder stichprobenweise (samplewise=True) Multilabel-Konfusionsmatrix zur Bewertung der Genauigkeit einer Klassifizierung. multilabel_confusion_matrix behandelt auch Multiklassendaten so, als wären sie Multilabel, da dies eine übliche Transformation zur Bewertung von Multiklassenproblemen mit binären Klassifizierungsmetriken (wie Präzision, Recall usw.) ist.

Bei der Berechnung einer klassenweisen Multilabel-Konfusionsmatrix \(C\) ist die Anzahl der wahren Negativen für Klasse \(i\) \(C_{i,0,0}\), die falschen Negativen \(C_{i,1,0}\), die wahren Positiven \(C_{i,1,1}\) und die falschen Positiven \(C_{i,0,1}\).

Hier ist ein Beispiel, das die Verwendung der Funktion multilabel_confusion_matrix mit einer Multilabel-Indikatormatrix als Eingabe demonstriert

>>> import numpy as np
>>> from sklearn.metrics import multilabel_confusion_matrix
>>> y_true = np.array([[1, 0, 1],
...                    [0, 1, 0]])
>>> y_pred = np.array([[1, 0, 0],
...                    [0, 1, 1]])
>>> multilabel_confusion_matrix(y_true, y_pred)
array([[[1, 0],
        [0, 1]],

       [[1, 0],
        [0, 1]],

       [[0, 1],
        [1, 0]]])

Oder eine Konfusionsmatrix kann für die Labels jeder Stichprobe erstellt werden

>>> multilabel_confusion_matrix(y_true, y_pred, samplewise=True)
array([[[1, 0],
        [1, 1]],

       [[1, 1],
        [0, 1]]])

Hier ist ein Beispiel, das die Verwendung der Funktion multilabel_confusion_matrix mit einer Multiklassen-Eingabe demonstriert

>>> y_true = ["cat", "ant", "cat", "cat", "ant", "bird"]
>>> y_pred = ["ant", "ant", "cat", "cat", "ant", "cat"]
>>> multilabel_confusion_matrix(y_true, y_pred,
...                             labels=["ant", "bird", "cat"])
array([[[3, 1],
        [0, 2]],

       [[5, 0],
        [1, 0]],

       [[2, 1],
        [1, 2]]])

Hier sind einige Beispiele, die die Verwendung der Funktion multilabel_confusion_matrix zur Berechnung von Recall (oder Sensitivität), Spezifität, Fallout und Miss Rate für jede Klasse in einem Problem mit Multilabel-Indikatormatrix-Eingabe demonstrieren.

Berechnung des Recall (auch als True-Positive-Rate oder Sensitivität bezeichnet) für jede Klasse

>>> y_true = np.array([[0, 0, 1],
...                    [0, 1, 0],
...                    [1, 1, 0]])
>>> y_pred = np.array([[0, 1, 0],
...                    [0, 0, 1],
...                    [1, 1, 0]])
>>> mcm = multilabel_confusion_matrix(y_true, y_pred)
>>> tn = mcm[:, 0, 0]
>>> tp = mcm[:, 1, 1]
>>> fn = mcm[:, 1, 0]
>>> fp = mcm[:, 0, 1]
>>> tp / (tp + fn)
array([1. , 0.5, 0. ])

Berechnung der Spezifität (auch als True-Negative-Rate bezeichnet) für jede Klasse

>>> tn / (tn + fp)
array([1. , 0. , 0.5])

Berechnung des Fallout (auch als False-Positive-Rate bezeichnet) für jede Klasse

>>> fp / (fp + tn)
array([0. , 1. , 0.5])

Berechnung der Miss Rate (auch als False-Negative-Rate bezeichnet) für jede Klasse

>>> fn / (fn + tp)
array([0. , 0.5, 1. ])

3.4.4.15. Receiver Operating Characteristic (ROC)#

Die Funktion roc_curve berechnet die Receiver Operating Characteristic (ROC) Kurve. Zitiert aus Wikipedia

„Eine Receiver Operating Characteristic (ROC) oder einfach ROC-Kurve ist eine grafische Darstellung, die die Leistung eines binären Klassifikationssystems bei variierendem Diskriminierungsschwellenwert veranschaulicht. Sie wird erstellt, indem der Anteil der wahren Positiven an den Positiven (TPR = True Positive Rate) gegen den Anteil der falschen Positiven an den Negativen (FPR = False Positive Rate) bei verschiedenen Schwellenwerteinstellungen geplottet wird. TPR ist auch als Sensitivität bekannt, und FPR ist eins minus der Spezifität oder True Negative Rate.“

Diese Funktion benötigt die wahren binären Werte und die Zielwerte, die entweder Wahrscheinlichkeitsschätzungen der positiven Klasse, Konfidenzwerte oder binäre Entscheidungen sein können. Hier ist ein kleines Beispiel, wie die Funktion roc_curve verwendet wird

>>> import numpy as np
>>> from sklearn.metrics import roc_curve
>>> y = np.array([1, 1, 2, 2])
>>> scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> fpr, tpr, thresholds = roc_curve(y, scores, pos_label=2)
>>> fpr
array([0. , 0. , 0.5, 0.5, 1. ])
>>> tpr
array([0. , 0.5, 0.5, 1. , 1. ])
>>> thresholds
array([ inf, 0.8 , 0.4 , 0.35, 0.1 ])

Im Vergleich zu Metriken wie der Subset Accuracy, dem Hamming Loss oder dem F1-Score erfordert ROC keine Optimierung eines Schwellenwerts für jedes Label.

Die Funktion roc_auc_score, bezeichnet als ROC-AUC oder AUROC, berechnet die Fläche unter der ROC-Kurve. Dadurch werden die Informationen der Kurve in einer einzigen Zahl zusammengefasst.

Die folgende Abbildung zeigt die ROC-Kurve und den ROC-AUC-Score für einen Klassifizierer, der dazu dient, die Virginica-Blume vom Rest der Arten im Iris-Pflanzen-Datensatz zu unterscheiden

Weitere Informationen finden Sie im Wikipedia-Artikel zu AUC.

3.4.4.15.1. Binärer Fall#

Im binären Fall können Sie entweder die Wahrscheinlichkeitsschätzungen über die Methode classifier.predict_proba() oder die nicht-thresholdierten Entscheidungswerte aus der Methode classifier.decision_function() bereitstellen. Im Falle der Bereitstellung von Wahrscheinlichkeitsschätzungen sollte die Wahrscheinlichkeit für die Klasse mit dem „größeren Label“ angegeben werden. Das „größere Label“ entspricht classifier.classes_[1] und somit classifier.predict_proba(X)[:, 1]. Daher ist der Parameter y_score von der Größe (n_samples,).

>>> from sklearn.datasets import load_breast_cancer
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.metrics import roc_auc_score
>>> X, y = load_breast_cancer(return_X_y=True)
>>> clf = LogisticRegression().fit(X, y)
>>> clf.classes_
array([0, 1])

Wir können die Wahrscheinlichkeitsschätzungen verwenden, die zu clf.classes_[1] gehören.

>>> y_score = clf.predict_proba(X)[:, 1]
>>> roc_auc_score(y, y_score)
0.99

Alternativ können wir die nicht-thresholdierten Entscheidungswerte verwenden

>>> roc_auc_score(y, clf.decision_function(X))
0.99

3.4.4.15.2. Multiklassenfall#

Die Funktion roc_auc_score kann auch bei der Multiklassenklassifizierung verwendet werden. Zwei Mittelungsstrategien werden derzeit unterstützt: der Eins-gegen-Eins-Algorithmus berechnet das Mittel der paarweisen ROC-AUC-Scores, und der Eins-gegen-Rest-Algorithmus berechnet das Mittel der ROC-AUC-Scores für jede Klasse gegen alle anderen Klassen. In beiden Fällen werden die vorhergesagten Labels in einem Array mit Werten von 0 bis n_classes bereitgestellt, und die Scores entsprechen den Wahrscheinlichkeitsschätzungen, dass eine Stichprobe zu einer bestimmten Klasse gehört. Die OvO- und OvR-Algorithmen unterstützen die gleichmäßige Gewichtung (average='macro') und die Gewichtung nach Prävalenz (average='weighted').

3.4.4.15.3. Multilabel-Fall#

In der Multilabel-Klassifizierung wird die Funktion roc_auc_score durch Mittelung über die Labels wie oben erweitert. In diesem Fall sollten Sie ein y_score der Form (n_samples, n_classes) bereitstellen. Bei Verwendung von Wahrscheinlichkeitsschätzungen muss daher für jede Ausgabe die Wahrscheinlichkeit der Klasse mit dem größeren Label ausgewählt werden.

>>> from sklearn.datasets import make_multilabel_classification
>>> from sklearn.multioutput import MultiOutputClassifier
>>> X, y = make_multilabel_classification(random_state=0)
>>> inner_clf = LogisticRegression(random_state=0)
>>> clf = MultiOutputClassifier(inner_clf).fit(X, y)
>>> y_score = np.transpose([y_pred[:, 1] for y_pred in clf.predict_proba(X)])
>>> roc_auc_score(y, y_score, average=None)
array([0.828, 0.851, 0.94, 0.87, 0.95])

Und die Entscheidungswerte erfordern keine solche Verarbeitung.

>>> from sklearn.linear_model import RidgeClassifierCV
>>> clf = RidgeClassifierCV().fit(X, y)
>>> y_score = clf.decision_function(X)
>>> roc_auc_score(y, y_score, average=None)
array([0.82, 0.85, 0.93, 0.87, 0.94])

Beispiele

Siehe Multiklassen-Receiver Operating Characteristic (ROC) für ein Beispiel zur Verwendung von ROC zur Bewertung der Qualität der Ausgabe eines Klassifizierers.
Siehe Receiver Operating Characteristic (ROC) mit Kreuzvalidierung für ein Beispiel zur Verwendung von ROC zur Bewertung der Qualität der Klassifikatorausgabe mit Kreuzvalidierung.
Siehe Artenverbreitungsmodellierung für ein Beispiel zur Verwendung von ROC zur Modellierung der Artenverbreitung.

Referenzen

[HT2001] (1,2)

Hand, D.J. and Till, R.J., (2001). A simple generalisation of the area under the ROC curve for multiple class classification problems. Machine learning, 45(2), pp. 171-186.

[FC2009]

Ferri, Cèsar & Hernandez-Orallo, Jose & Modroiu, R. (2009). An Experimental Comparison of Performance Measures for Classification. Pattern Recognition Letters. 30. 27-38.

[PD2000]

Provost, F., Domingos, P. (2000). Well-trained PETs: Improving probability estimation trees (Section 6.2), CeDER Working Paper #IS-00-04, Stern School of Business, New York University.

[F2006]

Fawcett, T., 2006. An introduction to ROC analysis. Pattern Recognition Letters, 27(8), pp. 861-874.

[F2001]

Fawcett, T., 2001. Using rule sets to maximize ROC performance In Data Mining, 2001. Proceedings IEEE International Conference, pp. 131-138.

3.4.4.16. Detection Error Tradeoff (DET)#

Die Funktion det_curve berechnet die Detection Error Tradeoff (DET) Kurve [WikipediaDET2017]. Zitiert aus Wikipedia

„Ein Detection Error Tradeoff (DET) Graph ist eine grafische Darstellung von Fehlerraten für binäre Klassifikationssysteme, die die False Reject Rate gegen die False Accept Rate aufträgt. Die x- und y-Achsen sind nichtlinear nach ihren Standardnormalabweichungen (oder einfach durch logarithmische Transformation) skaliert, was zu Tradeoff-Kurven führt, die linearer sind als ROC-Kurven und den größten Teil der Bildfläche nutzen, um die Unterschiede von Bedeutung im kritischen Betriebsbereich hervorzuheben.“

DET-Kurven sind eine Variante von Receiver Operating Characteristic (ROC)-Kurven, bei denen die False Negative Rate auf der y-Achse anstelle der True Positive Rate aufgetragen wird. DET-Kurven werden üblicherweise im Normalverteilungsmaßstab geplottet, indem sie mit \(\phi^{-1}\) (wobei \(\phi\) die kumulative Verteilungsfunktion ist) transformiert werden. Die resultierenden Leistungskurven visualisieren explizit den Tradeoff der Fehlertypen für gegebene Klassifikationsalgorithmen. Siehe [Martin1997] für Beispiele und weitere Motivation.

Diese Abbildung vergleicht die ROC- und DET-Kurven zweier Beispielklassifizierer für dieselbe Klassifikationsaufgabe

Beispiele

Siehe Detection Error Tradeoff (DET) Curve für einen Beispielvergleich zwischen Receiver Operating Characteristic (ROC)-Kurven und Detection Error Tradeoff (DET)-Kurven.

Referenzen

[WikipediaDET2017]

Wikipedia-Autoren. Detection error tradeoff. Wikipedia, The Free Encyclopedia. 4. September 2017, 23:33 UTC. Verfügbar unter: https://en.wikipedia.org/w/index.php?title=Detection_error_tradeoff&oldid=798982054. Zugegriffen am 19. Februar 2018.

[Martin1997]

A. Martin, G. Doddington, T. Kamm, M. Ordowski, and M. Przybocki, The DET Curve in Assessment of Detection Task Performance, NIST 1997.

[Navratil2007]

J. Navratil and D. Klusacek, „On Linear DETs“, 2007 IEEE International Conference on Acoustics, Speech and Signal Processing - ICASSP ‘07, Honolulu, HI, 2007, pp. IV-229-IV-232.

3.4.4.17. Zero-One-Loss#

Die Funktion zero_one_loss berechnet die Summe oder den Durchschnitt des 0-1-Klassifikationsfehlers (\(L_{0-1}\)) über \(n_{\text{samples}}\). Standardmäßig wird die Funktion über die Stichprobe normalisiert. Um die Summe der \(L_{0-1}\) zu erhalten, setzen Sie normalize auf False.

Bei der Multilabel-Klassifikation bewertet die Funktion zero_one_loss eine Teilmenge als eins, wenn ihre Labels exakt mit den Vorhersagen übereinstimmen, und als null, wenn es Fehler gibt. Standardmäßig gibt die Funktion den Prozentsatz der fehlerhaft vorhergesagten Teilmengen zurück. Um stattdessen die Anzahl solcher Teilmengen zu erhalten, setzen Sie normalize auf False.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der 0-1-Fehler \(L_{0-1}\) definiert als

\[L_{0-1}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples}-1} 1(\hat{y}_i \not= y_i)\]

wobei \(1(x)\) die Indikatorfunktion ist. Der Null-Eins-Fehler kann auch als \(\text{Null-Eins-Fehler} = 1 - \text{Genauigkeit}\) berechnet werden.

>>> from sklearn.metrics import zero_one_loss
>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> zero_one_loss(y_true, y_pred)
0.25
>>> zero_one_loss(y_true, y_pred, normalize=False)
1.0

Im Multilabel-Fall mit binären Label-Indikatoren, wobei die erste Label-Menge [0,1] einen Fehler aufweist

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)),  normalize=False)
1.0

Beispiele

Siehe Rekursives Merkmalseliminationsverfahren mit Kreuzvalidierung für ein Beispiel zur Verwendung des Null-Eins-Fehlers zur Durchführung einer rekursiven Merkmalselimination mit Kreuzvalidierung.

3.4.4.18. Brier-Score-Fehler#

Die Funktion brier_score_loss berechnet den Brier-Score für binäre und multiklassige Wahrscheinlichkeitsvorhersagen und ist äquivalent zum mittleren quadratischen Fehler. Zitat von Wikipedia

„Der Brier-Score ist eine strikt richtige Scoring-Regel, die die Genauigkeit von Wahrscheinlichkeitsvorhersagen misst. […] [Er] ist anwendbar auf Aufgaben, bei denen Vorhersagen Wahrscheinlichkeiten für eine Menge von sich gegenseitig ausschließenden diskreten Ergebnissen oder Klassen zuweisen müssen.“

Seien die wahren Labels für eine Menge von \(N\) Datenpunkten als binäre Indikatormatrix 1-aus-K \(Y\) kodiert, d. h. \(y_{i,k} = 1\), wenn die Stichprobe \(i\) das Label \(k\) aus einer Menge von \(K\) Labels hat. Sei \(\hat{P}\) eine Matrix von Wahrscheinlichkeitsschätzungen mit den Elementen \(\hat{p}_{i,k} \approx \operatorname{Pr}(y_{i,k} = 1)\). Gemäß der ursprünglichen Definition von [Brier1950] ist der Brier-Score gegeben durch

\[BS(Y, \hat{P}) = \frac{1}{N}\sum_{i=0}^{N-1}\sum_{k=0}^{K-1}(y_{i,k} - \hat{p}_{i,k})^{2}\]

Der Brier-Score liegt im Intervall \([0, 2]\), und je niedriger der Wert, desto besser sind die Wahrscheinlichkeitsschätzungen (die mittlere quadratische Abweichung ist kleiner). Tatsächlich ist der Brier-Score eine strikt richtige Scoring-Regel, was bedeutet, dass er die beste Punktzahl nur dann erreicht, wenn die geschätzten Wahrscheinlichkeiten den wahren entsprechen.

Beachten Sie, dass im binären Fall der Brier-Score normalerweise durch zwei geteilt wird und zwischen \([0,1]\) liegt. Für binäre Zielwerte \(y_i \in \{0, 1\}\) und Wahrscheinlichkeitsschätzungen \(\hat{p}_i \approx \operatorname{Pr}(y_i = 1)\) für die positive Klasse ist der Brier-Score dann gleich

\[BS(y, \hat{p}) = \frac{1}{N} \sum_{i=0}^{N - 1}(y_i - \hat{p}_i)^2\]

Die Funktion brier_score_loss berechnet den Brier-Score anhand der Ground-Truth-Labels und der vorhergesagten Wahrscheinlichkeiten, wie sie von der predict_proba Methode eines Estimators zurückgegeben werden. Der Parameter scale_by_half steuert, welche der beiden obigen Definitionen befolgt wird.

>>> import numpy as np
>>> from sklearn.metrics import brier_score_loss
>>> y_true = np.array([0, 1, 1, 0])
>>> y_true_categorical = np.array(["spam", "ham", "ham", "spam"])
>>> y_prob = np.array([0.1, 0.9, 0.8, 0.4])
>>> brier_score_loss(y_true, y_prob)
0.055
>>> brier_score_loss(y_true, 1 - y_prob, pos_label=0)
0.055
>>> brier_score_loss(y_true_categorical, y_prob, pos_label="ham")
0.055
>>> brier_score_loss(
...    ["eggs", "ham", "spam"],
...    [[0.8, 0.1, 0.1], [0.2, 0.7, 0.1], [0.2, 0.2, 0.6]],
...    labels=["eggs", "ham", "spam"],
... )
0.146

Der Brier-Score kann verwendet werden, um zu beurteilen, wie gut ein Klassifikator kalibriert ist. Ein niedrigerer Brier-Score-Fehler bedeutet jedoch nicht immer eine bessere Kalibrierung. Dies liegt daran, dass der Brier-Score-Fehler analog zur Bias-Varianz-Zerlegung des mittleren quadratischen Fehlers als Summe aus Kalibrierungsfehler und Verfeinerungsfehler zerlegt werden kann [Bella2012]. Der Kalibrierungsfehler ist definiert als die mittlere quadratische Abweichung von empirischen Wahrscheinlichkeiten, die aus der Steigung von ROC-Segmenten abgeleitet werden. Der Verfeinerungsfehler kann als der erwartete optimale Fehler definiert werden, gemessen an der Fläche unter der optimalen Kostenkurve. Der Verfeinerungsfehler kann unabhängig vom Kalibrierungsfehler variieren, sodass ein niedrigerer Brier-Score-Fehler nicht unbedingt ein besser kalibriertes Modell bedeutet. „Nur wenn der Verfeinerungsfehler gleich bleibt, bedeutet ein niedrigerer Brier-Score-Fehler immer eine bessere Kalibrierung“ [Bella2012], [Flach2008].

Beispiele

Siehe Wahrscheinlichkeitskalibrierung von Klassifikatoren für ein Beispiel zur Verwendung des Brier-Score-Fehlers zur Wahrscheinlichkeitskalibrierung von Klassifikatoren.

Referenzen

[Brier1950]

G. Brier, Verification of forecasts expressed in terms of probability, Monthly weather review 78.1 (1950)

[Bella2012] (1,2)

Bella, Ferri, Hernández-Orallo, und Ramírez-Quintana „Calibration of Machine Learning Models“ in Khosrow-Pour, M. „Machine learning: concepts, methodologies, tools and applications.“ Hershey, PA: Information Science Reference (2012).

[Flach2008]

Flach, Peter, und Edson Matsubara. „On classification, ranking, and probability estimation.“ Dagstuhl Seminar Proceedings. Schloss Dagstuhl-Leibniz-Zentrum für Informatik (2008).

3.4.4.19. Klassen-Likelihood-Verhältnisse#

Die Funktion class_likelihood_ratios berechnet das positive und negative Likelihood-Verhältnis \(LR_\pm\) für binäre Klassen, was als Verhältnis von Post-Test- zu Pre-Test-Odds interpretiert werden kann, wie unten erläutert. Infolgedessen ist diese Metrik invariant gegenüber der Klassenhäufigkeit (der Anzahl der Stichproben in der positiven Klasse geteilt durch die Gesamtzahl der Stichproben) und **kann zwischen Populationen unabhängig von jeglichem möglichen Klassenungleichgewicht extrapoliert werden.**

Die \(LR_\pm\)-Metriken sind daher in Szenarien sehr nützlich, in denen die verfügbaren Daten zum Erlernen und Bewerten eines Klassifikators eine Studienpopulation mit nahezu ausgeglichenen Klassen sind, wie z. B. eine Fall-Kontroll-Studie, während die Zielanwendung, d. h. die Allgemeinbevölkerung, eine sehr geringe Prävalenz aufweist.

Das positive Likelihood-Verhältnis \(LR_+\) ist die Wahrscheinlichkeit, dass ein Klassifikator korrekt vorhersagt, dass eine Stichprobe zur positiven Klasse gehört, geteilt durch die Wahrscheinlichkeit, die positive Klasse für eine Stichprobe vorherzusagen, die zur negativen Klasse gehört.

\[LR_+ = \frac{\text{PR}(P+|T+)}{\text{PR}(P+|T-)}.\]

Die Notation hier bezieht sich auf die vorhergesagte (\(P\)) oder wahre (\(T\)) Label und die Zeichen \(+\) und \(-\) beziehen sich auf die positive bzw. negative Klasse, z. B. \(P+\) steht für „positiv vorhergesagt“.

Analog dazu ist das negative Likelihood-Verhältnis \(LR_-\) die Wahrscheinlichkeit, dass eine Stichprobe der positiven Klasse als zur negativen Klasse gehörig klassifiziert wird, geteilt durch die Wahrscheinlichkeit, dass eine Stichprobe der negativen Klasse korrekt klassifiziert wird.

\[LR_- = \frac{\text{PR}(P-|T+)}{\text{PR}(P-|T-)}.\]

Für Klassifikatoren oberhalb des Zufallsniveaus ist \(LR_+\) größer als 1 und **höher ist besser**, während \(LR_-\) von 0 bis 1 reicht und **niedriger ist besser**. Werte von \(LR_\pm\approx 1\) entsprechen dem Zufallsniveau.

Beachten Sie, dass Wahrscheinlichkeiten von Zählungen abweichen, zum Beispiel ist \(\operatorname{PR}(P+|T+)\) nicht gleich der Anzahl der True-Positive-Zählungen tp (siehe die Wikipedia-Seite für die tatsächlichen Formeln).

Beispiele

Klassen-Likelihood-Verhältnisse zur Messung der Klassifikationsleistung

3.4.4.20. D²-Score für Klassifikation#

Der D²-Score berechnet den Bruchteil der erklärten Varianz. Es ist eine Verallgemeinerung von R², bei der der quadratische Fehler verallgemeinert und durch eine Klassifikations-Devianz nach Wahl (\(\text{dev}(y, \hat{y})\), z. B. Log-Loss, Brier-Score) ersetzt wird. D² ist eine Form eines Skill-Scores. Er wird berechnet als

\[D^2(y, \hat{y}) = 1 - \frac{\text{dev}(y, \hat{y})}{\text{dev}(y, y_{\text{null}})} \,.\]

Wobei \(y_{\text{null}}\) die optimale Vorhersage eines Modells nur mit Achsenabschnitt ist (z. B. der Anteil pro Klasse von y_true im Falle von Log-Loss und Brier-Score).

Wie bei R² ist der bestmögliche Score 1,0 und er kann negativ sein (da das Modell beliebig schlechter sein kann). Ein konstantes Modell, das immer \(y_{\text{null}}\) vorhersagt und die Eingabemerkmale ignoriert, würde einen D²-Score von 0,0 erhalten.

3.4.5. Multilabel-Ranking-Metriken#

Im Multilabel-Lernen kann jede Stichprobe eine beliebige Anzahl von Ground-Truth-Labels haben. Das Ziel ist es, den Ground-Truth-Labels hohe Bewertungen und eine bessere Rangfolge zu geben.

3.4.5.1. Coverage-Fehler#

Die Funktion coverage_error berechnet die durchschnittliche Anzahl von Labels, die in die endgültige Vorhersage aufgenommen werden müssen, damit alle wahren Labels vorhergesagt werden. Dies ist nützlich, wenn Sie wissen möchten, wie viele Top-bewertete Labels Sie im Durchschnitt vorhersagen müssen, ohne ein wahres Label zu verpassen. Der beste Wert dieser Metrik ist daher die durchschnittliche Anzahl wahrer Labels.

Hinweis

Die Implementierung unseres Scores liegt 1 über dem von Tsoumakas et al., 2010 angegebenen Wert. Dies erweitert ihn, um den degenerierten Fall zu behandeln, in dem eine Instanz 0 wahre Labels hat.

Formal sei eine binäre Indikatormatrix der Ground-Truth-Labels \(y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}\) und die Punktzahl, die jedem Label zugeordnet ist, \(\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}\), dann ist die Coverage definiert als

\[coverage(y, \hat{f}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}} - 1} \max_{j:y_{ij} = 1} \text{rank}_{ij}\]

wobei \(\text{rank}_{ij} = \left|\left\{k: \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\right|\). Angesichts der Rangdefinition werden Bindungen in y_scores gebrochen, indem der maximale Rang vergeben wird, der allen gebundenen Werten zugewiesen worden wäre.

Hier ist ein kleines Beispiel für die Verwendung dieser Funktion

>>> import numpy as np
>>> from sklearn.metrics import coverage_error
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> coverage_error(y_true, y_score)
2.5

3.4.5.2. Durchschnittliche Präzision des Label-Rankings#

Die Funktion label_ranking_average_precision_score implementiert die durchschnittliche Präzision des Label-Rankings (LRAP). Diese Metrik ist mit der Funktion average_precision_score verknüpft, basiert aber auf dem Konzept des Label-Rankings anstelle von Präzision und Recall.

Das durchschnittliche Präzisionsmaß für das Label-Ranking (LRAP) bildet den Durchschnitt der Antworten auf die folgende Frage für jede Stichprobe: Welcher Bruchteil der höher eingestuften Labels waren wahre Labels, für jedes Ground-Truth-Label? Dieses Leistungsmaß ist höher, wenn Sie den Labels, die mit jeder Stichprobe verbunden sind, eine bessere Rangfolge geben können. Der erhaltene Score ist immer strikt größer als 0, und der beste Wert ist 1. Wenn es genau ein relevantes Label pro Stichprobe gibt, ist die durchschnittliche Präzision des Label-Rankings gleich dem mittleren reziproken Rang.

Formal sei eine binäre Indikatormatrix der Ground-Truth-Labels \(y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}\) und die Punktzahl, die jedem Label zugeordnet ist, \(\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}\), dann ist die durchschnittliche Präzision definiert als

\[LRAP(y, \hat{f}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}} - 1} \frac{1}{||y_i||_0} \sum_{j:y_{ij} = 1} \frac{|\mathcal{L}_{ij}|}{\text{rank}_{ij}}\]

wobei \(\mathcal{L}_{ij} = \left\{k: y_{ik} = 1, \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\), \(\text{rank}_{ij} = \left|\left\{k: \hat{f}_{ik} \geq \hat{f}_{ij} \right\}\right|\), \(|\cdot|\) die Kardinalität der Menge berechnet (d. h. die Anzahl der Elemente in der Menge) und \(||\cdot||_0\) die \(\ell_0\) „Norm“ ist (die die Anzahl der Nicht-Null-Elemente in einem Vektor berechnet).

Hier ist ein kleines Beispiel für die Verwendung dieser Funktion

>>> import numpy as np
>>> from sklearn.metrics import label_ranking_average_precision_score
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_average_precision_score(y_true, y_score)
0.416

3.4.5.3. Ranking-Fehler#

Die Funktion label_ranking_loss berechnet den Ranking-Fehler, der über die Stichproben die Anzahl der falsch geordneten Label-Paare mittelt, d. h. wahre Labels haben eine niedrigere Punktzahl als falsche Labels, gewichtet mit dem Kehrwert der Anzahl der geordneten Paare aus falschen und wahren Labels. Der niedrigste erreichbare Ranking-Fehler ist null.

Formal sei eine binäre Indikatormatrix der Ground-Truth-Labels \(y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}\) und die Punktzahl, die jedem Label zugeordnet ist, \(\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}\), dann ist der Ranking-Fehler definiert als

\[ranking\_loss(y, \hat{f}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}} - 1} \frac{1}{||y_i||_0(n_\text{labels} - ||y_i||_0)} \left|\left\{(k, l): \hat{f}_{ik} \leq \hat{f}_{il}, y_{ik} = 1, y_{il} = 0 \right\}\right|\]

wobei \(|\cdot|\) die Kardinalität der Menge berechnet (d. h. die Anzahl der Elemente in der Menge) und \(||\cdot||_0\) die \(\ell_0\) „Norm“ ist (die die Anzahl der Nicht-Null-Elemente in einem Vektor berechnet).

Hier ist ein kleines Beispiel für die Verwendung dieser Funktion

>>> import numpy as np
>>> from sklearn.metrics import label_ranking_loss
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_loss(y_true, y_score)
0.75
>>> # With the following prediction, we have perfect and minimal loss
>>> y_score = np.array([[1.0, 0.1, 0.2], [0.1, 0.2, 0.9]])
>>> label_ranking_loss(y_true, y_score)
0.0

3.4.5.4. Normalisierter Discounted Cumulative Gain#

Discounted Cumulative Gain (DCG) und Normalized Discounted Cumulative Gain (NDCG) sind Ranking-Metriken, die in dcg_score und ndcg_score implementiert sind; sie vergleichen eine vorhergesagte Reihenfolge mit Ground-Truth-Scores, wie z. B. der Relevanz von Antworten auf eine Abfrage.

Von der Wikipedia-Seite zu Discounted Cumulative Gain

„Discounted cumulative gain (DCG) ist ein Maß für die Ranking-Qualität. In der Information Retrieval wird es oft zur Messung der Effektivität von Suchmaschinenalgorithmen oder verwandten Anwendungen verwendet. Unter Verwendung einer abgestuften Relevanzskala von Dokumenten in einem Suchmaschinenergebnis-Set misst DCG den Nutzen oder Gewinn eines Dokuments basierend auf seiner Position in der Ergebnisliste. Der Gewinn wird von der Spitze der Ergebnisliste bis zum Ende akkumuliert, wobei der Gewinn jedes Ergebnisses bei niedrigeren Rängen abgezinst wird.“

DCG ordnet die wahren Ziele (z. B. Relevanz von Abfrageantworten) in der vorhergesagten Reihenfolge an, multipliziert sie dann mit einem logarithmischen Abfall und summiert das Ergebnis. Die Summe kann nach den ersten \(K\) Ergebnissen abgeschnitten werden, in diesem Fall nennen wir es DCG@K. NDCG oder NDCG@K ist DCG dividiert durch den DCG, der durch eine perfekte Vorhersage erzielt wird, sodass er immer zwischen 0 und 1 liegt. Normalerweise wird NDCG gegenüber DCG bevorzugt.

Im Vergleich zum Ranking-Fehler kann NDCG Relevanz-Scores berücksichtigen, anstatt eine Ground-Truth-Rangfolge. Wenn die Ground-Truth nur aus einer Reihenfolge besteht, sollte der Ranking-Fehler bevorzugt werden; wenn die Ground-Truth tatsächliche Nützlichkeits-Scores enthält (z. B. 0 für irrelevant, 1 für relevant, 2 für sehr relevant), kann NDCG verwendet werden.

Für eine Stichprobe, gegeben den Vektor der kontinuierlichen Ground-Truth-Werte für jedes Ziel \(y \in \mathbb{R}^{M}\), wobei \(M\) die Anzahl der Ausgaben ist, und die Vorhersage \(\hat{y}\), die die Ranking-Funktion \(f\) induziert, ist der DCG-Score

\[\sum_{r=1}^{\min(K, M)}\frac{y_{f(r)}}{\log(1 + r)}\]

und der NDCG-Score ist der DCG-Score geteilt durch den DCG-Score, der für \(y\) erzielt wurde.

3.4.6. Regressionsmetriken#

Das Modul sklearn.metrics implementiert mehrere Verlust-, Score- und Hilfsfunktionen zur Messung der Regressionsleistung. Einige davon wurden erweitert, um den Multioutput-Fall zu handhaben: mean_squared_error, mean_absolute_error, r2_score, explained_variance_score, mean_pinball_loss, d2_pinball_score und d2_absolute_error_score.

Diese Funktionen haben ein Schlüsselwortargument multioutput, das angibt, wie die Scores oder Verluste für jedes einzelne Ziel gemittelt werden sollen. Der Standardwert ist 'uniform_average', was einen gleichmäßig gewichteten Mittelwert über die Ausgaben angibt. Wenn ein ndarray der Form (n_outputs,) übergeben wird, werden dessen Einträge als Gewichte interpretiert und ein entsprechender gewichteter Durchschnitt zurückgegeben. Wenn multioutput 'raw_values' ist, werden alle unveränderten individuellen Scores oder Verluste in einem Array der Form (n_outputs,) zurückgegeben.

Die Funktionen r2_score und explained_variance_score akzeptieren den zusätzlichen Wert 'variance_weighted' für den Parameter multioutput. Diese Option führt zu einer Gewichtung jedes einzelnen Scores mit der Varianz der entsprechenden Zielvariablen. Diese Einstellung quantifiziert die global erfasste, unskalierte Varianz. Wenn die Zielvariablen unterschiedliche Skalen haben, legt dieser Score mehr Wert auf die Erklärung der Variablen mit höherer Varianz.

3.4.6.1. R²-Score, der Bestimmtheitskoeffizient#

Die Funktion r2_score berechnet den Bestimmtheitskoeffizienten, üblicherweise als \(R^2\) bezeichnet.

Er repräsentiert den Anteil der Varianz (von y), der durch die unabhängigen Variablen im Modell erklärt wurde. Er gibt einen Hinweis auf die Güte der Anpassung und somit ein Maß dafür, wie gut nicht gesehene Stichproben vom Modell wahrscheinlich vorhergesagt werden, durch den Anteil der erklärten Varianz.

Da die Varianz datensatzabhängig ist, ist \(R^2\) möglicherweise nicht sinnvoll über verschiedene Datensätze hinweg vergleichbar. Der bestmögliche Score ist 1,0 und er kann negativ sein (da das Modell beliebig schlechter sein kann). Ein konstantes Modell, das immer den erwarteten (durchschnittlichen) Wert von y vorhersagt, unabhängig von den Eingabemerkmalen, würde einen \(R^2\)-Score von 0,0 erzielen.

Hinweis: Wenn die Vorhersageresiduale den Mittelwert Null haben, sind der \(R^2\)-Score und der Score der erklärten Varianz identisch.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert für insgesamt \(n\) Stichproben ist, ist der geschätzte \(R^2\) definiert als

\[R^2(y, \hat{y}) = 1 - \frac{\sum_{i=1}^{n} (y_i - \hat{y}_i)^2}{\sum_{i=1}^{n} (y_i - \bar{y})^2}\]

wobei \(\bar{y} = \frac{1}{n} \sum_{i=1}^{n} y_i\) und \(\sum_{i=1}^{n} (y_i - \hat{y}_i)^2 = \sum_{i=1}^{n} \epsilon_i^2\).

Beachten Sie, dass r2_score das unbereinigte \(R^2\) berechnet, ohne Korrektur für Verzerrungen in der Stichprobenvarianz von y.

Im speziellen Fall, dass das wahre Ziel konstant ist, ist der \(R^2\)-Score nicht endlich: er ist entweder NaN (perfekte Vorhersagen) oder -Inf (unvollkommene Vorhersagen). Solche nicht-endlichen Scores können die korrekte Modelloptimierung wie Grid-Search-Kreuzvalidierung verhindern. Aus diesem Grund ist das Standardverhalten von r2_score, sie durch 1,0 (perfekte Vorhersagen) oder 0,0 (unvollkommene Vorhersagen) zu ersetzen. Wenn force_finite auf False gesetzt wird, fällt dieser Score auf die ursprüngliche \(R^2\)-Definition zurück.

Hier ist ein kleines Beispiel für die Verwendung der Funktion r2_score

>>> from sklearn.metrics import r2_score
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> r2_score(y_true, y_pred)
0.948
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='variance_weighted')
0.938
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='uniform_average')
0.936
>>> r2_score(y_true, y_pred, multioutput='raw_values')
array([0.965, 0.908])
>>> r2_score(y_true, y_pred, multioutput=[0.3, 0.7])
0.925
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2]
>>> r2_score(y_true, y_pred)
1.0
>>> r2_score(y_true, y_pred, force_finite=False)
nan
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2 + 1e-8]
>>> r2_score(y_true, y_pred)
0.0
>>> r2_score(y_true, y_pred, force_finite=False)
-inf

Beispiele

Siehe L1-basierte Modelle für Sparse Signale für ein Beispiel der R²-Score-Verwendung zur Auswertung von Lasso und Elastic Net auf sparse Signalen.

3.4.6.2. Mittlerer absoluter Fehler#

Die Funktion mean_absolute_error berechnet den mittleren absoluten Fehler, eine Risiko-Metrik, die dem erwarteten Wert des absoluten Fehlerverlusts oder der \(l1\)-Norm-Verlust entspricht.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der mittlere absolute Fehler (MAE), geschätzt über \(n_{\text{samples}}\), definiert als

\[\text{MAE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \left| y_i - \hat{y}_i \right|.\]

Hier ist ein kleines Beispiel für die Verwendung der Funktion mean_absolute_error

>>> from sklearn.metrics import mean_absolute_error
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> mean_absolute_error(y_true, y_pred)
0.5
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> mean_absolute_error(y_true, y_pred)
0.75
>>> mean_absolute_error(y_true, y_pred, multioutput='raw_values')
array([0.5, 1. ])
>>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7])
0.85

3.4.6.3. Mittlerer quadratischer Fehler#

Die Funktion mean_squared_error berechnet den mittleren quadratischen Fehler, eine Risiko-Metrik, die dem erwarteten Wert des quadrierten (quadratischen) Fehlers oder Verlusts entspricht.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der mittlere quadratische Fehler (MSE), geschätzt über \(n_{\text{samples}}\), definiert als

\[\text{MSE}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples} - 1} (y_i - \hat{y}_i)^2.\]

Hier ist ein kleines Beispiel für die Verwendung der Funktion mean_squared_error

>>> from sklearn.metrics import mean_squared_error
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> mean_squared_error(y_true, y_pred)
0.375
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> mean_squared_error(y_true, y_pred)
0.7083

Beispiele

Siehe Gradient Boosting Regression für ein Beispiel der Verwendung des mittleren quadratischen Fehlers zur Auswertung der Gradient Boosting Regression.

Die Quadratwurzel des MSE, der mittlere quadratische Fehler (RMSE), ist eine weitere gängige Metrik, die ein Maß in den gleichen Einheiten wie die Zielvariable liefert. RMSE ist über die Funktion root_mean_squared_error verfügbar.

3.4.6.4. Mittlerer logarithmischer quadratischer Fehler#

Die Funktion mean_squared_log_error berechnet eine Risiko-Metrik, die dem erwarteten Wert des logarithmischen (quadratischen) Fehlers oder Verlusts entspricht.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der mittlere logarithmische quadratische Fehler (MSLE), geschätzt über \(n_{\text{samples}}\), definiert als

\[\text{MSLE}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples} - 1} (\log_e (1 + y_i) - \log_e (1 + \hat{y}_i) )^2.\]

Dabei bezeichnet \(\log_e (x)\) den natürlichen Logarithmus von \(x\). Diese Metrik eignet sich am besten, wenn die Ziele exponentielles Wachstum aufweisen, wie z. B. Bevölkerungszahlen, durchschnittliche Verkäufe einer Ware über mehrere Jahre usw. Beachten Sie, dass diese Metrik eine unterschätzte Vorhersage stärker bestraft als eine überschätzte Vorhersage.

Hier ist ein kleines Beispiel für die Verwendung der Funktion mean_squared_log_error

>>> from sklearn.metrics import mean_squared_log_error
>>> y_true = [3, 5, 2.5, 7]
>>> y_pred = [2.5, 5, 4, 8]
>>> mean_squared_log_error(y_true, y_pred)
0.0397
>>> y_true = [[0.5, 1], [1, 2], [7, 6]]
>>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]]
>>> mean_squared_log_error(y_true, y_pred)
0.044

Der mittlere logarithmische quadratische Fehler (RMSLE) ist über die Funktion root_mean_squared_log_error verfügbar.

3.4.6.5. Mittlerer absoluter prozentualer Fehler#

Der mean_absolute_percentage_error (MAPE), auch bekannt als mittlerer absoluter prozentualer Fehler (MAPD), ist eine Auswertungsmetrik für Regressionsprobleme. Die Idee dieser Metrik ist, empfindlich auf relative Fehler zu reagieren. Sie wird beispielsweise durch eine globale Skalierung der Zielvariablen nicht verändert.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der mittlere absolute prozentuale Fehler (MAPE), geschätzt über \(n_{\text{samples}}\), definiert als

\[\text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left| y_i - \hat{y}_i \right|}{\max(\epsilon, \left| y_i \right|)}\]

wobei \(\epsilon\) eine beliebig kleine, aber strikt positive Zahl ist, um undefinierte Ergebnisse zu vermeiden, wenn y Null ist.

Die Funktion mean_absolute_percentage_error unterstützt Multioutput.

Hier ist ein kleines Beispiel für die Verwendung der Funktion mean_absolute_percentage_error

>>> from sklearn.metrics import mean_absolute_percentage_error
>>> y_true = [1, 10, 1e6]
>>> y_pred = [0.9, 15, 1.2e6]
>>> mean_absolute_percentage_error(y_true, y_pred)
0.2666

Im obigen Beispiel hätte die Verwendung von mean_absolute_error die Werte mit geringer Magnitude ignoriert und nur den Fehler bei der Vorhersage des Werts mit der höchsten Magnitude widergespiegelt. Dieses Problem wird jedoch im Fall von MAPE gelöst, da es den relativen prozentualen Fehler in Bezug auf die tatsächliche Ausgabe berechnet.

Hinweis

Die MAPE-Formel hier repräsentiert nicht die übliche „prozentuale“ Definition: Die Prozentangabe im Bereich [0, 100] wird durch Division durch 100 in einen relativen Wert im Bereich [0, 1] umgewandelt. Somit entspricht ein Fehler von 200 % einem relativen Fehler von 2. Die Motivation hierfür ist, einen Wertebereich zu haben, der mit anderen Fehlermetriken in scikit-learn, wie z. B. accuracy_score, konsistenter ist.

Um den mittleren absoluten prozentualen Fehler gemäß der Wikipedia-Formel zu erhalten, multiplizieren Sie den hier berechneten mean_absolute_percentage_error mit 100.

3.4.6.6. Mittlerer absoluter Medianfehler#

Der median_absolute_error ist besonders interessant, da er robust gegenüber Ausreißern ist. Der Verlust wird berechnet, indem der Median aller absoluten Differenzen zwischen dem Ziel und der Vorhersage genommen wird.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der mittlere absolute Medianfehler (MedAE), geschätzt über \(n_{\text{samples}}\), definiert als

\[\text{MedAE}(y, \hat{y}) = \text{median}(\mid y_1 - \hat{y}_1 \mid, \ldots, \mid y_n - \hat{y}_n \mid).\]

Der median_absolute_error unterstützt kein Multioutput.

Hier ist ein kleines Beispiel für die Verwendung der Funktion median_absolute_error

>>> from sklearn.metrics import median_absolute_error
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> median_absolute_error(y_true, y_pred)
0.5

3.4.6.7. Maximaler Fehler#

Die Funktion max_error berechnet den maximalen Residualfehler, eine Metrik, die den schlimmsten Fallfehler zwischen dem vorhergesagten Wert und dem wahren Wert erfasst. Bei einem perfekt angepassten Einzelziel-Regressionsmodell wäre max_error auf dem Trainingsdatensatz 0. Obwohl dies in der realen Welt höchst unwahrscheinlich wäre, zeigt diese Metrik das Ausmaß des Fehlers, den das Modell bei seiner Anpassung aufwies.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der maximale Fehler definiert als

\[\text{Max Error}(y, \hat{y}) = \max(| y_i - \hat{y}_i |)\]

Hier ist ein kleines Beispiel für die Verwendung der Funktion max_error

>>> from sklearn.metrics import max_error
>>> y_true = [3, 2, 7, 1]
>>> y_pred = [9, 2, 7, 1]
>>> max_error(y_true, y_pred)
6.0

Der max_error unterstützt kein Multioutput.

3.4.6.8. Score der erklärten Varianz#

Die Funktion explained_variance_score berechnet den Score der erklärten Varianz für die Regression.

Wenn \(\hat{y}\) die geschätzte Zielausgabe ist, \(y\) die entsprechende (korrekte) Zielausgabe und \(Var\) die Varianz, das Quadrat der Standardabweichung, dann wird die erklärte Varianz wie folgt geschätzt

\[explained\_{}variance(y, \hat{y}) = 1 - \frac{Var\{ y - \hat{y}\}}{Var\{y\}}\]

Der bestmögliche Score ist 1,0, niedrigere Werte sind schlechter.

Im speziellen Fall, dass das wahre Ziel konstant ist, ist der Score der erklärten Varianz nicht endlich: er ist entweder NaN (perfekte Vorhersagen) oder -Inf (unvollkommene Vorhersagen). Solche nicht-endlichen Scores können die korrekte Modelloptimierung wie Grid-Search-Kreuzvalidierung verhindern. Aus diesem Grund ist das Standardverhalten von explained_variance_score, sie durch 1,0 (perfekte Vorhersagen) oder 0,0 (unvollkommene Vorhersagen) zu ersetzen. Sie können den Parameter force_finite auf False setzen, um diese Korrektur zu verhindern und auf den ursprünglichen Score der erklärten Varianz zurückzufallen.

Hier ist ein kleines Beispiel für die Verwendung der Funktion explained_variance_score

>>> from sklearn.metrics import explained_variance_score
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> explained_variance_score(y_true, y_pred)
0.957
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> explained_variance_score(y_true, y_pred, multioutput='raw_values')
array([0.967, 1.        ])
>>> explained_variance_score(y_true, y_pred, multioutput=[0.3, 0.7])
0.990
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2]
>>> explained_variance_score(y_true, y_pred)
1.0
>>> explained_variance_score(y_true, y_pred, force_finite=False)
nan
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2 + 1e-8]
>>> explained_variance_score(y_true, y_pred)
0.0
>>> explained_variance_score(y_true, y_pred, force_finite=False)
-inf

3.4.6.9. Mittlere Poisson-, Gamma- und Tweedie-Devianzen#

Die Funktion mean_tweedie_deviance berechnet den mittleren Tweedie-Devianzfehler mit einem Parameter power (\(p\)). Dies ist eine Metrik, die vorhergesagte Erwartungswerte von Regressionszielen ermittelt.

Folgende Sonderfälle existieren:

wenn power=0, ist sie äquivalent zu mean_squared_error.
wenn power=1, ist sie äquivalent zu mean_poisson_deviance.
wenn power=2, ist sie äquivalent zu mean_gamma_deviance.

Wenn \(\hat{y}_i\) der vorhergesagte Wert der \(i\)-ten Stichprobe und \(y_i\) der entsprechende wahre Wert ist, dann ist der mittlere Tweedie-Devianzfehler (D) für die Potenz \(p\), geschätzt über \(n_{\text{samples}}\), definiert als

\[\begin{split}\text{D}(y, \hat{y}) = \frac{1}{n_\text{samples}} \sum_{i=0}^{n_\text{samples} - 1} \begin{cases} (y_i-\hat{y}_i)^2, & \text{für }p=0\text{ (Normal)}\\ 2(y_i \log(y_i/\hat{y}_i) + \hat{y}_i - y_i), & \text{für }p=1\text{ (Poisson)}\\ 2(\log(\hat{y}_i/y_i) + y_i/\hat{y}_i - 1), & \text{für }p=2\text{ (Gamma)}\\ 2\left(\frac{\max(y_i,0)^{2-p}}{(1-p)(2-p)}- \frac{y_i\,\hat{y}_i^{1-p}}{1-p}+\frac{\hat{y}_i^{2-p}}{2-p}\right), & \text{sonst} \end{cases}\end{split}\]

Die Tweedie-Devianz ist eine homogene Funktion vom Grad 2-power. Daher bedeutet die Gamma-Verteilung mit power=2, dass gleichzeitiges Skalieren von y_true und y_pred keinen Einfluss auf die Devianz hat. Für die Poisson-Verteilung power=1 skaliert die Devianz linear, und für die Normalverteilung (power=0) quadratisch. Im Allgemeinen gibt eine höhere power weniger Gewicht auf extreme Abweichungen zwischen wahren und vorhergesagten Zielwerten.

Zum Beispiel vergleichen wir die beiden Vorhersagen 1,5 und 150, die beide 50 % größer sind als ihr jeweiliger wahrer Wert.

Der mittlere quadratische Fehler (power=0) ist sehr empfindlich gegenüber dem Vorhersageunterschied des zweiten Punktes,

>>> from sklearn.metrics import mean_tweedie_deviance
>>> mean_tweedie_deviance([1.0], [1.5], power=0)
0.25
>>> mean_tweedie_deviance([100.], [150.], power=0)
2500.0

Wenn wir power auf 1 erhöhen,

>>> mean_tweedie_deviance([1.0], [1.5], power=1)
0.189
>>> mean_tweedie_deviance([100.], [150.], power=1)
18.9

verringert sich die Differenz der Fehler. Schließlich erhalten wir durch Setzen von power=2

>>> mean_tweedie_deviance([1.0], [1.5], power=2)
0.144
>>> mean_tweedie_deviance([100.], [150.], power=2)
0.144

identische Fehler. Die Devianz ist bei power=2 somit nur empfindlich auf relative Fehler.

3.4.6.10. Pinball-Verlust#

Die Funktion mean_pinball_loss wird zur Auswertung der Vorhersageleistung von Quantilregressionsmodellen verwendet.

\[\text{pinball}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \alpha \max(y_i - \hat{y}_i, 0) + (1 - \alpha) \max(\hat{y}_i - y_i, 0)\]

Der Wert des Pinball-Verlusts entspricht der Hälfte des mean_absolute_error, wenn der Quantilparameter alpha auf 0,5 gesetzt ist.

Hier ist ein kleines Beispiel für die Verwendung der Funktion mean_pinball_loss

>>> from sklearn.metrics import mean_pinball_loss
>>> y_true = [1, 2, 3]
>>> mean_pinball_loss(y_true, [0, 2, 3], alpha=0.1)
0.033
>>> mean_pinball_loss(y_true, [1, 2, 4], alpha=0.1)
0.3
>>> mean_pinball_loss(y_true, [0, 2, 3], alpha=0.9)
0.3
>>> mean_pinball_loss(y_true, [1, 2, 4], alpha=0.9)
0.033
>>> mean_pinball_loss(y_true, y_true, alpha=0.1)
0.0
>>> mean_pinball_loss(y_true, y_true, alpha=0.9)
0.0

Es ist möglich, ein Scorer-Objekt mit einer spezifischen Wahl von alpha zu erstellen

>>> from sklearn.metrics import make_scorer
>>> mean_pinball_loss_95p = make_scorer(mean_pinball_loss, alpha=0.95)

Ein solches Scorer-Objekt kann verwendet werden, um die Generalisierungsleistung eines Quantilregressors mittels Kreuzvalidierung auszuwerten

>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import cross_val_score
>>> from sklearn.ensemble import GradientBoostingRegressor
>>>
>>> X, y = make_regression(n_samples=100, random_state=0)
>>> estimator = GradientBoostingRegressor(
...     loss="quantile",
...     alpha=0.95,
...     random_state=0,
... )
>>> cross_val_score(estimator, X, y, cv=5, scoring=mean_pinball_loss_95p)
array([13.6, 9.7, 23.3, 9.5, 10.4])

Es ist auch möglich, Scorer-Objekte für die Hyperparameter-Optimierung zu erstellen. Das Vorzeichen des Verlusts muss umgekehrt werden, um sicherzustellen, dass „größer besser“ bedeutet, wie im unten verlinkten Beispiel erläutert.

Beispiele

Siehe Vorhersageintervalle für Gradient Boosting Regression für ein Beispiel zur Verwendung des Pinball-Verlusts zur Auswertung und Optimierung der Hyperparameter von Quantilregressionsmodellen auf Daten mit nicht-symmetrischem Rauschen und Ausreißern.

3.4.6.11. D²-Score#

Der D²-Score berechnet den Anteil der erklärten Devianz. Er ist eine Generalisierung von R², wobei der quadrierte Fehler verallgemeinert und durch eine gewählte Devianz \(\text{dev}(y, \hat{y})\) (z. B. Tweedie, Pinball oder mittlerer absoluter Fehler) ersetzt wird. D² ist eine Form eines Leistungs-Scores. Er wird berechnet als

\[D^2(y, \hat{y}) = 1 - \frac{\text{dev}(y, \hat{y})}{\text{dev}(y, y_{\text{null}})} \,.\]

Wobei \(y_{\text{null}}\) die optimale Vorhersage eines Modells nur mit Achsenabschnitt ist (z. B. der Mittelwert von y_true für den Tweedie-Fall, der Median für den absoluten Fehler und das Alpha-Quantil für den Pinball-Verlust).

Wie bei R² ist der bestmögliche Score 1,0 und er kann negativ sein (da das Modell beliebig schlechter sein kann). Ein konstantes Modell, das immer \(y_{\text{null}}\) vorhersagt und die Eingabemerkmale ignoriert, würde einen D²-Score von 0,0 erhalten.

3.4.6.12. Visuelle Auswertung von Regressionsmodellen#

Unter den Methoden zur Beurteilung der Qualität von Regressionsmodellen bietet scikit-learn die Klasse PredictionErrorDisplay an. Sie ermöglicht die visuelle Inspektion der Vorhersagefehler eines Modells auf zwei verschiedene Arten.

../_images/sphx_glr_plot_cv_predict_001.png

Der Plot auf der linken Seite zeigt die tatsächlichen Werte im Vergleich zu den vorhergesagten Werten. Bei einer rauschfreien Regressionsaufgabe, deren Ziel die Vorhersage des (bedingten) Erwartungswerts von y ist, würden perfekte Regressionsmodelle Datenpunkte auf der Diagonalen anzeigen, die durch die Gleichheit von vorhergesagten und tatsächlichen Werten definiert ist. Je weiter von dieser optimalen Linie entfernt, desto größer ist der Fehler des Modells. In einem realistischeren Szenario mit nicht reduzierbarem Rauschen, d. h. wenn nicht alle Variationen von y durch Merkmale in X erklärt werden können, würde das beste Modell zu einer dichten Punktwolke um die Diagonale führen.

Beachten Sie, dass das Obige nur gilt, wenn der vorhergesagte Wert der Erwartungswert von y gegeben X ist. Dies ist typischerweise der Fall bei Regressionsmodellen, die die mittlere quadratische Fehlerminimierungsfunktion oder allgemeiner die mittlere Tweedie-Devianz für jeden Wert ihres „Potenz“-Parameters minimieren.

Beim Plotten der Vorhersagen eines Schätzers, der ein Quantil von y gegeben X vorhersagt, z. B. QuantileRegressor oder jedes andere Modell, das den Pinball-Verlust minimiert, wird erwartet, dass ein Bruchteil der Punkte entweder über oder unter der Diagonale liegt, abhängig vom geschätzten Quantilniveau.

Alles in allem ist dieser Plot zwar intuitiv zu lesen, informiert uns aber nicht wirklich darüber, was getan werden kann, um ein besseres Modell zu erhalten.

Der Plot auf der rechten Seite zeigt die Residuen (d. h. die Differenz zwischen den tatsächlichen und den vorhergesagten Werten) im Verhältnis zu den vorhergesagten Werten.

Dieser Plot erleichtert die Visualisierung, ob die Residuen eine homoskedastische oder heteroskedastische Verteilung aufweisen.

Insbesondere wenn die wahre Verteilung von y|X Poisson- oder Gamma-verteilt ist, wird erwartet, dass die Varianz der Residuen des optimalen Modells mit dem vorhergesagten Wert von E[y|X] wächst (entweder linear für Poisson oder quadratisch für Gamma).

Beim Anpassen eines linearen Kleinste-Quadrate-Regressionsmodells (siehe LinearRegression und Ridge) können wir diesen Plot verwenden, um zu überprüfen, ob einige der Modellannahmen erfüllt sind, insbesondere dass die Residuen unkorreliert sein sollten, ihr Erwartungswert Null sein sollte und ihre Varianz konstant sein sollte (Homoskedastizität).

Wenn dies nicht der Fall ist und die Residuen-Plot insbesondere eine bananenförmige Struktur aufweist, ist dies ein Hinweis darauf, dass das Modell wahrscheinlich falsch spezifiziert ist und dass nichtlineares Feature Engineering oder ein Wechsel zu einem nichtlinearen Regressionsmodell nützlich sein könnte.

Siehe das folgende Beispiel, um eine Modellbewertung zu sehen, die diese Darstellung nutzt.

Beispiele

Siehe Auswirkung der Transformation der Zielwerte im Regressionsmodell für ein Beispiel, wie PredictionErrorDisplay verwendet werden kann, um die Verbesserung der Vorhersagequalität eines Regressionsmodells zu visualisieren, die durch Transformation des Zielwerts vor dem Lernen erzielt wird.

3.4.7. Clustering-Metriken#

Das Modul sklearn.metrics implementiert mehrere Verlust-, Score- und Hilfsfunktionen zur Messung der Clustering-Leistung. Weitere Informationen finden Sie im Abschnitt Bewertung der Clustering-Leistung für Instanz-Clustering und im Abschnitt Bewertung von Biclustering für Biclustering.

3.4.8. Dummy-Schätzer#

Bei der überwachten Lernerstellung besteht ein einfacher Plausibilitätstest darin, einen Schätzer mit einfachen Faustregeln zu vergleichen. DummyClassifier implementiert mehrere solcher einfachen Strategien für die Klassifizierung.

stratified erzeugt zufällige Vorhersagen unter Berücksichtigung der Klassenverteilung des Trainingsdatensatzes.
most_frequent sagt immer das häufigste Label im Trainingsdatensatz voraus.
prior sagt immer die Klasse voraus, die die Klassenwahrscheinlichkeiten maximiert (ähnlich wie most_frequent), und predict_proba gibt die Klassenwahrscheinlichkeiten zurück.
uniform erzeugt Vorhersagen gleichmäßig zufällig.
constant sagt immer ein vom Benutzer bereitgestelltes konstantes Label voraus.
Eine Hauptmotivation dieser Methode ist die F1-Bewertung, wenn die positive Klasse in der Minderheit ist.

Beachten Sie, dass bei all diesen Strategien die Methode predict die Eingabedaten vollständig ignoriert!

Um DummyClassifier zu veranschaulichen, erstellen wir zunächst einen unausgeglichenen Datensatz.

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> y[y != 1] = -1
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

Als Nächstes vergleichen wir die Genauigkeit von SVC und most_frequent.

>>> from sklearn.dummy import DummyClassifier
>>> from sklearn.svm import SVC
>>> clf = SVC(kernel='linear', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.63
>>> clf = DummyClassifier(strategy='most_frequent', random_state=0)
>>> clf.fit(X_train, y_train)
DummyClassifier(random_state=0, strategy='most_frequent')
>>> clf.score(X_test, y_test)
0.579

Wir sehen, dass SVC nicht viel besser abschneidet als ein Dummy-Klassifikator. Ändern wir nun den Kernel.

>>> clf = SVC(kernel='rbf', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.94

Wir sehen, dass die Genauigkeit auf fast 100 % gesteigert wurde. Eine Kreuzvalidierungsstrategie wird für eine bessere Schätzung der Genauigkeit empfohlen, wenn diese nicht zu rechenintensiv ist. Weitere Informationen finden Sie im Abschnitt Kreuzvalidierung: Bewertung der Schätzerleistung. Wenn Sie außerdem über den Parameterraum optimieren möchten, wird dringend empfohlen, eine geeignete Methodik zu verwenden. Einzelheiten finden Sie im Abschnitt Optimierung der Hyperparameter eines Schätzers.

Allgemeiner gesagt, wenn die Genauigkeit eines Klassifikators zu nahe am Zufall liegt, bedeutet dies wahrscheinlich, dass etwas schiefgelaufen ist: die Merkmale sind nicht hilfreich, ein Hyperparameter ist nicht korrekt eingestellt, der Klassifikator leidet unter Klassenungleichgewicht usw.

DummyRegressor implementiert ebenfalls vier einfache Faustregeln für die Regression.

mean sagt immer den Durchschnitt der Trainingsziele voraus.
median sagt immer den Median der Trainingsziele voraus.
quantile sagt immer ein vom Benutzer bereitgestelltes Quantil der Trainingsziele voraus.
constant sagt immer einen vom Benutzer bereitgestellten konstanten Wert voraus.

Bei all diesen Strategien ignoriert die Methode predict die Eingabedaten vollständig.

3.4. Metriken und Scoring: Quantifizierung der Qualität von Vorhersagen#

3.4.1. Welche Scoring-Funktion sollte ich verwenden?#

3.4.2. Überblick über die Scoring-API#

3.4.3. Der scoring-Parameter: Regeln für die Modellevaluierung definieren#

3.4.3.1. Zeichenkettennamen-Scorer#

3.4.3.2. Aufrufbare Scorer#

3.4.3.2.1. Anpassen vordefinierter Metriken über make_scorer#

3.4.3.2.2. Erstellen eines benutzerdefinierten Scorer-Objekts#

3.4.3.3. Verwendung von Mehrfachmetrik-Evaluierung#

3.4.4. Klassifikationsmetriken#

3.4.4.1. Von binär zu Multiclass und Multilabel#

3.4.4.2. Genauigkeitspunktzahl#

3.4.4.3. Top-k Genauigkeitspunktzahl#

3.4.4.4. Ausbalancierte Genauigkeitspunktzahl#

3.4.4.5. Cohens Kappa#

3.4.4.6. Konfusionsmatrix#

3.4.4.7. Klassifizierungsbericht#

3.4.4.8. Hamming-Verlust#

3.4.4.9. Präzision, Recall und F-Maße#

3.4.4.9.1. Binäre Klassifizierung#

3.4.4.9.2. Multiclass- und Multilabel-Klassifizierung#

3.4.4.10. Jaccard-Ähnlichkeitskoeffizient-Score#

3.4.4.11. Hinge Loss#

3.4.4.12. Log Loss#

3.4.4.13. Matthews-Korrelationskoeffizient#

3.4.4.14. Multilabel-Konfusionsmatrix#

3.4.4.15. Receiver Operating Characteristic (ROC)#

3.4.4.15.1. Binärer Fall#

3.4.4.15.2. Multiklassenfall#

3.4.4.15.3. Multilabel-Fall#

3.4.4.16. Detection Error Tradeoff (DET)#

3.4.4.17. Zero-One-Loss#

3.4.4.18. Brier-Score-Fehler#

3.4.4.19. Klassen-Likelihood-Verhältnisse#

3.4.4.20. D²-Score für Klassifikation#

3.4.5. Multilabel-Ranking-Metriken#

3.4.5.1. Coverage-Fehler#

3.4.5.2. Durchschnittliche Präzision des Label-Rankings#

3.4.5.3. Ranking-Fehler#

3.4.5.4. Normalisierter Discounted Cumulative Gain#

3.4.6. Regressionsmetriken#

3.4.6.1. R²-Score, der Bestimmtheitskoeffizient#

3.4.6.2. Mittlerer absoluter Fehler#

3.4.6.3. Mittlerer quadratischer Fehler#

3.4.6.4. Mittlerer logarithmischer quadratischer Fehler#

3.4.6.5. Mittlerer absoluter prozentualer Fehler#

3.4.6.6. Mittlerer absoluter Medianfehler#

3.4.6.7. Maximaler Fehler#

3.4.6.8. Score der erklärten Varianz#

3.4.6.9. Mittlere Poisson-, Gamma- und Tweedie-Devianzen#

3.4.6.10. Pinball-Verlust#

3.4.6.11. D²-Score#

3.4.6.12. Visuelle Auswertung von Regressionsmodellen#

3.4.7. Clustering-Metriken#

3.4.8. Dummy-Schätzer#

Diese Seite

3.4.3. Der `scoring`-Parameter: Regeln für die Modellevaluierung definieren#

3.4.3.2.1. Anpassen vordefinierter Metriken über `make_scorer`#