Cálculo do índice Rand

Estou tentando descobrir como calcular o índice Rand de um algoritmo de cluster, mas estou parado no momento em como calcular os negativos verdadeiros e verdadeiros.

No momento, estou usando o exemplo do livro Uma Introdução à Recuperação de Informações (Manning, Raghavan & Schütze, 2009). Na página 359, eles falam sobre como calcular o índice Rand. Neste exemplo, eles usam três clusters e os clusters contêm os seguintes objetos.

1. aaaaab
2. abbbbc
3. aaccc

Substituo o objeto (sinais originais em letras, mas a idéia e a contagem permanecem as mesmas). Darei as palavras exatas do livro para ver do que elas estão falando:

Primeiro calculamos TP + FP. Os três clusters contêm 6, 6 e 5 pontos, respectivamente, portanto, o número total de "positivos" ou pares de documentos que estão no mesmo cluster é:

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

Desses, os pares a no cluster 1, pares b no cluster 2, pares c no cluster 3 e pares a no cluster 3 são verdadeiros positivos:

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

Assim, FP = 40 - 20 = 20.

Até aqui, os cálculos são claros e, se eu der outros exemplos, obtenho os mesmos resultados, mas quando quero calcular o falso negativo e o negativo negativo Manning et al. indique o seguinte:

FN e TN são calculados de maneira semelhante, resultando na seguinte tabela de contingência:

A tabela de contingência tem a seguinte aparência:

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

A frase: "FN e TN são calculados da mesma forma" não é clara para mim e não entendo quais números eu preciso calcular para TN e FN. Eu posso calcular o lado direito da tabela fazendo o seguinte:

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

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

Assim, FN + TN = 136 - TP + FP = 136 - 40 = 96, mas isso realmente não ajuda a descobrir como calcular as variáveis ​​separadamente. Especialmente quando os autores dizem: "FN e TN são computados de maneira semelhante". Eu não vejo como. Além disso, quando observo outros exemplos, eles calculam cada célula da tabela de contingência observando cada par.

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

Minha primeira pergunta, baseada no exemplo de Manning et al (2009), é possível calcular o TN e o FN se você conhece apenas o TP & NP? E se sim, como é o cálculo semelhante com base no exemplo fornecido?

Eu estava pensando sobre o mesmo, e resolvi assim. Suponha que você tenha uma tabela de matriz / contingência de coocorrência em que as linhas sejam os clusters de verdade do solo e as colunas sejam os clusters encontrados pelo algoritmo de clustering.

Portanto, para o exemplo do livro, seria semelhante a:

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

Agora, você pode facilmente calcular o TP + FP, tomando a soma por coluna e 'escolha 2' sobre todos esses valores. Portanto, as somas são [6, 6, 5] e você escolhe 6 '2' + '6 escolhe 2' + '5 escolhe 2'.

Agora, de fato, da mesma forma, você pode obter TP + FN assumindo a soma das linhas (ou seja, [8, 5, 4] no exemplo acima), aplique 'escolha 2' sobre todos esses valores e faça o soma disso.

Os próprios TP podem ser calculados aplicando 'escolha 2' a todas as células da matriz e tomando a soma de tudo (assumindo que '1 escolha 2' seja 0).

De fato, aqui está um código Python que faz exatamente isso:

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

Se eu executá-lo, recebo:

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

Na verdade, eu não verifiquei nenhum outro exemplo além deste, então espero ter feito certo .... ;-)

Depois de ter estudado as outras respostas neste segmento, aqui está minha implementação do Python, que recebe matrizes 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

Não tenho muita certeza, mas foi assim que fiz o valor de
TN : TN = (7 2) (10 2) (4 2)

(7 2) - Cluster 1 - o teste diz 'x', então conte aqueles que NÃO são x (e estão corretamente agrupados nos clusters 2 e 3)

ou seja, 4 'o + 3' d's (diamantes) = (7 2)

(10 2) - Cluster 2, conte aqueles que NÃO são do tipo 'e está corretamente agrupado nos clusters 1 e 3,

ou seja, 5 'x' + (2'x '+ 3'd') = (10 2)

(4 2) - Cluster 3, conte os que NÃO são 'x' e NOT 'd' (elemento em forma de diamante) s que estão corretamente agrupados nos clusters 1 e 2.

ou seja, 4 'o no cluster 2. = (4 2)

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

Então FN é:

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

Tomando o exemplo de outra pergunta:

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

A resposta razoável para a FN:

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

Explicação:

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

  escolha 2 de 8 para 'x' (a) a combinação da mesma classe nos mesmos clusters (c (5,2) para o cluster 1 ec (2,2) para o cluster 3),

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

  escolha 2 de 5 'o' (b) menos a combinação da mesma classe nos mesmos clusters (c (4,2) para o cluster 2)

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

  escolha 2 de 4 para '◇' (c) menos a combinação da mesma classe nos mesmos clusters (c (3,2) para o cluster 3)

Eu deduzi assim.

Eu tenho uma implementação disso em R, que explicarei:

TP (a no código) é a soma de cada célula, escolha 2. Conforme a pergunta original (0 ou 1, escolha 2 igual a 0)

FN (b) é a soma de cada linha, escolha 2, todas somadas, menos TP. Onde cada soma de linha representa o número de documentos em cada classe True.

A soma disso é todos os documentos semelhantes e no mesmo cluster (TP) mais todos os documentos semelhantes e que não estão no mesmo cluster (FN).

Então este é (TP + FN) - TP = FN

FP (c) é calculado da mesma forma. A soma de cada coluna escolhe 2, todos somados, menos TP. Nesse caso, a soma de cada coluna representa o número de documentos em cada cluster.

Portanto, a soma disso é todos os documentos que são semelhantes e no mesmo cluster (TP) mais todos os documentos que não são semelhantes e estão no mesmo cluster (FP).

Então este é (TP + FP) - TP = FP

Com estes 3 calculados, o cálculo restante da TN é direto. A soma da tabela escolhe 2, menos TP, FP e FN = TN (d)

A única consulta que tenho com esse método é a definição de TP. Usando a terminologia nesta pergunta, não entendo por que os 2 a no cluster 3 são considerados TP. Eu encontrei isso aqui e no livro relacionado. No entanto, eu entendo o cálculo com a suposição de que o cálculo do TP está correto.

Espero que isto ajude

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)
}

Você pode calcular TN e FN da mesma maneira.

Apenas mude os papéis de rótulos e clusters .

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

... então execute os mesmos cálculos.

Eu acho que fiz engenharia reversa do falso negativo (FN). Para os verdadeiros positivos, você criou 4 grupos positivos. No cluster 1, você tinha os cinco a's; no cluster 2, você tinha os 4 b's; no cluster 3, você tinha os 3 c E os 2 a.

Assim, para o falso negativo.

1. Comece com as no cluster 1; existem 5 a corretamente colocados no cluster 1. Você tem 1 a falso no cluster 2 e dois a falsos no cluster 3. Isso fornece (5 1) e (5 2).
2. Depois, para os b's. Existem 4 b's corretamente colocados que você calculou anteriormente. Você tem um falso b no cluster 1, e é isso. Isso fornece (4 1) para os b's.
3. Depois, para os c's. Você tem um c falso no cluster 2, com três corretos no cluster 3, então existe (3 1).
4. Depois disso, não podemos esquecer o par de a no cluster 3 que chamamos de positivo verdadeiro. Portanto, com relação a isso, temos 1 a falso no cluster 2. Embora existam outros a no cluster 1, não podemos chamá-los de falso a porque existem muitos.

Portanto, você tem (5 1) + (5 2) + (4 1) + (3 1) + (2 1) o que equivale a 5 + 10 + 4 + 3 + 2 = 24. É daí que vêm os 24, então subtraia isso dos 136 que você já encontrou para obter o verdadeiro neg (TN).

Aqui está como calcular todas as métricas do Rand Index sem subtrair

Notas laterais para facilitar a compreensão:

1) Rand Index é baseado na comparação de pares de elementos. A teoria sugere que pares de elementos semelhantes devem ser colocados no mesmo cluster, enquanto pares de elementos diferentes devem ser colocados em grupos separados.

2) O RI não se importa com a diferença no número de clusters. Ele se importa apenas com pares de elementos Verdadeiro / Falso.

Com base nessa premissa, o Rand Index é calculado

Ok, vamos mergulhar aqui é o nosso exemplo:

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

No denominador, temos o total de pares possíveis, que é (17 2) = 136

Agora vamos calcular todas as métricas para melhor entendimento:

A) Vamos começar com fácil um , ( verdadeiros positivos ou correta semelhante )

Isso significa que você precisa encontrar todos os pares possíveis de elementos, onde previsão e rótulo verdadeiro foram colocados juntos. No exemplo de grade, significa obter a soma dos pares possíveis dentro de cada célula.

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) Agora, vamos fazer c ( falsos positivos ou diferentes incorretos )

Significa encontrar todos os pares que colocamos juntos, mas que devem estar em grupos diferentes. No exemplo da grade, significa encontrar todos os pares possíveis entre duas células horizontais

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) Calculando d ( falso negativo ou similar incorreto ) Significa encontrar todos os pares que colocamos em grupos diferentes, mas que devem estar juntos. No exemplo de grade, encontre todos os pares possíveis entre duas células verticais

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) E, finalmente, vamos fazer b ( Verdadeiros Negativos ou corrigir diferentes )

Significa encontrar todos os pares que colocamos em diferentes grupos, que também devem estar em diferentes grupos. Na grade, significa encontrar todos os pares possíveis entre duas células não verticais e não horizontais

Aqui estão quais números devem ser multiplicados, para entender melhor o que eu quis dizer:

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

Em 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

E no final o Rand Index é igual: (20 + 72) / 136 = 0.676

Abaixo está a imagem que descreve sua pergunta:

Para resolver esse problema, você precisa considerar esta matriz:

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

É assim que calculamos TP, FN, FP para o Rand Index:

NOTA: Nas equações acima, usei um triângulo para mostrar o diamante na figura.

Por exemplo, para Falso Negativo, devemos escolher da classe, mas em grupos diferentes. Então, podemos escolher

• ${5 \choose 1}{1 \choose 1} = 5$
• ${5 \choose 1}{2 \choose 1} = 10$
• ${1 \choose 1}{4 \choose 1} = 4$
• ${1 \choose 1}{2 \choose 1} = 2$
• $\diamond$$\diamond$${1 \choose 1}{3 \choose 1} = 3$

$24$$=5+10+4+2+3$

O mesmo é para o resto das equações.

A parte mais difícil é a TN, que pode ser feita como na figura abaixo:

Existem alguns caminhos mais curtos para calcular o índice Rand, mas é o cálculo em profundidade e passo a passo. Por fim, a tabela de contingência tem a seguinte aparência:

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