Cálculo del índice de rand

Estoy tratando de descubrir cómo calcular el índice Rand de un algoritmo de clúster, pero no sé cómo calcular los negativos verdaderos y falsos.

En este momento estoy usando el ejemplo del libro Introducción a la recuperación de información (Manning, Raghavan y Schütze, 2009). En la página 359 hablan sobre cómo calcular el índice Rand. Para este ejemplo, usan tres grupos y los grupos contienen los siguientes objetos.

1. aaaaab
2. abbbbc
3. aaccc

Reemplazo el objeto (signos originales a letras, pero la idea y el recuento permanecen igual). Daré las palabras exactas del libro para ver de qué están hablando:

Primero calculamos TP + FP. Los tres grupos contienen 6, 6 y 5 puntos, respectivamente, por lo que el número total de "positivos" o pares de documentos que están en el mismo grupo es:

TP + FP = + (${6 \choose 2}$ + (${6 \choose 2}$ = 15 + 15+ 10 = 40${5 \choose 2}$

De estos, los pares a en el grupo 1, los pares b en el grupo 2, los pares c en el grupo 3 y los pares a en el grupo 3 son verdaderos positivos:

TP = + (${5 \choose 2}$ + (${4 \choose 2}$ + (${3 \choose 2}$ = 10 + 6 + 3 + 1 = 20${2 \choose 2}$

Por lo tanto, FP = 40-20 = 20.

Hasta aquí, los cálculos son claros, y si tomo otros ejemplos obtengo los mismos resultados, pero cuando quiero calcular el falso negativo y el verdadero negativo, Manning et al. declare lo siguiente:

FN y TN se calculan de manera similar, dando como resultado la siguiente tabla de contingencia:

La tabla de contingencia tiene el siguiente aspecto:

+--------+--------+
| TP: 20 | FN: 24 |
+--------+--------+
| FP: 20 | TN: 72 |
+--------+--------+

La frase: "FN y TN se calculan de manera similar" no está clara para mi y no entiendo qué números necesito para calcular el TN y FN. Puedo calcular el lado derecho de la tabla haciendo lo siguiente:

TP + FP + FN + TN = = (${n \choose 2}$ = 136${17 \choose 2}$

Fuente: http://en.wikipedia.org/wiki/Rand_index

Por lo tanto, FN + TN = 136 - TP + FP = 136 - 40 = 96, pero esto realmente no me ayuda a descubrir cómo calcular las variables por separado. Especialmente cuando los autores dicen: "FN y TN se calculan de manera similar". No veo como Además, cuando miro otros ejemplos, calculan cada celda de la tabla de contingencia mirando cada par.

Por ejemplo: http://www.otlet-institute.org/wikics/Clustering_Problems.html#toc-Subsection-4.1

Mi primera pregunta, basada en el ejemplo de Manning et al (2009), ¿es posible calcular el TN y el FN si solo conoce el TP y el NP? Y si es así, ¿cómo se ve un cálculo similar basado en el ejemplo dado?

Estaba reflexionando sobre lo mismo, y lo resolví así. Suponga que tiene una matriz de coincidencia / tabla de contingencia donde las filas son los grupos de verdad fundamentales y las columnas son los grupos encontrados por el algoritmo de agrupación.

Entonces, para el ejemplo en el libro, se vería así:

  | 1 | 2 | 3
--+---+---+---
x | 5 | 1 | 2
--+---+---+---
o | 1 | 4 | 0
--+---+---+---
◊ | 0 | 1 | 3

Ahora, puedes calcular muy fácilmente el TP + FP tomando la suma por columna y 'elige 2' sobre todos esos valores. Entonces las sumas son [6, 6, 5] y usted hace '6 elige 2' + '6 elige 2' + '5 elige 2'.

Ahora, de manera similar, puede obtener TP + FN tomando la suma sobre las filas (es decir, [8, 5, 4] en el ejemplo anterior), aplique 'elegir 2' sobre todos esos valores y tome el suma de eso.

Los propios TP pueden calcularse aplicando 'elegir 2' a cada celda de la matriz y tomando la suma de todo (suponiendo que '1 elegir 2' es 0).

De hecho, aquí hay un código de Python que hace exactamente eso:

import numpy as np
from scipy.misc import comb

# There is a comb function for Python which does 'n choose k'                                                                                            
# only you can't apply it to an array right away                                                                                                         
# So here we vectorize it...                                                                                                                             
def myComb(a,b):
  return comb(a,b,exact=True)

vComb = np.vectorize(myComb)

def get_tp_fp_tn_fn(cooccurrence_matrix):
  tp_plus_fp = vComb(cooccurrence_matrix.sum(0, dtype=int),2).sum()
  tp_plus_fn = vComb(cooccurrence_matrix.sum(1, dtype=int),2).sum()
  tp = vComb(cooccurrence_matrix.astype(int), 2).sum()
  fp = tp_plus_fp - tp
  fn = tp_plus_fn - tp
  tn = comb(cooccurrence_matrix.sum(), 2) - tp - fp - fn

  return [tp, fp, tn, fn]

if __name__ == "__main__":
  # The co-occurrence matrix from example from                                                                                                           
  # An Introduction into Information Retrieval (Manning, Raghavan & Schutze, 2009)                                                                       
  # also available on:                                                                                                                                   
  # http://nlp.stanford.edu/IR-book/html/htmledition/evaluation-of-clustering-1.html                                                                     
  #                                                                                                                                                      
  cooccurrence_matrix = np.array([[ 5,  1,  2], [ 1,  4,  0], [ 0,  1,  3]])

  # Get the stats                                                                                                                                        
  tp, fp, tn, fn = get_tp_fp_tn_fn(cooccurrence_matrix)

  print "TP: %d, FP: %d, TN: %d, FN: %d" % (tp, fp, tn, fn)

  # Print the measures:                                                                                                                                  
  print "Rand index: %f" % (float(tp + tn) / (tp + fp + fn + tn))

  precision = float(tp) / (tp + fp)
  recall = float(tp) / (tp + fn)

  print "Precision : %f" % precision
  print "Recall    : %f" % recall
  print "F1        : %f" % ((2.0 * precision * recall) / (precision + recall))

Si lo ejecuto me sale:

$ python testCode.py
TP: 20, FP: 20, TN: 72, FN: 24
Rand index: 0.676471
Precision : 0.500000
Recall    : 0.454545
F1        : 0.476190

De hecho, no verifiqué ningún otro ejemplo que este, así que espero haberlo hecho bien ... ;-)

Después de haber estudiado las otras respuestas en este hilo, aquí está mi implementación de Python, que toma matrices como entradas, sklearn-style:

import numpy as np
from scipy.misc import comb

def rand_index_score(clusters, classes):

    tp_plus_fp = comb(np.bincount(clusters), 2).sum()
    tp_plus_fn = comb(np.bincount(classes), 2).sum()
    A = np.c_[(clusters, classes)]
    tp = sum(comb(np.bincount(A[A[:, 0] == i, 1]), 2).sum()
             for i in set(clusters))
    fp = tp_plus_fp - tp
    fn = tp_plus_fn - tp
    tn = comb(len(A), 2) - tp - fp - fn
    return (tp + tn) / (tp + fp + fn + tn)

In [319]: clusters
Out[319]: [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]

In [320]: classes
Out[320]: [0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 2, 1, 0, 2, 2, 2, 0]

In [321]: rand_index_score(clusters, classes)
Out[321]: 0.67647058823529416

No estoy muy seguro de mí mismo, pero así es como hice el valor
TN : TN = (7 2) (10 2) (4 2)

(7 2) - Grupo 1 - la prueba dice 'x', así que cuente los que NO son x (y están agrupados correctamente en los grupos 2 y 3)

es decir, 4 'o's + 3' d's (diamantes) = (7 2)

(10 2) - Grupo 2, cuente los que NO son 'o' y están agrupados correctamente en los grupos 1 y 3,

es decir, 5 'x' + (2'x '+ 3'd') = (10 2)

(4 2) - Grupo 3, cuente los que NO son 'x' y NO 'd' (elemento en forma de diamante) que están agrupados correctamente en los grupos 1 y 2.

es decir, 4 'o en el grupo 2. = (4 2)

TN = (7 2) + (10 2) + (4 2) = 72.

Entonces FN es:

FN = (17 2) - (TP + FP) - TN = 136 - 40-72 = 24. ---> (17 = número total de documentos)

Tomando el ejemplo de otra pregunta:

  | 1 | 2 | 3
--+---+---+---
x | 5 | 1 | 2
--+---+---+---
o | 1 | 4 | 0
--+---+---+---
◊ | 0 | 1 | 3

La respuesta razonable para FN:

FN = (c(8,2)-c(5,2)-c(2,2))+(c(5,2)-c(4,2))+(c(4,2)-c(3,2))=24  

Explicación:

• (c (8,2) -c (5,2) -c (2,2))

  elija 2 de 8 para 'x' (a) la combinación de la misma clase en los mismos grupos (c (5,2) para el grupo 1 yc (2,2) para el grupo 3),

• (c (5,2) -c (4,2))

  elija 2 de 5 'o' (b) menos la combinación de la misma clase en los mismos grupos (c (4,2) para el grupo 2)

• (c (4,2) -c (3,2)

  elija 2 de 4 para '◇' (c) menos la combinación de la misma clase en los mismos grupos (c (3,2) para el grupo 3)

Lo deduje así.

Tengo una implementación de esto en R que explicaré:

TP (a en el código) es la suma de cada celda elige 2. Según la pregunta original (0 o 1 elige 2 que equivale a 0)

FN (b) es la suma de cada fila, elija 2, todo sumado, menos TP. Donde cada suma de filas representa el número de documentos en cada clase True.

La suma de esto es todos los documentos que son similares y están en el mismo grupo (TP) más todos los documentos que son similares y no están en el mismo grupo (FN).

Entonces esto es (TP + FN) - TP = FN

FP (c) se calcula de manera similar. La suma de cada columna elige 2, todos sumados, menos TP. En este caso, la suma de cada columna representa el número de documentos en cada grupo.

Entonces, la suma de esto es todos los documentos que son similares y están en el mismo grupo (TP) más todos los documentos que no son similares y están en el mismo grupo (FP).

Entonces esto es (TP + FP) - TP = FP

Con estos 3 calculados, el cálculo restante de TN es sencillo. La suma de la tabla elige 2, menos TP, FP y FN = TN (d)

La única consulta que tengo con este método es su definición de TP. Usando la terminología en esta pregunta, no entiendo por qué las 2 a en el grupo 3 se consideran TP. He encontrado esto aquí y en el libro de texto relacionado. Sin embargo, entiendo su cálculo con la suposición de que su cálculo de TP es correcto.

Espero que esto ayude

FMeasure = function (x, y, beta) 
{
  x <- as.vector(x)
  y <- as.vector(y)
  if (length(x) != length(y)) 
    stop("arguments must be vectors of the same length")
  tab <- table(x, y)
  if (all(dim(tab) == c(1, 1))) 
    return(1)
  a <- sum(choose(tab, 2))
  b <- sum(choose(rowSums(tab), 2)) - a
  c <- sum(choose(colSums(tab), 2)) - a
  d <- choose(sum(tab), 2) - a - b - c
  ## Precision
  P = a / (a + c)
  ## Recall
  R = a / (a + b)
  ##F-Measure
  Fm <- (beta^2 + 1) * P * R / (beta^2*P + R)
  return(Fm)
}

Puede calcular TN y FN de la misma manera.

Simplemente cambie los roles de etiquetas y clústeres .

a) 1 1 1 1 1 2 3 3
b) 1 2 2 2 2
c) 2 3 3 3 3

... luego realiza los mismos cálculos.

Creo que hice ingeniería inversa del falso negativo (FN). Para los verdaderos positivos, hiciste 4 grupos que fueron positivos. En el grupo 1, tenías las cinco a; en el grupo 2, tenías las 4 b's; en el grupo 3 tenías las 3 c y las 2 a.

Entonces para el falso negativo.

1. Comience con las a en el grupo 1; hay 5 a colocadas correctamente en el grupo 1. Tiene 1 a falsa en el grupo 2 y dos a falsas en el grupo 3. Eso da (5 1) y (5 2).
2. Luego por las b. Hay 4 b correctamente colocadas que calculó anteriormente. Tienes una falsa b en el grupo 1, y eso es todo. Eso te da (4 1) para los b.
3. Luego por las c. Tiene una c falsa en el grupo 2, con tres correctas en el grupo 3, por lo que hay (3 1).
4. Después de eso, no podemos olvidarnos de ese par de a en el grupo 3 que llamamos un verdadero positivo. Entonces, con respecto a eso, tenemos 1 a falso en el grupo 2. Aunque hay otras a en el grupo 1, no podemos llamarlas a falsas porque hay muchas.

Por lo tanto, tiene (5 1) + (5 2) + (4 1) + (3 1) + (2 1) que equivale a 5 + 10 + 4 + 3 + 2 = 24. De ahí viene el 24, entonces solo resta eso de los 136 que ya encontraste para obtener el verdadero neg (TN).

Aquí se explica cómo calcular cada métrica para el índice Rand sin restar

Notas al margen para facilitar la comprensión:

1) Rand Index se basa en comparar pares de elementos. La teoría sugiere que pares de elementos similares deben colocarse en el mismo grupo, mientras que pares de elementos diferentes deben colocarse en grupos separados.

2) RI no se preocupa por la diferencia en el número de grupos. Simplemente se preocupa por los pares de elementos Verdadero / Falso.

Sobre la base de este supuesto, se calcula el índice Rand

Ok, vamos a sumergirnos aquí es nuestro ejemplo:

  | 1 | 2 | 3
--+---+---+---
x | 5 | 1 | 2
--+---+---+---
o | 1 | 4 | 0
--+---+---+---
◊ | 0 | 1 | 3

En denominador, tenemos un total de pares posibles, que es (17 2) = 136

Ahora calculemos cada métrica para una mejor comprensión:

A) Comencemos con fácil a , ( Positivos verdaderos o correctos similares )

Significa que necesita encontrar todos los pares de elementos posibles, donde la predicción y la etiqueta verdadera se colocaron juntas. En el ejemplo de cuadrícula significa obtener la suma de los posibles pares dentro de cada celda.

a = (5 2) + (1 2) + (2 2) + (1 2) + (4 2) + (0 2) + (0 2) + (1 2) + (3 2) = 
  = 10 + 0 + 1 + 0 + 6 + 0 + 0 + 0 + 3 = 20

C) Ahora, hagamos c ( Positivos falsos o incorrectos diferentes )

Significa, encontrar todos los pares, que colocamos juntos, pero que deberían estar en diferentes grupos. En el ejemplo de cuadrícula, significa, encontrar todos los pares posibles entre 2 celdas horizontales

c = 5*1 + 5*2 + 1*2 + 
  + 1*4 + 1*0 + 4*0 + 
  + 0*1 + 0*3 + 1*3 = 
  = 5 + 10 + 2 + 4 + 0 + 0 + 0 + 0 + 3 = 24

D) Calcular d ( falso negativo o incorrecto similar ) Significa, encontrar todos los pares que colocamos en diferentes grupos, pero que deberían estar juntos. En el ejemplo de cuadrícula, encuentre todos los pares posibles entre 2 celdas verticales

d = 5*1 + 5*0 + 1*0 + 
  + 1*4 + 1*1 + 4*1 + 
  + 2*0 + 2*3 + 0*3 = 
  = 5 + 0 + 0 + 4 + 1 + 4 + 0 + 6 + 0 = 20

B) Y, finalmente, hagamos b ( Verdaderos negativos o correctos diferentes )

Significa, encontrar todos los pares que colocamos en diferentes grupos, que también deberían estar en diferentes grupos. En la cuadrícula, significa encontrar todos los pares posibles entre 2 celdas no verticales y no horizontales

A continuación, se detallan los números que se deben multiplicar para comprender mejor lo que quise decir:

d = x1*o2 + x1*o3 + x1*◊2 + x1*◊3 + 
  + x2*o1 + x2*o3 + x2*◊1 + x2*◊3 + 
  + x3*o1 + x3*o2 + x3*◊1 + x3*◊2 + 
  + o1*◊2 + o1*◊3 + 
  + o2*◊1 + o2*◊3 + 
  + o3*◊1 + o3*◊2

En números:

d = 5*4 + 5*0 + 5*1 + 5*3 + 
  + 1*1 + 1*0 + 1*0 + 1*3 + 
  + 2*1 + 2*4 + 2*0 + 2*1 + 
  + 1*1 + 1*3 +
  + 4*0 + 4*3 = 72

Y al final Rand Index es igual: (20 + 72) / 136 = 0.676

A continuación se muestra la imagen que describe su pregunta:

Para resolver este problema, debe considerar esta matriz:

+--------------------------------+--------------------------------------+
| TP:                            | FN:                                  |
| Same class + same cluster      | Same class + different clusters      |
+--------------------------------+--------------------------------------+
| FP:                            | TN:                                  |
| different class + same cluster | different class + different clusters |
+--------------------------------+--------------------------------------+

Así es como calculamos TP, FN, FP para el índice Rand:

NOTA: En las ecuaciones anteriores, usé un triángulo para mostrar el diamante en la imagen.

Por ejemplo, para Falso negativo, deberíamos elegir de la clase pero en diferentes grupos. Entonces, podemos elegir

• 1 X del grupo 1 y 1 X del grupo 2 = ${5 \choose 1}{1 \choose 1} = 5$
• 1 X del grupo 1 y 1 X del grupo 3 = ${5 \choose 1}{2 \choose 1} = 10$
• 1 O del grupo 1 y 1 O del grupo 2 = ${1 \choose 1}{4 \choose 1} = 4$
• 1 X del grupo 2 y 1 X del grupo 3 = ${1 \choose 1}{2 \choose 1} = 2$
• 1 $\diamond$ del grupo 2 y 1 $\diamond$ del grupo 3 = ${1 \choose 1}{3 \choose 1} = 3$

Finalmente tendremos $24$ ($=5+10+4+2+3$) estados.

Lo mismo es para el resto de las ecuaciones.

La parte más difícil es TN, que se puede hacer como la imagen de abajo:

Hay algunas rutas más cortas para calcular el índice Rand, pero es el cálculo en profundidad y paso a paso. Finalmente, la tabla de contingencia tiene el siguiente aspecto:

+--------+--------+
| TP: 20 | FN: 24 |
+--------+--------+
| FP: 20 | TN: 72 |
+--------+--------+