Me pregunto cómo calcular las medidas de precisión y recuperación para la clasificación multiclase multicabel, es decir, la clasificación donde hay más de dos etiquetas y cada instancia puede tener varias etiquetas.

Otra herramienta popular para medir el rendimiento del clasificador es ROC / AUC ; este también tiene una extensión multi-clase / multi-etiqueta: ver [Hand 2001]

[Hand 2001]: una generalización simple del área bajo la curva ROC a problemas de clasificación de múltiples clases

Aquí hay algunos comentarios sobre el hilo del foro sobre la matriz de confusión y la medición de precisión / recuperación de múltiples clases.

La idea básica es calcular toda la precisión y recuperación de todas las clases, luego promediarlas para obtener una sola medición de número real.

La matriz de confusión facilita el cálculo de la precisión y la recuperación de una clase.

A continuación hay una explicación básica sobre la matriz de confusión, copiada de ese hilo:

Una matriz de confusión es una forma de clasificar los verdaderos positivos, los verdaderos negativos, los falsos positivos y los falsos negativos, cuando hay más de 2 clases. Se utiliza para calcular la precisión y la recuperación y, por lo tanto, la puntuación f1 para problemas de varias clases.

Los valores reales están representados por columnas. Los valores predichos están representados por filas.

Ejemplos:

10 ejemplos de entrenamiento que en realidad son 8, se clasifican (predicen) incorrectamente como 5
13 ejemplos de entrenamiento que en realidad son 4, se clasifican incorrectamente como 9

Matriz de confusión

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

Para la clase x:

• Verdadero positivo: posición diagonal, cm (x, x).

• Falso positivo: suma de la columna x (sin diagonal principal), suma (cm (:, x)) - cm (x, x).

• Falso negativo: suma de la fila x (sin diagonal principal), suma (cm (x, :), 2) -cm (x, x).

Puede calcular la precisión, la recuperación y la puntuación F1 siguiendo la fórmula del curso.

El promedio de todas las clases (con o sin ponderación) proporciona valores para todo el modelo.

Para la clasificación de etiquetas múltiples, tiene dos formas de hacerlo Primero, considere lo siguiente.

• $n$ es el número de ejemplos.
• $Y_i$ es la asignación de etiqueta de verdad fundamental del ejemplo .$i^{th}$
• $x_i$ es el ejemplo .$i^{th}$
• $h(x_i)$ son las etiquetas predichas para el ejemplo .$i^{th}$

Basado en ejemplos

Las métricas se calculan por punto de datos. Para cada etiqueta pronosticada, solo se calcula su puntaje, y luego estos puntajes se agregan en todos los puntos de datos.

• Precisión = , La proporción de cuánto de lo predicho es correcto. El numerador encuentra cuántas etiquetas en el vector predicho tienen en común con la verdad fundamental, y la razón calcula cuántas de las etiquetas verdaderas predichas están realmente en la verdad fundamental.$\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|h(x_{i})|}$
• Recall = , The relación de cuántas de las etiquetas reales se predijeron. El numerador encuentra cuántas etiquetas en el vector predicho tienen en común con la verdad fundamental (como se indicó anteriormente), luego encuentra la relación con el número de etiquetas reales, obteniendo así qué fracción de las etiquetas reales se predijeron.$\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|Y_{i}|}$

También hay otras métricas.

Etiqueta basada

Aquí las cosas se hacen con etiquetas. Para cada etiqueta, se calculan las métricas (p. Ej., Precisión, recuperación) y luego se agregan estas métricas con etiquetas. Por lo tanto, en este caso, termina calculando la precisión / recuperación de cada etiqueta en todo el conjunto de datos, como lo hace para una clasificación binaria (ya que cada etiqueta tiene una asignación binaria), luego la agrega.

La manera fácil es presentar la forma general.

Esto es solo una extensión del equivalente estándar de varias clases.

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

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

Aquí los son los verdadero positivo, falso positivo, verdadero negativo y falso negativo respectivamente solo para la etiqueta . j t $TP_{j},FP_{j},TN_{j},FN_{j}$$j^{th}$

Aquí representa cualquiera de las métricas basadas en la matriz de confusión. En su caso, deberá conectar la precisión estándar y las fórmulas de recuperación. Para el promedio macro, pasa el recuento por etiqueta y luego suma, para el promedio micro primero promedia los recuentos y luego aplica su función métrica.$B$

Que podría estar interesado en echar un vistazo en el código para las métricas de marca mult aquí , que una parte del paquete mldr en R . También es posible que le interese buscar en la biblioteca MULAN de etiquetas múltiples de Java .

Este es un buen artículo para entrar en las diferentes métricas: una revisión de algoritmos de aprendizaje de etiquetas múltiples

No sé sobre la parte de etiquetas múltiples, pero para la clasificación de clase múltiple, esos enlaces te ayudarán

Este enlace explica cómo construir la matriz de confusión que puede usar para calcular la precisión y la recuperación de cada categoría

Y este enlace explica cómo calcular las medidas micro-f1 y macro-f1 para evaluar el clasificador como un todo.

Espero que lo hayas encontrado útil.

este enlace me ayudó ... https://www.youtube.com/watch?v=HBi-P5j0Kec Espero que también te ayude

diga la distribución de la siguiente manera

    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 precisión para A sería

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

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... esencialmente tome el verdadero positivo de la clase y divida por los datos de la columna en las filas

recordar por un sería

R (A) = 100 / 100+ 80 + 10 + 10 = 0.5

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

psst ... esencialmente toma el verdadero positivo de la clase y divide por los datos de la fila en las columnas

una vez que obtenga todos los valores, tome el promedio macro

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

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

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

Echa un vistazo a estas diapositivas de cs205.org en Harvard . Una vez que llega a la sección sobre Medidas de error, se discute la precisión y recuperación en configuraciones de varias clases (por ejemplo, uno contra todos o uno contra uno) y matrices de confusión. Las matrices de confusión es lo que realmente quieres aquí.

Para su información, en el paquete de software de Python scikits.learn , hay métodos integrados para calcular automáticamente cosas como la matriz de confusión de clasificadores entrenados en datos de múltiples clases. Probablemente también pueda calcular directamente los gráficos de recuperación de precisión para usted. Digno de una mirada.

De Ozgur et al (2005) es posible ver que debe calcular Precisión y recuperación siguiendo las expresiones normales, pero en lugar de promediar el total de N instancias en su conjunto de datos, debe usar N = [instancias con al menos una etiqueta con el clase en cuestión asignada a].

Aquí está la referencia mencionada: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.104.8244&rep=rep1&type=pdf

Exactamente de la misma manera que lo haría en caso general, con conjuntos:

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

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

Aquí hay funciones simples de Python que hacen exactamente eso:

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