blocks|key|1397924|text|首先，构建数据的minimum+spanning+tree。移除K-1条最昂贵的边会将树分割成K个簇，|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1397925|因此，您可以构建MST一次，查看各种K的集群间距/指标，并采取曲线的膝盖。|1397926|这只适用于Single-linkage_clustering，但就这一点而言，它又快又简单。另外，MST可以提供很好的视觉效果。|1397927|例如，请参阅stats.stackexchange+visualization+software+for+clustering下的MST图。|1397928|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Minimum_spanning_tree|1|http://en.wikipedia.org/wiki/Single-linkage_clustering|2|https://stats.stackexchange.com/questions/1475/visualization-software-for-clustering^0|8|L|0|0|0|5|P|1|0|6|1L|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]|T|$5|M|N|O|C|$P|U]]]]

First build a <a href="http://en.wikipedia.org/wiki/Minimum_spanning_tree" rel="nofollow noreferrer">minimum spanning tree</a> of your data.
Removing the K-1 most expensive edges splits the tree into K clusters, 
so you can build the MST once, look at cluster spacings / metrics for various K,
and take the knee of the curve. 

This works only for <a href="http://en.wikipedia.org/wiki/Single-linkage_clustering" rel="nofollow noreferrer">Single-linkage_clustering</a>,
but for that it's fast and easy. Plus, MSTs make good visuals. 
See for example the MST plot under
<a href="https://stats.stackexchange.com/questions/1475/visualization-software-for-clustering">stats.stackexchange visualization software for clustering</a>.

blocks|key|1397972|text|看看这篇论文，“学习k-means中的k”，作者是格雷格·哈姆利，查尔斯·埃尔坎。它使用高斯测试来确定正确的集群数量。此外，作者还声称，这种方法比公认的答案中提到的BIC更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1397973|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Look at <a href="http://books.nips.cc/papers/files/nips16/NIPS2003_AA36.pdf" rel="noreferrer">this</a> paper, "Learning the k in k-means" by Greg Hamerly, Charles Elkan. It uses a Gaussian test to determine the right number of clusters. Also, the authors claim that this method is better than BIC which is mentioned in the accepted answer.

blocks|key|1398093|text|是的，你可以使用弯头方法找到最佳聚类数，但我发现使用脚本从弯头图中找到聚类值是很麻烦的。您可以观察弯头图形并自己找到弯头点，但要从脚本中找到它需要大量的工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1398094|因此，另一个选择是使用Silhouette+Method来查找它。由轮廓得到的结果与R。|offset|length|1398095|我就是这么做的。|1398096|#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%5E2))),+
++++++++++++++++y+=+unlist(lapply(1:g,+function(i)+rnorm(n/g,+runif(1)*i%5E2))))
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")|code-block|syntax|javascript|1398097|希望它能有所帮助！！|1398098|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Determining_the_number_of_clusters_in_a_data_set^0|0|B|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Yes, you can find the best number of clusters using Elbow method, but I found it troublesome to find the value of clusters from elbow graph using script. You can observe the elbow graph and find the elbow point yourself, but it was lot of work finding it from script.

So another option is to use <a href="http://en.wikipedia.org/wiki/Determining_the_number_of_clusters_in_a_data_set">Silhouette Method</a> to find it. The result from Silhouette completely comply with result from Elbow method in R. 

Here`s what I did.

<pre><code>#Dataset for Clustering
n = 150
g = 6 
set.seed(g)
d &lt;- 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&lt;-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 &lt;- (nrow(mydata)-1)*sum(apply(mydata,2,var))
 for (i in 2:15) {
 wss[i] &lt;- 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 &lt;- dist(mydata, method = "euclidean") # distance matrix
fit &lt;- hclust(d, method="ward") 
plot(fit) # display dendogram
groups &lt;- 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 &lt;- numeric(20)
for (k in 2:20)
 asw[[k]] &lt;- pam(mydata, k) $ silinfo $ avg.width
k.best &lt;- which.max(asw)

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

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

Hope it helps!!

blocks|key|1398154|text|我的想法是使用Silhouette+Coefficient来找到最优的簇数(K)。详情解释为here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1398155|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Silhouette_(clustering)|1|https://stats.stackexchange.com/questions/10540/how-to-interpret-mean-of-silhouette-plot^0|7|M|0|1A|4|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

My idea is to use <a href="http://en.wikipedia.org/wiki/Silhouette_(clustering)" rel="nofollow noreferrer">Silhouette Coefficient</a> to find the optimal cluster number(K). Details explanation is <a href="https://stats.stackexchange.com/questions/10540/how-to-interpret-mean-of-silhouette-plot">here</a>.

blocks|key|1398208|text|有一种叫做经验法则的东西。它说集群的数量可以通过以下公式计算|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1398209|k+=+(n/2)%5E0.5|offset|length|style|CODE|1398210|其中n是样本中元素的总数。您可以在以下纸张上检查此信息的真实性：|1398211|http://www.ijarcsms.com/docs/paper/volume1/issue6/V1I6-0015.pdf|1398212|还有另一种称为G均值的方法，其中你的分布遵循高斯分布或正态分布。它包括递增k，直到所有k组都遵循高斯分布。这需要大量的统计数据，但这是可以做到的。以下是源代码：|1398213|http://papers.nips.cc/paper/2526-learning-the-k-in-k-means.pdf|1398214|我希望这能帮到你!|1398215|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|0|D|0|0|0|1R|0|0|0|0|1Q|1|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|K]]|Y|$5|U|V|W|A|$X|O]]]]

There is something called Rule of Thumb. It says that the number of clusters can be calculated by 

<code>k = (n/2)^0.5</code>

where n is the total number of elements from your sample.
You can check the veracity of this information on the following paper:

<a href="http://www.ijarcsms.com/docs/paper/volume1/issue6/V1I6-0015.pdf" rel="nofollow noreferrer">http://www.ijarcsms.com/docs/paper/volume1/issue6/V1I6-0015.pdf</a>

There is also another method called G-means, where your distribution follows a Gaussian Distribution or Normal Distribution.
It consists of increasing k until all your k groups follow a Gaussian Distribution.
It requires a lot of statistics but can be done.
Here is the source:

<a href="http://papers.nips.cc/paper/2526-learning-the-k-in-k-means.pdf" rel="nofollow noreferrer">http://papers.nips.cc/paper/2526-learning-the-k-in-k-means.pdf</a>

I hope this helps!

blocks|key|1398258|text|假设您有一个名为DATA的数据矩阵，您可以使用聚类数估计(通过轮廓分析)围绕medoids执行分区，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1398259|library(fpc)
maxk+<-+20++#+arbitrary+here,+you+can+set+this+to+whatever+you+like
estimatedK+<-+pamk(dist(DATA),+krange=1:maxk)$nc|code-block|syntax|javascript|1398260|entityMap^0|8|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Assuming you have a matrix of data called <code>DATA</code>, you can perform partitioning around medoids with estimation of number of clusters (by silhouette analysis) like this:

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

blocks|key|1182891|text|我很惊讶没有人提到这篇优秀的文章：http://www.ee.columbia.edu/~dpwe/papers/PhamDN05-kmeans.pdf|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1182892|在遵循了其他几个建议之后，我终于在阅读这篇博客时看到了这篇文章：https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/|1182893|在那之后，我在Scala中实现了它，对于我的用例来说，这个实现提供了非常好的结果。代码如下：|1182894|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+%7C%7C+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+%2B+(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+%2B=+fkAlphaDispersionCentroids(k,+dispersion,+alpha)
++++++k+%2B=+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]]
}|code-block|syntax|javascript|1182895|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ee.columbia.edu/~dpwe/papers/PhamDN05-kmeans.pdf|1|https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/^0|H|1N|0|0|W|2M|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

I'm surprised nobody has mentioned this excellent article:
<a href="http://www.ee.columbia.edu/~dpwe/papers/PhamDN05-kmeans.pdf" rel="nofollow">http://www.ee.columbia.edu/~dpwe/papers/PhamDN05-kmeans.pdf</a>

After following several other suggestions I finally came across this article while reading this blog:
<a href="https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/" rel="nofollow">https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/</a>

After that I implemented it in Scala, an implementation which for my use cases provide really good results. Here's code:

<pre><code>import breeze.linalg.DenseVector
import Kmeans.{Features, _}
import nak.cluster.{Kmeans =&gt; 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 &lt;= 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]]
}
</code></pre>

blocks|key|1398332|text|如果你使用MATLAB，那么自2013b以来的任何版本，你都可以使用evalclusters函数来找出对于给定的数据集，最优k应该是什么。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1398333|此功能可让您从3种聚类算法-+kmeans、linkage和gmdistribution中进行选择。|1398334|它还允许您从4个集群评估标准中进行选择-+CalinskiHarabasz、DaviesBouldin、gap和silhouette。|1398335|entityMap^0|Y|C|1Q|1|0|F|6|M|7|U|E|0|L|G|12|D|1G|3|1K|A|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|K|$]]

If you use MATLAB, any version since 2013b that is, you can make use of the function <code>evalclusters</code> to find out what should the optimal <code>k</code> be for a given dataset. 

This function lets you choose from among 3 clustering algorithms - <code>kmeans</code>, <code>linkage</code> and <code>gmdistribution</code>.

It also lets you choose from among 4 clustering evaluation criteria - <code>CalinskiHarabasz</code>, <code>DaviesBouldin</code>, <code>gap</code> and <code>silhouette</code>.

blocks|key|1398357|text|一种可能的答案是使用元启发式算法，比如遗传算法来寻找k，这很简单。你可以使用随机K(在一定范围内)，用轮廓等度量来评估遗传算法的拟合函数，并在拟合函数的基础上找到最佳K。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1398358|https://en.wikipedia.org/wiki/Silhouette_(clustering)|offset|length|1398359|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

One possible answer is to use Meta Heuristic Algorithm like Genetic Algorithm to find k.
That's simple. you can use random K(in some range) and evaluate the fit function of Genetic Algorithm with some measurment like Silhouette
And Find best K base on fit function.

<a href="https://en.wikipedia.org/wiki/Silhouette_(clustering)" rel="nofollow">https://en.wikipedia.org/wiki/Silhouette_(clustering)</a>

blocks|key|1182955|text|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})|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1182956|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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]&gt;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})
</code></pre>

blocks|key|1183010|text|我使用了我在这里找到的解决方案：http://efavdb.com/mean-shift/，它对我非常有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1183011|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

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

#%25%25+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()%2B1

#%25%25+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+%2B+'.')
++++plt.plot(cluster_center[0],+cluster_center[1],
+++++++++++++'o',+markerfacecolor=col,
+++++++++++++markeredgecolor='k',+markersize=14)
plt.title('Estimated+number+of+clusters:+%25d'+%25+n_clusters_)
plt.show()|code-block|syntax|javascript|1183012|​|1183013|📷|atomic|1183014|1183015|entityMap|0|LINK|mutability|MUTABLE|url|http://efavdb.com/mean-shift/|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/bfc40f4ab20a11fbd565d1bd8f661a06.png|imageAlt^0|G|T|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|N|3|J|5|6|7|1C|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|X|S|Y|C|$Z|10|11|-4]]]]

I used the solution I found here : <a href="http://efavdb.com/mean-shift/" rel="nofollow noreferrer">http://efavdb.com/mean-shift/</a> and it worked very well for me : 

<pre class="lang-python prettyprint-override"><code>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()
</code></pre>

<a href="https://i.stack.imgur.com/euIyv.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/euIyv.png" alt="enter image description here"></a>

blocks|key|1183060|text|嗨，我会让它变得简单明了，我喜欢使用'NbClust‘库来确定集群。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1183061|现在，如何使用'NbClust‘函数来确定正确的集群数量:您可以使用实际数据和集群检查Github中的实际项目--对此'kmeans’算法的扩展也使用了正确数量的‘中心’。|1183062|Github项目链接：https://github.com/RutvijBhutaiya/Thailand-Customer-Engagement-Facebook|offset|length|1183063|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/RutvijBhutaiya/Thailand-Customer-Engagement-Facebook^0|0|0|B|1Z|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Hi I'll make it simple and straight to explain, I like to determine clusters using 'NbClust' library. 

Now, how to use the 'NbClust' function to determine the right number of clusters: You can check the actual project in Github with actual data and clusters - Extention to this 'kmeans' algorithm also performed using the right number of 'centers'. 

Github Project Link: <a href="https://github.com/RutvijBhutaiya/Thailand-Customer-Engagement-Facebook" rel="nofollow noreferrer">https://github.com/RutvijBhutaiya/Thailand-Customer-Engagement-Facebook</a>

blocks|key|1183146|text|您可以通过直观地检查您的数据点来选择聚类的数量，但您很快就会意识到，除了最简单的数据集之外，这个过程对所有人都有很多不明确之处。这并不总是糟糕的，因为您正在进行无监督学习，并且在标记过程中存在一些固有的主观性。在这里，以前处理该特定问题或类似问题的经验将帮助您选择正确的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1183147|如果需要有关应使用的簇数的一些提示，可以应用Elbow方法：|1183148|首先，计算一些k值(例如2、4、6、8等)的平方误差和(SSE)。SSE被定义为集群的每个成员与其质心之间距离的平方和。数学上：|1183149|SSE=∑Ki=1∑x∈cidist(x，ci)2|1183150|如果您绘制k与SSE的关系图，您将看到误差随着k的增大而减小；这是因为当簇的数量增加时，它们应该会更小，因此失真也会更小。弯曲法的思想是选择上证综指突然下降的k。这会在图表中产生“肘部效果”，如下图所示：|1183151|​|1183152|📷|atomic|offset|length|1183153|1183154|在本例中，k=6是弯头方法选择的值。考虑到弯头方法是一种启发式方法，因此，它在您的特定情况下可能工作得也可能不好。有时，有多个肘部，或者根本没有肘部。在这些情况下，您通常会通过评估k-means在您试图解决的特定集群问题的上下文中的执行情况来计算最佳k。|1183155|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/8f7093138ec8f086d24b0df43db50356.jpeg|imageAlt^0|0|0|0|0|0|0|0|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|18|8|@]|9|@$O|19|P|1A|1|1B]]|A|$]]|$1|Q|3|K|5|6|7|1C|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1D|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10|11|-4]]]]

You can choose the number of clusters by visually inspecting your data points, but you will soon realize that there is a lot of ambiguity in this process for all except the simplest data sets. This is not always bad, because you are doing unsupervised learning and there's some inherent subjectivity in the labeling process. Here, having previous experience with that particular problem or something similar will help you choose the right value.

If you want some hint about the number of clusters that you should use, you can apply the Elbow method:

First of all, compute the sum of squared error (SSE) for some values of k (for example 2, 4, 6, 8, etc.). The SSE is defined as the sum of the squared distance between each member of the cluster and its centroid. Mathematically:

SSE=∑Ki=1∑x∈cidist(x,ci)2 

If you plot k against the SSE, you will see that the error decreases as k gets larger; this is because when the number of clusters increases, they should be smaller, so distortion is also smaller. The idea of the elbow method is to choose the k at which the SSE decreases abruptly. This produces an "elbow effect" in the graph, as you can see in the following picture:

<a href="https://i.stack.imgur.com/WLIKx.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/WLIKx.jpg" alt="enter image description here"></a>

In this case, k=6 is the value that the Elbow method has selected. Take into account that the Elbow method is an heuristic and, as such, it may or may not work well in your particular case. Sometimes, there are more than one elbow, or no elbow at all. In those situations you usually end up calculating the best k by evaluating how well k-means performs in the context of the particular clustering problem you are trying to solve.

blocks|key|1398628|text|我开发了一个Python包Kneedle(+kneed算法)。它动态地查找簇编号，作为曲线开始变平的点。给定一组x和y值，knee将返回函数的拐点。膝关节是曲率最大的点。以下是示例代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1398629|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,+
5467.352265375117,+5395.4493783888756,+5345.3459908298091,+
5290.6769823693812,+5243.5271656371888,+5207.2501206569532,+
5164.9617535255456]

x+=+range(1,+len(y)%2B1)

from+kneed+import+KneeLocator
kn+=+KneeLocator(x,+y,+curve='convex',+direction='decreasing')

print(kn.knee)|code-block|syntax|javascript|1398630|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I worked on a Python package kneed (Kneedle algorithm). It finds cluster numbers dynamically as the point where the curve starts to flatten. Given a set of x and y values, kneed will return the knee point of the function. The knee joint is the point of maximum curvature. Here is the sample code.
<pre class="lang-py prettyprint-override"><code>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, 
5467.352265375117, 5395.4493783888756, 5345.3459908298091, 
5290.6769823693812, 5243.5271656371888, 5207.2501206569532, 
5164.9617535255456]

x = range(1, len(y)+1)

from kneed import KneeLocator
kn = KneeLocator(x, y, curve='convex', direction='decreasing')

print(kn.knee)
</code></pre>

I've been studying about <a href="http://en.wikipedia.org/wiki/K-means_clustering" rel="noreferrer">k-means clustering</a>, and one thing that's not clear is how you choose the value of k. Is it just a matter of trial and error, or is there more to it?

How do I determine k when using k-means clustering?

Python

我一直在研究，有一件事是不清楚的，那就是如何选择k的值。这只是一个试错的问题，还是还有更多的问题？

问在使用k-means聚类时，如何确定k？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在使用k-means聚类时，如何确定k？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在使用k-means聚类时，如何确定k？
EN