Mi chiedo come calcolare la precisione e richiamare le misure per la classificazione multilabel multiclasse, vale a dire la classificazione in cui vi sono più di due etichette e dove ogni istanza può avere più etichette?

Un altro strumento popolare per misurare le prestazioni del classificatore è ROC / AUC ; anche questo ha un'estensione multi-classe / multi-etichetta: vedi [Mano 2001]

[Mano 2001]: una semplice generalizzazione dell'area sotto la curva ROC a problemi di classificazione di più classi

Ecco alcune discussioni sul thread del forum di Coursera sulla matrice di confusione e la misurazione multi-classe di precisione / richiamo.

L'idea di base è calcolare tutta la precisione e il richiamo di tutte le classi, quindi fare una media per ottenere una singola misurazione del numero reale.

La matrice di confusione semplifica il calcolo della precisione e il richiamo di una classe.

Di seguito sono riportate alcune spiegazioni di base sulla matrice di confusione, copiate da quel thread:

Una matrice di confusione è un modo per classificare veri positivi, veri negativi, falsi positivi e falsi negativi, quando ci sono più di 2 classi. È usato per calcolare la precisione e il richiamo e quindi il punteggio f1 per problemi multi classe.

I valori effettivi sono rappresentati da colonne. I valori previsti sono rappresentati da righe.

Esempi:

10 esempi di allenamento che sono effettivamente 8, sono classificati (previsti) in modo errato come 5
13 esempi di allenamento che sono effettivamente 4, sono classificati in modo errato come 9

Matrice di confusione

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

Per la classe x:

• Vero positivo: posizione diagonale, cm (x, x).

• Falso positivo: somma della colonna x (senza diagonale principale), somma (cm (:, x)) - cm (x, x).

• Falso negativo: somma della riga x (senza diagonale principale), somma (cm (x, :), 2) -cm (x, x).

Puoi calcolare precisione, richiamo e punteggio F1 seguendo la formula del corso.

La media di tutte le classi (con o senza ponderazione) fornisce valori per l'intero modello.

Per la classificazione multi-etichetta hai due modi di procedere Innanzitutto considera quanto segue.

• $n$ è il numero di esempi.
• $Y_i$ è l'assegnazione dell'etichetta di verità di base dell'esempio .$i^{th}$
• $x_i$ è l'esempio .$i^{th}$
• $h(x_i)$ sono le etichette previste per l'esempio .$i^{th}$

Basato sull'esempio

Le metriche vengono calcolate in modo per punto dati. Per ogni etichetta prevista viene calcolato solo il suo punteggio, quindi questi punteggi vengono aggregati su tutti i punti dati.

• Precisione = , Il rapporto tra quanto previsto è corretto. Il numeratore trova quante etichette nel vettore previsto hanno in comune con la verità fondamentale e il rapporto viene calcolato, quante delle etichette reali previste sono effettivamente nella verità fondamentale.$\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|h(x_{i})|}$
• Richiama = , The rapporto di quante delle etichette effettive sono state previste. Il numeratore trova quante etichette nel vettore previsto hanno in comune con la verità di base (come sopra), quindi trova il rapporto con il numero di etichette effettive, ottenendo quindi quale frazione delle etichette effettive era prevista.$\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|Y_{i}|}$

Ci sono anche altre metriche.

Basato sull'etichetta

Qui le cose sono fatte in termini di etichette. Per ogni etichetta vengono calcolate le metriche (ad es. Precisione, richiamo) e quindi queste metriche sagge all'etichetta vengono aggregate. Quindi, in questo caso, si finisce per calcolare la precisione / richiamo per ciascuna etichetta sull'intero set di dati, come si fa per una classificazione binaria (poiché ogni etichetta ha un'assegnazione binaria), quindi aggregarla.

Il modo più semplice è presentare il modulo generale.

Questa è solo un'estensione dell'equivalente multi-classe standard.

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

• Micro media$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})$

Qui sono i conteggi vero positivo, falso positivo, vero negativo e falso negativo rispettivamente solo per l' etichetta . j t $TP_{j},FP_{j},TN_{j},FN_{j}$$j^{th}$

Qui sta per una delle metriche basate sulla matrice di confusione. Nel tuo caso inseriresti la precisione standard e richiamerai le formule. Per la macro media si passa al conteggio per etichetta e quindi si somma, per la micro media si esegue prima la media dei conteggi, quindi si applica la funzione metrica.$B$

Potreste essere interessati ad avere uno sguardo al codice per le metriche mult-label qui , che una parte del pacchetto mldr in R . Inoltre potresti essere interessato a consultare la libreria multi-label Java MULAN .

Questo è un bel documento per approfondire le diverse metriche: una recensione sugli algoritmi di apprendimento multi-etichetta

Non conosco la parte multietichetta ma per la classificazione in più classi quei collegamenti ti aiuteranno

Questo collegamento spiega come creare la matrice di confusione che è possibile utilizzare per calcolare la precisione e il richiamo per ciascuna categoria

E questo link spiega come calcolare le misure micro-f1 e macro-f1 per valutare il classificatore nel suo insieme.

spero che tu l'abbia trovato utile.

questo link mi ha aiutato .. https://www.youtube.com/watch?v=HBi-P5j0Kec spero che possa aiutare anche te

dire la distribuzione come di seguito

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

la precisione per A sarebbe

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

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... essenzialmente prende il vero positivo della classe e si divide per i dati della colonna tra le righe

il richiamo per un sarebbe

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

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

psst ... essenzialmente prende il vero positivo della classe e si divide per i dati di riga tra le colonne

una volta ottenuti tutti i valori, prendi la media delle macro

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

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

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

Scopri queste diapositive da cs205.org ad Harvard . Una volta arrivati ​​alla sezione Misure di errore, si discute di precisione e richiamo in impostazioni multi-classe (ad es. One-vs-all o one-vs-one) e matrici di confusione. Le matrici di confusione sono ciò che vuoi davvero qui.

Cordiali saluti, nel pacchetto software Python scikits.learn , ci sono metodi integrati per calcolare automaticamente cose come la matrice di confusione da classificatori addestrati su dati multi-classe. Probabilmente può calcolare direttamente anche grafici di richiamo di precisione anche per te. Vale la pena dare un'occhiata.

Da Ozgur et al (2005) è possibile vedere che dovresti calcolare Precisione e Richiamo seguendo le espressioni normali, ma invece di fare la media su N istanze totali nel tuo set di dati, dovresti usare N = [istanze con almeno un'etichetta con il classe in questione assegnata a].

ecco il riferimento menzionato: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Esattamente allo stesso modo in cui lo faresti caso generale, con set:

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

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

Ecco alcune semplici funzioni di Python che fanno esattamente questo:

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']))