K- साधन क्लस्टरिंग का उपयोग करते समय मैं कैसे निर्धारित करूं?

Question

मैं k- साधन क्लस्टरिंग के बारे में अध्ययन कर रहा हूं , और एक बात जो स्पष्ट नहीं है कि आप k का मूल्य कैसे चुनते हैं। क्या यह सिर्फ परीक्षण और त्रुटि का मामला है, या इसके लिए और भी बहुत कुछ है?

Comments

आह आह ... यह वास्तव में सवाल है (के-मीन के बारे में)।

— एमजेवी

क्या आप फ़ंक्शन L (लॉग संभावना) के लिए कोड साझा कर सकते हैं? X, Y और बिंदुओं पर केंद्र (x (i = 1,2,3,4, ..., n), y (i = 1,2,3,4, .., n)), कैसे क्या मुझे एल मिलता है?

इस विषय पर विकिपीडिया लेख का लिंक: en.wikipedia.org/wiki/…

— Amro

मैंने Rयहाँ पर आधा दर्जन तरीकों (उपयोग करके ) के साथ समान Q का उत्तर दिया है: stackoverflow.com/a/15376462/1036500

— Ben

Answer 1

आप बायेसियन सूचना मानदंड (BIC) को अधिकतम कर सकते हैं:

BIC(C | X) = L(X | C) - (p / 2) * log n

जहां L(X | C)डेटासेट के लॉग-संभावना है Xमॉडल के अनुसार C, pमॉडल में पैरामीटर की संख्या है C, और nडेटासेट में अंकों की संख्या है। देखें "एक्स-साधन: विस्तार कश्मीर समूहों की संख्या के कुशल आकलन के साथ -means" आईसीएमएल 2000 में दान Pelleg और एंड्रयू मूर द्वारा।

एक अन्य दृष्टिकोण यह है कि इसके लिए एक बड़े मूल्य के साथ शुरुआत करें kऔर सेंट्रोइड्स को हटाते रहें (कश्मीर को कम करें) जब तक कि यह विवरण लंबाई को कम नहीं करता है। हॉर्स्ट बिस्चोफ , एलेस लियोनार्डिस, और अलेक्जेंडर सेलब द्वारा पैटर्न विश्लेषण और अनुप्रयोग खंड में "मजबूत वेक्टर मात्रा के लिए एमडीएल सिद्धांत" देखें । 2, पी। 59-72, 1999।

अंत में, आप एक क्लस्टर के साथ शुरू कर सकते हैं, फिर बंटवारे समूहों को तब तक रख सकते हैं जब तक कि प्रत्येक क्लस्टर को दिए गए बिंदुओं में गौसियन वितरण न हो। में "लर्निंग कश्मीर में कश्मीर -means" (nips 2003), ग्रेग Hamerly और चार्ल्स Elkan कुछ सबूत है कि यह काम करता है बीआईसी की तुलना में बेहतर है, और उस बीआईसी दृढ़ता से पर्याप्त मॉडल की जटिलता को दंडित नहीं करता दिखा।

Comments

बहुत बढ़िया जवाब! एक्स-मीन्स के लिए, क्या आप जानते हैं कि कुल मिलाकर BIC स्कोर n: = k * 2 (k क्लस्टर्स, प्रत्येक क्लस्टर जो गौसियन द्वारा माध्य / विचरण मापदंडों के साथ बनाया गया है)। यदि आप "पैरेंट" BIC> "2 बच्चे" BIC का निर्धारण करते हैं, तो क्या आप उस क्लस्टर को अगले पुनरावृत्ति में विभाजित करेंगे?

— बुड्रिक

@ न्यूड्रिक, ये शायद अलग प्रश्न होने चाहिए, और शायद आँकड़े.स्टैकएक्सचेंज.कॉम पर।

— वेबजर्न लोजोसा

Answer 2

मूल रूप से, आप दो चर के बीच एक संतुलन खोजना चाहते हैं: समूहों की संख्या ( k ) और समूहों का औसत विचरण। आप बाद को छोटा करते हुए पूर्व को कम से कम करना चाहते हैं। बेशक, जैसे ही गुच्छों की संख्या बढ़ती है, औसत विचरण कम हो जाता है ( k = n और भिन्नता = 0 के तुच्छ मामले तक )।

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

Answer 3

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

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

यहाँ `मैंने क्या किया।

#Dataset for Clustering
n = 150
g = 6 
set.seed(g)
d <- data.frame(x = unlist(lapply(1:g, function(i) rnorm(n/g, runif(1)*i^2))), 
                y = unlist(lapply(1:g, function(i) rnorm(n/g, runif(1)*i^2))))
mydata<-d
#Plot 3X2 plots
attach(mtcars)
par(mfrow=c(3,2))

#Plot the original dataset
plot(mydata$x,mydata$y,main="Original Dataset")

#Scree plot to deterine the number of clusters
wss <- (nrow(mydata)-1)*sum(apply(mydata,2,var))
  for (i in 2:15) {
    wss[i] <- sum(kmeans(mydata,centers=i)$withinss)
}   
plot(1:15, wss, type="b", xlab="Number of Clusters",ylab="Within groups sum of squares")

# Ward Hierarchical Clustering
d <- dist(mydata, method = "euclidean") # distance matrix
fit <- hclust(d, method="ward") 
plot(fit) # display dendogram
groups <- cutree(fit, k=5) # cut tree into 5 clusters
# draw dendogram with red borders around the 5 clusters 
rect.hclust(fit, k=5, border="red")

#Silhouette analysis for determining the number of clusters
library(fpc)
asw <- numeric(20)
for (k in 2:20)
  asw[[k]] <- pam(mydata, k) $ silinfo $ avg.width
k.best <- which.max(asw)

cat("silhouette-optimal number of clusters:", k.best, "\n")
plot(pam(d, k.best))

# K-Means Cluster Analysis
fit <- kmeans(mydata,k.best)
mydata 
# get cluster means 
aggregate(mydata,by=list(fit$cluster),FUN=mean)
# append cluster assignment
mydata <- data.frame(mydata, clusterid=fit$cluster)
plot(mydata$x,mydata$y, col = fit$cluster, main="K-means Clustering results")

आशा करता हूँ की ये काम करेगा!!

Comments

अजगर उपयोगकर्ताओं के लिए बस सिल्हूट विश्लेषण ट्यूटोरियल में जोड़ने के लिए scikit-learn.org/stable/auto_examples/cluster/…

— चैतन्य शिवडे

Answer 4

हो सकता है कि कोई मेरे जैसा कोड उदाहरण की तलाश में शुरुआत करे। सिल्हूट_कोर के लिए जानकारी यहाँ उपलब्ध है।

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

range_n_clusters = [2, 3, 4]            # clusters range you want to select
dataToFit = [[12,23],[112,46],[45,23]]  # sample data
best_clusters = 0                       # best cluster number which you will get
previous_silh_avg = 0.0

for n_clusters in range_n_clusters:
    clusterer = KMeans(n_clusters=n_clusters)
    cluster_labels = clusterer.fit_predict(dataToFit)
    silhouette_avg = silhouette_score(dataToFit, cluster_labels)
    if silhouette_avg > previous_silh_avg:
        previous_silh_avg = silhouette_avg
        best_clusters = n_clusters

# Final Kmeans for best_clusters
kmeans = KMeans(n_clusters=best_clusters, random_state=0).fit(dataToFit)

Answer 5

ग्रेग हैमरली, चार्ल्स एलकान द्वारा "काग-का-लर्निंग द के" में इस पेपर को देखें। यह समूहों की सही संख्या निर्धारित करने के लिए एक गाऊसी परीक्षण का उपयोग करता है। साथ ही, लेखकों का दावा है कि यह विधि BIC से बेहतर है जिसका उल्लेख स्वीकृत उत्तर में किया गया है।

Answer 6

रूम ऑफ थम्ब नाम की कोई चीज होती है। यह कहता है कि समूहों की संख्या की गणना किसके द्वारा की जा सकती है

k = (n/2)^0.5

जहाँ n आपके नमूने के तत्वों की कुल संख्या है। आप निम्नलिखित कागज पर इस जानकारी की सत्यता की जांच कर सकते हैं:

http://www.ijarcsms.com/docs/paper/volume1/issue6/V1I6-0015.pdf

G-mean नामक एक अन्य विधि भी है, जहाँ आपका वितरण एक Gaussian वितरण या सामान्य वितरण का अनुसरण करता है। यह तब तक बढ़ता है जब तक कि आपके सभी k समूह एक गाऊसी वितरण का अनुसरण नहीं करते हैं। इसके लिए बहुत सारे आँकड़ों की आवश्यकता होती है लेकिन किया जा सकता है। यहाँ स्रोत है:

http://papers.nips.cc/paper/2526-learning-the-k-in-k-means.pdf

आशा है कि ये आपकी मदद करेगा!

Answer 7

सबसे पहले अपने डेटा के न्यूनतम फैले हुए पेड़ का निर्माण करें। K-1 सबसे महंगे किनारों को हटाने से पेड़ K समूहों में विभाजित हो जाता है,
इसलिए आप MST का निर्माण एक बार कर सकते हैं, विभिन्न K के लिए क्लस्टर स्पेसिंग / मेट्रिक्स को देख सकते हैं, और वक्र को मोड़ सकते हैं।

यह केवल Single-linkage_clustering के लिए काम करता है , लेकिन इसके लिए यह तेज़ और आसान है। साथ ही, एमएसटी अच्छे दृश्य बनाते हैं।
उदाहरण के लिए क्लस्टरिंग के लिए आँकड़े.स्टैकएक्सचेंज विज़ुअलाइज़ेशन सॉफ़्टवेयर के तहत एमएसटी प्लॉट देखें ।

Answer 8

मुझे आश्चर्य है कि किसी ने भी इस उत्कृष्ट लेख का उल्लेख नहीं किया है: http://www.ee.columbia.edu/~dpwe/papers/PhamDN05-kmeans.pdf

कई अन्य सुझावों के बाद मैं इस ब्लॉग को पढ़ते हुए आखिरकार इस लेख पर आया: https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/

उसके बाद मैंने इसे स्काला में लागू किया, एक कार्यान्वयन जो मेरे उपयोग के मामलों के लिए वास्तव में अच्छे परिणाम प्रदान करता है। यहाँ कोड है:

import breeze.linalg.DenseVector
import Kmeans.{Features, _}
import nak.cluster.{Kmeans => NakKmeans}

import scala.collection.immutable.IndexedSeq
import scala.collection.mutable.ListBuffer

/*
https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/
 */
class Kmeans(features: Features) {
  def fkAlphaDispersionCentroids(k: Int, dispersionOfKMinus1: Double = 0d, alphaOfKMinus1: Double = 1d): (Double, Double, Double, Features) = {
    if (1 == k || 0d == dispersionOfKMinus1) (1d, 1d, 1d, Vector.empty)
    else {
      val featureDimensions = features.headOption.map(_.size).getOrElse(1)
      val (dispersion, centroids: Features) = new NakKmeans[DenseVector[Double]](features).run(k)
      val alpha =
        if (2 == k) 1d - 3d / (4d * featureDimensions)
        else alphaOfKMinus1 + (1d - alphaOfKMinus1) / 6d
      val fk = dispersion / (alpha * dispersionOfKMinus1)
      (fk, alpha, dispersion, centroids)
    }
  }

  def fks(maxK: Int = maxK): List[(Double, Double, Double, Features)] = {
    val fadcs = ListBuffer[(Double, Double, Double, Features)](fkAlphaDispersionCentroids(1))
    var k = 2
    while (k <= maxK) {
      val (fk, alpha, dispersion, features) = fadcs(k - 2)
      fadcs += fkAlphaDispersionCentroids(k, dispersion, alpha)
      k += 1
    }
    fadcs.toList
  }

  def detK: (Double, Features) = {
    val vals = fks().minBy(_._1)
    (vals._3, vals._4)
  }
}

object Kmeans {
  val maxK = 10
  type Features = IndexedSeq[DenseVector[Double]]
}

Comments

स्कैला 2.11.7 में हवा 0.12 और नाक 1.3

— एरिरलर

हाय @eirirlar मैं पायथन के साथ एक ही कोड लागू करने की कोशिश कर रहा हूं - लेकिन मैं वेबसाइट में कोड का पालन नहीं कर सकता। मेरी पोस्ट देखें: stackoverflow.com/questions/36729826/python-k-means-clustering

— piccolo

@ImranRashid क्षमा करें, मैंने केवल 2 आयामों के साथ परीक्षण किया है, और मैं पायथन विशेषज्ञ नहीं हूं।

— एरिरलार

Answer 9

यदि आप MATLAB, 2013b के बाद से किसी भी संस्करण का उपयोग करते हैं, तो आप यह evalclustersपता लगाने के लिए फ़ंक्शन का उपयोग कर सकते हैं कि kकिसी दिए गए डेटासेट के लिए इष्टतम क्या होना चाहिए ।

- यह समारोह आप 3 क्लस्टरिंग एल्गोरिदम के बीच में से चयन कर सकते हैं kmeans, linkageऔर gmdistribution।

- यह भी आप 4 क्लस्टरिंग मूल्यांकन मानदंडों के बीच में से चयन कर सकते हैं CalinskiHarabasz, DaviesBouldin, gapऔर silhouette।

Answer 10

यदि आप k- साधनों को पैरामीटर के रूप में प्रदान करने के लिए k समूहों की संख्या नहीं जानते हैं तो इसे स्वचालित रूप से खोजने के चार तरीके हैं:

• G-mean algortithm: यह एक k- साधन केंद्र को दो में विभाजित करने के लिए यह तय करने के लिए एक सांख्यिकीय परीक्षण का उपयोग करके स्वचालित रूप से क्लस्टर की संख्या को पता चलता है। यह एल्गोरिथ्म क्लस्टर की संख्या का पता लगाने के लिए एक पदानुक्रमित दृष्टिकोण लेता है, परिकल्पना के लिए एक सांख्यिकीय परीक्षण के आधार पर कि डेटा का एक सबसेट गॉसियन वितरण (निरंतर फ़ंक्शन जो घटनाओं के सटीक द्विपद वितरण का अनुमान लगाता है) का अनुसरण करता है, और यदि यह क्लस्टर को विभाजित नहीं करता है । यह छोटी संख्या में केंद्रों से शुरू होता है, केवल एक क्लस्टर (k = 1) कहते हैं, फिर एल्गोरिथ्म इसे दो केंद्रों (k = 2) में विभाजित करता है और इन दो केंद्रों में से प्रत्येक को फिर से विभाजित करता है (k = 4), जिसमें चार केंद्र होते हैं संपूर्ण। यदि जी-मतलब इन चार केंद्रों को स्वीकार नहीं करता है, तो इसका उत्तर पिछला चरण है: इस मामले में दो केंद्र (के = 2)। यह आपके डेटासेट को विभाजित करने वाले क्लस्टर की संख्या है। जी-साधन बहुत उपयोगी है, जब आपके पास अपने उदाहरणों को समूहीकृत करने के बाद आपको मिलने वाले समूहों की संख्या का अनुमान नहीं होता है। ध्यान दें कि "के" पैरामीटर के लिए एक असुविधाजनक विकल्प आपको गलत परिणाम दे सकता है। जी-साधनों के समानांतर संस्करण को कहा जाता हैp- साधन । जी-मतलब स्रोत: स्रोत 1 स्रोत 2 स्रोत 3

• x- साधन : एक नया एल्गोरिथ्म जो कुशलता से, बाइसियन सूचना मानदंड (बीआईसी) या एकेइक सूचना मानदंड (एआईसी) उपाय को अनुकूलित करने के लिए क्लस्टर स्थानों और समूहों की संख्या की खोज करता है। K- साधनों के इस संस्करण में संख्या k का पता चलता है और k- साधनों को गति भी देता है।

• ऑनलाइन k- साधन या स्ट्रीमिंग k- साधन: यह पूरे डेटा को एक बार स्कैन करके k- साधनों को निष्पादित करने की अनुमति देता है और यह कश्मीर की इष्टतम संख्या को स्वचालित रूप से पाता है। स्पार्क इसे लागू करता है।

• मीन्सशिफ्ट एल्गोरिथ्म : यह एक नॉनपेर्मेट्रिक क्लस्टरिंग तकनीक है, जिसमें क्लस्टर की संख्या के पूर्व ज्ञान की आवश्यकता नहीं होती है और यह क्लस्टर के आकार को बाधित नहीं करता है। मीनिंग शिफ्ट क्लस्टरिंग का उद्देश्य सैंपल के सघन घनत्व में "ब्लब्स" की खोज करना है। यह एक सेंट्रोइड-आधारित एल्गोरिथ्म है, जो सेंट्रोइड्स के लिए उम्मीदवारों को अपडेट करके एक दिए गए क्षेत्र के भीतर बिंदुओं का मतलब है। इन उम्मीदवारों को तब पोस्ट-प्रोसेसिंग चरण में फ़िल्टर किया जाता है ताकि सेंट्रोइड्स के अंतिम सेट को बनाने के लिए लगभग डुप्लिकेट को समाप्त किया जा सके। स्रोत: source1 , source2 , source3

Answer 11

मैंने यहां पाए गए समाधान का उपयोग किया: http://efavdb.com/mean-shift/ और इसने मेरे लिए बहुत अच्छा काम किया:

import numpy as np
from sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.datasets.samples_generator import make_blobs
import matplotlib.pyplot as plt
from itertools import cycle
from PIL import Image

#%% Generate sample data
centers = [[1, 1], [-.75, -1], [1, -1], [-3, 2]]
X, _ = make_blobs(n_samples=10000, centers=centers, cluster_std=0.6)

#%% Compute clustering with MeanShift

# The bandwidth can be automatically estimated
bandwidth = estimate_bandwidth(X, quantile=.1,
                               n_samples=500)
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

n_clusters_ = labels.max()+1

#%% Plot result
plt.figure(1)
plt.clf()

colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk')
for k, col in zip(range(n_clusters_), colors):
    my_members = labels == k
    cluster_center = cluster_centers[k]
    plt.plot(X[my_members, 0], X[my_members, 1], col + '.')
    plt.plot(cluster_center[0], cluster_center[1],
             'o', markerfacecolor=col,
             markeredgecolor='k', markersize=14)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()

Answer 12

मेरा विचार इष्टतम क्लस्टर संख्या (K) को खोजने के लिए सिल्हूट गुणांक का उपयोग करना है। विवरण विवरण यहाँ है ।

Answer 13

यह मानते हुए कि आपके पास डेटा का एक मैट्रिक्स है DATA, आप इस तरह के समूहों (सिल्हूट विश्लेषण द्वारा) की संख्या के आकलन के साथ मेडोइड्स के आसपास विभाजन कर सकते हैं:

library(fpc)
maxk <- 20  # arbitrary here, you can set this to whatever you like
estimatedK <- pamk(dist(DATA), krange=1:maxk)$nc

Answer 14

इसका एक संभावित उत्तर है कि काया को खोजने के लिए जेनेटिक एलगोरिदम जैसे मेटा हेयोरिस्टिक एल्गोरिथम का उपयोग करना। यह आसान है। आप यादृच्छिक K (कुछ रेंज में) का उपयोग कर सकते हैं और सिल्हूट जैसे कुछ मापक के साथ जेनेटिक एल्गोरिदम के फिट फ़ंक्शन का मूल्यांकन कर सकते हैं और फिट फ़ंक्शन पर सर्वश्रेष्ठ K आधार का पता लगा सकते हैं।

https://en.wikipedia.org/wiki/Silhouette_(clustering)

Answer 15

km=[]
for i in range(num_data.shape[1]):
    kmeans = KMeans(n_clusters=ncluster[i])#we take number of cluster bandwidth theory
    ndata=num_data[[i]].dropna()
    ndata['labels']=kmeans.fit_predict(ndata.values)
    cluster=ndata
    co=cluster.groupby(['labels'])[cluster.columns[0]].count()#count for frequency
    me=cluster.groupby(['labels'])[cluster.columns[0]].median()#median
    ma=cluster.groupby(['labels'])[cluster.columns[0]].max()#Maximum
    mi=cluster.groupby(['labels'])[cluster.columns[0]].min()#Minimum
    stat=pd.concat([mi,ma,me,co],axis=1)#Add all column
    stat['variable']=stat.columns[1]#Column name change
    stat.columns=['Minimum','Maximum','Median','count','variable']
    l=[]
    for j in range(ncluster[i]):
        n=[mi.loc[j],ma.loc[j]] 
        l.append(n)

    stat['Class']=l
    stat=stat.sort(['Minimum'])
    stat=stat[['variable','Class','Minimum','Maximum','Median','count']]
    if missing_num.iloc[i]>0:
        stat.loc[ncluster[i]]=0
        if stat.iloc[ncluster[i],5]==0:
            stat.iloc[ncluster[i],5]=missing_num.iloc[i]
            stat.iloc[ncluster[i],0]=stat.iloc[0,0]
    stat['Percentage']=(stat[[5]])*100/count_row#Freq PERCENTAGE
    stat['Cumulative Percentage']=stat['Percentage'].cumsum()
    km.append(stat)
cluster=pd.concat(km,axis=0)## see documentation for more info
cluster=cluster.round({'Minimum': 2, 'Maximum': 2,'Median':2,'Percentage':2,'Cumulative Percentage':2})

Comments

आप डेटा और पुस्तकालय ऐड चयन करें और आप किमी = [] का प्रतिशत करने के लिए 'नकल: 2}) पिछले और अपने अजगर चलाने के लिए और देखने

— सुमित

ढेर अतिप्रवाह में आपका स्वागत है! हालाँकि यह कोड समस्या को हल करने में मदद कर सकता है, लेकिन यह इस बात की व्याख्या नहीं करता कि क्यों और / या यह कैसे उत्तर देता है। इस अतिरिक्त संदर्भ को प्रदान करने से इसके दीर्घकालिक शैक्षिक मूल्य में काफी सुधार होगा। कृपया स्पष्टीकरण जोड़ने के लिए अपने जवाब को संपादित करें, जिसमें सीमाएं और मान्यताएं शामिल हैं।

— टोबे स्पाइट

Answer 16

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

कागज का संदर्भ है

अब्देलाह अमीन एट अल।, क्लस्टरिंग तकनीक और एलआरएफएम मॉडल का उपयोग करके ई-कॉमर्स में ग्राहक सेगमेंटेशन मॉडल: मोरक्को में ऑनलाइन स्टोर का मामला, वर्ल्ड एकेडमी ऑफ साइंस, इंजीनियरिंग और टेक्नोलॉजी इंटरनेशनल जर्नल ऑफ कंप्यूटर और सूचना इंजीनियरिंग वॉल्यूम: 9, नंबर: 8 , 2015, 1999 - 2010

Answer 17

नमस्ते, मैं इसे सरल और स्पष्ट कर दूंगा, मुझे 'NbClust' लाइब्रेरी का उपयोग करके क्लस्टर निर्धारित करना पसंद है।

अब, समूहों की सही संख्या निर्धारित करने के लिए 'NbClust' फ़ंक्शन का उपयोग कैसे करें: आप वास्तविक डेटा और क्लस्टर के साथ जीथब में वास्तविक परियोजना की जांच कर सकते हैं - इस 'किमीमीटर' एल्गोरिथ्म का विस्तार भी 'केंद्रों' की सही संख्या का उपयोग करके किया।

Github प्रोजेक्ट लिंक: https://github.com/RutvijBhutaiya/Thailand-Customer-Engagement-Facebook

Comments

जीथब लिंक जोड़ने के बजाय, क्या आप कोड की कुछ मुख्य पंक्तियों को जोड़ सकते हैं जो दूसरों की मदद कर सकती हैं भले ही आपका कोड उपलब्ध न हो?

— Giulio Caccin

Answer 18

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

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

सबसे पहले, कश्मीर के कुछ मूल्यों (उदाहरण 2, 4, 6, 8, आदि) के लिए चुकता त्रुटि (एसएसई) की राशि की गणना करें। SSE को क्लस्टर के प्रत्येक सदस्य और उसके केन्द्रक के बीच वर्ग दूरी के योग के रूप में परिभाषित किया गया है। गणितीय:

SSE = ΣKi = 1Σx∈cidist (एक्स, ci) 2

यदि आप SSE के खिलाफ k प्लॉट करते हैं, तो आप देखेंगे कि k बड़ा हो जाने के कारण त्रुटि कम हो जाती है; इसका कारण यह है कि जब समूहों की संख्या बढ़ती है, तो उन्हें छोटा होना चाहिए, इसलिए विकृति भी छोटी होती है। कोहनी विधि का विचार उस कश्मीर को चुनना है जिस पर SSE अचानक घटता है। यह ग्राफ में एक "कोहनी प्रभाव" पैदा करता है, जैसा कि आप निम्नलिखित चित्र में देख सकते हैं:

इस मामले में, k = 6 वह मान है जिसे एल्बो विधि ने चुना है। ध्यान रखें कि कोहनी विधि एक हेयुरिस्टिक है और, जैसे, यह आपके विशेष मामले में अच्छी तरह से काम कर सकती है या नहीं। कभी-कभी, एक से अधिक कोहनी, या बिल्कुल भी कोहनी नहीं होती है। उन स्थितियों में आप आमतौर पर सबसे अच्छा कश्मीर की गणना करके समाप्त करते हैं कि आप जिस विशेष क्लस्टरिंग समस्या को हल करने का प्रयास कर रहे हैं उसके संदर्भ में कितनी अच्छी तरह से k- साधन करता है।

Answer 19

मैंने पायथन पैकेज निड (नीडल एल्गोरिथम) पर काम किया। यह क्लस्टर नंबर को गतिशील रूप से उस बिंदु के रूप में पाता है, जहां वक्र समतल होना शुरू हो जाता है..जिसमें x और y मानों का एक सेट होता है, kneed फ़ंक्शन के घुटने बिंदु को वापस कर देगा। घुटने का बिंदु अधिकतम वक्रता का बिंदु है। यह नमूना कोड है।

y = [7342.1301373073857, 6881.7109460930769, 6531.1657905495022,
6356.2255554679778, 6209.8382535595829, 6094.9052166741121, 5980.0191582610196, 5880.1869867848218, 5779.8957906367368, 5691.1879324562778, 5617.5153566271356, 5532.2613232619951, ५,४६७.३५२२६५३७५११७, 5395.4493783888756, 5345.3459908298091, 5290.6769823693812, 5243.5271656371888, 5207.2501206569532, 5164.9617535255456]

x = श्रेणी (1, len (y) +1)

kneed आयात से KneeLocator kn = KneeLocator (x, y, वक्र = 'उत्तल', दिशा = 'घटती')

प्रिंट (kn.knee)

Comments

कृपया अपने उत्तर में कुछ स्पष्टीकरण जोड़ें, ताकि अन्य लोग इससे सीख सकें

— निको हसे