兰德指数计算

我试图弄清楚如何计算群集算法的兰德指数，但我被困在如何计算真假阴性的问题上。

目前，我正在使用《信息检索入门》一书中的示例（Manning，Raghavan和Schütze，2009年）。在第359页，他们讨论了如何计算兰德指数。在此示例中，他们使用三个群集，并且这些群集包含以下对象。

1. a
2. abbbbc
3. 交流会

我替换了对象（原始符号改为字母，但是想法和计数保持不变）。我将给出书中确切的词，以查看他们在说什么：

我们首先计算TP + FP。这三个群集分别包含6、6和5个点，因此同一群集中的“阳性”或成对的文档总数为：

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

其中，簇1中的a对，簇2中的b对，簇3中的c对以及簇3中的a对为正数：

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

因此，FP = 40-20 = 20。

到这里为止，计算是很清楚的，如果以其他示例为例，我将得到相同的结果，但是当我要计算假负和真负Manning等人时。陈述以下内容：

FN和TN的计算方法类似，得出以下列联表：

列联表如下：

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

我不太清楚这句话：“ FN和TN的计算方式相似”，我不明白我需要计算哪个数字才能计算TN和FN。我可以通过执行以下操作来计算表格的右侧：

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

资料来源：http : //en.wikipedia.org/wiki/Rand_index

因此，FN + TN = 136-TP + FP = 136-40 = 96，但这并不能真正帮助我确定如何分别计算变量。特别是当作者说：“ FN和TN的计算方法相似时”。我不知道如何。同样，当我查看其他示例时，它们通过查看每一对来计算列联表的每个单元格。

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

我的第一个问题是基于Manning等人（2009）的示例，如果仅了解TP和NP，是否可以计算TN和FN？如果是这样，根据给定的示例，类似的计算结果如何？

我正在考虑相同的问题，并且我这样解决了。假设您有一个同时出现的矩阵/列联表，其中的行是地面实况群集，列是群集算法找到的群集。

因此，对于本书中的示例，它看起来像：

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

现在，您可以很容易地计算出TP + FP，方法是取每列的总和并在所有这些值上“选择2”。因此总和为[6，6，5]，然后您执行“ 6选择2” +“ 6选择2” +“ 5选择2”。

现在，实际上，类似地，您可以通过对行进行求和来获得TP + FN（因此，在上面的示例中为[8，5，4]），对所有这些值应用“选择2”，然后取总和。

TP本身可以通过对矩阵中的每个单元格应用“选择2”并取所有值的总和来计算（假设“ 1选择2”为0）。

实际上，这里有一些Python代码可以做到这一点：

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

如果我运行它，我得到：

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

除了这个例子，我实际上没有检查其他任何例子，所以我希望我做对了... ;-)

在研究了该线程中的其他答案之后，这是我的Python实现，该实现将数组作为输入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

我不确定自己，但是这就是我做TN值的方式：
TN =（7 2）（10 2）（4 2）

（7 2）–群集1 –测试说“ x”，因此计算不是x的那些（并正确地群集在群集2和3中）

即4'o's + 3'd's（钻石）=（7 2）

（10 2）–群集2，计算那些不是'o'并且正确地群集在群集1和3中的群集，

即5'x'+（2'x'+ 3'd'）=（10 2）

（4 2）–聚类3，计算那些在聚类1和2中正确聚类的NOT'x'和NOT'd'（菱形元素）。

即群集2中的4个o。=（4 2）

TN =（7 2）+（10 2）+（4 2）= 72。

那么FN是：

FN =（17 2）-（TP + FP）-TN = 136-40 -72 = 24. --->（17 =文件总数）

以另一个问题为例：

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

FN的合理答案：

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

说明：

• （c（8,2）-c（5,2）-c（2,2））

  对于'x'（a），从8中选择2（相同簇中相同类的组合（对于簇1为c（5,2），对于簇3为c（2,2））），

• （c（5,2）-c（4,2））

  从5'o'（b）中选择2减去相同群集中相同类别的组合（群集2的c（4,2））

• （c（4,2）-c（3,2）

  为'◇'（c）从4中选择2减去相同群集中相同类别的组合（群集3中的c（3,2））

我是这样衍生的。

我在R中有一个实现，我将解释：

TP（代码中的a）是每个单元格选择2的总和。按照原始问题（0或1选择2等于0）

FN（b）是每一行的总和，选择2，全部相加，减去TP。其中，每个行总和表示每个True类中的文档数。

这是所有相似且位于同一群集（TP）中的所有文档加上所有相似且不在同一群集（FN）中的所有文档。

所以这是（TP + FN）-TP = FN

FP（c）的计算方法类似。每列的总和选择2，所有总和减去TP。在这种情况下，每个列的总和表示每个群集中的文档数。

因此，这是所有相似且在同一群集（TP）中的文档加上所有不相似且在同一群集（FP）中的文档的总和。

所以这是（TP + FP）-TP = FP

通过计算这3个，TN的剩余计算很简单。表的总和选择2，减去TP，FP和FN = TN（d）

我对此方法的唯一查询是TP的定义。使用此问题中的术语，我不理解为什么群集3中的2 a被视为TP。我在这里和相关的教科书中都发现了这一点。但是，我确实以他们的目标价格计算正确的假设理解他们的计算。

希望这可以帮助

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和FN。

只需切换角色 标签和群集。

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

...然后执行相同的计算。

我认为我已经从中反向设计了假阴性（FN）。对于真正的积极因素，您将4个小组定为积极因素。在群集1中，您有五个a；在聚类2中，您有4个b；在群集3中，您有3个c和2个a。

因此对于假阴性。

1. 从群集1中的a开始；在簇1中有5个正确放置的a。在簇2中有1个假a，在簇3中有2个假a。得出（5 1）和（5 2）。
2. 然后为b的。您先前计算了4个正确放置的b。您在簇1中有一个假b，仅此而已。那给你（4 1）的b值。
3. 然后是c。您在集群2中有一个错误的c，在集群3中有三个正确的c，因此为（3 1）。
4. 在那之后，我们不能忘记簇3中的那对被我们称为正阳性的对。因此，关于这一点，群集2中有1个false a。即使群集1中还有其他a，我们也不能称它们为false a，因为有很多a。

因此，您有（5 1）+（5 2）+（4 1）+（3 1）+（2 1）等于5 + 10 + 4 + 3 + 2 =24。这是24的来源，然后只需从136中减去就可以得到真实的负值（TN）。

这是如何计算兰特指数的每个指标而不减去

旁注以方便理解：

1）兰德指数基于对成对元素的比较。理论表明，相似的元素对应放置在同一群集中，而相似的元素对应放置在单独的群集中。

2）RI不关心簇数的差异。它只关心True / False对元素。

基于此假设，可以计算兰德指数

好的，让我们深入研究以下示例：

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

在分母中，我们有可能的总对，即 (17 2) = 136

现在让我们计算每个指标以更好地理解：

A）让我们从简单的a开始，（True Positives或纠正类似）开始

这意味着，您需要找到所有可能的元素对，将预测和真实标签放在一起。在网格示例中，这意味着获取每个像元内可能对的总和。

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）现在，让我们做c（误报或不正确的相异）

这意味着找到所有我们放在一起的对，但它们应该在不同的簇中。在网格示例中，这意味着找到任意2个水平像元之间的所有可能对

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）计算d（错误的负数或不正确的相似度）这意味着，找到我们放置在不同群集中但应该在一起的所有对。在网格示例中，找到任意两个垂直像元之间的所有可能对

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）最后，让我们做b（真否定词或正确的相异词）

这意味着，找到我们放置在不同群集中的所有对，它们也应该位于不同群集中。在网格上，这意味着找到任意两个非垂直和非水平单元之间的所有可能对

这是应该相乘的数字，以便更好地理解我的意思：

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

数量：

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

最后，兰德指数等于： (20 + 72) / 136 = 0.676

下图描述了您的问题：

要解决此问题，您需要考虑以下矩阵：

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

这是我们计算兰德指数的TP，FN，FP的方法：

注意：在上述公式中，我使用三角形在图片中显示菱形。

例如，对于False Negative，我们应该从类中选择，但是要放在不同的类中。所以，我们可以选择

• ${5 \choose 1}{1 \choose 1} = 5$
• ${5 \choose 1}{2 \choose 1} = 10$
• 群集1的1 O和群集2的1 O = ${1 \choose 1}{4 \choose 1} = 4$
• 来自群集2的1 X和来自群集3的1 X = ${1 \choose 1}{2 \choose 1} = 2$
• 1个 $\diamond$ 来自集群2和1 $\diamond$ 来自集群3 = ${1 \choose 1}{3 \choose 1} = 3$

最后，我们将有 $24$ （$=5+10+4+2+3$） 状态。

其余等式也是如此。

最难的部分是TN，可以如下图所示进行操作：

有一些较短的路径可以计算兰德指数，但这是深入而逐步的计算。最后，列联表如下所示：

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