KMeans(n_clusters, init, n_init, max_iter, tol,
precompute_distances, verbose, random_state, copy_x, n_jobs, algorithm)
KMeans类的主要参数有：
1) n_clusters: 即我们的k值，一般需要多试一些值以获得较好的聚类效果。k值好坏的评估标准在下面会讲。
2）max_iter： 最大的迭代次数，一般如果是凸数据集的话可以不管这个值，如果数据集不是凸的，可能很难收敛，此时可以指定最大的迭代次数让算法可以及时退出循环。
3）n_init：用不同的初始化质心运行算法的次数。由于K-Means是结果受初始值影响的局部最优的迭代算法，因此需要多跑几次以选择一个较好的聚类效果，默认是10，一般不需要改。如果你的k值较大，则可以适当增大这个值。
4）init： 即初始值选择的方式，可以为完全随机选择‘random‘,优化过的‘k-means++‘或者自己指定初始化的k个质心。一般建议使用默认的‘k-means++‘。
5）algorithm：有“auto”, “full” or “elkan”三种选择。"full"就是我们传统的K-Means算法， “elkan”是我们原理篇讲的elkan K-Means算法。默认的"auto"则会根据数据值是否是稀疏的，来决定如何选择"full"和“elkan”。一般数据是稠密的，那么就是 “elkan”，否则就是"full"。一般来说建议直接用默认的"auto"
适用于大数据集的MiniBatchKMeans 算法：
MiniBatchKMeans类的主要参数比KMeans类稍多，主要有：
1) n_clusters: 即我们的k值，和KMeans类的n_clusters意义一样。
2）max_iter：最大的迭代次数， 和KMeans类的max_iter意义一样。
3）n_init：用不同的初始化质心运行算法的次数。这里和KMeans类意义稍有不同，KMeans类里的n_init是用同样的训练集数据来跑不同的初始化质心从而运行算法。而MiniBatchKMeans类的n_init则是每次用不一样的采样数据集来跑不同的初始化质心运行算法。
4）batch_size：即用来跑Mini Batch KMeans算法的采样集的大小，默认是100.如果发现数据集的类别较多或者噪音点较多，需要增加这个值以达到较好的聚类效果。
5）init： 即初始值选择的方式，和KMeans类的init意义一样。
6）init_size: 用来做质心初始值候选的样本个数，默认是batch_size的3倍，一般用默认值就可以了。
7）reassignment_ratio: 某个类别质心被重新赋值的最大次数比例，这个和max_iter一样是为了控制算法运行时间的。这个比例是占样本总数的比例，乘以样本总数就得到了每个类别质心可以重新赋值的次数。如果取值较高的话算法收敛时间可能会增加，尤其是那些暂时拥有样本数较少的质心。默认是0.01。如果数据量不是超大的话，比如1w以下，建议使用默认值。如果数据量超过1w，类别又比较多，可能需要适当减少这个比例值。具体要根据训练集来决定。
8）max_no_improvement：即连续多少个Mini Batch没有改善聚类效果的话，就停止算法， 和reassignment_ratio， max_iter一样是为了控制算法运行时间的。默认是10.一般用默认值就足够了。
来源于：刘建平的blog
K-Means的主要优点有：
1）原理比较简单，实现也是很容易，收敛速度快。
2）聚类效果较优。
3）算法的可解释度比较强。
4）主要需要调参的参数仅仅是簇数k。
K-Means的主要缺点有：
1）K值的选取不好把握
2）对于不是凸的数据集比较难收敛
3）如果各隐含类别的数据不平衡，比如各隐含类别的数据量严重失衡，或者各隐含类别的方差不同，则聚类效果不佳。
4） 采用迭代方法，得到的结果只是局部最优。
5） 对噪音和异常点比较的敏感。
k 值评估标准：
from sklearn.metrics import calinski_harabaz_score计算公式为：
其中m为训练集样本数，k为类别数。为类别之间的协方差矩阵，
为类别内部数据的协方差矩阵。tr为矩阵的迹。
类别内部数据的协方差越小越好，类别之间的协方差越大越好，这样的Calinski-Harabasz分数会高.
#coding=gbk
# 在scikit-learn中，包括两个K-Means的算法，一个是传统的K-Means算法，对应的类是KMeans。
# 另一个是基于采样的Mini Batch K-Means算法，对应的类是MiniBatchKMeans。
# from sklearn.cluster import KMeans
# km = KMeans(n_clusters, init, n_init, max_iter, tol, precompute_distances, verbose, random_state, copy_x, n_jobs, algorithm)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets.samples_generator import make_blobs
centers = [[-1,-1],[0,0], [1,1], [2,2]]
cluster_std = [0.4, 0.2, 0.2, 0.2]
X, y = make_blobs(n_samples=1000, n_features=2, centers = centers, cluster_std = cluster_std, random_state = 666)
plt.scatter(X[:, 0], X[:, 1], marker=‘o‘)
print(X.shape)
# plt.show()
from sklearn.cluster import KMeans
km = KMeans(n_clusters=2, random_state = 666) #将数据集分为2类
y_pre = km.fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c= y_pre) #c 为color 使得y_pre 的数据是另一种颜色。
# plt.show()
print(y_pre[:5]) # [0 1 1 0 1] 将X 每行对应的数据 为y_pre 类
# 使用Calinski-Harabasz Index评估的聚类分数: 分数越高，表示聚类的效果越好
from sklearn.metrics import calinski_harabaz_score
print(calinski_harabaz_score(X, y_pre)) # 3088.084577541466
#将簇分为3类
y_pre1 = KMeans(n_clusters=3, random_state=666).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c =y_pre1)
# plt.show()
print(calinski_harabaz_score(X, y_pre1)) # 2963.0232832196702
#将簇分为4类
y_pre2 = KMeans(n_clusters=4, random_state=666).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pre2)
# plt.show()
print(calinski_harabaz_score(X, y_pre2)) # 6154.881371748304
#使用MiniBatchKMeans 类， 使用batch size为200
from sklearn.cluster import MiniBatchKMeans
for index, k in enumerate((2,3,4,5)):
plt.subplot(2, 2, index+1)
y_pre = MiniBatchKMeans(n_clusters=k, batch_size=200, random_state=666).fit_predict(X)
score = calinski_harabaz_score(X, y_pre)
plt.text(.99, .01, (‘k=%d, score: %.2f‘%(k, score)), transform=plt.gca().transAxes, size=10, horizontalalignment=‘right‘)
plt.scatter(X[:, 0], X[:, 1], c=y_pre)
plt.show()
BIRCH 聚类是一种基于层次划分的算法， 算法详细原理可以参照：刘建平的blogs
摘自其算法小结：
BIRCH算法可以不用输入类别数K值，这点和K-Means，Mini Batch K-Means不同。如果不输入K值，则最后的CF元组的组数即为最终的K，否则会按照输入的K值对CF元组按距离大小进行合并。
一般来说，BIRCH算法适用于样本量较大的情况，这点和Mini Batch K-Means类似，但是BIRCH适用于类别数比较大的情况，而Mini Batch K-Means一般用于类别数适中或者较少的时候。BIRCH除了聚类还可以额外做一些异常点检测和数据初步按类别规约的预处理。但是如果数据特征的维度非常大，比如大于20，则BIRCH不太适合，此时Mini Batch K-Means的表现较好。
对于调参，BIRCH要比K-Means，Mini Batch K-Means复杂，因为它需要对CF Tree的几个关键的参数进行调参，这几个参数对CF Tree的最终形式影响很大。
最后总结下BIRCH算法的优缺点：
BIRCH算法的主要优点有：
1) 节约内存，所有的样本都在磁盘上，CF Tree仅仅存了CF节点和对应的指针。
2) 聚类速度快，只需要一遍扫描训练集就可以建立CF Tree，CF Tree的增删改都很快。
3) 可以识别噪音点，还可以对数据集进行初步分类的预处理
BIRCH算法的主要缺点有：
1) 由于CF Tree对每个节点的CF个数有限制，导致聚类的结果可能和真实的类别分布不同.
2) 对高维特征的数据聚类效果不好。此时可以选择Mini Batch K-Means
3) 如果数据集的分布簇不是类似于超球体，或者说不是凸的，则聚类效果不好。
| 聚类算法 | 样本量 | 特征维度 | 类别数，簇 |
| K-Means | 较小，凸数据集 | 较小 | 较小 |
| MiniBatchKMeans | 较大，凸数据集 | > 20, 较大 | 适中或者较少 |
| BIRCH | 较大，凸数据集 | < 20, 较小 | 较大 |
| DBSCAN | ，凸、非凸数据集 | ||
在CF Tree中，几个关键的参数为内部节点的最大CF数B， 叶子节点的最大CF数L， 叶节点每个CF的最大样本半径阈值T。这三个参数定了，CF Tree的结构也基本确定了，最后的聚类效果也基本确定。可以说BIRCH的调参就是调试B,L和T。
至于类别数K，此时反而是可选的，不输入K，则BIRCH会对CF Tree里各叶子节点CF中样本的情况自己决定类别数K值，如果输入K值，则BIRCH会CF Tree里各叶子节点CF进行合并，直到类别数为K。
BIRCH参数：
1) threshold:即叶节点每个CF的最大样本半径阈值T，它决定了每个CF里所有样本形成的超球体的半径阈值。一般来说threshold越小，则CF Tree的建立阶段的规模会越大，即BIRCH算法第一阶段所花的时间和内存会越多。但是选择多大以达到聚类效果则需要通过调参决定。默认值是0.5.如果样本的方差较大，则一般需要增大这个默认值。
2) branching_factor：即CF Tree内部节点的最大CF数B，以及叶子节点的最大CF数L。这里scikit-learn对这两个参数进行了统一取值。也就是说，branching_factor决定了CF Tree里所有节点的最大CF数。默认是50。如果样本量非常大，比如大于10万，则一般需要增大这个默认值。选择多大的branching_factor以达到聚类效果则需要通过和threshold一起调参决定
3）n_clusters：即类别数K，在BIRCH算法是可选的，如果类别数非常多，我们也没有先验知识，则一般输入None，此时BIRCH算法第4阶段不会运行。但是如果我们有类别的先验知识，则推荐输入这个可选的类别值。默认是3，即最终聚为3类。
4）compute_labels：布尔值，表示是否标示类别输出，默认是True。一般使用默认值挺好，这样可以看到聚类效果。
#coding=gbk
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets.samples_generator import make_blobs
centers = [[-1,-1],[0,0], [1,1], [2,2]]
cluster_std = [0.4, 0.3, 0.4, 0.2]
X, y = make_blobs(n_samples=1000, n_features=2, centers = centers, cluster_std = cluster_std, random_state = 666)
# plt.scatter(X[:, 0], X[:, 1], marker=‘o‘)
# print(X.shape)
# plt.show()
print(y.shape)
# plt.scatter(X[:, 0], X[:, 1], c= y) #原数据的散点图
# plt.show()
from sklearn.cluster import Birch
from sklearn.metrics import calinski_harabaz_score
y_pre = Birch(n_clusters=None).fit_predict(X)
plt.scatter(X[:,0], X[:,1], c= y_pre)
# plt.show()
print(calinski_harabaz_score(X, y_pre)) # 2868.147538476159
#我们知道原来的簇就是4类， 当输入的簇是 4 的时候
y_pre1 = Birch(n_clusters=4).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_pre1)
# plt.show()
print(calinski_harabaz_score(X, y_pre1)) # 3678.4610499009887
# 对于threshold和branching_factor我们前面还没有去调参，使用了默认的threshold值0.5和默认的branching_factor值50
#将阈值降低
y_pre2 = Birch(n_clusters=4, threshold=0.3).fit_predict(X)
print(calinski_harabaz_score(X, y_pre2)) # 3598.0354960257487 反而降低了
y_pre3 = Birch(n_clusters=4, threshold=0.1).fit_predict(X)
print(calinski_harabaz_score(X, y_pre3)) # 3427.014275063579
#将默认的branching_factor 降低
y_pre4 = Birch(n_clusters=4, branching_factor=20).fit_predict(X)
print(calinski_harabaz_score(X, y_pre4)) # 3678.4610499009887 #未改变
y_pre5 = Birch(n_clusters=4, branching_factor=10,).fit_predict(X)
print(calinski_harabaz_score(X, y_pre5)) # 3678.4610499009887
y_pred = Birch(n_clusters=4, branching_factor=80).fit_predict(X)
print(calinski_harabaz_score(X, y_pred)) #3678.4610499009887
DBSCAN 算法是一种基于密度的聚类算法。
DBSCAN 算法是一种基于密度的聚类算法：
1.聚类的时候不需要预先指定簇的个数
2.最终的簇的个数不确定
DBSCAN算法将数据点分为三类：
1.核心点：在半径Eps内含有超过MinPts数目的点。
2.边界点：在半径Eps内点的数量小于MinPts,但是落在核心点的邻域内的点。
3.噪音点：既不是核心点也不是边界点的点。
图中黄色的点为边界点（以其为中心点），因为在半径Eps内，它领域内的点不超过MinPts个，我们这里设置的MinPts为5。
和传统的K-Means算法相比，DBSCAN最大的不同就是不需要输入类别数k，当然它最大的优势是可以发现任意形状的聚类簇，而不是像K-Means，一般仅仅使用于凸的样本集聚类。同时它在聚类的同时还可以找出异常点，这点和BIRCH算法类似。
那么我们什么时候需要用DBSCAN来聚类呢？一般来说，如果数据集是稠密的，并且数据集不是凸的，那么用DBSCAN会比K-Means聚类效果好很多。如果数据集不是稠密的，则不推荐用DBSCAN来聚类。
下面对DBSCAN算法的优缺点做一个总结。
DBSCAN的主要优点有：
1） 可以对任意形状的稠密数据集进行聚类，相对的，K-Means之类的聚类算法一般只适用于凸数据集。
2） 可以在聚类的同时发现异常点，对数据集中的异常点不敏感。
3） 聚类结果没有偏倚，相对的，K-Means之类的聚类算法初始值对聚类结果有很大影响。
DBSCAN的主要缺点有：
1）如果样本集的密度不均匀、聚类间距差相差很大时，聚类质量较差，这时用DBSCAN聚类一般不适合。
2） 如果样本集较大时，聚类收敛时间较长，此时可以对搜索最近邻时建立的KD树或者球树进行规模限制来改进。
3） 调参相对于传统的K-Means之类的聚类算法稍复杂，主要需要对距离阈值?，邻域样本数阈值MinPts联合调参，不同的参数组合对最后的聚类效果有较大影响。
from : 刘建平的blog
1）eps： DBSCAN算法参数，即?-邻域的距离阈值，和样本距离超过??的样本点不在??-邻域内。默认值是0.5.一般需要通过在多组值里面选择一个合适的阈值。eps过大，则更多的点会落在核心对象的??-邻域，此时我们的类别数可能会减少， 本来不应该是一类的样本也会被划为一类。反之则类别数可能会增大，本来是一类的样本却被划分开。
2）min_samples： DBSCAN算法参数，即样本点要成为核心对象所需要的??-邻域的样本数阈值。默认值是5. 一般需要通过在多组值里面选择一个合适的阈值。通常和eps一起调参。在eps一定的情况下，min_samples过大，则核心对象会过少，此时簇内部分本来是一类的样本可能会被标为噪音点，类别数也会变多。反之min_samples过小的话，则会产生大量的核心对象，可能会导致类别数过少。
3）metric：最近邻距离度量参数。可以使用的距离度量较多，一般来说DBSCAN使用默认的欧式距离（即p=2的闵可夫斯基距离）就可以满足我们的需求。可以使用的距离度量参数有：
a) 欧式距离 “euclidean”:
b) 曼哈顿距离 “manhattan”：
c) 切比雪夫距离“chebyshev”:
d) 闵可夫斯基距离 “minkowski”:
p=1为曼哈顿距离， p=2为欧式距离。
e) 带权重闵可夫斯基距离 “wminkowski”:
其中w为特征权重
f) 标准化欧式距离 “seuclidean”: 即对于各特征维度做了归一化以后的欧式距离。此时各样本特征维度的均值为0，方差为1.
g) 马氏距离“mahalanobis”：
其中，
为样本协方差矩阵的逆矩阵。当样本分布独立时， S为单位矩阵，此时马氏距离等同于欧式距离。
还有一些其他不是实数的距离度量，一般在DBSCAN算法用不上，这里也就不列了。
4）algorithm：最近邻搜索算法参数，算法一共有三种，第一种是蛮力实现，第二种是KD树实现，第三种是球树实现。这三种方法在K近邻法(KNN)原理小结中都有讲述，如果不熟悉可以去复习下。对于这个参数，一共有4种可选输入，‘brute’对应第一种蛮力实现，‘kd_tree’对应第二种KD树实现，‘ball_tree’对应第三种的球树实现， ‘auto’则会在上面三种算法中做权衡，选择一个拟合最好的最优算法。需要注意的是，如果输入样本特征是稀疏的时候，无论我们选择哪种算法，最后scikit-learn都会去用蛮力实现‘brute’。个人的经验，一般情况使用默认的 ‘auto’就够了。 如果数据量很大或者特征也很多，用"auto"建树时间可能会很长，效率不高，建议选择KD树实现‘kd_tree’，此时如果发现‘kd_tree’速度比较慢或者已经知道样本分布不是很均匀时，可以尝试用‘ball_tree’。而如果输入样本是稀疏的，无论你选择哪个算法最后实际运行的都是‘brute’。
5）leaf_size：最近邻搜索算法参数，为使用KD树或者球树时， 停止建子树的叶子节点数量的阈值。这个值越小，则生成的KD树或者球树就越大，层数越深，建树时间越长，反之，则生成的KD树或者球树会小，层数较浅，建树时间较短。默认是30. 因为这个值一般只影响算法的运行速度和使用内存大小，因此一般情况下可以不管它。
6） p: 最近邻距离度量参数。只用于闵可夫斯基距离和带权重闵可夫斯基距离中p值的选择，p=1为曼哈顿距离， p=2为欧式距离。如果使用默认的欧式距离不需要管这个参数。
以上就是DBSCAN类的主要参数介绍，其实需要调参的就是两个参数eps和min_samples，这两个值的组合对最终的聚类效果有很大的影响。
#coding=gbk
#DBSCAN 聚类算法的使用,生成3簇数据，两组都是非凸的
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets.samples_generator import make_circles, make_blobs
#产生大小两个圆的数据，noise高斯噪声，factor:内圆和外圆之间的比例因子。
X1, y1 = make_circles(n_samples=5000, factor=0.6, noise=0.05, random_state=666)
X2, y2 = make_blobs(n_samples=1000, n_features=2, centers =[[1.2,1.2]], cluster_std=[[0.1]], random_state=666 )
X = np.concatenate((X1, X2))
y = np.concatenate((y1, y2))
plt.scatter(X[:, 0], X[:, 1], marker=‘o‘, color=‘red‘)
# plt.show()
# help(make_circles)
#使用KMeans进行聚类
from sklearn.cluster import KMeans
from sklearn.metrics import calinski_harabaz_score
y_km_pre = KMeans(n_clusters=3, random_state=666).fit_predict(X)
plt.scatter(X[:, 0], X[:, 1], c=y_km_pre)
# plt.show()
print(calinski_harabaz_score(X, y_km_pre)) # 6662.414512503257
print(‘原来的聚类分簇的分数：‘+ str(calinski_harabaz_score(X, y))) # 原来的聚类分簇的分数：373.350055300171, 不能使用此方法进行评定
#使用DBSCAN 算法进行调参
from sklearn.cluster import DBSCAN
y_db_pre = DBSCAN(eps=0.5, min_samples=5).fit_predict(X) #使用默认参数
plt.scatter(X[:, 0], X[:, 1],c=y_db_pre)
# plt.show() #DBSCAN 在不进行调参的情况下，将全部数据都分为是一类
# print(calinski_harabaz_score(X, y_db_pre)) 只有一类，无法计算
#先只是将领域减小
y_pre = DBSCAN(eps=0.1, min_samples=5).fit_predict(X)
plt.scatter(X[:, 0], X[:,1], c=y_pre)
# plt.show()
print(calinski_harabaz_score(X, y_pre)) # 1387.9460424040549
#将领域减少并且增大周围的样本数
y_pre1 = DBSCAN(eps=0.1, min_samples=15).fit_predict(X)
plt.scatter(X[:,0], X[:, 1], c=y_pre1)
# plt.show()
print(calinski_harabaz_score(X, y_pre1)) # 1387.9460424040549
?
比起传统的K-Means算法，谱聚类对数据分布的适应性更强，聚类效果也很优秀，同时聚类的计算量也小很多，更加难能可贵的是实现起来也不复杂。
谱聚类算法的优缺点：
谱聚类算法的主要优点有：
1）谱聚类只需要数据之间的相似度矩阵，因此对于处理稀疏数据的聚类很有效。这点传统聚类算法比如K-Means 很难做到
2）由于使用了降维，因此在处理高维数据聚类时的复杂度比传统聚类算法好。
谱聚类算法的主要缺点有：
1）如果最终聚类的维度非常高，则由于降维的幅度不够，谱聚类的运行速度和最后的聚类效果均不好。
2) 聚类效果依赖于相似矩阵，不同的相似矩阵得到的最终聚类效果可能很不同。
#coding=gbk
import numpy as np
import time
from sklearn.cluster import SpectralClustering
from sklearn.datasets import make_blobs
from sklearn.metrics import calinski_harabaz_score
#生成500个 6 维的数据集， 分为 5 个簇
X, y = make_blobs(n_samples=500, n_features=6, centers=5, cluster_std=[0.4, 0.4, 0.3, 0.3, 0.4],
random_state=666)
print(X.shape)
print(y.shape)
y_pre = SpectralClustering().fit_predict(X)
score = calinski_harabaz_score(X, y_pre)
print(‘calinski_harabaz_score:‘+ str(score)) # calinski_harabaz_score:11509.943254338412
#使用高斯核，对n_cluster 和 gamma 进行调参
start = time.clock()
best_score, best_k, best_gamma = 0,0,0
for gamma in (0.01, 0.1, 1, 5):
for k in (3, 4, 5, 6):
y_pre = SpectralClustering(n_clusters=k, gamma=gamma).fit_predict(X)
score = calinski_harabaz_score(X, y_pre)
print(‘calinski_harabaz_score: %.3f, k value: % d, gamma value: %f‘%(calinski_harabaz_score(X, y_pre),
k, gamma))
if score > best_score:
best_score = score
best_k = k
best_gamma = gamma
print(‘best_score:%.3f, best_k: %d , best_gamma: %.3f‘%(best_score, best_k, best_gamma))
end = time.clock()
real_time = end -start
print(‘spending time: %.3f ‘%real_time + ‘s‘)(500, 6)
(500,)
calinski_harabaz_score:8470.922907812417
calinski_harabaz_score: 1015.206, k value: 3, gamma value: 0.010000
calinski_harabaz_score: 1739.986, k value: 4, gamma value: 0.010000
calinski_harabaz_score: 30624.310, k value: 5, gamma value: 0.010000
calinski_harabaz_score: 25497.191, k value: 6, gamma value: 0.010000
calinski_harabaz_score: 687.243, k value: 3, gamma value: 0.100000
calinski_harabaz_score: 1739.986, k value: 4, gamma value: 0.100000
calinski_harabaz_score: 30624.310, k value: 5, gamma value: 0.100000
calinski_harabaz_score: 25518.793, k value: 6, gamma value: 0.100000
calinski_harabaz_score: 161.824, k value: 3, gamma value: 1.000000
calinski_harabaz_score: 455.559, k value: 4, gamma value: 1.000000
calinski_harabaz_score: 30624.310, k value: 5, gamma value: 1.000000
calinski_harabaz_score: 25489.137, k value: 6, gamma value: 1.000000
calinski_harabaz_score: 56.004, k value: 3, gamma value: 5.000000
calinski_harabaz_score: 99.142, k value: 4, gamma value: 5.000000
calinski_harabaz_score: 98.842, k value: 5, gamma value: 5.000000
calinski_harabaz_score: 109.097, k value: 6, gamma value: 5.000000
best_score:30624.310, best_k: 5 , best_gamma: 0.010
spending time: 2.280 s
原文：https://www.cnblogs.com/junge-mike/p/12761685.html