Je me demande comment calculer les mesures de précision et de rappel pour la classification multiclass à étiquettes multiples, c'est-à-dire une classification dans laquelle il existe plus de deux étiquettes et où chaque instance peut avoir plusieurs étiquettes?

Le ROC / AUC est un autre outil populaire pour mesurer les performances du classifieur . celui-ci aussi a une extension multi-classe / multi-label: voir [Hand 2001]

[Hand 2001]: Une simple généralisation de l'aire sous la courbe ROC à des problèmes de classification de classes multiples

Voici quelques discussions sur le fil de discussion de coursera sur la matrice de confusion et la mesure de précision / rappel multi-classes.

L'idée de base est de calculer toute la précision et le rappel de toutes les classes, puis de les calculer en moyenne pour obtenir une mesure de nombre réel unique.

La matrice de confusion facilite le calcul de la précision et du rappel d'une classe.

Vous trouverez ci-dessous quelques explications de base sur la matrice de confusion, copiées à partir de ce fil de discussion:

Une matrice de confusion est un moyen de classer les vrais positifs, les vrais négatifs, les faux positifs et les faux négatifs lorsqu'il existe plus de 2 classes. Il est utilisé pour calculer la précision et le rappel, et donc le score f1 pour des problèmes à plusieurs classes.

Les valeurs réelles sont représentées par des colonnes. Les valeurs prédites sont représentées par des lignes.

Exemples:

10 exemples de formation qui sont en réalité 8, sont classés (prédits) incorrectement comme 5
13 exemples de formation qui sont en réalité 4, sont classés incorrectement comme 9

Matrice de confusion

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

Pour la classe x:

• Vrai positif: position diagonale, cm (x, x).

• Faux positif: somme de la colonne x (sans la diagonale principale), somme (cm (:, x)) - cm (x, x).

• Faux négatif: somme de la ligne x (sans la diagonale principale), somme (cm (x, :), 2) - cm (x, x).

Vous pouvez calculer la précision, le rappel et le score F1 en suivant la formule du cours.

La moyenne de toutes les classes (avec ou sans pondération) donne des valeurs pour l'ensemble du modèle.

Pour la classification multi-étiquettes, vous avez deux possibilités. Commencez par examiner les points suivants.

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

Exemple basé

Les métriques sont calculées par point de donnée. Pour chaque étiquette prédite, seul son score est calculé, puis ces scores sont agrégés sur tous les points de données.

• $\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}|}$

Il existe également d'autres mesures.

Basé sur les étiquettes

Ici, les choses sont faites au niveau des étiquettes. Pour chaque étiquette, les métriques (par exemple, précision, rappel) sont calculées et ensuite, ces métriques par étiquette sont agrégées. Par conséquent, dans ce cas, vous finissez par calculer la précision / le rappel de chaque étiquette sur l'ensemble du jeu de données, comme pour une classification binaire (chaque étiquette ayant une affectation binaire), puis agrégez-la.

Le moyen le plus simple est de présenter la forme générale.

Ceci est juste une extension de l’équivalent standard multi-classes.

• $\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$

Vous pourriez être intéressé d'avoir un coup d' oeil dans le code pour les mesures mult-étiquette ici , dont une partie du paquet mldr dans R . Vous pouvez également être intéressé par la bibliothèque multi-étiquettes Java MULAN .

C’est un article intéressant pour entrer dans les différentes mesures: Examen des algorithmes d’apprentissage multi-étiquettes

Je ne connais pas la partie multi-étiquettes, mais pour la classification multi-classe, ces liens vous aideront

Ce lien explique comment créer la matrice de confusion que vous pouvez utiliser pour calculer la précision et le rappel de chaque catégorie.

Et ce lien explique comment calculer des mesures micro-f1 et macro-f1 pour évaluer le classifieur dans son ensemble.

J'espère que vous avez trouvé cela utile.

ce lien m'a aidé .. https://www.youtube.com/watch?v=HBi-P5j0Kec J'espère que cela vous aidera aussi

dites la distribution comme ci-dessous

    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 précision pour A serait

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

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... essentiellement, prenez le vrai positif de la classe et divisez-le par les données de colonne sur les lignes

rappel pour un serait

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

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

psst ... prend essentiellement le vrai positif de la classe et se divise par les données de ligne dans les colonnes

une fois que vous obtenez toutes les valeurs, prenez la moyenne 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 * moyen (P) * moyen (R) / moyen (P) + moyen (R)

Découvrez ces diapositives de cs205.org à Harvard . Une fois que vous arrivez à la section sur les mesures d'erreur, vous discuterez de la précision et du rappel dans les paramètres multi-classes (par exemple, un-contre-tout ou un-contre-un) et les matrices de confusion. Les matrices de confusion sont ce que vous voulez vraiment ici.

Pour votre information, dans le progiciel Python scikits.learn , il existe des méthodes intégrées permettant de calculer automatiquement des éléments tels que la matrice de confusion à partir de classificateurs formés à partir de données multi-classes. Il peut probablement aussi calculer directement des tracés de rappel de précision pour vous aussi. Ça vaut le coup d'oeil.

D'après Ozgur et al (2005), il est possible de calculer les valeurs de précision et de rappel en suivant les expressions normales, mais au lieu de calculer la moyenne sur le nombre total d'instances N dans votre jeu de données, vous devez utiliser les instances N = [avec au moins une étiquette classe en question assignée à].

voici la référence mentionnée: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Exactement de la même manière que vous le feriez dans le cas général, avec les ensembles:

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

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

Voici de simples fonctions Python qui font exactement cela:

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