1.1 无监督学习与聚类算法
“有监督学习”的一部分，即是说，模型在训练的时候，即需要特征矩阵X，也需要真实标签y
有相当一部分算法属于“无监督学习”，无监督的算法在训练的时候只需要特征矩阵X，不需要标签。
1.2 sklearn中的聚类算法
聚类算法在sklearn中有两种表现形式，一种是类（和我们目前为止学过的分类算法以及数据预处理方法们都一样），需要实例化，训练并使用接口和属性来调用结果。另一种是函数（function），只需要输入特征矩阵和超参数，即可返回聚类的结果和各种指标。
意思就是录入的数据可以是有多种特征矩阵的方式，而不是监督学习中的列才是特征；在KMEAN中行和列都是特征
2 KMeans
2.1 KMeans是如何工作的
关键概念：簇与质心
在KMeans算法中，簇的个数K是一个超参数，需要我们人为输入来确定。KMeans的核心任务就是根据我们设定好的K，找出K个最优的质心，并将离这些质心最近的数据分别分配到这些质心代表的簇中去
那什么情况下，质心的位置会不再变化呢？当我们找到一个质心，在每次迭代中被分配到这个质心上的样本都是一致的，即每次新生成的簇都是一致的，所有的样本点都不会再从一个簇转移到另一个簇，质心就不会变化了。
2.2 簇内误差平方和的定义和解惑
被分在同一个簇中的数据是有相似性的，而不同簇中的数据是不同的，当聚类完毕之后，我们就要分别去研究每个簇中的样本都有什么样的性质，从而根据业务需求制定不同的商业或者科技策略。
。这个听上去和我们在上周的评分卡案例中讲解的“分箱”概念有些类似，即我们分箱的目的是希望，一个箱内的人有着相似的信用风险，而不同箱的人的信用风险差异巨大，以此来区别不同信用度的人，因此我们追求“组内差异小，组间差异大”
聚类算法也是同样的目的，我们追求“簇内差异小，簇外差异大”。而这个“差异“，由样本点到其所在簇的质心的距离来衡量。
如我们采用欧几里得距离，则一个簇中所有样本点到质心的距离的平方和为：
理解：损失函数针对的是对逻辑回归之类的有参数的求解，是求参数产生的；
如果不是求参数产生的，而是要整体平方和最小，则不称为损失函数。
而这些组合，都可以由严格的数学证明来推导。在sklearn当中，我们无法选择使用的距离，只能使用欧式距离。因此，我们也无需去担忧这些距离所搭配的质心选择是如何得来的了。
2.3 KMeans算法的时间复杂度
除了模型本身的效果之外，我们还使用另一种角度来度量算法：算法复杂度。
算法的复杂度分为时间复杂度和空间复杂度，时间复杂度是指执行算法所需要的计算工作量，常用大O符号表述；而空间复杂度是指执行这个算法所需要的内存空间。
也就是付出与收获的问题
3 sklearn.cluster.KMeans
3.1 重要参数n_clusters
n_clusters是KMeans中的k，表示着我们告诉模型我们要分几类。这是KMeans当中唯一一个必填的参数，默认为8类，但通常我们的聚类结果会是一个小于8的结果。通常，在开始聚类之前，我们并不知道n_clusters究竟是多少，因此我们要对它进行探索。
————也就是说不会默认为8，而是会手工调整
3.1.1 先进行一次聚类看看吧
首先，我们来自己创建一个数据集。这样的数据集是我们自己创建，所以是有标签的。
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)
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])#仅以前200训练，即部分样本来训练
y_pred_ = cluster_smallsub.predict(X)
y_pred == y_pred_#会发现有一样也有不一样的
centroid = cluster.cluster_centers_#找出质点，n_clusters=3，所以有3个点
centroid
inertia = cluster.inertia_#看簇内平方和
inertia#1903.56因为没有标准，也不知道是大还是小
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_
n_clusters = 5
cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
inertia_ = cluster_.inertia_
inertia_
n_clusters = 6
cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
inertia_ = cluster_.inertia_
inertia_
可以发现n_clusters越大，inertia_的值越小，也就是模型越好
而这样说明，n_clusters这个参数这样使用是不好的，不可能将样本分成任意多的簇
分6组就有六个簇
3.1.2 聚类算法的模型评估指标
在分类中，有直接结果（标签）的输出，并且分
类的结果有正误之分，所以我们使用预测的准确度，混淆矩阵，ROC曲线等等指标来进行评估，但无论如何评估，都是在”模型找到正确答案“的能力。
而回归中，由于要拟合数据，我们有SSE均方误差，有损失函数来衡量模型的拟合程度。但这些衡量指标都不能够使用于聚类。
Inertia可以，但是这个指标的缺点和极限太大。
所以使用Inertia作为评估指标，会让聚类算法在一些细长簇，环形簇，或者不规则形状的流形时表现不佳：
3.1.2.1 当真实标签已知的时候
3.1.2.2 当真实标签未知的时候：轮廓系数
在99%的情况下，我们是对没有真实标签的数据进行探索，也就是对不知道真正答案的数据进行聚类。这样的聚类，是完全依赖于评价簇内的稠密程度（簇内差异小）和簇间的离散程度（簇外差异大）来评估聚类的效果。
其中轮廓系数是最常用的聚类算法的评价指标
它是对每个样本来定义的，它能够同时衡量：
1）样本与其自身所在的簇中的其他样本的相似度a，等于样本与同一簇中所有其他点之间的平均距离
样本与其他簇中的样本的相似度b，等于样本与下一个最近的簇中的所有点之间的平均距离
根据聚类的要求”簇内差异小，簇外差异大“，我们希望b永远大于a，并且大得越多越好。
很容易理解轮廓系数范围是(-1,1)，其中值越接近1表示样本与自己所在的簇中的样本很相似，并且与其他簇中的样本不相似，当样本点与簇外的样本更相似的时候，轮廓系数就为负。当轮廓系数为0时，则代表两个簇中的样本相似度一致，两个簇本应该是一个簇。可以总结为轮廓系数越接近于1越好，负数则表示聚类效果非常差。
越接近1越好；越接近-1越不好
如果一个簇中的大多数样本具有比较高的轮廓系数，则簇会有较高的总轮廓系数，则整个数据集的平均轮廓系数越高，则聚类是合适的。如果许多样本点具有低轮廓系数甚至负值，则聚类是不合适的，聚类的超参数K可能设定得
太大或者太小。
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获得的聚类结果，如果使用轮廓系数来衡量，则会表现出比真实聚类效果更高的分数。
3.1.2.3 当真实标签未知的时候：Calinski-Harabaz Index
除了轮廓系数是最常用的，我们还有卡林斯基-哈拉巴斯指数（Calinski-Harabaz Index，简称CHI，也被称为方差比标准），戴维斯-布尔丁指数（Davies-Bouldin）以及权变矩阵（Contingency Matrix）可以使用。
from sklearn.metrics import calinski_harabasz_score
X
y_pred
calinski_harabaz_score(X, y_pred)
也针对的评分
虽然calinski-Harabaz指数没有界，在凸型的数据上的聚类也会表现虚高。但是比起轮廓系数，它有一个巨大的优点，就是计算非常快速。
之前我们使用过魔法命令%%timeit来计算一个命令的运算时间，今天我们来选择另一种方法：时间戳计算运行时间。
from time import time
#time()时间戳是一行数字，用来记录此时此刻的时间
t0 = time()
calinski_harabasz_score(X, y_pred)
time() - t0
t0 = time()
silhouette_score(X,y_pred)
time() - t0#对比轮廓系数的打分，CHI打分好太多
import datetime
#时间戳骑过datatime中的函数fromtimestamp转换成真正的时间格式
datetime.datetime.fromtimestamp(t0).strftime("%Y-%m-%d %H:%M:%S")
datetime.datetime.fromtimestamp(t0).strftime("%Y/%m/%d")
t0#时间戳是一长串数字
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
import matplotlib.cm as cm#colormap
import numpy as np
import pandas as pd
#基于我们的轮廓系数来选择最佳的n_clusters
#知道每个聚出来的类的轮廓系数是多少，还想要一个各个类之间的轮廓系数的对比
#知道聚类完毕之后图像的分布是什么模样
#其实就是一次聚类后，知道聚得好的，也有不好的，对于不好的第二次再聚；还得画图，看图上的点
#先设定我们要分成的簇数
n_clusters = 4
#创建一个画布，画布上共有一行两列两个图
fig, (ax1, ax2) = plt.subplots(1, 2)
#画布尺寸，也就是设置了子图的尺寸
fig.set_size_inches(18, 7)#一个子图就是9
#画出来的是一个横向的条形图
#首先我们来设定横坐标
#轮廓系数的取值范围在[-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])
分别设置X轴和Y轴的范围
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来报一下结果，现在的簇数量(n_clusters)下，整体的轮廓系数究竟有多少
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轴上的取值，应该是由初始值(y_Lower)开始，到初始值+加上这个簇中的样本数量结束(y_uppe）
y_upper = y_lower + size_cluster_i
#colormap库中的，使用小数来调用颜色的函数
#在nipy_spectral([输入任意小数来代表一个颜色])光谱；是以小数来表示的
#在这里我们希望每个簇的颜色是不同的，我们需要的颜色种类刚好是循环的个数的种类
#在这里，只要能够确保，每次循环生成的小数是不同的，可以使用任意方式来获取小数
#在这里，我是用i的浮点数除以n_clusters，在不同的i下，自然生成不同的小数
#以确保所有的簇会有不同的颜色
color = cm.nipy_spectral(float(i)/n_clusters)
#保证了每次颜色都是有可比性的
#开始填充子图1中的内容
#fill_between是填充曲线与直角之间的空间的函数#fill_betweenx的直角是在纵坐标上
#fill_betweeny的直角是在横坐标上
#fill_betweenx的参数应该输入(定义曲线的点的横坐标，定义曲线的点的纵坐标，X轴上的取值，柱状图的颜色)
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(i))
#为下一个簇计算新的y轴上的初始值，是每一次迭代之后，y的上线再加上10
#以此来保证，不同的簇的图像之间显示有空隙
y_lower = y_upper + 10
#给图1加上标题，横坐标轴，纵座标轴的标签
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轴不显示任何刻度，因为y轴上已经有0，1，2，3的数字了
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()
将上述过程包装成一个循环，可以得到：
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()
选择4个好还是2个好，取决于业务，取决于预算限制
3.2 重要参数init & random_state & n_init：初始质心怎么放好?
在K-Means中有一个重要的环节，就是放置初始质心。如果有足够的时间，K-means一定会收敛，但Inertia可能收敛到局部最小值。是否能够收敛到真正的最小值很大程度上取决于质心的初始化。init就是用来帮助我们决定初始化方式的参数。
初始质心放置的位置不同，聚类的结果很可能也会不一样，一个好的质心选择可以让K-Means避免更多的计算，让算法收敛稳定且更快。在之前讲解初始质心的放置时，我们是使用”随机“的方法在样本点中抽取k个样本作为初始质心，这种方法显然不符合”稳定且更快“的需求。为此，我们可以使用random_state参数来控制每次生成的初始质心都在相同位置，甚至可以画学习曲线来确定最优的random_state是哪个整数。
一个random_state对应一个质心随机初始化的随机数种子。如果不指定随机数种子，则sklearn中的K-means并不会只选择一个随机模式扔出结果，而会在每个随机数种子下运行多次，并使用结果最好的一个随机数种子来作为初始质心。我们可以使用参数n_init来选择，每个随机数种子下运行的次数。这个参数不常用到，默认10次，如果我们希望运行的结果更加精确，那我们可以增加这个参数n_init的值来增加每个随机数种子下运行的次数。
然而这种方法依然是基于随机性的。
。在sklearn中，我们使用参数init ='k-means ++'来选择使用k-means ++作为质心初始化的方案。通常来说，我建议保留默认的"k-means++"的方法。
X
y
plus = KMeans(n_clusters = 10).fit(X)
plus.n_iter_
random = KMeans(n_clusters = 10,init="random",random_state=420).fit(X)
random.n_iter_
3.3 重要参数max_iter & tol：让迭代停下来
在之前描述K-Means的基本流程时我们提到过，当质心不再移动，Kmeans算法就会停下来。但在完全收敛之前，我们也可以使用max_iter，最大迭代次数，或者tol，两次迭代间Inertia下降的量，这两个参数来让迭代提前停下来。有时候，当我们的n_clusters选择不符合数据的自然分布，或者我们为了业务需求，必须要填入与数据的自然分布不合的n_clusters，提前让迭代停下来反而能够提升模型的表现。
max_iter：整数，默认300，单次运行的k-means算法的最大迭代次数tol：浮点数，默认1e-4，两次迭代间Inertia下降的量，如果两次迭代之间Inertia下降的值小于tol所设定的值，迭代就会停下
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)
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)
可以看到，限制迭代次数，表现反而好
n_clusters 主要原因是最好的是4，而现在是10
3.4 重要属性与重要接口
3.5 函数cluster.k_means
函数k_means的用法其实和类非常相似，不过函数是输入一系列值，而直接返回结果。一次性地，函数k_means会依次返回质心，每个样本对应的簇的标签，inertia以及最佳迭代次数。
from sklearn.cluster import k_means
k_means(X,4,return_n_iter=True)
4 案例：聚类算法用于降维，KMeans的矢量量化应用
K-Means聚类最重要的应用之一是非结构数据（图像，声音）上的矢量量化（VQ）。非结构化数据往往占用比较多的储存空间，文件本身也会比较大，运算非常缓慢，我们希望能够在保证数据质量的前提下，尽量地缩小非结构化数据的大小，或者简化非结构化数据的结构。矢量量化就可以帮助我们实现这个目的。KMeans聚类的矢量量化本质是一种降维运用，但它与我们之前学过的任何一种降维算法的思路都不相同。特征选择的降维是直接选取对模型贡献最大的特征，PCA的降维是聚合信息，而矢量量化的降维是在同等样本量上压缩信息的大小，即不改变特征的数目也不改变样本的数目，只改变在这些特征下的样本上的信息量。
对于图像来说，一张图片上的信息可以被聚类如下表示：
这是一组40个样本的数据，分别含有40组不同的信息(x1,x2)。我们将代表所有样本点聚成4类，找出四个质心，我们认为，这些点和他们所属的质心非常相似，因此他们所承载的信息就约等于他们所在的簇的质心所承载的信息。
于是，我们可以使用每个样本所在的簇的质心来覆盖原有的样本，有点类似四舍五入的感觉，类似于用1来代替0.9和0.8。这样，40个样本带有的40种取值，就被我们压缩了4组取值，虽然样本量还是40个，但是这40个样本所带的取值其实只有4个，就是分出来的四个簇的质心。
用K-Means聚类中获得的质心来替代原有的数据，可以把数据上的信息量压缩到非常小，但又不损失太多信息。我们接下来就通过一张图图片的矢量量化来看一看K-Means如何实现压缩数据大小，却不损失太多信息量。
1. 导入需要的库
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
2. 导入数据，探索数据
#查看图片的步骤
#导入颐和园的照片
china = load_sample_image("china.jpg")
china
china.dtype#dtype('uint8')是典型的图片类型，Python可以处理
china.shape#长度为427，宽度为640，3个像素 组成来表示颜色
china[0][0]
#查看包含有多少种颜色
newimage = china.reshape((427 * 640,3))
newimage.shape#(273280, 3)发现颜色数量有27W+
#(96615, 3),去除重复后也即只有9W多种颜色
import pandas as pd
pd.DataFrame(newimage).drop_duplicates().shape
#查看图片
plt.figure(figsize=(15,15))
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种颜色的矢量量化图像。我们需要随机选取64个样本点作为随机质心，计算原数据中每个样本到它们的距离来找出离每个样本最近的随机质心，然后用每个样本所对应的随机质心来替换原本的样本。两种状况下，我们观察图像可视化之后的状况，以查看图片信息的损失。
在这之前，我们需要把数据处理成sklearn中的K-Means类能够接受的数据。
3. 决定超参数，数据预处理
n_clusters = 64#我要缩成64种颜色
#plt.imshow在浮点致上表现非常优异。在这里我们把china中的数据。转换为浮点数，压缅到[0,1]之间
china = np.array(china, dtype=np.float64) / china.max()
# (china<0).sum()
# (china>1).sum()
#无china从图像格式,转换成矩阵格式
w, h, d = original_shape = tuple(china.shape)
#确保d是等于3，assert是警告的意思
assert d == 3
#assert相当于raise error if not，表示为，“不为True就报错”
#要求d必须等于3，如果不等于，就报错
#展示assert的功能
image_array = np.reshape(china, (w * h, d))#reshape是改变结构
#np.reshape(a，newshape,order= ' C"'), reshape函数的第一个参数a是要改变结构的对象，第二个参数是要改变的新结构#展示np.reshape的效果
4. 对数据进行K-Means的矢量量化
#首先,先使用1800个数据来找出质心
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_
kmeans.cluster_centers_.shape
#找出质心之后，按照已存在的质心对所有数据进行聚类
labels = kmeans.predict(image_array)
labels.shape
#看这64个质心的索引
set(labels)
#使用质心来苔换所有的样本
image_kmeans = image_array.copy()
image_kmeans#2了w个样本点,9w多种不同的颜色(像素点）
labels#这27w个样本点所对应的族的质心的索引
for i in range(w*h):
image_kmeans[i] = kmeans.cluster_centers_[labels[i]]
#查看图片生成的信息
# image_kmeans.shape#(427, 640, 3)
image_kmeans
pd.DataFrame(image_kmeans).drop_duplicates().shape
image_kmeans = image_kmeans.reshape(w,h,d)
image_kmeans.shape
5. 对数据进行随机的矢量量化
centroid_random = shuffle(image_array, random_state=0)[:n_clusters]
labels_random = pairwise_distances_argmin(centroid_random,image_array,axis=0)
#函数pairwise_distances_argmin(x1,x2,axis)#x1利lx2分别是序列
#用来计算x2中的每个样本到x1中的每个样本点的距离，并返回和x2相同形状的，x1中对应的最近的样本点的索引
labels_random.shape
len(set(labels_random))#set为去重
#随机质心来替换所有样本
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
6. 将原图，按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()
