ランドインデックスの計算


17

クラスターアルゴリズムのランドインデックスを計算する方法を理解しようとしていますが、真と偽のネガを計算する方法で立ち往生しています。

現時点では、書籍「情報検索入門」(Manning、Raghavan&Schütze、2009)の例を使用しています。359ページで、ランドインデックスの計算方法について説明しています。この例では、3つのクラスターを使用し、クラスターには次のオブジェクトが含まれています。

  1. ああああ
  2. abbbbc
  3. aaccc

オブジェクトを置き換えます(元の文字から文字へのサインですが、アイデアとカウントは同じままです)。彼らが何を話しているかを見るために、本から正確な言葉を与えます。

最初にTP + FPを計算します。3つのクラスターにはそれぞれ6、6、および5ポイントが含まれているため、同じクラスター内にある「陽性」またはドキュメントのペアの総数は次のとおりです。

TP + FP = (62) + (62) + (52) = 15 + 15+ 10 = 40

これらのうち、クラスター1のaペア、クラスター2のbペア、クラスター3のcペア、クラスター3のaペアは真陽性です。

TP = (52) + (42) + (32) + (22) = 10 + 6 + 3 + 1 = 20

したがって、FP = 40 − 20 = 20です。

ここまで計算は明確であり、他の例を取り上げると同じ結果が得られますが、偽陰性と真陰性を計算したい場合はマニングら。次のように述べます。

FNとTNも同様に計算され、次の分割表が作成されます。

分割表は次のようになります。

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

「FNとTNは同様に計算されます」という文は私には明確ではなく、TNとFNを計算するために必要な数値がわかりません。以下を実行することで、テーブルの右側を計算できます。

TP + FP + FN + TN = = = 136(n2)(172)

ソース: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 et al(2009)の例に基づく私の最初の質問は、TPとNPしかわからない場合にTNとFNを計算することは可能ですか?もしそうなら、同様の計算は与えられた例に基づいてどのように見えますか?

回答:


9

私も同じことを考えていましたが、このように解決しました。行がグラウンドトゥルースクラスターであり、列がクラスタリングアルゴリズムによって検出されたクラスターである共起行列/コンティンジェンシーテーブルがあるとします。

したがって、本の例では、次のようになります。

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

これで、列ごとの合計を取得し、それらすべての値に対して「2」を選択することで、TP + FPを非常に簡単に計算できます。したがって、合計は[6、6、5]であり、「6 choose 2」+「6 choose 2」+「5 choose 2」を実行します。

さて、実際に、同様に、行全体の合計(つまり、上記の例では[8、5、4])を取得してTP + FNを取得し、それらすべての値に「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

私は実際にこれ以外の例をチェックしなかったので、正しくやったことを願っています... ;-)


答えはtyですが、あなたは説明しません。両方の時間列ベースと言います。回答を更新し、FP + TPと同じようにFN + TNを含めることができますか?
MonsterMMORPG

TPで「2を選択2」が考慮される理由がわかりませんでした。xが誤ってasに分類されているという意味ではありませんか?
vcosk

TP + FNの「行の合計」を意味しないのですか?
ザイトン

ごめんなさい、はい、あなたは正しいです。答えを修正しました。
トム

6

このスレッドで他の答えを研究した後、ここに私のsklearnスタイルのPython実装があります。

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

4

私自身はよくわかりませんが、これが私が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に正しくクラスター化されている '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 =ドキュメントの総数)


これは私にとって最も理にかなっている答えですが、本が言うように、質問が言及しているように、「FNとTNが同様に計算される」方法を実際に示していません。おそらく、クラスター/クラスの切り替え戦略に関するヒントが示唆されているように、もっと簡単な方法があるのではないかと思います。
チャウビン

これは間違っています。この説明は他の例では機能しません。私の賛成票を返してください!正解は@ user9668です。
Özgür

この答えは実際に完全に理にかなっています。
-EhsanF

2

別の質問の例を取り上げます。

  | 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)同じクラスターの同じクラスの組み合わせ(クラスター1のc(5,2)およびクラスター3のc(2,2))の8から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))

このように導きました。


1

私はこれをRで実装していますが、これについて説明します:

TP(コード内のa)は、すべてのセル選択2の合計です。元の質問に従って(0または1は、0に等しい2を選択します)

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と見なされる理由がわかりません。ここと関連する教科書の両方でこれを見つけました。ただし、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)
}

これはとても流行しています、デル、行、列とはどういう意味ですか?
Özgür

Rand Statisticを流行と説明している理由がわかりませんか?セル、行、および列は、混同マトリックスのセルの行と列を指します。OPの質問によると。
サンパスモア

さて、元の質問には混同マトリックスがないので?そして、あなたはそれが混同マトリックスであるとは述べていません。上記の最初の回答にあり、一度使用すると、あなたの方法は機能しているようです。
Özgür

0

TNとFNを同じ方法で計算できます。

ラベルクラスターの役割を切り替えるだけです。

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

...その後、同じ計算を実行します。


もっと明示できますか?また、リストには3つ追加されています(c)17個のアイテムがあるはずです。
チャウビン

非常に不明確な答え
-MonsterMMORPG

0

偽陰性(FN)をリバースエンジニアリングしたと思います。真のポジティブについては、ポジティブな4つのグループを作成しました。クラスター1では、5つのaがありました。クラスタ2では、4つのbがありました。クラスター3では、3つのcと2つのaがありました。

偽陰性については。

  1. クラスタ1のaから始めます。クラスタ1には5個のaが正しく配置されています。クラスタ2には1個のfalse aがあり、クラスタ3には2個のfalse aがあります。これは(5 1)と(5 2)を与えます。
  2. その後、Bの。先に計算したbが正しく配置されています。クラスター1にfalse bが1つあり、それだけです。それはあなたに(4 1)を与えます。
  3. その後、Cの。クラスター2に1つのfalse cがあり、クラスター3に3つの正しいcがあるため、(3 1)があります。
  4. その後、クラスター3の真のポジティブと呼ばれるaのペアについて忘れることはできません。そのため、クラスター2には1つのfalse aがあります。クラスター1には他のaがありますが、非常に多いため、それらをfalse aと呼ぶことはできません。

したがって、5 + 10 + 4 + 3 + 2 = 24に等しい(5 1)+(5 2)+(4 1)+(3 1)+(2 1)があります。既に見つけた136からそれを差し引くだけで、真のネガ(TN)が得られます。


0

以下は、減算せずにランドインデックスのすべてのメトリックを計算する方法です。

理解を容易にするための補足事項:

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 Positiveまたは正しい類似

つまり、予測と真のラベルが一緒に配置された要素のすべての可能なペアを見つける必要があります。グリッドの例では、各セル内で可能なペアの合計を取得することを意味します。

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)dFalse Negativeまたは不正確な類似)の計算。これは、異なるクラスターに配置したが、一緒にする必要があるすべてのペアを見つけることを意味します。グリッドの例では、任意の2つの垂直セル間のすべての可能なペアを見つけます

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をしましょう(True Negativesまたは修正非類似

つまり、異なるクラスターに配置したすべてのペアを検索します。これらのクラスターも異なるクラスターに配置する必要があります。グリッドでは、2つの非垂直セルと非水平セルの間で可能なすべてのペアを見つけることを意味します

ここに、私が何を意味するのかをよりよく理解するために、どの数字を掛けるべきかを示します。

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


0

以下はあなたの質問を説明する写真です:

ランドインデックス質問

この問題を解決するには、次のマトリックスを考慮する必要があります。

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

これが、ランドインデックスのTP、FN、FPの計算方法です。

ランドインデックスのTP、FN、およびFP計算

注:上記の方程式では、三角形を使用して写真にダイヤモンドを表示しました。

たとえば、False Negativeの場合、クラスから選択する必要がありますが、クラスターは異なります。だから、私たちは選ぶことができます

  • クラスター1から1 X、クラスター2から1 X =(51)(11)=5
  • クラスター1から1 X、クラスター3から1 X =(51)(21)=10
  • クラスター1から1 O、クラスター2から1 O =(11)(41)=4
  • クラスター2から1 X、クラスター3から1 X =(11)(21)=2
  • 1個のクラスター2から1個のクラスターから3 =(11)(31)=3

最後に、()の状態があります。24=5+10+4+2+3

同じことが残りの方程式にも当てはまります。

最も難しい部分はTNで、次の図のように実行できます。

ランドインデックスのTN計算

ランドインデックスを計算するためのいくつかの短いパスがありますが、それは詳細で段階的な計算です。最後に、分割表は次のようになります。

+--------+--------+
| TP: 20 | FN: 24 |
+--------+--------+
| FP: 20 | TN: 72 |
+--------+--------+
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.