Perhitungan indeks Rand

Saya mencoba mencari cara untuk menghitung Rand Index dari algoritma cluster, tapi saya terjebak pada titik bagaimana menghitung negatif benar dan salah.

Saat ini saya menggunakan contoh dari buku An Introduction to Information Retrieval (Manning, Raghavan & Schütze, 2009). Di halaman 359 mereka berbicara tentang bagaimana cara menghitung indeks Rand. Untuk contoh ini mereka menggunakan tiga cluster dan cluster berisi objek-objek berikut.

1. aaaaab
2. abbbbc
3. aaccc

Saya mengganti objek (tanda-tanda asli ke huruf, tetapi gagasan dan jumlah tetap sama). Saya akan memberikan kata-kata persis dari buku untuk melihat apa yang mereka bicarakan:

Kami pertama-tama menghitung TP + FP. Tiga cluster berisi 6, 6, dan 5 poin, masing-masing, sehingga jumlah total "positif" atau pasangan dokumen yang berada di cluster yang sama adalah:

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

Dari jumlah tersebut, pasangan a dalam kluster 1, pasangan b di kluster 2, pasangan c di kluster 3, dan pasangan di kluster 3 adalah positif sebenarnya:

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

Jadi, FP = 40 - 20 = 20.

Sampai di sini ada perhitungan yang jelas, dan jika saya mengambil contoh lain saya mendapatkan hasil yang sama, tetapi ketika saya ingin menghitung Manning et al negatif dan negatif palsu. nyatakan sebagai berikut:

FN dan TN dihitung dengan cara yang sama, menghasilkan tabel kontingensi berikut:

Tabel kontingensi terlihat sebagai berikut:

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

Kalimat: "FN dan TN dihitung dengan cara yang sama" tidak jelas untuk saya dan saya tidak mengerti angka mana yang saya butuhkan untuk menghitung TN dan FN. Saya dapat menghitung sisi kanan tabel dengan melakukan hal berikut:

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

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

Dengan demikian, FN + TN = 136 - TP + FP = 136 - 40 = 96, tetapi ini tidak benar-benar membantu saya dalam mencari tahu bagaimana menghitung variabel secara terpisah. Terutama ketika penulis mengatakan: "FN dan TN dihitung sama". Saya tidak mengerti caranya. Juga ketika saya melihat contoh lain mereka menghitung setiap sel dari tabel kontingensi dengan melihat masing-masing pasangan.

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

Pertanyaan pertama saya, berdasarkan contoh Manning et al (2009), apakah mungkin menghitung TN dan FN jika Anda hanya mengetahui TP & NP? Dan jika demikian, bagaimana perhitungan yang serupa terlihat dari contoh yang diberikan?

Saya sedang memikirkan hal yang sama, dan saya menyelesaikannya seperti ini. Misalkan Anda memiliki matriks co-kejadian / tabel kontingensi di mana baris adalah cluster kebenaran dasar, dan kolom adalah cluster yang ditemukan oleh algoritma pengelompokan.

Jadi, untuk contoh dalam buku ini, akan terlihat seperti:

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

Sekarang, Anda dapat dengan mudah menghitung TP + FP dengan mengambil jumlah per kolom dan 'memilih 2' di atas semua nilai tersebut. Jadi jumlahnya adalah [6, 6, 5] dan Anda memilih '6 pilih 2' + '6 pilih 2' + '5 pilih 2'.

Sekarang, tentu saja, dengan cara yang sama, Anda bisa mendapatkan TP + FN dengan mengambil jumlah di atas baris (jadi, yaitu [8, 5, 4] dalam contoh di atas), terapkan 'pilih 2' atas semua nilai-nilai itu, dan ambil jumlah itu.

TP itu sendiri dapat dihitung dengan menerapkan 'pilih 2' ke setiap sel dalam matriks dan mengambil jumlah semuanya (dengan asumsi bahwa '1 pilih 2' adalah 0).

Sebenarnya, berikut adalah beberapa kode Python yang melakukan hal itu:

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

Jika saya menjalankannya saya mendapat:

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

Saya sebenarnya tidak memeriksa contoh lain selain yang ini, jadi saya harap saya melakukannya dengan benar .... ;-)

Setelah mempelajari jawaban lain di utas ini, inilah implementasi Python saya, yang menggunakan array sebagai input, 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

Saya sendiri tidak begitu yakin, tetapi ini adalah bagaimana saya melakukan nilai TN:
TN = (7 2) (10 2) (4 2)

(7 2) - Cluster 1 - test mengatakan 'x', jadi hitung yang TIDAK x (dan dikelompokkan dengan benar dalam cluster 2 & 3)

yaitu 4 'o's + 3' d's (berlian) = (7 2)

(10 2) - Cluster 2, hitung yang TIDAK 'o's dan dikelompokkan dengan benar dalam cluster 1 dan 3,

yaitu 5 'x' + (2'x '+ 3'd') = (10 2)

(4 2) - Cluster 3, hitung yang BUKAN 'x' dan BUKAN 'd' (elemen berbentuk berlian) yang dikelompokkan dengan benar dalam klaster 1 & 2.

yaitu 4 'o dalam cluster 2. = (4 2)

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

Maka FN adalah:

FN = (17 2) - (TP + FP) - TN = 136 - 40 -72 = 24. ---> (17 = jumlah total dokumen)

Ambil contoh pertanyaan lain:

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

Jawaban yang masuk akal untuk FN:

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

Penjelasan:

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

  pilih 2 dari 8 untuk 'x' (a) kombinasi kelas yang sama dalam kluster yang sama (c (5,2) untuk klaster 1 dan c (2,2) untuk klaster 3),

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

  pilih 2 dari 5 'o' (b) minus kombinasi kelas yang sama dalam kelompok yang sama (c (4,2) untuk klaster 2)

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

  pilih 2 dari 4 untuk '◇' (c) minus kombinasi kelas yang sama dalam kelompok yang sama (c (3,2) untuk klaster 3)

Saya mendapatkannya seperti ini.

Saya memiliki implementasi ini dalam R yang akan saya jelaskan:

TP (a dalam kode) adalah jumlah dari setiap sel pilih 2. Sesuai pertanyaan awal (0 atau 1 pilih 2 sama dengan 0)

FN (b) adalah jumlah setiap baris pilih 2, semua dijumlahkan, kurang TP. Di mana setiap jumlah Row mewakili jumlah dokumen di setiap kelas True.

Jumlahnya adalah semua dokumen yang serupa dan di cluster yang sama (TP) ditambah semua dokumen yang serupa dan tidak berada di cluster yang sama (FN).

Jadi ini (TP + FN) - TP = FN

FP (c) dihitung dengan cara yang sama. Jumlah setiap kolom pilih 2, semuanya dijumlahkan, kurang TP. Dalam hal ini setiap jumlah kolom mewakili jumlah dokumen di setiap cluster.

Jadi jumlah dari semua ini adalah semua dokumen yang sama dan berada di cluster yang sama (TP) ditambah semua dokumen yang tidak sama dan berada di cluster yang sama (FP).

Jadi ini (TP + FP) - TP = FP

Dengan 3 perhitungan ini, sisa perhitungan TN lurus ke depan. Jumlah tabel pilih 2, lebih sedikit TP, FP & FN = TN (d)

Satu-satunya pertanyaan yang saya miliki dengan metode ini adalah definisi TP. Menggunakan terminologi dalam pertanyaan ini, saya tidak mengerti mengapa 2 a di cluster 3 dianggap TP. Saya telah menemukan ini di sini dan di buku teks terkait. Namun saya mengerti perhitungan mereka dengan asumsi bahwa perhitungan TP mereka benar.

Semoga ini membantu

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

Anda dapat menghitung TN dan FN dengan cara yang sama.

Alihkan peran label dan kluster .

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

... lalu lakukan perhitungan yang sama.

SAYA BERPIKIR Saya telah merekayasa balik false negative (FN) darinya. Untuk positif sejati, Anda membuat 4 grup yang positif. Di cluster 1, Anda memiliki lima a; di kluster 2, Anda memiliki 4 b; dalam klaster 3 Anda memiliki 3 c dan 2 a.

Jadi untuk negatif palsu.

1. Mulai dengan a's di cluster 1; ada 5 ditempatkan dengan benar di cluster 1. Anda memiliki 1 false di cluster 2, dan dua false di cluster 3. Itu memberi (5 1) dan (5 2).
2. Lalu untuk b's. Ada 4 ditempatkan dengan benar karena Anda menghitung sebelumnya. Anda memiliki satu b palsu di cluster 1, dan hanya itu. Itu memberi Anda (4 1) untuk b's.
3. Lalu untuk huruf c. Anda memiliki satu c salah di cluster 2, dengan tiga yang benar di cluster 3, jadi ada (3 1).
4. Setelah itu, kita tidak bisa melupakan pasangan a di cluster 3 yang kita sebut benar positif. Jadi sehubungan dengan itu, kita memiliki 1 false a di cluster 2. Meskipun ada a yang lain di cluster 1, kita tidak bisa menyebutnya false a's karena ada begitu banyak.

Oleh karena itu, Anda memiliki (5 1) + (5 2) + (4 1) + (3 1) + (2 1) yang sama dengan 5 + 10 + 4 + 3 + 2 = 24. Dari situlah 24 berasal, kemudian kurangi saja dari 136 yang sudah Anda temukan untuk mendapatkan neg sebenarnya (TN).

Berikut ini cara menghitung setiap metrik untuk Rand Index tanpa mengurangi

Catatan tambahan untuk memudahkan pemahaman:

1) Rand Index didasarkan pada membandingkan pasangan elemen. Teori menunjukkan, bahwa pasangan elemen yang sama harus ditempatkan di cluster yang sama, sedangkan pasangan elemen yang berbeda harus ditempatkan dalam kelompok yang terpisah.

2) RI tidak peduli dengan perbedaan jumlah cluster. Itu hanya peduli tentang pasangan elemen Benar / Salah.

Berdasarkan asumsi ini, Rand Index, dihitung

Ok, mari selami contohnya di sini:

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

Dalam penyebut, kami memiliki total pasangan yang memungkinkan, yaitu (17 2) = 136

Sekarang mari kita hitung setiap metrik untuk pemahaman yang lebih baik:

A) Mari kita mulai dengan a mudah , ( Benar Positif atau benar serupa )

Artinya, Anda harus menemukan semua pasangan elemen yang memungkinkan, di mana prediksi dan label sebenarnya ditempatkan bersama. Pada contoh grid, ini berarti mendapatkan jumlah pasangan yang memungkinkan dalam setiap sel.

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) Sekarang, mari kita lakukan c ( Positif Salah atau tidak sama berbeda )

Artinya, temukan semua pasangan, yang kita tempatkan bersama, tetapi yang seharusnya berada dalam kelompok berbeda. Pada contoh grid artinya, temukan semua pasangan yang memungkinkan antara 2 sel horizontal

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) Menghitung d ( False Negative atau salah serupa ) Artinya, temukan semua pasangan yang kami tempatkan di cluster yang berbeda, tetapi yang harus bersama. Pada contoh grid, temukan semua pasangan yang memungkinkan antara 2 sel vertikal

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) Dan, akhirnya mari kita lakukan b ( Benar Negatif atau benar berbeda )

Artinya, temukan semua pasangan yang kami tempatkan di kelompok berbeda, yang juga harus ada di kelompok berbeda. Pada grid, itu berarti menemukan semua pasangan yang memungkinkan antara 2 sel non-vertikal dan non-horizontal

Inilah angka yang harus dikalikan, untuk mendapatkan pemahaman yang lebih baik tentang apa yang saya maksud:

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

Dalam angka:

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

Dan pada akhirnya Rand Index sama: (20 + 72) / 136 = 0.676

Di bawah ini adalah gambar yang menjelaskan pertanyaan Anda:

Untuk mengatasi masalah ini, Anda perlu mempertimbangkan matriks ini:

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

Inilah cara kami menghitung TP, FN, FP untuk Rand Index:

CATATAN: Dalam persamaan di atas, saya menggunakan segitiga untuk menunjukkan berlian pada gambar.

Misalnya, untuk False Negative, kita harus memilih dari kelas tetapi dalam kelompok yang berbeda. Jadi, kita bisa memilih

• 1 X dari cluster 1 dan 1 X dari cluster 2 = ${5 \choose 1}{1 \choose 1} = 5$
• 1 X dari cluster 1 dan 1 X dari cluster 3 = ${5 \choose 1}{2 \choose 1} = 10$
• 1 O dari cluster 1 dan 1 O dari cluster 2 = ${1 \choose 1}{4 \choose 1} = 4$
• 1 X dari cluster 2 dan 1 X dari cluster 3 = ${1 \choose 1}{2 \choose 1} = 2$
• 1 $\diamond$ dari klaster 2 dan 1 $\diamond$ dari cluster 3 = ${1 \choose 1}{3 \choose 1} = 3$

Akhirnya, kita akan memilikinya $24$ ($=5+10+4+2+3$) menyatakan.

Hal yang sama untuk sisa persamaan.

Bagian tersulit adalah TN yang dapat dilakukan seperti gambar di bawah ini:

Ada beberapa jalur yang lebih pendek untuk menghitung Indeks Rand, tetapi ini adalah perhitungan secara mendalam dan langkah demi langkah. Akhirnya, Tabel kontingensi terlihat sebagai berikut:

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