रैंड इंडेक्स गणना

17

मैं यह जानने की कोशिश कर रहा हूं कि क्लस्टर एल्गोरिथम के रैंड इंडेक्स की गणना कैसे की जाए, लेकिन मैं इस बिंदु पर अटका हुआ हूं कि सही और गलत नकारात्मक की गणना कैसे की जाए।

फिलहाल मैं एक किताब से एक परिचय इंफॉर्मेशन रिट्रीवल (मैनिंग, राघवन एंड शूज, 2009) का उपयोग कर रहा हूं। पृष्ठ 359 पर वे रैंड इंडेक्स की गणना करने के तरीके के बारे में बात करते हैं। इस उदाहरण के लिए वे तीन समूहों का उपयोग करते हैं और क्लस्टर में निम्नलिखित ऑब्जेक्ट होते हैं।

aaaaab
abbbbc
aaccc

मैं ऑब्जेक्ट (मूल चिह्नों को अक्षरों में बदल देता हूं, लेकिन विचार और गणना समान रहते हैं)। मैं पुस्तक से सटीक शब्द बताऊंगा ताकि यह देख सकें कि वे किस बारे में बात कर रहे हैं:

हम पहले टीपी + एफपी की गणना करते हैं। तीन समूहों में क्रमशः 6, 6, और 5 अंक होते हैं, इसलिए कुल संख्या "सकारात्मक" या एक ही समूह में होने वाले दस्तावेजों के जोड़े हैं:

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

इनमें से, क्लस्टर 1 में एक जोड़े, क्लस्टर 2 में बी जोड़े, क्लस्टर 3 में सी जोड़े और क्लस्टर 3 में एक जोड़ी सही सकारात्मक हैं:

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

इस प्रकार, एफपी = 40 - 20 = 20।

यहां तक गणना स्पष्ट हैं, और यदि मैं अन्य उदाहरण लेता हूं तो मुझे वही परिणाम मिलते हैं, लेकिन जब मैं झूठे नकारात्मक और सच्चे नकारात्मक मैनिंग एट अल की गणना करना चाहता हूं। निम्नलिखित बताएं:

FN और TN की गणना समान रूप से की जाती है, जिसके परिणामस्वरूप निम्नलिखित आकस्मिक तालिका होती है:

आकस्मिकता तालिका निम्नानुसार है:

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

वाक्य: "एफएन और टीएन की गणना इसी तरह की जाती है" मेरे लिए स्पष्ट नहीं है और मुझे समझ में नहीं आता कि मुझे टीएन और एफएन की गणना करने के लिए किन संख्याओं की आवश्यकता है। मैं निम्न कार्य करके तालिका के दाईं ओर की गणना कर सकता हूं:

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

स्रोत: http://en.wikipedia.org/wiki/Rand_index

इस प्रकार, एफएन + टीएन = 136 - टीपी + एफपी = 136 - 40 = 96, लेकिन यह वास्तव में मुझे यह पता लगाने में मदद नहीं करता है कि अलग-अलग चर की गणना कैसे करें। खासकर जब लेखक कहते हैं: "एफएन और टीएन की गणना इसी तरह की जाती है"। मैं नहीं देखता कि कैसे। इसके अलावा जब मैं अन्य उदाहरणों को देखता हूं तो वे प्रत्येक जोड़ी को देखकर आकस्मिक तालिका के प्रत्येक सेल की गणना करते हैं।

उदाहरण के लिए: http://www.otlet-institute.org/wikics/Clustering_Problems.html#toc-Subsection-4.1

मैनिंग एट अल (2009) के उदाहरण के आधार पर मेरा पहला सवाल क्या टीएन और एफएन की गणना करना संभव है, यदि आप केवल टीपी और एनपी जानते हैं? और यदि हां, तो दिए गए उदाहरण के आधार पर समान गणना कैसे दिखती है?

clustering

— Pakspul
स्रोत

9

मैं उसी के बारे में विचार कर रहा था, और मैंने इसे इस तरह हल किया। मान लें कि आपके पास एक सह-घटना मैट्रिक्स / आकस्मिकता तालिका है जहां पंक्तियाँ जमीनी सच्चाई क्लस्टर हैं, और कॉलम क्लस्टरिंग एल्गोरिदम द्वारा पाए गए क्लस्टर हैं।

इसलिए, पुस्तक में उदाहरण के लिए, ऐसा लगेगा:

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

अब, आप बहुत आसानी से प्रति कॉलम राशि लेकर TP + FP की गणना कर सकते हैं और उन सभी मूल्यों पर '2' चुन सकते हैं। तो योग [६, ६, ५] हैं और आप 2 ६ चुन २ ’+’ ६ ६ चुन २ ’+। ५ चुन २’ करते हैं।

अब, वास्तव में, इसी तरह, आप पंक्तियों के ऊपर राशि लेकर टीपी + एफएन प्राप्त कर सकते हैं (इसलिए, उपरोक्त उदाहरण में [4, ५, ४]), उन सभी मूल्यों पर 2 चूज 2 ’लागू करें, और लें उस राशि का।

टीपी की खुद की मैट्रिक्स में हर सेल में 'चूज 2' को लागू करके और हर चीज का योग लेते हुए गणना की जा सकती है (यह मानते हुए कि '1 चूज 2' 0 है)।

वास्तव में, यहां कुछ पायथन कोड है जो बिल्कुल ऐसा करता है:

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

— मॉन्स्टरमोरपीजी

मुझे समझ नहीं आया कि टीपी के लिए '2 चूज 2' क्यों माना जाता है। क्या इसका मतलब यह नहीं है कि x को x के रूप में गलत तरीके से वर्गीकृत किया गया है?

— vcosk

टीपी + एफएन के लिए क्या आपका मतलब "पंक्तियों पर योग" नहीं है?

— ज़ायथन

मुझे क्षमा करें, हाँ आप सही हैं। जवाब में तय किया।

— टॉम

6

इस सूत्र में अन्य उत्तरों का अध्ययन करने के बाद, यहाँ मेरा पायथन कार्यान्वयन है, जो इनपुट के रूप में सरणियाँ लेता है, 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

— cjauvin
स्रोत

4

मुझे खुद पर पूरा यकीन नहीं है, लेकिन यह है कि मैंने TN मान कैसे किया:
TN = (7 2) (10 2) (4 2)

(((२) - क्लस्टर १ - परीक्षण में 2 x ’कहा गया है, इसलिए गणना करें कि x नहीं हैं (और सही ढंग से क्लस्टर 2 और 3 में क्लस्टर किए गए हैं)

यानी 4 'ओ + 3' डी (हीरे) = (7 2)

(१० २) - क्लस्टर २, उन लोगों को गिनें जो and ओ ’नहीं हैं और सही ढंग से क्लस्टर 1 और 3 में क्लस्टर किए गए हैं,

यानी 5 'x' + (2'x '+ 3'd') = (10 2)

(४ २) - क्लस्टर ३, उन लोगों को गिनें जो x x ’नहीं हैं और (d’ (हीरे के आकार का तत्व) नहीं हैं, जो सही ढंग से क्लस्टर 1 और 2 में हैं।

4 क्लस्टर में 4 'ओ' = (4 2)

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

तो FN है:

एफएन = (17 2) - (टीपी + एफपी) - टीएन = 136 - 40 -72 = 24. ---> (17 = दस्तावेजों की कुल संख्या)

— Mersell
स्रोत

यह वह उत्तर है जो मेरे लिए सबसे अधिक समझ में आता है, हालांकि यह वास्तव में नहीं दिखाता है कि "एफएन और टीएन को समान रूप से कैसे गणना की जाती है", जैसा कि पुस्तक कहती है और प्रश्न संदर्भित करता है। मुझे संदेह है कि एक सरल तरीका हो सकता है, जैसा कि उत्तर में क्लस्टर / कक्षाओं का उल्लेख करते हुए रणनीति संकेत पर स्विच करना है।

— काज्विन

यह गलत है, यह विवरण अन्य उदाहरणों में काम नहीं करता है। मेरे उत्थान को वापस दे दो! सही उत्तर @ @ उपयोगकर्ता 9668 है।

— 00zgür

यह जवाब वास्तव में सही समझ में आता है।

— एहसानएफ

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

स्पष्टीकरण:

(ग (8.2) -c (5,2) -c (2,2))

'x' के लिए 8 में से 2 का चयन करें (a) क्लस्टर (1 और c (2,2) के लिए समान क्लस्टर में क्लस्टर 3 के लिए समान वर्ग का संयोजन)
(ग (5,2) -c (4,2))

5 'ओ' में से 2 चुनें (बी) एक ही वर्ग के समूह में एक ही वर्ग के संयोजन को घटाएं (क्लस्टर 2 के लिए (4,2))
(ग (4,2) -c (3,2)

'(' के लिए 4 में से 2 का चयन करें (c) समान समूहों में समान वर्ग का संयोजन (c (3,2) क्लस्टर के लिए)

मैंने इसे इस तरह से निकाला।

— user9668
स्रोत

1

मेरे पास आर में इसका एक कार्यान्वयन है जिसे मैं समझाऊंगा:

टीपी (कोड में) प्रत्येक सेल चुनने का योग है 2. मूल प्रश्न के अनुसार (0 या 1 चुनें 2 के बराबर 0)

एफएन (बी) प्रत्येक पंक्ति का योग है 2 चुनें, सभी संक्षेप, कम टीपी। जहां प्रत्येक रो योग प्रत्येक सच वर्ग में दस्तावेजों की संख्या का प्रतिनिधित्व करता है।

इसका योग सभी दस्तावेज समान और समान क्लस्टर (टीपी) में हैं और सभी दस्तावेज जो समान हैं और समान क्लस्टर (एफएन) में नहीं हैं।

तो यह है (टीपी + एफएन) - टीपी = एफएन

एफपी (सी) की गणना इसी तरह की जाती है। प्रत्येक कॉलम का योग 2 चुनता है, सभी सारांशित, कम टीपी। इस स्थिति में प्रत्येक स्तंभ राशि प्रत्येक क्लस्टर में दस्तावेजों की संख्या का प्रतिनिधित्व करती है।

तो इस का योग सभी दस्तावेज हैं जो समान हैं और समान क्लस्टर (टीपी) में हैं और सभी दस्तावेज जो समान नहीं हैं और एक ही क्लस्टर (एफपी) में हैं।

तो यह है (टीपी + एफपी) - टीपी = एफपी

इन 3 की गणना के साथ TN की शेष गणना सीधे आगे है। तालिका का योग 2 चुनें, कम टीपी, एफपी और एफएन = टीएन (डी)

इस विधि के साथ मेरे पास केवल क्वेरी है, यह TP की परिभाषा है। इस प्रश्न में शब्दावली का उपयोग करते हुए, मुझे समझ में नहीं आता है कि क्लस्टर 3 में 2 के ए को टीपी क्यों माना जाता है। मुझे यह दोनों यहाँ और संबंधित पाठ्यपुस्तक में मिला है। हालाँकि मैं उनकी गणना को इस धारणा के साथ समझता हूं कि उनकी टीपी गणना सही है।

उम्मीद है की यह मदद करेगा

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

— SamPassmore
स्रोत

यह बहुत प्रचलन में है, आपको dell, row, column से क्या मतलब है?

— .zgür

मुझे यकीन नहीं है कि आप रैंड स्टैटिस्टिक को प्रचलन के रूप में क्यों बता रहे हैं? सेल, पंक्ति और स्तंभ भ्रम की मैट्रिक्स की कोशिकाओं की पंक्तियों और स्तंभों को संदर्भित करते हैं। ओपी के सवाल के अनुसार।

— सैमपासमोर

खैर, क्योंकि मूल प्रश्न में कोई उलझन मैट्रिक्स नहीं है? और आपने कहीं नहीं कहा कि यह भ्रम मैट्रिक्स है। यह ऊपर दिए गए पहले उत्तर में है और एक बार उपयोग करने के बाद, हाँ आपकी विधि काम कर रही है।

— 51zgü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

... फिर वही संगणनाएँ करें।

— QUIT है - एनीनी-मूस
स्रोत

क्या आप अधिक स्पष्ट हो सकते हैं? इसके अलावा, आपको अपनी सूची में एक अतिरिक्त 3 मिला है (ग) मेरा मानना है, क्योंकि 17 आइटम होने चाहिए।

— cjauvin

बहुत अस्पष्ट जवाब

— मॉन्स्टरमोरपीजी

0

I THINK मैंने रिवर्स नकारात्मक (FN) को इससे बाहर निकाल दिया है। सही सकारात्मक के लिए, आपने 4 समूह बनाए जो सकारात्मक थे। क्लस्टर 1 में, आपके पास पांच ए थे; क्लस्टर 2 में, आपके पास 4 बी है; क्लस्टर 3 में आपके पास 3 सी और 2 का ए है।

तो झूठी नकारात्मक के लिए।

क्लस्टर 1 में ए के साथ शुरू करें; क्लस्टर में 5 सही तरीके से रखे गए हैं। क्लस्टर 2 में आपके पास 1 गलत है, और क्लस्टर में दो झूठे हैं। यह (5 1) और (5 2) देता है।
फिर बी के लिए। वहाँ 4 सही ढंग से बी की गणना कर रहे हैं आप पहले की गणना की। आपके पास क्लस्टर 1 में एक गलत बी है, और यह वह है। जो आपको b के लिए (4 1) देता है।
फिर सी के लिए। आपके पास क्लस्टर 2 में एक गलत सी है, क्लस्टर 3 में तीन सही हैं, इसलिए वहां (3 1) है।
उसके बाद, हम क्लस्टर 3 में ए की उस जोड़ी के बारे में नहीं भूल सकते हैं जिसे हमने सच्चा सकारात्मक कहा है। तो उस संबंध में, हमारे पास क्लस्टर 1 में 1 गलत है। भले ही क्लस्टर 1 में अन्य हैं, हम उन्हें झूठी नहीं कह सकते क्योंकि बहुत सारे हैं।

इसलिए, आपके पास (5 1) + (5 2) + (4 1) + (3 1) + (2 1) है जो 5 + 10 + 4 + 3 + 2 = 24 के बराबर है। यही वह जगह है जहाँ से 24 आता है, फिर बस इसे घटाएँ 136 से आप पहले से ही सही नकारात्मक (TN) प्राप्त कर सकते हैं।

— एलेक्सिस फिशर
स्रोत

0

यहां बताया गया है कि बिना घटाए रैंड इंडेक्स के लिए हर मीट्रिक की गणना कैसे की जाए

आसान समझने के लिए साइड नोट्स:

1) रैंड इंडेक्स तत्वों के जोड़े की तुलना पर आधारित है। थ्योरी बताती है, कि तत्वों के समान जोड़े को एक ही क्लस्टर में रखा जाना चाहिए, जबकि तत्वों के असमान जोड़े को अलग-अलग समूहों में रखा जाना चाहिए।

2) आरआई समूहों की संख्या में अंतर के बारे में परवाह नहीं करता है। यह बस तत्वों के सच्चे / गलत जोड़े की परवाह करता है।

इस धारणा के आधार पर, रैंड इंडेक्स की गणना की जाती है

ठीक है, चलो यहाँ में गोता लगाएँ हमारा उदाहरण है:

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

हर में, हमारे पास कुल संभव जोड़े हैं, जो है (17 2) = 136

अब बेहतर समझने के लिए हर मीट्रिक की गणना करें:

ए) आसान के साथ आइए शुरू एक , ( सच सकारात्मक या सही समान )

इसका मतलब है, आपको उन सभी संभावित जोड़े को खोजने की जरूरत है, जहां भविष्यवाणी और सही लेबल को एक साथ रखा गया था। ग्रिड उदाहरण पर इसका मतलब है कि प्रत्येक कोशिका के भीतर संभावित जोड़े का योग प्राप्त करें।

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

सी) अब, सी करते हैं ( गलत सकारात्मक या गलत असहमति )

इसका अर्थ है, सभी जोड़े खोजें, जिन्हें हमने एक साथ रखा था, लेकिन जो अलग-अलग समूहों में होना चाहिए। ग्रिड उदाहरण पर इसका मतलब है, किसी भी 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

डी) डी ( झूठी नकारात्मक या गलत समान ) की गणना करना इसका मतलब है, उन सभी जोड़ों को ढूंढें जिन्हें हमने विभिन्न समूहों में रखा था, लेकिन जो एक साथ होना चाहिए। ग्रिड उदाहरण पर, किसी भी 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

बी) और, आखिरकार बी करते हैं ( ट्रू नेगेटिव्स या सही डिसिमिलर )

इसका अर्थ है, उन सभी जोड़ों को खोजें जिन्हें हमने अलग-अलग समूहों में रखा है, जो अलग-अलग समूहों में भी होना चाहिए। ग्रिड पर, इसका मतलब है कि किसी भी 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 |
+--------------------------------+--------------------------------------+

इस तरह हम रैंड इंडेक्स के लिए टीपी, एफएन, एफपी की गणना करते हैं:

नोट: उपरोक्त समीकरणों में, मैंने चित्र में हीरे को दिखाने के लिए एक त्रिकोण का उपयोग किया।

उदाहरण के लिए, झूठी नकारात्मक के लिए, हमें कक्षा से लेकिन विभिन्न समूहों में चुनना चाहिए। तो, हम चुन सकते हैं

${5 \choose 1}{1 \choose 1} = 5$
${5 \choose 1}{2 \choose 1} = 10$
${1 \choose 1}{4 \choose 1} = 4$
क्लस्टर 2 से 1 एक्स और क्लस्टर 3 = 1 एक्स ${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 |
+--------+--------+

— Hadij
स्रोत