Ich frage mich, wie man Genauigkeits- und Rückrufmaße für die Multiklassen-Multilabel-Klassifizierung berechnet, dh eine Klassifizierung, bei der es mehr als zwei Labels gibt und bei der jede Instanz mehrere Labels haben kann.

Ein weiteres beliebtes Tool zur Messung der Klassifikatorleistung ist ROC / AUC . Auch diese hat eine Multi-Class / Multi-Label-Erweiterung: siehe [Hand 2001]

[Hand 2001]: Eine einfache Verallgemeinerung des Bereichs unter der ROC-Kurve auf mehrere Klassifizierungsprobleme

Im Folgenden wird der Thread des coursera-Forums zur Verwirrungsmatrix und zur Präzisions- / Rückrufmessung in mehreren Klassen erörtert.

Die Grundidee besteht darin, die gesamte Genauigkeit und den Abruf aller Klassen zu berechnen und sie dann zu mitteln, um eine einzige reelle Zahlenmessung zu erhalten.

Die Verwirrungsmatrix erleichtert die Berechnung der Genauigkeit und den Abruf einer Klasse.

Im Folgenden finden Sie einige grundlegende Erklärungen zur Verwirrungsmatrix, die aus diesem Thread kopiert wurden:

Eine Verwirrungsmatrix ist eine Methode zum Klassifizieren von echten Positiven, echten Negativen, falschen Positiven und falschen Negativen, wenn es mehr als zwei Klassen gibt. Es wird zur Berechnung der Präzision und des Rückrufs und damit der f1-Punktzahl für Probleme mit mehreren Klassen verwendet.

Die tatsächlichen Werte werden durch Spalten dargestellt. Die vorhergesagten Werte werden durch Zeilen dargestellt.

Beispiele:

10 Trainingsbeispiele, die tatsächlich 8 sind, werden fälschlicherweise als 5 klassifiziert (vorhergesagt).
13 Trainingsbeispiele, die tatsächlich 4 sind, werden fälschlicherweise als 9 klassifiziert

Verwirrung Matrix

cm =
     0 1 2 3 4 5 6 7 8 9 10
     1 298 2 1 0 1 1 3 1 1 0
     2 0 293 7 4 1 0 5 2 0 0
     3 1 3 263 0 8 0 0 3 0 2
     4 1 5 0 261 4 0 3 2 0 1
     5 0 0 10 0 254 3 0 10 2 1
     6 0 4 1 1 4 300 0 1 0 0
     7 1 3 2 0 0 0 264 0 7 1
     8 3 5 3 1 7 1 0 289 1 0
     9 0 1 3 13 1 0 11 1 289 0
    10 0 6 0 1 6 1 2 1 4 304

Für Klasse X:

• Richtig positiv: Diagonale Position, cm (x, x).

• Falsch positiv: Summe von Spalte x (ohne Hauptdiagonale), Summe (cm (:, x)) - cm (x, x).

• Falsch negativ: Summe von Zeile x (ohne Hauptdiagonale), Summe (cm (x, :), 2) - cm (x, x).

Sie können die Genauigkeit, den Abruf und die F1-Punktzahl anhand der Kursformel berechnen.

Die Mittelung über alle Klassen (mit oder ohne Gewichtung) ergibt Werte für das gesamte Modell.

Bei der Klassifizierung mit mehreren Etiketten haben Sie zwei Möglichkeiten. Beachten Sie zunächst Folgendes.

• $n$
• $Y_i$$i^{th}$
• $x_i$$i^{th}$
• $h(x_i)$$i^{th}$

Beispiel basiert

Die Metriken werden pro Datenpunkt berechnet. Für jedes vorhergesagte Etikett wird nur seine Punktzahl berechnet, und diese Punktzahlen werden dann über alle Datenpunkte aggregiert.

• $\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|h(x_{i})|}$
• $\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|Y_{i}|}$

Es gibt auch andere Metriken.

Label basiert

Hier werden die Dinge etikettenweise erledigt. Für jedes Etikett werden die Metriken (z. B. Genauigkeit, Rückruf) berechnet und dann diese kennsatzweisen Metriken aggregiert. In diesem Fall berechnen Sie also die Genauigkeit / den Rückruf für jedes Etikett über den gesamten Datensatz, wie Sie es für eine binäre Klassifizierung tun (da jedes Etikett eine binäre Zuordnung hat), und aggregieren sie dann.

Der einfache Weg ist, die allgemeine Form zu präsentieren.

Dies ist nur eine Erweiterung des Standardäquivalents für mehrere Klassen.

• $\frac{1}{q}\sum_{j=1}^{q}B(TP_{j},FP_{j},TN_{j},FN_{j})$

• $B(\sum_{j=1}^{q}TP_{j},\sum_{j=1}^{q}FP_{j},\sum_{j=1}^{q}TN_{j},\sum_{j=1}^{q}FN_{j})$

$TP_{j},FP_{j},TN_{j},FN_{j}$$j^{th}$

$B$

Vielleicht möchten Sie hier einen Blick in den Code für die Multilabel-Metriken werfen , der Teil des Pakets mldr in R ist . Vielleicht interessieren Sie sich auch für die Java Multi-Label-Bibliothek MULAN .

Dies ist ein nützliches Dokument, um die verschiedenen Metriken kennenzulernen: Ein Überblick über Multi-Label-Lernalgorithmen

Ich weiß nichts über den Multilabel-Teil, aber für die Klassifizierung mehrerer Klassen helfen Ihnen diese Links

In diesem Link wird erläutert, wie Sie die Verwirrungsmatrix erstellen, mit der Sie die Genauigkeit und den Rückruf für jede Kategorie berechnen können

In diesem Link wird erläutert, wie Sie die Maße micro-f1 und macro-f1 berechnen, um den Klassifikator als Ganzes zu bewerten.

Ich hoffe, dass Sie das nützlich fanden.

Dieser Link hat mir geholfen. https://www.youtube.com/watch?v=HBi-P5j0Kec Ich hoffe, es wird Ihnen auch helfen

Sagen Sie die Verteilung wie folgt

    A   B   C   D
A   100 80  10  10
B   0    9   0   1
C   0    1   8   1
D   0    1   0   9

die Präzision für A wäre

P (A) = 100/100 + 0 + 0 + 0 = 100

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... nehme im wesentlichen das wahre Positiv der Klasse und teile es durch die Spaltendaten über die Zeilen auf

Rückruf für eine wäre

R (A) = 100 / 100+ 80 + 10 + 10 = 0,5

R (B) = 9 / 9+ 0 + 0 + 1 = 0,9

psst ... nehme im Wesentlichen das wahre Positiv der Klasse und teile es durch die Zeilendaten über Spalten auf

Sobald Sie alle Werte erhalten haben, nehmen Sie den Makro-Durchschnitt

Durchschnitt (P) = P (A) + P (B) + P (C) + P (D) / 4

Durchschnitt (R) = R (A) + R (B) + R (C) + R (D) / 4

F1 = 2 * Durchschnitt (P) * Durchschnitt (R) / Durchschnitt (P) + Durchschnitt (R)

Schauen Sie sich diese Folien von cs205.org in Harvard an . Sobald Sie den Abschnitt über Fehlermaßnahmen erreicht haben, werden Genauigkeit und Rückruf in Einstellungen für mehrere Klassen (z. B. Eins-gegen-Alles oder Eins-gegen-Eins) und Verwirrungsmatrizen erörtert. Verwirrungsmatrizen sind das, was Sie hier wirklich wollen.

Zu Ihrer Information , im Python-Softwarepaket scikits.learn gibt es integrierte Methoden, um automatisch Dinge wie die Verwirrungsmatrix aus Klassifikatoren zu berechnen, die auf Daten mehrerer Klassen trainiert wurden. Es kann wahrscheinlich auch direkt Präzisions-Rückruf-Diagramme für Sie berechnen. Einen Blick wert.

Aus Ozgur et al. (2005) geht hervor, dass Sie Precision and Recall anhand der normalen Ausdrücke berechnen sollten. Statt jedoch den Durchschnitt über insgesamt N Instanzen in Ihrem Datensatz zu bilden, sollten Sie N = [Instanzen mit mindestens einer Bezeichnung mit dem verwenden betreffende Klasse zugewiesen].

Hier wird die Referenz erwähnt: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Genau so, wie Sie es im Allgemeinen mit Mengen machen würden:

http://en.wikipedia.org/wiki/F1_score

http://en.wikipedia.org/wiki/Precision_and_recall

Hier sind einfache Python-Funktionen, die genau das tun:

def precision(y_true, y_pred):
    i = set(y_true).intersection(y_pred)
    len1 = len(y_pred)
    if len1 == 0:
        return 0
    else:
        return len(i) / len1


def recall(y_true, y_pred):
    i = set(y_true).intersection(y_pred)
    return len(i) / len(y_true)


def f1(y_true, y_pred):
    p = precision(y_true, y_pred)
    r = recall(y_true, y_pred)
    if p + r == 0:
        return 0
    else:
        return 2 * (p * r) / (p + r)


if __name__ == '__main__':
    print(f1(['A', 'B', 'C'], ['A', 'B']))