Rand endeksi hesaplama

Bir küme algoritmasının Rand Endeksi'ni nasıl hesaplayacağımı anlamaya çalışıyorum, ancak doğru ve yanlış negatifleri nasıl hesaplayacağım noktasında sıkıştım.

Şu anda, Bilgi Edinme Anına Giriş kitabından bir örnek kullanıyorum (Manning, Raghavan ve Schütze, 2009). 359 Sayfasında Rand endeksinin nasıl hesaplanacağı hakkında konuşuyorlar. Bu örnek için üç küme kullanırlar ve kümeler aşağıdaki nesneleri içerir.

1. aaaaab
2. abbbbc
3. aaccc

Nesneyi değiştiriyorum (orjinal işaretler harflere, ancak fikir ve sayım aynı kalıyor). Ne hakkında konuştuklarını görmek için kitaptan tam kelimeleri vereceğim:

Önce TP + FP'yi hesaplıyoruz. Üç kümede sırasıyla 6, 6 ve 5 nokta bulunur, bu nedenle aynı kümedeki toplam "pozitif" veya belge çifti sayısı:

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

Bunlardan küme 1'deki a çiftleri, küme 2'deki b çiftleri, küme 3'teki c çiftleri ve küme 3'teki bir çift gerçek pozitiflerdir:

TP = + + {3 \ 2'yi seçin} + {2 \ 2'yi seçin} = 10 + 6 + 3 + 1 = 20${5 \choose 2}$${4 \choose 2}$${3 \choose 2}$${2 \choose 2}$

Böylece FP = 40-20 = 20.

Buraya kadar hesaplamalar açıktır ve başka örnekler alırsam aynı sonuçları alırım, ancak yanlış negatif ve gerçek negatif hesaplamak istediğimde Manning ve ark. aşağıdakileri belirtin:

FN ve TN benzer şekilde hesaplanır ve aşağıdaki beklenmedik durum tablosu ile sonuçlanır:

Acil durum tablosu aşağıdaki gibidir:

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

Cümle: "FN ve TN benzer şekilde hesaplanır" benim için net değildir ve TN ve FN'yi hesaplamak için hangi sayılara ihtiyacım olduğunu anlamıyorum. Aşağıdakileri yaparak tablonun sağ tarafını hesaplayabilirim:

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

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

Bu nedenle, FN + TN = 136 - TP + FP = 136 - 40 = 96, ancak bu, değişkenlerin ayrı ayrı nasıl hesaplanacağını anlamamda gerçekten yardımcı olmuyor. Özellikle yazarlar “FN ve TN benzer şekilde hesaplanır” derken. Nasıl olduğunu göremiyorum. Ayrıca diğer örneklere baktığımda, her bir çifte bakarak beklenmedik durum tablosunun her hücresini hesaplıyorlar.

Örneğin: http://www.otlet-institute.org/wikics/Clustering_Problems.html#toc-Subsection-4.1

Manning ve arkadaşlarının (2009) örneğine dayanan ilk sorum, sadece TP ve NP'yi biliyorsanız TN ve FN'yi hesaplamak mümkün mü? Ve eğer öyleyse, benzer hesaplama verilen örneğe göre nasıl görünüyor?

Ben de aynı şeyi düşünüyordum ve bu şekilde çözdüm. Satırların temel doğruluk kümeleri ve sütunların kümeleme algoritması tarafından bulunan kümeler olduğu bir ortak oluşum matrisi / olasılık tablosuna sahip olduğunuzu varsayalım.

Yani, kitaptaki örnek için, şöyle görünecektir:

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

Artık, sütun başına toplamı alarak ve tüm bu değerler üzerinde '2'yi seçerek TP + FP'yi çok kolay bir şekilde hesaplayabilirsiniz. Yani toplamlar [6, 6, 5] ve '6'yı seç' 2 '+' 6'yı seç 2 '+' 5'i seç 2 '.

Şimdi, gerçekten de, benzer şekilde, toplamı satırların üzerinden alarak TP + FN elde edebilirsiniz (yani, yukarıdaki örnekte [8, 5, 4]), tüm bu değerlerin üzerine '2'yi seçin' ve toplamı.

TP'lerin kendileri, matristeki her hücreye 'select 2' uygulanarak ve her şeyin toplamı alınarak ('1 select 2' 0 olduğu varsayılarak) hesaplanabilir.

Aslında, işte tam olarak bunu yapan bazı Python kodları:

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

Eğer çalıştırırsam:

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

Aslında bunun dışında başka örnekleri kontrol etmedi, bu yüzden umarım doğru yaptım .... ;-)

Bu konudaki diğer cevapları inceledikten sonra, dizileri girdi olarak alan Python uygulamam, 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

Kendimden tam olarak emin değilim, ama TN değerini böyle yaptım:
TN = (7 2) (10 2) (4 2)

(7 2) - Küme 1 - test 'x' diyor, bu nedenle x DEĞİL olanları sayın (2 ve 3 numaralı kümelerde doğru bir şekilde kümelenmiştir)

yani 4 'o + 3' d (elmas) = ​​(7 2)

(10 2) - Küme 2, 1 ve 3 kümelerinde OLMAYAN ve doğru kümelenmiş olanları sayın,

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

(4 2) - Küme 3, kümeler 1 ve 2'de doğru bir şekilde kümelenmiş 'x' ve DEĞİL 'd' (elmas şeklindeki eleman) 'ları sayın.

yani küme 2'de 4 'o. = (4 2)

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

O zaman FN:

FN = (17 2) - (TP + FP) - TN = 136-40-72 = 24. ---> (17 = toplam belge sayısı)

Başka bir soru örneğini alarak:

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

FN için makul cevap:

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

Açıklama:

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

  'x' için 8'den 2'yi seçin (a) aynı kümelerde aynı sınıfın kombinasyonu (küme 1 için c (5,2) ve küme 3 için c (2,2)),

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

  5 'o' (b) eksi 2'yi aynı kümelerdeki aynı sınıfın kombinasyonunu seçin (küme 2 için c (4,2))

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

  '◇' (c) eksi için aynı sınıfın aynı kümelerdeki birleşimini (küme 3 için c (3,2)) 4'ten 2'yi seçin

Ben böyle elde ettim.

Ben bunu açıklayacağım R bir uygulaması var:

TP (koddaki a) her hücre 2'nin toplamıdır. Orijinal soruya göre (0 veya 1, 0'a eşit olan 2'yi seçin)

FN (b) her satırın 2, toplamı, daha az TP seçili toplamıdır. Her Satır toplamı, her bir True sınıfındaki belge sayısını temsil eder.

Bunun toplamı, benzer ve aynı kümedeki (TP) tüm belgeler ve benzer olan ve aynı kümedeki (FN) olmayan tüm belgelerdir.

Yani bu (TP + FN) - TP = FN

FP (c) benzer şekilde hesaplanır. Her sütunun toplamı 2, tümü toplanmış, daha az TP seçer. Bu durumda, her sütun toplamı, her kümedeki belge sayısını temsil eder.

Yani toplamı, benzer ve aynı kümedeki (TP) tüm belgeler ve benzer olmayan ve aynı kümedeki (FP) tüm belgelerdir.

Yani bu (TP + FP) - TP = FP

Hesaplanan bu 3 ile geriye kalan TN hesaplaması basittir. Tablonun toplamı 2, daha az TP, FP ve FN = TN (d) seçin

Bu yöntemle sahip olduğum tek sorgu TP tanımıdır. Bu sorudaki terminolojiyi kullanarak, 3. kümedeki 2 a'ların neden TP olarak kabul edildiğini anlamıyorum. Bunu hem burada hem de ilgili ders kitabında buldum. Ancak TP hesaplarının doğru olduğu varsayılarak hesaplamalarını anlıyorum.

Bu yardımcı olur umarım

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

TN ve FN'yi aynı şekilde hesaplayabilirsiniz.

Sadece etiketlerin ve kümelerin rollerini değiştirin .

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

... sonra aynı hesaplamaları yapın.

Ben yanlış negatif (FN) tersine mühendislik düşündüm. Gerçek pozitifler için, pozitif 4 grup oluşturdunuz. Küme 1'de beş aa vardı; küme 2'de 4 b vardı; küme 3'te 3 c VE 2 a's vardı.

Yani yanlış negatif için.

1. Küme 1'deki a'lerle başlayın; küme 1'de 5 doğru a yerleştirilir. Küme 2'de 1 yanlış a ve küme 3'te iki yanlış a var. Bu, (5 1) ve (5 2) değerini verir.
2. Sonra b'ler için. Daha önce hesapladığınız 4 doğru yerleştirilmiş b vardır. Küme 1'de bir yanlış b var ve hepsi bu. Bu size b'ler için (4 1) verir.
3. Sonra c'ler için. Küme 2'de bir yanlış c, küme 3'te üç doğru olan var, bu nedenle (3 1) var.
4. Bundan sonra, 3. kümedeki gerçek bir pozitif dediğimiz a çiftini unutamayız. Dolayısıyla, küme 2'de 1 yanlış a var. Küme 1'de başka a'lar olsa da, onlara yanlış a diyemeyiz çünkü çok fazla var.

Bu nedenle, 5 + 10 + 4 + 3 + 2 = 24'e eşit olan (5 1) + (5 2) + (4 1) + (3 1) + (2 1) var. sadece gerçek neg (TN) almak için bulduğunuz 136 dan çıkarın.

Rand Dizini için her metriği çıkarmadan nasıl hesaplayacağınız aşağıda açıklanmıştır

Daha kolay anlaşılması için yan notlar:

1) Rand Endeksi, eleman çiftlerinin karşılaştırılmasına dayanmaktadır. Teori, benzer eleman çiftlerinin aynı kümeye yerleştirilmesi gerektiğini, benzer olmayan eleman çiftlerinin ayrı kümelere yerleştirilmesi gerektiğini göstermektedir.

2) UR, küme sayısındaki farkı umursamıyor. Sadece Doğru / Yanlış eleman çiftlerini önemsiyor.

Bu varsayım temel alınarak, Rand Endeksi,

Tamam, burada dalış yapalım bizim örneğimiz:

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

Paydada, toplam olası çiftlerimiz var, (17 2) = 136

Şimdi daha iyi anlamak için her metriği hesaplayalım:

A) Kolay a ile başlayalım , ( Gerçek Pozitif veya doğru benzer )

Bu, tahmin ve gerçek etiketin bir araya getirildiği olası tüm öğe çiftlerini bulmanız gerektiği anlamına gelir. Izgara örneğinde, bu, her hücre içindeki olası çiftlerin toplamını almak anlamına gelir.

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) Şimdi yapalım c ( Yanlış Pozitif veya yanlış benzemez )

Bu, birlikte yerleştirdiğimiz, ancak farklı kümelerde olması gereken tüm çiftleri bulmak anlamına gelir. Izgara örneğinde, herhangi bir 2 yatay hücre arasındaki tüm olası çiftleri bulmak anlamına gelir

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) Hesaplama d ( Yanlış Negatif veya yanlış benzer ) Bu, farklı kümelere yerleştirdiğimiz, ancak birlikte olması gereken tüm çiftleri bulmak anlamına gelir. Izgara örneğinde, 2 dikey hücre arasındaki tüm olası çiftleri bulun

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) Ve son olarak b yapalım ( Gerçek Negatifler veya doğru olmayan )

Bu, farklı kümelere yerleştirmemiz gereken farklı kümelere yerleştirdiğimiz tüm çiftleri bulmak anlamına gelir. Izgarada, dikey olmayan ve yatay olmayan 2 hücre arasındaki tüm olası çiftleri bulmak anlamına gelir

Ne demek istediğimi daha iyi anlamak için hangi sayıların çarpılması gerektiği:

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

Sayılarla:

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

Ve sonunda Rand Endeksi eşittir: (20 + 72) / 136 = 0.676

Sorunuzu açıklayan resim aşağıdadır:

Bu sorunu çözmek için bu matrisi dikkate almanız gerekir:

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

Rand Endeksi için TP, FN, FP'yi şu şekilde hesaplıyoruz:

NOT: Yukarıdaki denklemlerde, resimde elmasları göstermek için bir üçgen kullandım.

Örneğin, Yanlış Negatif için sınıftan seçmeliyiz, ancak farklı kümelerde. Böylece,

• Küme 1'den 1 X ve küme 2'den 1 X = ${5 \choose 1}{1 \choose 1} = 5$
• Küme 1'den 1 X ve küme 3'ten 1 X = ${5 \choose 1}{2 \choose 1} = 10$
• Küme 1'den 1 O ve küme 2'den 1 O = ${1 \choose 1}{4 \choose 1} = 4$
• Küme 2'den 1 X ve küme 3'ten 1 X = ${1 \choose 1}{2 \choose 1} = 2$
• 1 $\diamond$ küme 2 ve 1'den $\diamond$ 3. kümeden = ${1 \choose 1}{3 \choose 1} = 3$

Sonunda, $24$ ($=5+10+4+2+3$) belirtir.

Aynı şey denklemlerin geri kalanı için de geçerlidir.

En zor kısım, aşağıdaki resim gibi yapılabilecek TN'dir:

Rand Endeksini hesaplamak için bazı daha kısa yollar vardır, ancak derin ve adım adım hesaplamadır. Son olarak, beklenmedik durum tablosu aşağıdaki gibi görünür:

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