《菜菜的机器学习sklearn课堂》聚类算法Kmeans

古城微笑少年丶 2022-11-01 04:29 461阅读 0赞

### 聚类算法 ###

*  聚类算法
 *   *  无监督学习与聚类算法
     *  sklearn中的聚类算法
 *  KMeans
 *   *  KMeans是如何工作的
     *  簇内误差平方和的定义和解惑
 *  sklearn.cluster.KMeans
 *   *  重要参数 n\_clusters
     *  【实践】尝试聚类一次
     *  聚类算法的模型评估指标
     *   *  当真实标签已知的时候
         *  当真实标签未知的时候：轮廓系数
         *  当真实标签未知的时候：Calinski-Harabaz Index
 *  【案例】基于轮廓系数来选择n\_clusters

> [《菜菜的机器学习sklearn课堂》笔记目录 + 课件][sklearn_ _]

# 聚类算法 #

## 无监督学习与聚类算法 ##

我们已经学习了**决策树，随机森林，逻辑回归**，他们虽然有着不同的功能，但却都属于 **有监督学习** 的一部分，即是说：**模型在训练的时候，既需要特征矩阵X，也需要真实标签y**。

机器学习当中，还有相当一部分算法属于 **无监督学习**，无监督的算法在训练的时候**只需要特征矩阵X，不需要标签**。我们曾经学过的PCA降维算法就是无监督学习中的一种。聚类算法，也是无监督学习的代表算法之一。

**聚类算法又叫做“无监督分类”**，其目的是将数据划分成有意义或有用的组（或**簇**）。这种划分可以基于我们的业务需求或建模需求来完成，也可以单纯地帮助我们探索数据的自然结构和分布。

> 比如在商业中，如果我们手头有大量的当前和潜在客户的信息，我们可以使用聚类将客户划分为若干组，以便进一步分析和开展营销活动，最有名的客户价值判断模型RFM，就常常和聚类分析共同使用。  
>   
> 再比如，聚类可以用于降维和矢量量化（vector quantization），可以将高维特征压缩到一列当中，常常用于图像，声音，视频等非结构化数据，可以大幅度压缩数据量。

--------------------

**聚类 vs 分类**：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 2]

## sklearn中的聚类算法 ##

聚类算法在sklearn中有两种表现形式：

*  **类**（和我们之前学过的分类算法以及数据预处理方法一样）  
    需要实例化，训练并使用接口和属性来调用结果
 *  **函数**（function）  
    只需要输入特征矩阵和超参数，即可返回聚类的结果和各种指标

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 4]  
注意：**该模块中实现的算法可以采用不同类型的矩阵作为输入**

*  所有方法都接受形状`[n_samples，n_features]`的标准特征矩阵  
    这些可以从`sklearn.feature_extraction`模块中的类中获得
 *  对于亲和力传播，光谱聚类和DBSCAN 还可以输入形状`[n_samples, n_samples]`的相似性矩阵  
    可以使用`sklearn.metrics.pairwise`模块中的函数来获取相似性矩阵

# KMeans #

## KMeans是如何工作的 ##

作为聚类算法的典型代表，KMeans可以说是最简单的聚类算法没有之一，那它是怎么完成聚类的呢？

--------------------

**关键概念：簇与质心**  
KMeans算法将一组N个样本的特征矩阵X划分为K个无交集的簇，直观上来看是簇是一组一组聚集在一起的数据，在一个簇中的数据就认为是同一类；簇就是聚类的结果表现。  
簇中所有数据的均值 μ \\mu μ通常被称为这个簇的**质心(centroids)**。在一个二维平面中，一簇数据点的质心的横坐标就是这一簇数据点的横坐标的均值，质心的纵坐标就是这一簇数据点的纵坐标的均值。同理可推广至高维空间。

--------------------

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

<table> 
 <thead> 
  <tr> 
   <th>顺序</th> 
   <th>过程</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>随机抽取K个样本作为最初的质心</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>开始循环：</td> 
  </tr> 
  <tr> 
   <td>2.1</td> 
   <td>将每个样本点分配到离他们最近的质心，生成K个簇</td> 
  </tr> 
  <tr> 
   <td>2.2</td> 
   <td>对于每个簇，计算所有被分到该簇的样本点的平均值作为新的质心</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>当质心的位置不再发生变化，迭代停止，聚类完成</td> 
  </tr> 
 </tbody> 
</table>

什么情况下，质心的位置会不再变化呢？

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

这个过程在可以由下图来显示，我们规定将数据分为4(K=4)，其中白色X代表质心的位置：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][20210223221213768.gif]  
可以看见，第六次迭代之后，基本上质心的位置就不再改变了，生成的簇也变得稳定。此时我们的聚类就完成了，我们可以明显看出，KMeans按照数据的分布，将数据聚集成了我们规定的4类，接下来我们就可以按照我们的业务需求或者算法需求，对这四类数据进行不同的处理。

## 簇内误差平方和的定义和解惑 ##

聚类算法聚出的类有什么含义呢？这些类有什么样的性质？

我们认为，**被分在同一个簇中的数据是有相似性的，而不同簇中的数据是不同的**，当聚类完毕之后，我们就要分别去研究每个簇中的样本都有什么样的性质，从而根据业务需求制定不同的商业或者科技策略。

> 这个听上去和评分卡案例中讲解的“**分箱**”概念有些类似，即我们分箱的目的是希望：一个箱内的人有着相似的信用风险，而不同箱的人的信用风险差异巨大，以此来区别不同信用度的人，因此我们追求“**组内差异小，组间差异大**”。

聚类算法也是同样的目的，我们追求“**簇内差异小，簇外差异大**”。而这个“差异“，由样本点到其所在簇的质心的距离来衡量。

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

*  令 x x x表示簇中的一个样本点
 *   μ \\mu μ表示该簇中的质心
 *  n表示每个样本点中的特征数目
 *  i表示组成点 x x x的每个特征

则该样本点到质心的距离可以由以下距离来度量：

*  欧几里得距离 ： d ( x , μ ) = ∑ i = 1 n ( x i − x μ ) 2 d(x, \\mu) = \\sqrt\{\\sum\_\{i=1\} ^n (x\_i - x\_\\mu)^2\} d(x,μ)=i=1∑n(xi−xμ)2
 *  曼哈顿距离： d ( x , μ ) = ∑ i = 1 n ( ∣ x i − μ ∣ ) d(x, \\mu) = \\sum\_\{i=1\}^\{n\}(|x\_i - \\mu|) d(x,μ)=i=1∑n(∣xi−μ∣)
 *  余弦距离： c o s θ = ∑ 1 n ( x i ∗ μ ) ∑ 1 n ( x i ) 2 ∗ ∑ 1 n ( μ ) 2 cos\\theta = \\frac \{ \\sum \_1^n(x\_i \* \\mu)\} \{\\sqrt \{\\sum\_1^n(x\_i)^2\} \* \\sqrt\{\\sum\_1^n(\\mu)^2\}\} cosθ=∑1n(xi)2∗∑1n(μ)2∑1n(xi∗μ)

如我们采用欧几里得距离，则一个簇中所有样本点到质心的距离的平方和为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 6]  
其中，m为一个簇中样本的个数，j是每个样本的编号。

这个公式被称为**簇内平方和(cluster Sum of Square)**，又叫做Inertia。而将一个数据集中的所有簇的簇内平方和相加，就得到了**整体平方和(Total Cluster Sum ofSquare)**，又叫做total inertia。Total Inertia越小，代表着每个簇内样本越相似，聚类的效果就越好。因此KMeans追求的是：**求解能够让Inertia最小化的质心**。

实际上，在质心不断变化不断迭代的过程中，总体平方和是越来越小的。我们可以使用数学来证明，当整体平方和最小的时候，质心就不再发生变化了。如此，K-Means的求解过程，就变成了一个最优化问题。

> 这是我们第二次遇见最优化问题，即需要将某个指标最小化来求解模型中的一部分信息。  
> 记得我们在逻辑回归中式怎么做的吗：我们在一个固定的方程 y ( x ) = 1 e θ T x y(x) = \\frac 1 \{e^\{\\theta^Tx\}\} y(x)=eθTx1中最小化损失函数来求解模型的参数向量 θ \\theta θ，并且基于参数向量 θ \\theta θ的存在去使用模型。

在KMeans中，我们在一个固定的簇数K下，最小化总体平方和来求解最佳质心，并基于质心的存在去进行聚类。两个过程十分相似，并且，整体距离平方和的最小值其实可以使用梯度下降来求解。因此，有许多博客和教材都这样写道：“簇内平方和/整体平方和是KMeans的损失函数”。

> **解惑：Kmeans有损失函数吗？**  
> 损失函数本质是用来衡量模型的拟合效果的，只有有着求解参数需求的算法，才会有损失函数。  
> Kmeans不求解什么参数，它的模型本质也没有在拟合数据，而是在对数据进行一种探索。所以如果你去问大多数数据挖掘工程师，甚至是算法工程师，他们可能会告诉你说，K-Means不存在什么损失函数，Inertia更像是Kmeans的模型评估指标，而非损失函数。  
>   
> 但我们类比过了Kmeans中的Inertia和逻辑回归中的损失函数的功能，发现它们确实非常相似。所以，从“求解模型中的某种信息，用于后续模型的使用“这样的功能来看，我们可以认为Inertia是Kmeans中的损失函数，虽然这种说法并不严谨。  
>   
> 对比来看，在决策树中，我们有衡量分类效果的指标准确度accuracy，准确度所对应的损失叫做泛化误差，但我们不能通过最小化泛化误差来求解某个模型中需要的信息，我们只是希望模型的效果上表现出来的泛化误差很小。因此决策树，KNN等算法，是绝对没有损失函数的。

大家可以发现，我们的Inertia是基于欧几里得距离的计算公式得来的。实际上，我们也可以使用其他距离，每个距离都有自己对应的Inertia。在过去的经验中，我们总结出不同距离所对应的质心选择方法和Inertia，在Kmeans中，只要使用了正确的质心和距离组合，无论使用什么样的距离，都可以达到不错的聚类效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 7]  
这些组合，都可以由严格的数学证明来推导。在sklearn当中，我们无法选择使用的距离，只能使用欧式距离。因此，我们也无需去担忧这些距离所搭配的质心选择是如何得来的了。

# 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’
    )

## 重要参数 n\_clusters ##

`n_clusters` 是 KMeans 中的 k，表示着我们告诉模型我们要分几类

*  这是KMeans当中唯一一个必填的参数，默认为8类，但通常我们的聚类结果会小于8
 *  开始聚类之前，我们通常并不知道`n_clusters`究竟是多少，因此我们要对它进行探索

## 【实践】尝试聚类一次 ##

当我们拿到一个数据集，如果可能的话，我们希望能够通过绘图先观察一下这个数据集的数据分布，以此来为我们聚类时输入的`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)
    fig, ax1 = plt.subplots(1)
    ax1.scatter(X[:, 0], X[:, 1]
               ,marker='o' #点的形状
               ,s=8 #点的大小
               )
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 8]

基于这个分布，我们来使用Kmeans进行聚类。首先，我们要猜测一下，这个数据中有几簇？

*  根据上面画出的图，我们先猜测有 3 簇

from sklearn.cluster import KMeans
    n_clusters = 3
    cluster = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
    
    y_pred = cluster.labels_ #标签类别
    y_pred
    
    pre = cluster.fit_predict(X)
    pre == y_pred
    
    cluster_smallsub = KMeans(n_clusters=n_clusters, random_state=0).fit(X[:200])
    y_pred_ = cluster_smallsub.predict(X)
    y_pred == y_pred_
    
    centroid = cluster.cluster_centers_ # 质心
    centroid
    """ array([[-8.09286791, -3.50997357], [-1.54234022, 4.43517599], [-7.0877462 , -8.08923534]]) """
    
    centroid.shape
    """ (3, 2) """
    
    inertia = cluster.inertia_ #簇内平方和
    inertia
    """ 1903.5342237665059 """

画出 n\_clusters = 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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 9]  
调整 n\_clusters 的值，查看对应的**簇内平方和**：

*  发现当 n\_clusters 越大，簇内平方和越小，这能说明聚类效果好吗？（**并不能**）

n_clusters = 4
    cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
    inertia_ = cluster_.inertia_
    inertia_
    """ 908.3855684760603 """
    
    n_clusters = 5
    cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
    inertia_ = cluster_.inertia_
    inertia_
    """ 811.0952123653016 """
    
    n_clusters = 6
    cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
    inertia_ = cluster_.inertia_
    inertia_
    """ 728.2827697678249z """

**查看点的实际分布**

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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 10]

## 聚类算法的模型评估指标 ##

不同于分类模型和回归，聚类算法的模型评估不是一件简单的事。

> 在分类中，有直接结果（标签）的输出，并且分类的结果有正误之分，所以我们使用预测的准确度，混淆矩阵，ROC曲线等等指标来进行评估，但无论如何评估，都是在”模型找到正确答案“的能力。  
>   
> 而回归中，由于要拟合数据，我们有SSE均方误差，有损失函数来衡量模型的拟合程度。  
>   
> 但这些衡量指标都不能够使用于聚类。

> **面试高频问题：如何衡量聚类算法的效果？**  
> 聚类模型的结果不是某种标签输出，并且聚类的结果是不确定的，其优劣由业务需求或者算法需求来决定，并且没有永远的正确答案。那我们如何衡量聚类的效果呢？

记得我们说过，KMeans的目标是确保“**簇内差异小，簇外差异大**”，我们就可以通过**衡量簇内差异来衡量聚类的效果**。而`Inertia`是用距离来衡量簇内差异的指标，因此，我们是否可以使用Inertia来作为聚类的衡量指标呢？Inertia越小模型越好嘛?

可以，但是这个指标的缺点和极限太大。

*  首先，**它不是有界的**。我们只知道，Inertia是越小越好，是0最好，但我们不知道，一个较小的Inertia究竟有没有达到模型的极限，能否继续提高。
 *  第二，**它的计算太容易受到特征数目的影响**，数据维度很大的时候，Inertia的计算量会陷入维度诅咒之中，计算量会爆炸，不适合用来一次次评估模型。
 *  第三，**它会受到超参数K的影响**，在我们之前的尝试中其实我们已经发现，随着K越大，Inertia注定会越来越小，但这并不代表模型的效果越来越好了
 *  第四，**Inertia对数据的分布有假设**，它假设数据满足凸分布（即数据在二维平面图像上看起来是一个凸函数的样子），并且它假设数据是各向同性的（isotropic），即是说数据的属性在不同方向上代表着相同的含义。但是现实中的数据往往不是这样。所以使用Inertia作为评估指标，会让聚类算法在一些细长簇，环形簇，或者不规则形状的流形时表现不佳：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 11]

那我们可以使用什么指标呢？分两种情况来看。

*  真实标签已知的时候
 *  真实标签未知的时候

### 当真实标签已知的时候 ###

虽然我们在聚类中不输入真实标签，但这不代表我们拥有的数据中一定不具有真实标签，或者一定没有任何参考信息。当然，**在现实中，拥有真实标签的情况非常少见（几乎是不可能的）**。如果拥有真实标签，我们更倾向于使用**分类算法**。但不排除我们依然可能使用聚类算法的可能性。如果我们有样本真实聚类情况的数据，我们可以对于聚类算法的结果和真实结果来衡量聚类的效果。常用的有以下三种方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 12]

### 当真实标签未知的时候：轮廓系数 ###

99%的情况下，我们是对没有真实标签的数据进行探索，也就是对不知道真正答案的数据进行聚类。这样的聚类，**完全依赖于评价簇内的稠密程度（簇内差异小）和簇间的离散程度（簇外差异大）来评估聚类的效果**。其中**轮廓系数**是最常用的聚类算法的评价指标。它是对每个样本来定义的，它能够同时衡量：

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

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

单个样本的轮廓系数计算为：  
 s = b − a m a x ( a , b ) s = \\frac \{b-a\} \{max(a,b)\} s=max(a,b)b−a  
这个公式可以被解析为：  
 s = \{ 1 − a b , i f a < b 0 , i f a = b b a − 1 , i f a > b s = \\left\\\{\\begin\{matrix\} 1- \\frac a b , & if a < b \\\\ 0,& if a = b\\\\ \\frac b a - 1, & if a > b \\end\{matrix\}\\right. s=⎩⎨⎧1−ba,0,ab−1,ifa<bifa=bifa>b  
很容易理解轮廓系数范围是(-1,1)

*  值越接近1表示样本与自己所在的簇中的样本很相似，并且与其他簇中的样本不相似
 *  当样本点与簇外的样本更相似的时候，轮廓系数就为负。
 *  当轮廓系数为0时，则代表两个簇中的样本相似度一致，两个簇本应该是一个簇

可以总结为：**轮廓系数越接近于1越好，负数则表示聚类效果非常差**。

如果一个簇中的大多数样本具有比较高的轮廓系数，则簇会有较高的总轮廓系数，则整个数据集的平均轮廓系数越高，则聚类是合适的。如果许多样本点具有低轮廓系数甚至负值，则聚类是不合适的，聚类的超参数K可能设定得太大或者太小。

在sklearn中，我们使用模块`sklearn.metrics`中的`silhouette_score`类来计算轮廓系数，它返回的是一个数据集中所有样本的轮廓系数的均值。

*  `silhouette_sample` 的参数与轮廓系数一致，但返回数据集中每个样本自己的轮廓系数

我们来看看轮廓系数在我们自建的数据集上表现如何：

from sklearn.metrics import silhouette_score
    from sklearn.metrics import silhouette_samples
    
    X
    
    y_pred
    
    silhouette_score(X,y_pred)
    
    silhouette_score(X,cluster_.labels_)
    
    silhouette_samples(X,y_pred)

轮廓系数有很多优点：

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

但轮廓系数也有缺陷，它在凸型的类上表现会虚高，比如基于密度进行的聚类，或通过DBSCAN获得的聚类结果，如果使用轮廓系数来衡量，则会表现出比真实聚类效果更高的分数。

### 当真实标签未知的时候：Calinski-Harabaz Index ###

…

# 【案例】基于轮廓系数来选择n\_clusters #

我们通常会绘制轮廓系数分布图和聚类后的数据分布图来选择我们的最佳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
    
    n_clusters = 4
    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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 13]  
将上述过程包装成一个循环，可以得到：

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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 18]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 19]

[sklearn_ _]: https://blog.csdn.net/weixin_43734095/article/details/113793087
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]: /images/20221024/ef266d8c246647e49140a7d7ad2b6460.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/7ece3bc5e3ef466aaaf058d9bef5a3c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 2]: /images/20221024/400698e0aa2c4becb2288df92f497325.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 3]: /images/20221024/38b718da4561478a89afcc329512bba6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 4]: /images/20221024/76bd8186bcaa4dea9bd2debeddc6a653.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 5]: /images/20221024/5ea2708aabd74a688b5fb3fafda42629.png
[20210223221213768.gif]: /images/20221024/d16dd29113e240698faa6c77c531bdac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 6]: /images/20221024/b30081fc0b8448389f54129ff6935516.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 7]: /images/20221024/8b35a22874c249c2a4c8f182db48ae35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 8]: /images/20221024/e6bb756ae4124ec18aad0d989808c7e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 9]: /images/20221024/e7f1144a39ab4857adea663dfc9d4d6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 10]: /images/20221024/2f428c0dd3064a00a5b5ec2368c5043d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 11]: /images/20221024/e45a2f29de294313a869832ffbfc0d0e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 12]: /images/20221024/ea37f9c1b8c74cf0a164b0f333ddada6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 13]: /images/20221024/222cc4771ee24bc5aed3a3ea84e92dce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 14]: /images/20221024/19cfd6b9e9dc4aa784990c289bf987b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 15]: /images/20221024/915449355e47487bb4dca17e490cd57f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 16]: /images/20221024/6fc0ed1ed1ae4ee0b72f9ec05ef51f85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 17]: /images/20221024/36103c7f2f834a9b9988bba12494eb63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 18]: /images/20221024/b75a155e6a734a748fc1b93d4bfd5569.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 19]: /images/20221024/b1e2afdbc40045ec8ab8f8a3fd7ac9c2.png