1 概述

无监督的算法在训练的时候只需要特征矩阵X，不需要标签。
有监督学习是在模型在训练的时候，即需要特征矩阵X，也需要真实标签y。
聚类算法又叫做“无监督分类”，其目的是将数据划分成有意义或有用的组（或簇）。

机器学习：10--聚类算法KMeans - 图1

2 KMeans是如何工作的

簇和质心
KMeans算法是将一组N个样本的特征矩阵X划分为K个无交集的簇，簇是聚类结果的表现。簇中所有数据的均值通常被称为这个簇的“质心”（centroids）。在一个二维平面中，一簇数据点的质心的横坐标就是这一簇数据点的横坐标的均值，质心的纵坐标就是这一簇数据点的纵坐标的均值。

KMeans的核心任务：根据我们设定好的K，找出K个最优的质心，并将离这些质心最近的数据分别分配到这些质心代表的簇中去。

那什么情况下，质心的位置会不再变化呢？
当我们找到一个质心，在每次迭代中被分配到这个质心上的样本都是一致时，质心的位置就不会再改变。

聚类算法聚出的类有什么样的性质？
被分在同一个簇中的数据是有相似性的，而不同簇中的数据是不同的，即求“组内差异小，组间差异大”。而这个“差异“，由样本点到其所在簇的质心的距离来衡量。对于一个簇来说，所有样本点到质心的距离之和越小，我们就认为这个簇中的样本越相似，簇内差异就越小。
机器学习：10--聚类算法KMeans - 图2
其中，m为一个簇中样本的个数，j是每个样本的编号。这个公式被称为簇内平方和（cluster Sum of Square），又叫做Inertia。而将一个数据集中的所有簇的簇内平方和相加，就得到了整体平方和（Total Cluster Sum of Square），又叫做total inertia。Total Inertia越小，代表着每个簇内样本越相似，聚类的效果就越好。因此KMeans追求的是，求解能够让Inertia最小化的质心。

3 sklearn.cluster.KMeans

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

3.1 重要参数n_clusters

n_clusters是KMeans中的k，表示着我们告诉模型我们要分几类。默认为8类，但通常我们的聚类结果会是一个小于8的结果，因此我们要对它进行探索。

3.1.1 先进行一次聚类看看

当我们拿到一个数据集，如果可能的话，我们希望能够通过绘图先观察一下这个数据集的数据分布，以此来为我们聚类时输入的n_clusters做一个参考。
创建一个数据集探索

  1. from sklearn.datasets import make_blobs #make_blobs是帮我做几个簇的意思
  2. import matplotlib.pyplot as plt
  3. #自己创建数据集
  4. X, y = make_blobs(n_samples=500,n_features=2,centers=4,random_state=1) #500个数据 2个特征，4个簇，随机性规定，让数据稳定
  5. X.shape
  6. #(500, 2)
  7. y.shape
  8. #(500,)

画图探索

  1. fig, ax1 = plt.subplots(1) #生成子图1个：子图由两部分组成，画布fig 对象ax1
  2. ax1.scatter(X[:, 0], X[:, 1] #将二维数据两列全部画进去
  3.                 ,marker='o' #点的形状
  4.                 ,s=8 #点的大小
  5.                 )
  6. plt.show()

机器学习：10--聚类算法KMeans - 图3

显示点的分布
这是我们在创建数据的时候，已经规定了分为4簇，所以这里直接range(4)。

  1. #如果我们想要看见这个点的分布，怎么办？
  2. color = ["red","pink","orange","gray"]
  3. fig, ax1 = plt.subplots(1)
  4. for i in range(4):
  5.     ax1.scatter(X[y==i, 0], X[y==i, 1] #就是取出y_pred是0，1，2，3的那一簇的X
  6.                 ,marker='o' #点的形状
  7.                 ,s=8 #点的大小
  8.                 ,c=color[i]
  9.                 )
  10. plt.show()

机器学习：10--聚类算法KMeans - 图4

如果不知道真实数据分为几簇，我们来使用Kmeans进行聚类

  1. #基于这个分布，我们来使用Kmeans进行聚类
  2. from sklearn.cluster import KMeans
  3. n_clusters = 3 #假设分为了3簇
  4. #KMeans目的就是求出质心，已经把簇分好了，不需要接口
  5. cluster = KMeans(n_clusters=n_clusters, random_state=0).fit(X) #实例化，训练，random_state也是为了模型稳定
  8. # 重要属性labels_,查看聚好的类别，每个样本所对应的类，即标签
  9. y_pred = cluster.labels_
  10. y_pred
  13. #但其实KMeans也有接口predict和fit_predict，表示学习数据X并对X的类进行预测
  14. #但所得的结果和直接fit之后调用属性lables_一模一样
  15. pre = cluster.fit_predict(X)
  16. pre == y_pred
  19. #但是数据量大的时候，可以先使用部分数据来确定质心
  20. #在用法剩下的数据聚类结果，使用predict来调用，这样计算量会少很多
  21. cluster_smallsub = KMeans(n_clusters=n_clusters, random_state=0).fit(X[:200]) #X[:200]切片取200行进行质心计算
  22. y_pred_ = cluster_smallsub.predict(X) #再用整体数据做predict
  23. y_pred == y_pred_ #这说明整体数据不完全相似，但是在数据量很大的时候，效果还是比较好的

机器学习：10--聚类算法KMeans - 图5

重要属性clustercenters, inertia_

  1. #重要属性cluster_centers_，查看质心
  2. centroid = cluster.cluster_centers_
  3. print(centroid)
  4. centroid.shape
  6. #重要属性inertia_，查看总距离平方和，越小，模型效果越好。
  7. inertia = cluster.inertia_
  8. inertia

机器学习：10--聚类算法KMeans - 图6

画出3簇的散点图

  1. color = ["red","pink","orange","gray"]
  2. fig, ax1 = plt.subplots(1)
  3. for i in range(n_clusters):
  4.     ax1.scatter(X[y_pred==i, 0], X[y_pred==i, 1] #就是取出y_pred是0，1，2的那一类的X
  5.                 ,marker='o' #点的形状
  6.                 ,s=8 #点的大小
  7.                 ,c=color[i]
  8.                 )
  9. #对不同颜色的簇找出质心
  10. ax1.scatter(centroid[:,0],centroid[:,1]
  11.             ,marker="x"
  12.             ,s=20
  13.             ,c="black")
  14. plt.show()

机器学习：10--聚类算法KMeans - 图7

inertia不是一个有效的聚类评估指标
当n_cluster = 500时，inertia将等于0。

  1. #如果聚类效果更好的话，inertia应该更低
  2. #随着n_cluster越来越大，inertia可以等于0；所以模型的效果调整只有在K不变的时候，调整才对。
  3. #可见，inertia不是一个有效的评估指标
  4. n_clusters = 4
  5. cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
  6. inertia_ = cluster_.inertia_
  7. inertia_

输出结果

  1. 908.3855684760603

3.1.2聚类算法的有效模型评估指标

当真实标签未知的时候：轮廓系数
未知标签聚类是完全依赖于评价簇内的稠密程度（簇内差异小）和簇间的离散程度（簇外差异大）来评估聚类的效果。其中轮廓系数是最常用的聚类算法的评价指标。
1）样本与其自身所在的簇中的其他样本的相似度a，等于样本与同一簇中所有其他点之间的平均距离
2）样本与其他簇中的样本的相似度b，等于样本与下一个最近的簇中的所有点之间的平均距离
根据聚类的要求”簇内差异小，簇外差异大“，我们希望b永远大于a，并且大得越多越好。
机器学习：10--聚类算法KMeans - 图8

轮廓系数范围是(-1,1)，其中值越接近1表示样本与自己所在的簇中的样本很相似，并且与其他簇中的样本不相似。轮廓系数越接近于1越好，负数则表示聚类效果非常差。如果一个簇中的大多数样本具有比较高的轮廓系数，则簇会有较高的总轮廓系数，则整个数据集的平均轮廓系数越高，则聚类是合适的。

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

轮廓系数在自建模型上的表现

  1. #轮廓系数
  2. from sklearn.metrics import silhouette_score
  3. from sklearn.metrics import silhouette_samples
  5. #分3簇
  6. n_clusters = 3
  7. cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
  8. inertia_ = cluster_.inertia_
  9. inertia_
  10. silhouette_score(X,cluster_.labels_) #输入的是X和预测的标签(分好的簇)，silhouette_score返回的是所有样本的轮廓系数均值
  12. #分4簇
  13. n_clusters = 4
  14. cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
  15. inertia_ = cluster_.inertia_
  16. inertia_
  17. silhouette_score(X,cluster_.labels_)
  19. silhouette_samples(X,y_pred) #返回每一个样本的轮廓系数

输出结果

  1. 0.5882004012129721   3簇
  2. 0.6505186632729437   4簇

轮廓系数优点:它在有限空间中取值，使得我们对模型的聚类效果有一个“参考”。并且，轮廓系数对数据的分布没有假设，因此在很多数据集上都表现良好。它在每个簇的分割比较清洗时表现最好。

3.1.3 案例：基于轮廓系数来选择n_clusters

我们通常会绘制轮廓系数分布图和聚类后的数据分布图来选择我们的最佳n_clusters。
先解释代码，用n_cluster=4来画两图

  1. from sklearn.cluster import KMeans
  2. from sklearn.metrics import silhouette_samples, silhouette_score
  3. import matplotlib.pyplot as plt
  4. import matplotlib.cm as cm
  5. import numpy as np
  6. import pandas as pd
  9. #需要画两个图
  10. #知道每个聚类出来类的轮廓系数是多少（图1），还想要各个类之间的轮廓系数的对比（图2）
  11. #知道聚类后的图像的分布是什么模样
  12. #先画下一个n_clusters下两个图是怎么画出来的
  13. #先设定分成的簇数
  14. n_clusters = 4
  16. #创建一个画布，画布1行两列。
  17. fig, (ax1, ax2) = plt.subplots(1, 2)
  18. #画布尺寸
  19. fig.set_size_inches(18, 7) #给两个子图设置
  21. #第一个图是轮廓系数图像，是各个簇的轮廓系数组成的横向条形图
  22. #横坐标是轮廓系数取值，纵坐标是每个样本
  23. #横坐标的取值是[-1.1]，但是我们至少希望轮廓系数>0，所以只设定X轴的取值在[-0.1,1]之间
  24. ax1.set_xlim([-0.1, 1])
  26. #纵坐标的取值从0开始，最大值是 X.shape[0]，但是我们希望每个簇的在一起，不同簇的分开
  27. #因此，在 X.shape[0]上加上一个距离(n_clusters + 1) * 10，留作间隔用
  28. ax1.set_ylim([0, X.shape[0] + (n_clusters + 1) * 10])
  30. #开始建模，调用聚类好的标签
  31. clusterer = KMeans(n_clusters=n_clusters, random_state=10).fit(X)
  32. cluster_labels = clusterer.labels_
  34. #调用轮廓系数，silhouette_score是生成所有样本点的轮廓系数均值
  35. #两个需要的参数：特征矩阵X和聚类完毕后的标签
  36. silhouette_avg = silhouette_score(X, cluster_labels)
  37. #打印K和现在的轮廓系数
  38. print("For n_clusters =", n_clusters,
  39.         "The average silhouette_score is :", silhouette_avg)
  42. #调用silhouette_samples生成每个样本点的轮廓系数，就是横坐标
  43. sample_silhouette_values = silhouette_samples(X, cluster_labels)
  46. #设定y的初始取值
  47. y_lower = 10
  49. #接下来对每一个簇进行循环
  50. for i in range(n_clusters):
  51.     #从每个样本的轮廓系数结果中抽取出第i个簇的轮廓系数，sample_silhouette_values是每个样本的轮廓系数取值
  52.     ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
  53.     #然后对他进行排序
  54.     ith_cluster_silhouette_values.sort()
  55.     #查看这一个簇中有多少个样本
  56.     size_cluster_i = ith_cluster_silhouette_values.shape[0]
  57.     #这个簇在y上的取值就是y_lower=10开始，到初始值加上这个簇中样本数量结束（y_upper）
  58.     y_upper = y_lower + size_cluster_i
  61.     #在coclormap库中，使用小数来调用颜色的函数
  62.     #在nipy_spectral（）输入任意小数来代表颜色
  63.     #所以我们用i的浮点数除以n_clusters，在不同的i下，自然生成不同的小数
  64.     color = cm.nipy_spectral(float(i)/n_clusters)
  66.     #开始填充图1的内容
  67.     #fill_between是让一个范围中的柱状图都统一颜色的函数
  68.     #fill_betweenx的范围是在纵坐标上
  69.     #fill_betweeny的范围是在横坐标上
  70.     #fill_betweenx的参数输入（纵坐标的下限，上限，x轴上的取值，柱状图的颜色）
  71.     ax1.fill_betweenx(np.arange(y_lower, y_upper)
  72.                                 ,ith_cluster_silhouette_values #横坐标的取值是每一簇样本对应的轮廓系数
  73.                                 ,facecolor=color
  74.                                 ,alpha=0.7
  75.                                 )
  77.     #为每个簇的轮廓系数添加编号，且簇的编号显示在每个条形图的中间位置
  78.     #text(要显示编号的横坐标，纵坐标，编号内容)
  79.     ax1.text(-0.05 #在左边
  80.                 , y_lower + 0.5 * size_cluster_i #放在中间
  81.                 , str(i))
  83.     #每一次迭代后，y轴的上限+10，就是下一簇计算新的y轴的初始值
  84.     y_lower = y_upper + 10
  87. #给图1加标签和横纵坐标标签
  88. ax1.set_title("The silhouette plot for the various clusters.")
  89. ax1.set_xlabel("The silhouette coefficient values")
  90. ax1.set_ylabel("Cluster label")
  92. #将轮廓系数均值划线，可以看到哪个簇分的更好
  93. ax1.axvline(x=silhouette_avg, color="red", linestyle="--")
  95. #y轴不显示刻度，因为我不想知道每个簇有多少个样本
  96. ax1.set_yticks([])
  97. ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
  99. #这样子图1就处理完毕了
  103. #开始画第二个图：各个类之间的轮廓系数的对比
  104. #获取新颜色。cluster_labels.astype(float)取出500个颜色取出，但其实只有4类
  105. colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
  107. ax2.scatter(X[:, 0], X[:, 1]
  108.             ,marker='o'
  109.             ,s=8
  110.             ,c=colors
  111.             )
  113. #把质心放到图像中
  114. centers = clusterer.cluster_centers_
  115. # Draw white circles at cluster centers
  116. ax2.scatter(centers[:, 0], centers[:, 1], marker='x',
  117.             c="red", alpha=1, s=200)
  119. #设置标题
  120. ax2.set_title("The visualization of the clustered data.")
  121. ax2.set_xlabel("Feature space for the 1st feature")
  122. ax2.set_ylabel("Feature space for the 2nd feature")
  124. #为整个图设置标题
  125. plt.suptitle(("Silhouette analysis for KMeans clustering on sample data "
  126. "with n_clusters = %d" % n_clusters),
  127. fontsize=14, fontweight='bold')
  128. plt.show()

机器学习：10--聚类算法KMeans - 图9

将上面代码包装成循环

  1. from sklearn.cluster import KMeans
  2. from sklearn.metrics import silhouette_samples, silhouette_score
  3. import matplotlib.pyplot as plt
  4. import matplotlib.cm as cm
  5. import numpy as np
  7. for n_clusters in [2,3,4,5,6,7]:
  8.     n_clusters = n_clusters
  9.     fig, (ax1, ax2) = plt.subplots(1, 2)
  10.     fig.set_size_inches(18, 7)
  11.     ax1.set_xlim([-0.1, 1])
  12.     ax1.set_ylim([0, X.shape[0] + (n_clusters + 1) * 10])
  13.     clusterer = KMeans(n_clusters=n_clusters, random_state=10).fit(X)
  14.     cluster_labels = clusterer.labels_
  15.     silhouette_avg = silhouette_score(X, cluster_labels)
  16.     print("For n_clusters =", n_clusters,
  17.     "The average silhouette_score is :", silhouette_avg)
  18.     sample_silhouette_values = silhouette_samples(X, cluster_labels)
  19.     y_lower = 10
  20.     for i in range(n_clusters):
  21.         ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
  22.         ith_cluster_silhouette_values.sort()
  23.         size_cluster_i = ith_cluster_silhouette_values.shape[0]
  24.         y_upper = y_lower + size_cluster_i
  25.         color = cm.nipy_spectral(float(i)/n_clusters)
  26.         ax1.fill_betweenx(np.arange(y_lower, y_upper)
  27.                                     ,ith_cluster_silhouette_values
  28.                                     ,facecolor=color
  29.                                     ,alpha=0.7
  30.                                     )
  31.         ax1.text(-0.05
  32.                     , y_lower + 0.5 * size_cluster_i
  33.                     , str(i))
  35.         y_lower = y_upper + 10
  37.     ax1.set_title("The silhouette plot for the various clusters.")
  38.     ax1.set_xlabel("The silhouette coefficient values")
  39.     ax1.set_ylabel("Cluster label")
  40.     ax1.axvline(x=silhouette_avg, color="red", linestyle="--")
  41.     ax1.set_yticks([])
  42.     ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
  43.     colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
  44.     ax2.scatter(X[:, 0], X[:, 1]
  45.                 ,marker='o'
  46.                 ,s=8
  47.                 ,c=colors
  48.                 )
  49.     centers = clusterer.cluster_centers_
  50.     # Draw white circles at cluster centers
  51.     ax2.scatter(centers[:, 0], centers[:, 1], marker='x',
  52.     c="red", alpha=1, s=200)
  53.     ax2.set_title("The visualization of the clustered data.")
  54.     ax2.set_xlabel("Feature space for the 1st feature")
  55.     ax2.set_ylabel("Feature space for the 2nd feature")
  56.     plt.suptitle(("Silhouette analysis for KMeans clustering on sample data "
  57.                   "with n_clusters = %d" % n_clusters),
  58.     fontsize=14, fontweight='bold')
  59.     plt.show()

机器学习：10--聚类算法KMeans - 图10

3.2 重要参数init & random_state & n_init?

init：是用来帮助我们决定初始化方式的参数。在sklearn中，默认使用”k-means++”的方法，不需要修改。 ”k-means ++“初始化方案，使得初始质心（通常）彼此远离，以此来引导出比随机初始化更可靠的结果。

n_init：是每个随机数种子下运行的次数。这个参数不常用到，默认10次。

random_state：控制每次质心随机初始化的随机数种子。

3.3 重要参数max_iter & tol：在数据量很大的时候，需要用到

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

3.4 重要属性和接口

机器学习：10--聚类算法KMeans - 图11