Randindexberechnung

Ich versuche herauszufinden, wie der Rand-Index eines Cluster-Algorithmus berechnet wird, aber ich bin nicht sicher, wie die wahren und falschen Negative berechnet werden.

Im Moment verwende ich das Beispiel aus dem Buch Eine Einführung in die Informationsbeschaffung (Manning, Raghavan & Schütze, 2009). Auf Seite 359 wird erläutert, wie der Rand-Index berechnet wird. In diesem Beispiel werden drei Cluster verwendet, und die Cluster enthalten die folgenden Objekte.

1. aaaaab
2. abbbbc
3. aaccc

Ich ersetze das Objekt (Originalzeichen in Buchstaben, aber Idee und Anzahl bleiben gleich). Ich gebe die genauen Wörter aus dem Buch, um zu sehen, wovon sie sprechen:

Wir berechnen zuerst TP + FP. Die drei Cluster enthalten jeweils 6, 6 und 5 Punkte. Die Gesamtzahl der "Positiven" oder Dokumentpaare, die sich in demselben Cluster befinden, beträgt also:

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

Davon sind die a-Paare in Cluster 1, die b-Paare in Cluster 2, die c-Paare in Cluster 3 und das a-Paar in Cluster 3 echte Positive:

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

Somit ist FP = 40 - 20 = 20.

Bis hierher sind die Berechnungen klar, und wenn ich andere Beispiele nehme, erhalte ich die gleichen Ergebnisse, aber wenn ich das falsch-negative und das wahr-negative berechnen möchte, haben Manning et al. Geben Sie Folgendes an:

FN und TN werden auf ähnliche Weise berechnet und ergeben die folgende Kontingenztabelle:

Die Kontingenztabelle sieht wie folgt aus:

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

Der Satz: "FN und TN werden ähnlich berechnet" ist mir nicht klar und ich verstehe nicht, welche Zahlen ich zur Berechnung von TN und FN benötige. Ich kann die rechte Seite der Tabelle folgendermaßen berechnen:

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

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

Somit ist FN + TN = 136 - TP + FP = 136 - 40 = 96, aber dies hilft mir nicht wirklich dabei, herauszufinden, wie die Variablen separat berechnet werden. Besonders wenn die Autoren sagen: "FN und TN werden ähnlich berechnet". Ich verstehe nicht wie. Auch wenn ich mir andere Beispiele ansehe, berechnen sie jede Zelle der Kontingenztabelle, indem sie sich jedes Paar ansehen.

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

Meine erste Frage, basierend auf dem Beispiel von Manning et al. (2009), ist es möglich, TN und FN zu berechnen, wenn Sie nur die TP & NP kennen? Und wenn ja, wie sieht die ähnliche Berechnung basierend auf dem angegebenen Beispiel aus?

Ich habe darüber nachgedacht und es so gelöst. Angenommen, Sie haben eine Matrix / Kontingenz-Tabelle mit gemeinsamen Vorkommen, in der die Zeilen die Grundwahrheitscluster und die Spalten die vom Cluster-Algorithmus gefundenen Cluster sind.

Für das Beispiel im Buch würde es also so aussehen:

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

Jetzt können Sie das TP + FP ganz einfach berechnen, indem Sie die Summe pro Spalte nehmen und über all diese Werte '2' wählen. Die Summen sind also [6, 6, 5] und Sie tun '6 wählen 2' + '6 wählen 2' + '5 wählen 2'.

In der Tat können Sie jetzt in ähnlicher Weise TP + FN erhalten, indem Sie die Summe über die Zeilen ziehen (das heißt, [8, 5, 4] im obigen Beispiel), 'wähle 2' über all diese Werte und nehme die Summe davon.

Die TPs selbst können berechnet werden, indem für jede Zelle in der Matrix 'select 2' angewendet und die Summe von allem genommen wird (vorausgesetzt, '1 choose 2' ist 0).

In der Tat ist hier ein Python-Code, der genau das tut:

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

Wenn ich es laufen lasse, bekomme ich:

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

Ich habe eigentlich keine anderen Beispiele als diese überprüft, also hoffe ich, dass ich es richtig gemacht habe .... ;-)

Nachdem ich die anderen Antworten in diesem Thread gelesen habe, ist hier meine Python-Implementierung, die Arrays als Eingaben verwendet sklearn:

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

Ich bin mir nicht ganz sicher, aber so habe ich den TN-Wert ermittelt:
TN = (7 2) (10 2) (4 2)

(7 2) - Cluster 1 - Test sagt 'x', also zählen Sie diejenigen, die NICHT x sind (und in den Clustern 2 & 3 richtig gruppiert sind)

dh 4 'o's + 3' d's (Diamanten) = (7 2)

(10 2) - Cluster 2, zähle diejenigen, die NICHT 'O' sind und korrekt in Cluster 1 und 3 gruppiert sind,

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

(4 2) - Cluster 3: Zählen Sie diejenigen, die NICHT 'x' und NICHT 'd' (rautenförmige Elemente) sind, die korrekt in Cluster 1 und 2 gruppiert sind.

dh 4 'o's in Cluster 2. = (4 2)

TN = (72) + (102) + (42) = 72.

Dann ist FN:

FN = (17 2) - (TP + FP) - TN = 136 - 40 - 72 = 24. ---> (17 = Gesamtzahl der Dokumente)

Nehmen wir das Beispiel einer anderen Frage:

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

Die vernünftige Antwort für FN:

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

Erläuterung:

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

  Wählen Sie 2 aus 8 für 'x' (a) die Kombination derselben Klasse in denselben Clustern (c (5,2) für Cluster 1 und c (2,2) für Cluster 3),

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

  wähle 2 aus 5 'o' (b) minus der Kombination derselben Klasse in denselben Clustern (c (4,2) für Cluster 2)

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

  Wähle 2 aus 4 für '◇' (c) minus der Kombination derselben Klasse in denselben Clustern (c (3,2) für Cluster 3)

Ich habe es so abgeleitet.

Ich habe eine Implementierung davon in R, die ich erklären werde:

TP (a im Code) ist die Summe von jeder Zelle, wählen Sie 2. Gemäß der ursprünglichen Frage (0 oder 1 wählen Sie 2 gleich 0)

FN (b) ist die Summe jeder Zeile, wählen Sie 2, alle summiert, abzüglich TP. Wobei jede Zeilensumme die Anzahl der Dokumente in jeder True-Klasse darstellt.

Die Summe daraus sind alle Dokumente, die ähnlich sind und sich im selben Cluster (TP) befinden, sowie alle Dokumente, die ähnlich sind und sich nicht im selben Cluster (FN) befinden.

Das ist also (TP + FN) - TP = FN

FP (c) wird ähnlich berechnet. Die Summe jeder Spalte ergibt 2, alle summiert, abzüglich TP. In diesem Fall repräsentiert jede Spaltensumme die Anzahl der Dokumente in jedem Cluster.

Die Summe daraus sind also alle Dokumente, die ähnlich sind und sich im selben Cluster (TP) befinden, sowie alle Dokumente, die nicht ähnlich sind und sich im selben Cluster (FP) befinden.

Das ist also (TP + FP) - TP = FP

Mit diesen 3 berechneten ist die verbleibende Berechnung von TN einfach. Die Summe der Tabelle wählen Sie 2, weniger TP, FP & FN = TN (d)

Die einzige Frage, die ich bei dieser Methode habe, ist die Definition von TP. Unter Verwendung der Terminologie in dieser Frage verstehe ich nicht, warum die 2 a in Cluster 3 als TP gelten. Ich habe dies sowohl hier als auch im dazugehörigen Lehrbuch gefunden. Ich verstehe ihre Berechnung jedoch mit der Annahme, dass ihre TP-Berechnung korrekt ist.

Hoffe das hilft

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

Sie können TN und FN auf dieselbe Weise berechnen.

Wechseln Sie einfach die Rollen von Labels und Clustern .

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

... dann führen Sie die gleichen Berechnungen durch.

Ich denke, ich habe das falsche Negativ (FN) rückgängig gemacht. Für die wahren positiven Ergebnisse haben Sie 4 Gruppen gebildet, die positiv waren. In Cluster 1 hatten Sie die fünf Einsen; in Cluster 2 hatten Sie die 4 b; In Cluster 3 hatten Sie die 3 c und die 2 a.

Also für das falsche Negativ.

1. Beginnen Sie mit dem a in Cluster 1; Es gibt 5 korrekt platzierte a in Cluster 1. Sie haben 1 falsches a in Cluster 2 und zwei falsche a in Cluster 3. Das ergibt (5 1) und (5 2).
2. Dann für die B's. Es gibt 4 richtig platzierte B's, die Sie zuvor berechnet haben. Sie haben ein falsches b in Cluster 1, und das war's. Das gibt dir (4 1) für die B's.
3. Dann für die c's. Sie haben ein falsches c in Cluster 2 und drei richtige in Cluster 3, also gibt es (3 1).
4. Danach können wir das Paar von a in Cluster 3 nicht vergessen, das wir als wahres Positiv bezeichnet haben. In Bezug darauf haben wir 1 falsches a in Cluster 2. Auch wenn es in Cluster 1 andere a gibt, können wir sie nicht falsches a nennen, weil es so viele gibt.

Daher haben Sie (5 1) + (5 2) + (4 1) + (3 1) + (2 1), was 5 + 10 + 4 + 3 + 2 = 24 entspricht. Daher kommt dann die 24 Subtrahiere einfach das von den 136, die du bereits gefunden hast, um das wahre Neg (TN) zu erhalten.

Hier erfahren Sie, wie Sie jede Metrik für den Rand-Index berechnen, ohne sie zu subtrahieren

Randnotizen zum leichteren Verständnis:

1) Der Rand-Index basiert auf dem Vergleich von Elementpaaren. Die Theorie besagt, dass ähnliche Elementpaare in demselben Cluster platziert werden sollten, während unterschiedliche Elementpaare in separaten Clustern platziert werden sollten.

2) RI kümmert sich nicht um Unterschiede in der Anzahl der Cluster. Es geht nur um True / False-Elementpaare.

Basierend auf dieser Annahme wird der Rand-Index berechnet

Ok, lass uns hier eintauchen, das ist unser Beispiel:

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

Im Nenner haben wir also insgesamt mögliche Paare (17 2) = 136

Berechnen wir nun zum besseren Verständnis jede Metrik:

A) Beginnen wir mit easy a ( True Positives oder richtig ähnlich )

Es bedeutet, dass Sie alle möglichen Elementpaare finden müssen, bei denen Vorhersage und wahres Label zusammengesetzt wurden. In einem Gitterbeispiel bedeutet dies, dass die Summe der möglichen Paare in jeder Zelle ermittelt wird.

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) Nun lass uns c machen ( False Positives oder falsches Unähnliches )

Es bedeutet, alle Paare zu finden, die wir zusammengestellt haben, die sich aber in verschiedenen Clustern befinden sollten. In einem Gitterbeispiel bedeutet dies, dass alle möglichen Paare zwischen 2 beliebigen horizontalen Zellen gefunden werden

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) Berechnung von d ( falsch negativ oder falsch ähnlich ) Es bedeutet, alle Paare zu finden, die wir in verschiedenen Clustern platziert haben, die aber zusammen sein sollten. Suchen Sie im Raster-Beispiel alle möglichen Paare zwischen zwei beliebigen vertikalen Zellen

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) Und zum Schluss machen wir b ( True Negatives oder korrektes Unähnliches )

Es bedeutet, alle Paare zu finden, die wir in verschiedenen Clustern platziert haben, die sich auch in verschiedenen Clustern befinden sollten. Im Raster bedeutet dies, dass alle möglichen Paare zwischen 2 nicht vertikalen und nicht horizontalen Zellen gefunden werden

Hier ist, welche Zahlen multipliziert werden sollten, um besser zu verstehen, was ich meinte:

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

In Zahlen:

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

Und am Ende ist Rand Index gleich: (20 + 72) / 136 = 0.676

Unten ist das Bild, das Ihre Frage beschreibt:

Um dieses Problem zu lösen, müssen Sie diese Matrix berücksichtigen:

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

So berechnen wir TP, FN, FP für Rand Index:

HINWEIS: In den obigen Gleichungen habe ich ein Dreieck verwendet, um den Diamanten im Bild anzuzeigen.

Zum Beispiel sollten wir für False Negative aus der Klasse auswählen, aber in verschiedenen Clustern. Also können wir auswählen

• ${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$

Gleiches gilt für den Rest der Gleichungen.

Der schwierigste Teil ist TN, was wie im folgenden Bild gemacht werden kann:

Es gibt einige kürzere Wege, um den Rand-Index zu berechnen, aber es ist die Berechnung in tief und Schritt für Schritt. Schließlich sieht die Kontingenztabelle folgendermaßen aus:

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