KMEANS में k की संख्या का अनुमान लगाने के लिए BIC का उपयोग करना

मैं वर्तमान में अपने खिलौना डेटा सेट (inc iris (:) के लिए BIC की गणना करने की कोशिश कर रहा हूं। मैं यहां दिखाए गए अनुसार परिणाम को पुन: उत्पन्न करना चाहता हूं (चित्र 5)। यह पेपर भी BIC फॉर्मूलों के लिए मेरा स्रोत है।

मुझे इसके साथ 2 समस्याएं हैं:

संकेतन:
- $n_i$ = क्लस्टर में तत्वों की संख्या $i$
- $C_i$ = क्लस्टर का केंद्र निर्देशांक $i$
- $x_j$ = डेटा बिंदुओं को क्लस्टर को सौंपा गया $i$
- $m$ = समूहों की संख्या

1) Eq में परिभाषित रूपांतर। (2):

\sum_{i} = \frac{1}{n_{i} - m} \sum_{j = 1}^{n_{i}} ‖ x_{j} - C_{i} ‖^{2}

$\sum_i = \frac{1}{n_i-m}\sum_{j=1}^{n_i}\Vert x_j - C_i \Vert^2$

जहाँ तक मैं देख सकता हूँ कि यह समस्याग्रस्त है और इसे कवर नहीं किया गया है कि क्लस्टर में तत्वों की तुलना में अधिक क्लस्टर $m$ होने पर विचरण नकारात्मक हो सकता है । क्या ये सही है?

2) मैं सही बीआईसी की गणना करने के लिए सिर्फ अपना कोड काम नहीं कर सकता। उम्मीद है कि कोई त्रुटि नहीं है, लेकिन अगर किसी की जांच हो सकती है तो इसकी बहुत सराहना की जाएगी। पूरा समीकरण ईक में पाया जा सकता है। (५) कागज में। मैं अभी सब कुछ जानने के लिए scikit का उपयोग कर रहा हूं (कीवर्ड को सही ठहराने के लिए: P)।

from sklearn import cluster
from scipy.spatial import distance
import sklearn.datasets
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import numpy as np

def compute_bic(kmeans,X):
    """
    Computes the BIC metric for a given clusters

    Parameters:
    -----------------------------------------
    kmeans:  List of clustering object from scikit learn

    X     :  multidimension np array of data points

    Returns:
    -----------------------------------------
    BIC value
    """
    # assign centers and labels
    centers = [kmeans.cluster_centers_]
    labels  = kmeans.labels_
    #number of clusters
    m = kmeans.n_clusters
    # size of the clusters
    n = np.bincount(labels)
    #size of data set
    N, d = X.shape

    #compute variance for all clusters beforehand
    cl_var = [(1.0 / (n[i] - m)) * sum(distance.cdist(X[np.where(labels == i)], [centers[0][i]], 'euclidean')**2)  for i in xrange(m)]

    const_term = 0.5 * m * np.log10(N)

    BIC = np.sum([n[i] * np.log10(n[i]) -
           n[i] * np.log10(N) -
         ((n[i] * d) / 2) * np.log10(2*np.pi) -
          (n[i] / 2) * np.log10(cl_var[i]) -
         ((n[i] - m) / 2) for i in xrange(m)]) - const_term

    return(BIC)



# IRIS DATA
iris = sklearn.datasets.load_iris()
X = iris.data[:, :4]  # extract only the features
#Xs = StandardScaler().fit_transform(X)
Y = iris.target

ks = range(1,10)

# run 9 times kmeans and save each result in the KMeans object
KMeans = [cluster.KMeans(n_clusters = i, init="k-means++").fit(X) for i in ks]

# now run for each cluster the BIC computation
BIC = [compute_bic(kmeansi,X) for kmeansi in KMeans]

plt.plot(ks,BIC,'r-o')
plt.title("iris data  (cluster vs BIC)")
plt.xlabel("# clusters")
plt.ylabel("# BIC")

बीआईसी के लिए मेरे परिणाम इस तरह दिखते हैं:

जो कि मैंने जो अपेक्षा की है उसके करीब भी नहीं है और इससे कोई मतलब भी नहीं है ... मैंने कुछ समय के लिए समीकरणों पर ध्यान दिया और मुझे अपनी गलती का पता लगाने के लिए आगे नहीं मिल रहा है):

— काम सेन
स्रोत

यहां क्लस्टरिंग के लिए आपको BIC की गणना मिल सकती है । यह कैसे SPSS करता है। जरूरी नहीं कि जैसा आप दिखाते हैं वैसा ही हो।

— ttnphns

धन्यवाद ttnphns मैंने पहले आपका जवाब देखा। लेकिन इस बात का कोई संदर्भ नहीं है कि कदम कैसे निकाले जाते हैं और इस तरह से मैं क्या देख रहा था। इसके अलावा यह एसपीएसएस आउटपुट या जो भी वाक्यविन्यास है वह बहुत पठनीय नहीं है। वैसे भी धन्यवाद। इस प्रश्न में दिलचस्पी की कमी के कारण मैं संदर्भ के लिए देखूंगा और विचरण के लिए दूसरे अनुमान का उपयोग करूंगा।

— काम सेन

मुझे पता है कि यह आपके प्रश्न का उत्तर नहीं देता है (इस प्रकार मैं इसे एक टिप्पणी के रूप में छोड़ता हूं), लेकिन आर पैकेज mclust परिमित मिश्रण मॉडल (एक पैरामीट्रिक क्लस्टरिंग विधि) फिट बैठता है और स्वचालित रूप से समूहों की संख्या, आकार, आकार, अभिविन्यास और विषमता का अनुकूलन करता है। मैं समझता हूं कि आप स्केलेर का उपयोग कर रहे हैं, लेकिन इसे वहां से बाहर फेंकना चाहते हैं।

— ब्राश इक्विलिब्रियम

ब्राश, स्केलेर में GMM

— आईलर

@ क्या आप यहाँ मेरी मदद कर सकते हैं? : - आंकड़े.स्टैकएक्सचेंज.com

— प्रणय वानखेड़े

जवाबों:

ऐसा लगता है कि आपके सूत्रों में कुछ त्रुटियां हैं, जैसा कि निम्नलिखित द्वारा निर्धारित किया गया है:

https://www.cs.cmu.edu/~dpelleg/download/xmeans.pdf (कागज में कुछ त्रुटियां हैं)
https://github.com/bobhancock/goxmeans/blob/master/km.go
https://github.com/mynameisfiber/pyxmeans/blob/master/pyxmeans/xmeans.py
https://github.com/bobhancock/goxmeans/blob/master/doc/BIC_notes.pdf

1।

np.sum([n[i] * np.log(n[i]) -
               n[i] * np.log(N) -
             ((n[i] * d) / 2) * np.log(2*np.pi) -
              (n[i] / 2) * np.log(cl_var[i]) -
             ((n[i] - m) / 2) for i in range(m)]) - const_term

यहाँ कागज में तीन त्रुटियां हैं, चौथी और पाँचवीं पंक्तियाँ d के एक कारक को याद कर रही हैं, अंतिम पंक्ति 1 के लिए स्थानापन्न m है। इसे निम्न होना चाहिए:

np.sum([n[i] * np.log(n[i]) -
               n[i] * np.log(N) -
             ((n[i] * d) / 2) * np.log(2*np.pi*cl_var) -
             ((n[i] - 1) * d/ 2) for i in range(m)]) - const_term

2।

Const_term:

const_term = 0.5 * m * np.log(N)

होना चाहिए:

const_term = 0.5 * m * np.log(N) * (d+1)

3।

विचरण सूत्र:

cl_var = [(1.0 / (n[i] - m)) * sum(distance.cdist(p[np.where(label_ == i)], [centers[0][i]], 'euclidean')**2)  for i in range(m)]

एक स्केलर होना चाहिए:

cl_var = (1.0 / (N - m) / d) * sum([sum(distance.cdist(p[np.where(labels == i)], [centers[0][i]], 'euclidean')**2) for i in range(m)])

4।

अपने बेस 10 लॉग के बजाय प्राकृतिक लॉग का उपयोग करें।

5।

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

— eyaler
स्रोत

बस उल्लेख करने के लिए, BIC_notes ( https://github.com/bobhancock/goxmeans/blob/master/doc/BIC_notes.pdf ) में, (२२) से (२२) की व्युत्पत्ति को _ ) का संकेत मिला। गलत है। उच्चतम मत वाले उत्तर में कोड सही है।

\frac{M K (ϕ)}{2}

$\frac{MK(\phi)}{2}$

— मिकोयैन

@ यूलर क्या आप मुझे यहाँ सही कर सकते हैं? : - सांख्यिकी.स्टैकएक्सचेंज.com

— प्रणय वानखेड़े

क्या आप एक पेपर लिंक कर सकते हैं, या गणितीय मार्कअप में लिख सकते हैं?

— डैनलान

Pl मेरे संबंधित प्रश्न यहाँ देखें: आंकड़े

— rnso

@ Seanny123 और eyaler पोस्ट आँकड़े देखें ।stackexchange.com/ questions/374002/… यह सूत्र आइरिस डेटा पर लगभग 9 क्लस्टर दे रहा है जिसमें 3 क्लस्टर होना चाहिए

— बर्नार्डो ब्रागा

यह मूल रूप से आईलाइनर का समाधान है, कुछ नोटों के साथ .. मैंने अभी इसे टाइप किया है अगर कोई त्वरित कॉपी / पेस्ट चाहता है:

टिप्पणियाँ:

पलक 4 टिप्पणी गलत np.log पहले से ही एक प्राकृतिक लॉग है, कोई परिवर्तन की जरूरत है
पलकों 5 वीं उलटा के बारे में टिप्पणी सही है। नीचे दिए गए कोड में, आप MAXIMUM की तलाश कर रहे हैं - ध्यान रखें कि उदाहरण में नकारात्मक BIC नंबर हैं

कोड इस प्रकार है (फिर से, सभी क्रेडिट के लिए eyaler):

from sklearn import cluster
from scipy.spatial import distance
import sklearn.datasets
from sklearn.preprocessing import StandardScaler
import numpy as np

def compute_bic(kmeans,X):
    """
    Computes the BIC metric for a given clusters

    Parameters:
    -----------------------------------------
    kmeans:  List of clustering object from scikit learn

    X     :  multidimension np array of data points

    Returns:
    -----------------------------------------
    BIC value
    """
    # assign centers and labels
    centers = [kmeans.cluster_centers_]
    labels  = kmeans.labels_
    #number of clusters
    m = kmeans.n_clusters
    # size of the clusters
    n = np.bincount(labels)
    #size of data set
    N, d = X.shape

    #compute variance for all clusters beforehand
    cl_var = (1.0 / (N - m) / d) * sum([sum(distance.cdist(X[np.where(labels == i)], [centers[0][i]], 
             'euclidean')**2) for i in range(m)])

    const_term = 0.5 * m * np.log(N) * (d+1)

    BIC = np.sum([n[i] * np.log(n[i]) -
               n[i] * np.log(N) -
             ((n[i] * d) / 2) * np.log(2*np.pi*cl_var) -
             ((n[i] - 1) * d/ 2) for i in range(m)]) - const_term

    return(BIC)



# IRIS DATA
iris = sklearn.datasets.load_iris()
X = iris.data[:, :4]  # extract only the features
#Xs = StandardScaler().fit_transform(X)
Y = iris.target

ks = range(1,10)

# run 9 times kmeans and save each result in the KMeans object
KMeans = [cluster.KMeans(n_clusters = i, init="k-means++").fit(X) for i in ks]

# now run for each cluster the BIC computation
BIC = [compute_bic(kmeansi,X) for kmeansi in KMeans]

print BIC

— प्रभात नानीसत्ती
स्रोत

Github.com/bobhancock/goxmeans/blob/master/doc/BIC_notes.pdf को देखते हुए क्या आप बता सकते हैं कि यह BIC फॉर्मूला MAXIMUM के लिए कैसे अनुकूल है? क्या आप न्यूनतम के लिए दिखा सकते हैं और समझा सकते हैं कि यह मौखिक भाषा में क्या करता है? सूत्र की व्याख्या करना मुश्किल लग रहा है

— user305883

Pl मेरे संबंधित प्रश्न को यहां देखें: आंकड़े

— rnso

सूत्र में एक बग प्रतीत होता है। क्या कोई इसे ठीक करने में कामयाब रहा है?

— एसटीजीएमए