【机器学习】聚类算法Kmeans

---

聚类

聚类就是按照某个特定标准(如距离准则)把一个数据集分割成不同的类或簇，使得同一个簇内的数据对象的相似性尽可能大，同时不在同一个簇中的数据对象的差异性也尽可能地大。即聚类后同一类的数据尽可能聚集到一起，不同类的数据尽量远离。

和分类相似，每个实例都分配给一个组，但不同的是：聚类 (Clustering)简单地说就是把相似的东西分到一组，聚类的时候，我们并不关心某一类是什么，我们需要实现的目标只是把相似的东西聚到一起。

聚类 (Clustering)通常并不需要使用训练数据进行学习，这在机器学习中被称作无监督学习 (unsupervised learning)，通常只需要知道如何计算相似度就可以开始工作了。

不同的聚类算法有不同的应用背景，有的适合于大数据集，可以发现任意形状的聚簇；有的算法思想简单，适用于小数据集。

接下来通过将通过sklearn集成的Kmeans算法来理解Kmeans聚类算法，附sklearn上聚类算法的类和接口：

聚类算法在sklearn中有两种表现形式，一种是类，需要实例化，训练并使用接口和属性来调用结果。另一种是函数（function），只需要输入特征矩阵和超参数，即可返回聚类的结果和各种指标。

---

Kmeans

基于划分的方法是简单、常用的一种聚类方法，它通过将对象划分为互斥的簇进行聚类， 每个对象属于且仅属于一个簇；划分结果旨在使簇之间的相似性低，簇内部的相似度高。

K-Means算法是一种基于划分的简单算法，与其他聚类算法相比，能够非常快速、高效地对此类数据集进行聚类，通常只需几次迭代即可。
K-Means极易实现而且计算效率也很高。

核心：簇和质心

KMeans算法将一组N个样本的特征矩阵X划分为K个无交集的簇，直观上来看是簇是一组一组聚集在一起的数据，在一个簇中的数据就认为是同一类。簇就是聚类的结果表现。

簇中所有数据的均值${\mu }_j$通常被称为这个簇的“质心”（centroids）。在一个二维平面中，一簇数据点的质心的横坐标就是这一簇数据点的横坐标的均值，质心的纵坐标就是这一簇数据点的纵坐标的均值。同理可推广至高维空间。

通过计算样本点与质心的距离，与质心相近的样本点划分为同一类簇。

在KMeans算法中，簇的个数K是一个超参数，需要我们人为输入来确定。KMeans的核心任务就是根据我们设定好的K，找出K个最优的质心，并将离这些质心最近的数据分别分配到这些质心代表的簇中去。

具体过程：
迭代停止，质心的位置会不再变化：当我们找到一个质心，在每次迭代中被分配到这个质心上的样本都是一致的，即每次新生成的簇都是一致的，所有的样本点都不会再从一个簇转移到另一个簇，质心就不会变化了。

这个过程在可以由下图来显示，我们规定，将数据分为4簇（K=4），其中白色X代表质心的位置：

在数据集下多次迭代(iteration)，就会有：
第六次迭代之后，基本上质心的位置就不再改变了，生成的簇也变得稳定。此时我们的聚类就完成了，我们可以明显看出，KMeans按照数据的分布，将数据聚集成了我们规定的4类，接下来我们就可以按照我们的业务需求或者算法需求，对这四类数据进行不同的处理。

相似度是通过样本间的距离来衡量它们的，两个样本距离越远，则相似度越低，否则相似度越高。追求“簇内差异小，簇外差异大”，差异是由样本点到其所在簇的质心的距离来衡量。

对于一个簇来说，所有样本点到质心的距离之和越小，我们就认为这个簇中的样本越相似，簇内差异就越小。

计算样本点到质心距离的方式：

$x$表示簇中的一个样本点，$\mu$表示该簇中的质心，n表示每个样本点中的特征数目，i表示组成点$x$ 的每个特征。【数字与数字之间的距离主要采用欧几里得，余弦距离适用于文本与文本之间的距离】

• 簇内平方和（cluster Sum of Square），又叫做Inertia：簇内所有样本点到该簇质心的距离之和。
• 整体平方和（Total Cluster Sum ofSquare），又叫做total inertia：所有簇的簇内平方和相加。
  以欧几里得距离为例：（k个簇，每个簇m个样本，每个样本n个特征）
  
  Total Inertia越小，代表着每个簇内样本越相似，聚类的效果就越好。因此KMeans追求的是，求解能够让Inertia最小化的质心。实际上，在质心不断变化不断迭代的过程中，总体平方和是越来越小的。当整体平方和最小的时候，质心就不再发生变化了。

是属于最优化的问题：我们在一个固定的簇数K下，最小化总体平方和来求解最佳质心，并基于质心的存在去进行聚类。

时间复杂度

该算法的计算复杂度在实例数m，簇数k和维度n方面通常是线性的，但是，仅当数据具有聚类结构时才如此。如果不是这样，那么在最坏的情况下，复杂度会随着实例数量的增加而呈指数增加。实际上，这种情况很少发生，并且K-Means通常是最快的聚类算法之一。

---

sklearn.cluster.KMeans

class sklearn.cluster.KMeans (
n_clusters=8, 
init=’k-means++’, 
n_init=10, 
max_iter=300, 
tol=0.0001,
precompute_distances=’auto’, 
verbose=0, 
random_state=None, 
copy_x=True, 
n_jobs=None, 
algorithm=’auto’)

1. 参数：
   
2. 属性：

3. 接口：

一些重要的参数代码示例理解：

n_clusters

n_clusters是KMeans中的k，表示着我们告诉模型我们要分几类。这是KMeans当中唯一一个必填的参数，默认为8类，但通常我们的聚类结果会是一个小于8的结果。通常，在开始聚类之前，我们并不知道n_clusters究竟是多少，因此我们要对它进行探索。

from sklearn.datasets import make_blobs # 创建簇类数据
import matplotlib.pyplot as plt
X, y = make_blobs(n_samples=500,n_features=2,centers=4,random_state=1) 
# 500个样本，2个特征，4类的数据集，有标签的，方便与聚簇后的结果进行比较

看一下真实的分类：

color = ["red","pink","orange","gray"]
fig, ax1 = plt.subplots(1) # 参数：生成子图的数量
for i in range(4):
    ax1.scatter(X[y==i, 0], X[y==i, 1]
                ,marker='o' #点的形状
                ,s=8 #点的大小
                ,c=color[i]
                )
plt.show()

接下来，通过kmeans来对没有标签的上面的数据进行聚簇，看看和真实的差异：

1. 簇为3类时：

from sklearn.cluster import KMeans
n_clusters = 3
cluster = KMeans(n_clusters=n_clusters, random_state=0, n_init=10).fit(X)
y_pred = cluster.labels_ # 查看每个点对应的标签
y_pred # 每个样本对应的标签

可以一步到位，不需要fit后再查看labels_ ，直接fit_predict搞定

pre = cluster.fit_predict(X) # 学习数据X并对X进行预测
(pre != y_pred).sum() # 看看和上面是不是一样

如何数据量太多，太慢了，可以先聚类一部分数据，【有时候少部分数据就可以找到很完美的质心】迭代找到质心，再进行预测其他数据就可以了，这样可以大大减少时间：

cluster_smallsub = KMeans(n_clusters=n_clusters, random_state=0, n_init=10).fit(X[:200])
y_pred_ = cluster_smallsub.predict(X)
(pre != y_pred).sum()

可以看到只有少量数据聚类的结果不一样。

查看质心：cluster_centers_

centroid = cluster.cluster_centers_
centroid

查看总距离平方和：inertia_

inertia = cluster.inertia_
inertia

画出簇为3类的分类结果：

color = ["red","pink","orange","gray"]
fig, ax1 = plt.subplots(1)
for i in range(n_clusters):
    ax1.scatter(X[y_pred==i, 0], X[y_pred==i, 1]
           ,marker='o'
           ,s=8
           ,c=color[i]
           )
ax1.scatter(centroid[:,0],centroid[:,1]
           ,marker="x"
           ,s=15
           ,c="black")
plt.show()

2. 簇为4类时：

n_clusters = 4
cluster_ = KMeans(n_clusters=n_clusters, random_state=0, n_init=10).fit(X)
y_pred_4= cluster_.labels_

color = ["red","pink","orange","gray"]
fig, ax1 = plt.subplots(1)
for i in range(4):
    ax1.scatter(X[y_pred_4==i, 0], X[y_pred_4==i, 1]
                ,marker='o' #点的形状
                ,s=8 #点的大小
                ,c=color[i]
                )
plt.show()

只能说效果真的很好。

我们并不知道参数n_clusters取什么值好，也就是分几类，根据前面理论，聚类效果越好，距离平方和Inertia越小。
但是随着n_clusters增大，Inertia是越来越小了。当n_clusters等于样本数时，也就是每个点都质心，那么距离平方和Inertia=0，不能调节k，来降低Inertia的值，然后表示模型的效果变好了

Inertia不是模型评估指标

模型评估指标

聚类模型的结果不是某种标签输出，并且聚类的结果是不确定的，其优劣由业务需求或者算法需求来决定，并且没有永远的正确答案。

轮廓系数

KMeans的目标是确保“簇内差异小，簇外差异大”，根据目标出发，评估聚类的效果是完全依赖于评价簇内的稠密程度（簇内差异小）和簇间的离散程度（簇外差异大）来的。

轮廓系数是最常用的聚类算法的评价指标：

1）样本与其自身所在的簇中的其他样本的相似度a：等于样本与同一簇中所有其他点之间的平均距离
2）样本与其他簇中的样本的相似度b：等于样本与下一个最近的簇中的所有点之间的平均距离

根据聚类的要求”簇内差异小，簇外差异大“，我们希望b永远大于a，并且大得越多越好。

单个样本的轮廓系数计算为：

轮廓系数范围是(-1,1)，其中值越接近1表示样本与自己所在的簇中的样本很相似，并且与其他簇中的样本不相似，这就是聚簇想要达到的效果。
轮廓系数就为负，表示样本点与簇外的样本更相似，与聚簇的目标背道而驰。
轮廓系数为0，表示两个簇中的样本相似度一致，两个簇本应该是一个簇。

所以轮廓系数越接近于1越好，负数则表示聚类效果非常差。

如果许多样本点具有低轮廓系数甚至负值，说明聚类是不合适的，则需要重新设定聚类的超参数K。

sklearn中，模块metrics中的类silhouette_score是用来计算轮廓系数，它返回的是一个数据集中，返回所有样本的轮廓系数的均值。silhouette_sample，它的参数与轮廓系数一致，但返回的数据集中每个样本自己的轮廓系数。

from sklearn.metrics import silhouette_score
from sklearn.metrics import silhouette_samples
silhouette_score(X,y_pred) # 簇为3

可以看到分4簇时，轮廓系数是最大的，效果最好。

轮廓系数在每个簇的分割比较清洗时表现最好。
轮廓系数在凸型的类上表现会虚高，比如基于密度进行的聚类，或通过DBSCAN获得的聚类结果，如果使用轮廓系数来衡量，则会表现出比真实聚类效果更高的分数。

基于轮廓系数来选择n_clusters：
（每个聚出来的类的轮廓系数是多少，各个类之间的轮廓系数的对比）

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np
for n_clusters in [2,3,4,5,6,7]:
    n_clusters = n_clusters
    fig, (ax1, ax2) = plt.subplots(1, 2)
    fig.set_size_inches(18, 7)
    ax1.set_xlim([-0.1, 1])
    ax1.set_ylim([0, X.shape[0] + (n_clusters + 1) * 10])
    clusterer = KMeans(n_clusters=n_clusters, random_state=10).fit(X)
    cluster_labels = clusterer.labels_
    silhouette_avg = silhouette_score(X, cluster_labels)
    print("For n_clusters =", n_clusters,
          "The average silhouette_score is :", silhouette_avg)
    sample_silhouette_values = silhouette_samples(X, cluster_labels)
    y_lower = 10
    for i in range(n_clusters):
        ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
        ith_cluster_silhouette_values.sort()
        size_cluster_i = ith_cluster_silhouette_values.shape[0]
        y_upper = y_lower + size_cluster_i
        color = cm.nipy_spectral(float(i)/n_clusters)
        ax1.fill_betweenx(np.arange(y_lower, y_upper)
                         ,ith_cluster_silhouette_values
                         ,facecolor=color
                         ,alpha=0.7
                         )
        ax1.text(-0.05
                 , y_lower + 0.5 * size_cluster_i
                 , str(i))
        y_lower = y_upper + 10
    ax1.set_title("The silhouette plot for the various clusters.")
    ax1.set_xlabel("The silhouette coefficient values")
    ax1.set_ylabel("Cluster label")
    ax1.axvline(x=silhouette_avg, color="red", linestyle="--")
    ax1.set_yticks([])
    ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
    colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
    ax2.scatter(X[:, 0], X[:, 1]
               ,marker='o'
               ,s=8
               ,c=colors
               )
    centers = clusterer.cluster_centers_
    # Draw white circles at cluster centers
    ax2.scatter(centers[:, 0], centers[:, 1], marker='x',
                c="red", alpha=1, s=200)
    
    ax2.set_title("The visualization of the clustered data.")
    ax2.set_xlabel("Feature space for the 1st feature")
    ax2.set_ylabel("Feature space for the 2nd feature")
    plt.suptitle(("Silhouette analysis for KMeans clustering on sample data "
                  "with n_clusters = %d" % n_clusters),
                 fontsize=14, fontweight='bold')
    plt.show()

在轮廓系数较高，且每一簇都有贡献的只有n_clusters =2和n_clusters =4，具体选那个根据业务而定。
【图1的纵坐标是样本，每一簇样本的轮廓系数是从小到大排过序的，中间的红色虚线是平均的轮廓系数】

卡林斯基-哈拉巴斯指数

卡林斯基-哈拉巴斯指数（Calinski-Harabaz Index，简称CHI，也被称为方差比标准），Calinski-Harabaz指数越高越好。对于有k个簇的聚类而言，Calinski-Harabaz指数s(k)写作如下公式：

N为数据集中的样本量，k为簇的个数（即类别的个数），$B_k$ 是组间离散矩阵，即不同簇之间的协方差矩阵，$W_k$是簇内离散矩阵，即一个簇内数据的协方差矩阵，而$Tr$表示矩阵的迹。

数据之间的离散程度越高，协方差矩阵的迹就会越大。 簇内离散程度小，簇外离散程度大，对应$Tr(W_k)$小，$Tr(B_k)$大，即Calinski-Harabaz指数s(k)越高越好。

from sklearn.metrics import calinski_harabasz_score #Calinski-Harabaz指数

calinski_harabasz_score(X, y_pred)

calinski-Harabaz指数没有界，在凸型的数据上的聚类也会表现虚高。但是比起轮廓系数，它有一个巨大的优点，就是计算非常快速。

init & random_state & n_init：初始质心

如果有足够的时间，K-means一定会收敛，但Inertia可能收敛到局部最小值。
是否能够收敛到真正的最小值很大程度上取决于质心的初始化。
init就是用来帮助我们决定初始化方式的参数。

初始质心放置的位置不同，聚类的结果很可能也会不一样，一个好的质心选择可以让K-Means避免更多的计算，让算法收敛稳定且更快。

一个random_state对应一个质心随机初始化的随机数种子。如果不指定随机数种子，则sklearn中的K-means并不会只选择一个随机模式扔出结果，而会在每个随机数种子下运行多次，并使用结果最好的一个随机数种子来作为初始质心。

我们可以使用参数n_init来选择，每个随机数种子下运行的次数。这个参数不常用到，一般10次，默认是’auto’，如果我们希望运行的结果更加精确，那我们可以增加这个参数n_init的值来增加每个随机数种子下运行的次数。

• init：可输入"k-means++“，“random"或者一个n维数组。这是初始化质心的方法，默认"k-means++”。输入"kmeans++”：一种为K均值聚类选择初始聚类中心的聪明的办法，以加速收敛。如果输入了n维数组，数组的形状应该是(n_clusters，n_features)并给出初始质心。
• random_state：控制每次质心随机初始化的随机数种子
• n_init：整数，默认auto，使用不同的质心随机初始化的种子来运行k-means算法的次数。最终结果会是基于Inertia来计算的n_init次连续运行后的最佳输出

n_init will change from 10 to ‘auto’ in 1.4

初始质心选得好的话，模型会收敛得更快，迭代次数会更少：

max_iter & tol

当质心不再移动，Kmeans算法就会停下来。但在完全收敛之前，我们也可以使用max_iter（最大迭代次数）或者tol（两次迭代间Inertia下降的量），这两个参数来让迭代提前停下来。

当我们的n_clusters选择不符合数据的自然分布，或者我们为了业务需求，必须要填入与数据的自然
分布不合的n_clusters，提前让迭代停下来反而能够提升模型的表现。

• max_iter：整数，默认300，单次运行的k-means算法的最大迭代次数
• tol：浮点数，默认1e-4，两次迭代间Inertia下降的量，如果两次迭代之间Inertia下降的值小于tol所设定的值，迭代就会停下

k_means函数

sklearn.cluster.k_means (X, 
n_clusters,
 sample_weight=None, 
 init=’k-means++’,
 precompute_distances=’auto’,
 n_init=10, 
 max_iter=300, 
 verbose=False, 
 tol=0.0001, 
 random_state=None, 
 copy_x=True, 
 n_jobs=None,
 algorithm=’auto’, 
 return_n_iter=False)

和类得参数基本相同，不过函数调用直接返回结果

from sklearn.cluster import k_means
k_means(X, 4, return_n_iter=True) # 1.array数组-质心 2.标签值 3. Inertia 4.最佳迭代次数

返回值包括：1.array数组-质心 2.标签值 3. Inertia 4.最佳迭代次数【return_n_iter=True时返回】

---