sklearn：六、聚类算法

6.1 概述

6.1.1 无监督学习与聚类算法

无监督学习：在训练的时候只需要特征矩阵X，不需要标签；
聚类算法/无监督分类作用：将数据划分成有意义或有用的组（或簇）；

聚类和分类的对比

他俩内容的对比

6.1.2 sklearn里头的聚类算法

两种表现形式：

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

输入数据：该模块中实现的算法可以采用不同类型的矩阵作为输入。通用的矩阵形状是：[n_samples，n_features]的标准特征矩阵（可以从从sklearn.feature_extraction模块中的类中获得）/对于亲和力传播、光谱聚类和DBSCAN，可以输入[n_samples，n_samples]的相似性矩阵（可以使用sklearn.metrics.pairwise模块中的函数来获取相似性矩阵）；

6.2 KMeans

6.2.1 工作原理

在KMeans算法中，簇的个数K是一个超参数，需要我们人为输入来确定；

核心任务：根据我们设定好的K，找出K个最优的质心，并将离这些质心最近的数据分别分配到这些质心代表的簇中去；
过程：如下图所示：

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

此过程图像化就是下面这样：规定将数据分为4簇（K=4），其中白色X代表质心的位置

image.png

从右边的那个图可以看出：第六次迭代之后，基本上质心的位置就不再改变了，生成的簇也变得稳定。此时聚类就完成了，接下来就可以对这四类数据进行不同的处理；

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

类的含义/性质：被分在同一个簇中的数据是有相似性的，而
不同簇中的数据是不同的；

目标：簇内差异小，簇外差异大——>差异：由样本点到其所在簇的质心的距离来衡量；
对于一个簇来说，所有样本点到质心的距离之和越小，我们就认为这个簇中的样本越相似，簇内差异就越小；

各种距离算法：

采用欧几里得距离，那么对应的则一个簇中所有样本点到质心的距离的平方和为：

其中，m为一个簇中样本的个数，j是每个样本的编号

这个公式被称为簇内平方和(cluster Sum of Square/Inertia)。而将一个数据集中的所有簇的簇内平方和相加，就得到了整体平方和（Total Cluster Sum of Square/Total Inertial）。Total Inertia越小，代表着每个簇内样本越相似，聚类的效果就越好
——>KMeans追求的是，求解能够让Inertia最小化的质心;
整体平方和可以用梯度下降来进行求解。因此，有人就把整体平方和来作为损失函数；

使用不同的距离度量有着不同的质心和距离组合：

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

6.3.1 重要参数n_clusters

就是Kmeans中的K，表示着告诉模型我们要分几类。需要通过慢慢优化来得到最好的K

6.3.1.1 进行一次聚类

在拿到一个数据集后，最好先画个图然后看看它的数据分布，作为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()

#通过如下代码来看点的分布
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进行聚类。首先，先来确定一下有几类

from sklearn.cluster import KMeans
n_clusters = 3

cluster = KMeans(n_clusters=n_clusters, random_state=0).fit(X)

#重要属性：labels_,查看聚好的类别，每个样本所对应的类
y_pred = cluster.labels_
y_pred

#KMeans因为并不需要建立模型/预测结果，因此只用fit就能得到聚类结果
#Keamns也有接口predict和fit_predict，表示学习数据X并对其类进行预测
#但所得到的结果和不调用predict，直接fit之后调用labels_的结果一样
pre = cluster.fit_predict(X)
pre == y_pred

#当数据量过大的时候用predict
#但其实不用所有数据来找质心也可以。因此，在数据量过大的时候，可以使用部分数据来确认质心
#剩下的数据的聚类结果，用predict来调用

cluster_smallsub = KMeans(n_clusters=n_clusters, random_state=0).fit(X[:200])
y_pred_ = cluster_smallsub.predict(X)
y_pred == y_pred_

不知道为啥我这边全是false。。。可能现在这东西变笨了吧
但是当数据量太大的时候就可以使用类似的方法来通过少量数据获得近似的质心

#重要属性cluster_centers_,查看质心
centroid = cluster.cluster_centers_
centroid
#array([[-8.0807047 , -3.50729701],
#       [-1.54234022,  4.43517599],
#       [-7.11207261, -8.09458846]])

centroid.shape
#(3, 2)
#代表着拥有两个特征的三个点

#重要属性inertia_，查看总距离平方和
inertia = cluster.inertia_
inertia
#1903.5607664611762

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

#查看不同数量的簇对应的分类结果
n_clusters = 4
cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
inertia_ = cluster_.inertia_
inertia_
#908.3855684760613

n_clusters = 5
cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
inertia_ = cluster_.inertia_
inertia_
#811.0841324482413

n_clusters = 6
cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
inertia_ = cluster_.inertia_
inertia_
#733.1538350083081

可以看出，随着簇心得变多，inertia不断变小；因此其不能作为模型评估指标

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

当标签已知时：这种情况比较少，就算有也比较喜欢用分类算法。但偶尔也会选择聚类算法，可以对于聚类算法的结果和真实结果来衡量聚类的效果。常用的有以下三种方法：

当真实标签未知的时候：轮廓系数：绝大多数情况下都是对没有真实标签的数据进行探索——>完全依赖于评价簇内的稠密程度（簇内差异小）和簇间的离散程度（簇外差异大）来评估。这时候就用到了轮廓系数，它能够同时衡量：

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

根据准则，我们希望b永远大于a，并且大得越多越好；

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

将上面公式展开的话就是：

很容易理解轮廓系数范围是(-1,1)，其中值越接近1表示样本与自己所在的簇中的样本很相似，并且与其他簇中的样本不相似，当样本点与簇外的样本更相似的时候，轮廓系数就为负；当轮廓系数为0时，则代表两个簇中的样本相似度一致，两个簇本应该是一个簇。可以总结为轮廓系数越接近于1越好，负数则表示聚类效果非常差

总之，为轮廓系数越接近于1越好，负数则表示聚类效果非常差。；

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

#查看轮廓系数
from sklearn.metrics import silhouette_score
from sklearn.metrics import silhouette_samples

X

#.labels
y_pred

#输入两个参数：特征矩阵和运行结果
silhouette_score(X,y_pred)
#0.5882004012129721

#用n_clusters为4时来计算轮廓系数
silhouette_score(X,cluster_.labels_)
#0.6505186632729437
#可以看到，分4簇的效果比3簇要好

#用n_clusters为5时来计算轮廓系数
silhouette_score(X,cluster_.labels_)
#0.5746932321727456

#用n_clusters为6时来计算轮廓系数
silhouette_score(X,cluster_.labels_)
#0.5150064498560357
#可以看到4簇最好用

#返回每个样本的轮廓系数
silhouette_samples(X,y_pred)

优点：它在有限空间中取值，使得我们对模型的聚类效果有一个“参考”。并且，轮廓系数对数据的分布没有假设，因此在很多数据集上都表现良好。但它在每个簇的分割比较清洗时表现最好；
缺点：它在凸型的类上表现会虚高，比如基于密度进行的聚类，或通过DBSCAN获得的聚类结果，如果使用轮廓系数来衡量，则会表现出比真实聚类效果更高的分数；
当真实标签未知的时候：Calinski-Harabaz Index：除了之前讲的那个轮廓系数，这边还有仨可选：

卡林斯基-哈拉巴斯(Calinski-Harabaz)指数：值越高越好。对于有k个簇的聚类而言，其对应的公式如下：

其中N为数据集中的样本量，_k为簇的个数（即类别的个数），B_k是组间离散矩阵，即不同簇之间的协方差矩阵，W_k是簇内离散矩阵，即一个簇内数据的协方差矩阵，而tr表示矩阵的迹（主对角线上元素总和），数据之间的离
散程度越高，协方差矩阵的迹就会越大；

from sklearn.metrics import calinski_harabasz_score

X
y_pred

calinski_harabasz_score(X, y_pred)
#1809.991966958033

虽然calinski-Harabaz指数没有界，在凸型的数据上的聚类也会表现虚高，但是它算的快啊

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

通常会绘制轮廓系数分布图和聚类后的数据分布图来选择我们的最佳n_clusters

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score

import matplotlib.pyplot as plt
#colormap
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)
#第一个图是轮廓系数图像，由各个簇的轮廓系数组成的横向条形图
#横向条形图的横坐标是轮廓系数取值，纵坐标是样本

#首先设定横坐标
#轮廓系数得分取值范围是[-1,1]，但是一般都希望要大于0
#太长的横坐标也不利于可视化，因此设定x周取值在[-0.1,1]之间
ax1.set_xlim([-0.1, 1])

#然后设置纵坐标，一般是从0开始到X.shape[0]
#但是最好能让每个簇排在一起，不同的簇之间有一定的空隙
#以便看到不同的条形图聚合所得的块
#因此在设置纵坐标取值时，在X.shape[0]上，加了一个距离(n_clusters + 1)*10,留作间隔用
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_score生成的是均值
# 两个参数是：特征矩阵X和聚类后的标签
silhouette_avg = silhouette_score(X, cluster_labels)
#用print来报下结果，现在簇数量下，整体的轮廓系数有多少
print("For n_clusters =", n_clusters,
      "The average silhouette_score is :", silhouette_avg)

# 调用silhouette_samples，返回每个样本点的轮廓系数，即横坐标
sample_silhouette_values = silhouette_samples(X, cluster_labels)

#设定y轴上的初始值
y_lower = 10

#对每个簇进行循环
for i in range(n_clusters):
    #从每个样本的轮廓系数结果中抽取出第i个簇的轮廓系数，并对其进行排序
    ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
    #注意，.sort()这个命令会直接改掉原数据顺序
    ith_cluster_silhouette_values.sort()
    #查看该簇中有多少样本
    size_cluster_i = ith_cluster_silhouette_values.shape[0]
    #该簇再轴上的取值，应该是由初始值开始，到初始值+样本数y_upper
    y_upper = y_lower + size_cluster_i
    
    #colormap库中的，使用小数来调用颜色函数
    #在nipy_spectral([输入任意小数代表一个颜色])
    #在此希望每个簇的颜色不同，需要的颜色种类刚好是循环的个数的种类
    #要确保每次循环生成的小数不同，可以任意方式来获取小鼠
    #此处用的是i的浮点数/n_clusters，在不同的i下，自然生成不同的小数，以确保所有簇都有不同颜色
    #不用随机数是因为在对n_clusters循环时，每次取出的颜色都不一样，不好看了就
    color = cm.nipy_spectral(float(i)/n_clusters)
    
    #开始填充子图1中的内容
    #fill_between是填充曲线与直角之间的空间的函数
    #fill_betweenx的直角在纵坐标上
    #fill_betweeny的直角在横坐标上
    #fill_betweenx的参数应该输入(定义曲线的点的横坐标，定义曲线的点的纵坐标，柱状图的颜色)
    ax1.fill_betweenx(np.arange(y_lower, y_upper)
                      ,ith_cluster_silhouette_values
                      ,facecolor=color
                      ,alpha=0.7
                     )
    
    #为每个簇的轮廓系数协商簇的编号，并让簇的编号显示坐标轴上的每个条形图的中间位置
    #text的参数为(要显示编号的位置的横坐标，要显示编号的位置的纵坐标，要显示的编号内容)
    ax1.text(-0.05
            ,y_lower + 0.5 * size_cluster_i
            , str())
    
    #为下一个簇计算新的y轴上的初始值，时每一次迭代之后，y的上限+10
    #一次来保证：不同的簇的图像之间有空隙
    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="--")

#让y轴不显示刻度
ax1.set_yticks([])

#让x轴的刻度为规定值
ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])

对于每个簇，都有其对应的y_lowwer/upper，至此，子图1处理完毕

下面要一起跑才能出两个图

#第一个图：每个聚类的轮廓系数是多少，记忆每个类之间的轮廓系数的比较
#第二个图：聚类完毕后图像分布的样子

#先设定要分的簇数
n_clusters = 4
#创建画布，画布上共有一行两列两个图
fig, (ax1, ax2) = plt.subplots(1, 2)
#画布尺寸设置
fig.set_size_inches(18, 7)
#第一个图是轮廓系数图像，由各个簇的轮廓系数组成的横向条形图
#横向条形图的横坐标是轮廓系数取值，纵坐标是样本

#首先设定横坐标
#轮廓系数得分取值范围是[-1,1]，但是一般都希望要大于0
#太长的横坐标也不利于可视化，因此设定x周取值在[-0.1,1]之间
ax1.set_xlim([-0.1, 1])

#然后设置纵坐标，一般是从0开始到X.shape[0]
#但是最好能让每个簇排在一起，不同的簇之间有一定的空隙
#以便看到不同的条形图聚合所得的块
#因此在设置纵坐标取值时，在X.shape[0]上，加了一个距离(n_clusters + 1)*10,留作间隔用
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_score生成的是均值
# 两个参数是：特征矩阵X和聚类后的标签
silhouette_avg = silhouette_score(X, cluster_labels)
#用print来报下结果，现在簇数量下，整体的轮廓系数有多少
print("For n_clusters =", n_clusters,
      "The average silhouette_score is :", silhouette_avg)

# 调用silhouette_samples，返回每个样本点的轮廓系数，即横坐标
sample_silhouette_values = silhouette_samples(X, cluster_labels)

#设定y轴上的初始值
y_lower = 10

#对每个簇进行循环
for i in range(n_clusters):
    #从每个样本的轮廓系数结果中抽取出第i个簇的轮廓系数，并对其进行排序
    ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
    #注意，.sort()这个命令会直接改掉原数据顺序
    ith_cluster_silhouette_values.sort()
    #查看该簇中有多少样本
    size_cluster_i = ith_cluster_silhouette_values.shape[0]
    #该簇再轴上的取值，应该是由初始值开始，到初始值+样本数y_upper
    y_upper = y_lower + size_cluster_i
    
    #colormap库中的，使用小数来调用颜色函数
    #在nipy_spectral([输入任意小数代表一个颜色])
    #在此希望每个簇的颜色不同，需要的颜色种类刚好是循环的个数的种类
    #要确保每次循环生成的小数不同，可以任意方式来获取小鼠
    #此处用的是i的浮点数/n_clusters，在不同的i下，自然生成不同的小数，以确保所有簇都有不同颜色
    #不用随机数是因为在对n_clusters循环时，每次取出的颜色都不一样，不好看了就
    color = cm.nipy_spectral(float(i)/n_clusters)
    
    #开始填充子图1中的内容
    #fill_between是填充曲线与直角之间的空间的函数
    #fill_betweenx的直角在纵坐标上
    #fill_betweeny的直角在横坐标上
    #fill_betweenx的参数应该输入(定义曲线的点的横坐标，定义曲线的点的纵坐标，柱状图的颜色)
    ax1.fill_betweenx(np.arange(y_lower, y_upper)
                      ,ith_cluster_silhouette_values
                      ,facecolor=color
                      ,alpha=0.7)
    
    #为每个簇的轮廓系数协商簇的编号，并让簇的编号显示坐标轴上的每个条形图的中间位置
    #text的参数为(要显示编号的位置的横坐标，要显示编号的位置的纵坐标，要显示的编号内容)
    ax1.text(-0.05
             , y_lower + 0.5 * size_cluster_i
             , str())
    
    #为下一个簇计算新的y轴上的初始值，时每一次迭代之后，y的上限+10
    #一次来保证：不同的簇的图像之间有空隙
    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="--")

#让y轴不显示刻度
ax1.set_yticks([])

#让x轴的刻度为规定值
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()

每个簇都有样本超过了平均线，那么说明这个簇做的还算不错

接下来就是按照上面的方法来分别画出不同数量的簇下的分类效果

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

要根据实际情况来选择簇的数量；

6.3.2 重要参数init & random_state & n_init：初始质心怎么放才好?

是否能够收敛到真正的最小值很大程度上取决于质心的初始化。init就是用来帮助我们决定初始化方式的参数；

可以使用random_state参数来控制每次生成的初始质心都在相同位置，甚至可以画学习曲线来确定最优的random_state是哪个整数；

在sklearn中，我们使用参数init ='k-means ++'来选择使用k-means ++作为质心初始化的方案。通常来说，我建议保留默认的"k-means++"的方法；

plus = KMeans(n_clusters = 10).fit(X)
plus.n_iter_
#11

random = KMeans(n_clusters = 10,init="random",random_state=420).fit(X)
random.n_iter_
#19

6.3.3 重要参数max_iter & tol：让迭代停下来

在完全收敛之前，我们也可以使用max_iter，最大迭代次数，或者tol，两次迭代间Inertia下降的量，这两个参数来让迭代提前停下来。有时候，当我们的n_clusters选择不符合数据的自然分布，或者我们为了业务需求，必须要填入与数据的自然分布不合的n_clusters，提前让迭代停下来反而能够提升模型的表现；

#因为数据比较少，所以用random
random = KMeans(n_clusters = 10,init="random",max_iter=10,random_state=420).fit(X)
y_pred_max10 = random.labels_
silhouette_score(X,y_pred_max10)
#0.3952586444034157

random = KMeans(n_clusters = 10,init="random",max_iter=20,random_state=420).fit(X)
y_pred_max20 = random.labels_
silhouette_score(X,y_pred_max20)
#0.34015045375717007

6.3.4 重要属性与重要接口

6.3.5 函数cluster.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)

函数k_means的用法其实和类非常相似，不过函数是输入一系列值，而直接返回结果。函数k_means会依次返回质心，每个样本对应的簇的标签，inertia以及最佳迭代次数；

from sklearn.cluster import k_means

k_means(X,4,return_n_iter=True)
#参数return_n_iter默认为FALSE，条张伟True后可以看到返回的最佳迭代次数

6.4 案例：聚类算法用于降维，KMeans的矢量量化应用

非结构化数据往往占用比较多的储存空间，文件本身也会比较大，运算非常缓慢，我们希望能够在保证数据质量的前提下，尽量地缩小非结构化数据的大小，或者简化非结构化数据的结构——>矢量量化：KMeans聚类的矢量量化
本质是一种降维运用，不过矢量量化的降维是在同等样本量上压缩信息的大小，即不改变特征的数目也不改变样本的数目，只改变在这些特征下的样本上的信息量；

对于图像来说，一张图片上的信息可以被聚类如下表示：

这是一组40个样本的数据，分别含有40组不同的信息(x1,x2)。我们将代表所有样本点聚成4类，找出四个质心，我们认为，这些点和他们所属的质心非常相似，因此他们所承载的信息就约等于他们所在的簇的质心所承载的信息；

使用每个样本所在的簇的质心来覆盖原有的样本，有点类似四舍五入的感觉

导入需要的库

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.metrics import pairwise_distances_argmin
    #对两个序列中的点进行距离匹配的函数
from sklearn.datasets import load_sample_image
    #导入图片数据所用的类
from sklearn.utils import shuffle #洗牌

导入数据，探索数据

#实例化，导入颐和园的图片，一般都是三维数据
china = load_sample_image("china.jpg")

china

china.dtype
#dtype('uint8')

china.shape
#长度 x 宽度 x 像素 > 三个数决定的颜色
#(427, 640, 3)

china[0][0] 
#array([174, 201, 231], dtype=uint8)

#包含多少种不同的颜色?
newimage = china.reshape((427 * 640,3))
#(273280, 3)

import pandas as pd
pd.DataFrame(newimage).drop_duplicates().shape
#我们现在有9W多种颜色
#(96615, 3)

#图像可视化
plt.figure(figsize=(15,15))
#imshow只接受导入的三维数组所形成的图片
plt.imshow(china)

#查看模块中的另一张图
flower = load_sample_image("flower.jpg")
plt.figure(figsize=(15,15))
plt.imshow(flower)

图像现在有9W多种颜色。我们希望来试试看，能否使用K-Means将颜色压缩到64种，还不严重损耗图像的质量。为此，我们要使用K-Means来将9W种颜色聚类成64类，然后使用64个簇的质心来替代全部的9W种颜色，记得质心有着这样的性质：簇中的点都是离质心最近的样本点*；

需要随机选取64个样本点作为随机质心，计算原数据中每个样本到它们的距离来找出离每个样本最近的随机质心，然后用每个样本所对应的随机质心来替换原本的样本。两种状况下，我们观察图像可视化之后的状况，以查看图片信息的损失；

需要把数据处理成sklearn中的K-Means类能够接受的数据

决定超参数，数据预处理

#plt.imshow在浮点数上表现非常优异，在这里我们把china中的数据，转换为浮点数，压缩到[0,1]之间
china = np.array(china, dtype=np.float64) / china.max()

#把china从图像格式，转换成矩阵格式
w, h, d = original_shape = tuple(china.shape)

w
#427

h
#640

d
#3

assert d == 3
#assert相当于 raise error if not，表示为，“不为True就报错”
#要求d必须等于3，如果不等于，就报错

d_ = 5
assert d_ == 3, "一个格子中特征数不等于3"

#通过reshape来改变china的结构
#np.reshape(a, newshape, order='C'), reshape函数的第一个参数a是要改变结构的对象，第二个参数是要改变的新结构
image_array = np.reshape(china, (w * h, d))
image_array
#array([[0.68235294, 0.78823529, 0.90588235],
#       [0.68235294, 0.78823529, 0.90588235],
#       [0.68235294, 0.78823529, 0.90588235],
#       ...,
#       [0.16862745, 0.19215686, 0.15294118],
#       [0.05098039, 0.08235294, 0.02352941],
#       [0.05882353, 0.09411765, 0.02745098]])

image_array.shape
#(273280, 3)

对数据进行K-Means的矢量量化

n_clusters = 64

china = np.array(china, dtype=np.float64) / china.max()
w, h, d = original_shape = tuple(china.shape)
assert d == 3
image_array = np.reshape(china, (w * h, d))

#首先，先使用1000个数据来找出质心
#使用shuffle来打乱数据然后取出1000个数据来找质心
image_array_sample = shuffle(image_array, random_state=0)[:1000]
kmeans = KMeans(n_clusters=n_clusters, random_state=0).fit(image_array_sample)
kmeans.cluster_centers_.shape
#(64, 3)

#找出质心之后，按照已存在的质心对所有数据进行聚类
labels = kmeans.predict(image_array)
labels.shape
#(273280,)

#通过集合的去重查看labels中有多少类
set(labels)
#生成了0-63的数字

#使用质心来替换所有的样本
image_kmeans = image_array.copy()
image_kmeans 
#27W个样本点，9W多种不同的颜色（像素点）
#array([[0.68235294, 0.78823529, 0.90588235],
#       [0.68235294, 0.78823529, 0.90588235],
#       [0.68235294, 0.78823529, 0.90588235],
#       ...,
#       [0.16862745, 0.19215686, 0.15294118],
#       [0.05098039, 0.08235294, 0.02352941],
#       [0.05882353, 0.09411765, 0.02745098]])

labels 
#这27W个样本点所对应的簇的质心的索引

for i in range(w*h):
    image_kmeans[i] = kmeans.cluster_centers_[labels[i]]
    
#查看生成的新图片信息
image_kmeans.shape
#(273280, 3)

pd.DataFrame(image_kmeans).drop_duplicates().shape
#(64, 3)

#恢复图片的结构
image_kmeans = image_kmeans.reshape(w,h,d)
image_kmeans.shape
#(427, 640, 3)

对数据进行随机的矢量量化

centroid_random = shuffle(image_array, random_state=0)[:n_clusters]
centroid_random.shape
#(64, 3)

labels_random = pairwise_distances_argmin(centroid_random,image_array,axis=0)
labels_random.shape
#(273280,)
#函数pairwise_distances_argmin(x1,x2,axis) #x1和x2分别是序列
#用来计算x2中的每个样本到x1中的每个样本点的距离，并返回和x2相同形状的，x1中对应的最近的样本点的索引

#使用随机质心来替换所有样本
image_random = image_array.copy()
for i in range(w*h):
    image_random[i] = centroid_random[labels_random[i]]
#恢复图片的结构
image_random = image_random.reshape(w,h,d)
image_random.shape
#(427, 640, 3)

将原图，按KMeans矢量量化和随机矢量量化的图像绘制出来

plt.figure(figsize=(10,10))
plt.axis('off')
plt.title('Original image (96,615 colors)')
plt.imshow(china)
#这个前面看过了

plt.figure(figsize=(10,10))
plt.axis('off')
plt.title('Quantized image (64 colors, K-Means)')
plt.imshow(image_kmeans)

plt.figure(figsize=(10,10))
plt.axis('off')
plt.title('Quantized image (64 colors, Random)')
plt.imshow(image_random)
plt.show()

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 215,539评论 6赞 497
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,911评论 3赞 391
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 161,337评论 0赞 351
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,723评论 1赞 290
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,795评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,762评论 1赞 294
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,742评论 3赞 416
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,508评论 0赞 271
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,954评论 1赞 308
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,247评论 2赞 331
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,404评论 1赞 345
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,104评论 5赞 340
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,736评论 3赞 324
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,352评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,557评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,371评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,292评论 2赞 352