[数据挖掘笔记] 聚类算法KMeans

1.概述

1.1 无监督学习与聚类算法

聚类算法又叫做“无监督分类”,其目的是将数据划分成有意义或有用的组。这种划分可以基于我们的业务需求或建模需求来完成,也可以单纯地帮助我们探索数据的自然结构和分布。比如在商业中,如果我们手头有大量的当前和潜在客户的信息,我们可以使用聚类将客户划分为若干组,以便进一步分析和开展营销活动,如RFM模型。聚类可以用于降维和矢量量化,可以将高维特征压缩到一列当中,常常用于图像、声音、视频等非结构化数据,可以大幅度压缩数据量。
在这里插入图片描述

1.2 sklearn中的聚类算法

聚类算法在sklearn中有两种表现形式,一种是类,需要实例化,训练并使用接口和属性来调用结果。另一种是函数,只需要输入特征矩阵和超参数,即可返回聚类的结果和各种指标。
在这里插入图片描述
需要注意的一件重要事情是,该模块中实现的算法可以采用不同类型的矩阵作为输入。所有方法都接受形状[n_samples, n_features]的标准特征矩阵,这些可以从sklearn.feature_extraction模块中的类中获得。对于亲和力传播,光谱数据和DBSCAN,还可以输入形状[n_samples, n_samples]的相似性矩阵,我们可以使用sklearn.metrics.pairwise模块中的函数来获取相似性矩阵。

2.KMeans

2.1 KMeans是如何工作的

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

在KMeans算法中,簇的个数K是一个超参数,需要我们人为输入来确定。KMeans的核心任务就是根据我们设定好的K,找到K个最优的质心,并将离这些质心最近的数据分别分配到这些质心代表的簇中去。具体过程可以总结如下:
在这里插入图片描述
那什么情况下,质心的位置会不再发生变化呢?当我们找到一个质心,在每次迭代中被分配到这个质心上的样本都是一致的,即每次新生成的簇都是一致的,所有的样本点都不会再从一个簇转移到另一个簇,质心就不会变化了。这个过程可以由下图来显示,我们规定,将数据分为4簇,其中白色X代表质心的位置:
在这里插入图片描述

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

聚类算法聚出的类有什么含义呢?这些类有什么样的性质?我们认为,被分在同一个簇中的数据是有相似性的,而不同簇中的数据是不同的,当聚类完毕后,我们就要分别去研究每个簇中的样本都有什么样的性质,从而根据业务需求制定不同的商业或科技策略。聚类算法追求“簇内差异小,簇外差异大”。而这个差异,由样本点到其所在簇的质心的距离来衡量。

对于一个簇来说,所有样本点到质心的距离之和越小,我们就认为这个簇中的样本越相似,簇内差异就越小。而距离的衡量方法有多种,令x表示簇中的一个样本点,u表示该簇中的质心,n表示每个样本点中的特征数目,i表示组成点x的每个特征,则该样本点到质心的距离可以由以下距离来度量:
在这里插入图片描述
如我们采用欧几里得距离,则一个簇中所有样本点到质心的距离的平方和为:
在这里插入图片描述
其中,m为一个簇中样本的个数,j是每个样本的编号。这个公式被称为簇内平方和,又叫做Inertia。而将一个数据集中的所有簇的簇内平方和相加,就得到了整体平方和,又叫做total inertia。Total Inertia越小,代表着每个簇内样本越相似,聚类的效果就越好。因此KMeans追求的是,求解能够让Inertia最小化的质心。实际上,在质心不断变化不断迭代的过程中,总体平方和是越来越小的。我们可以使用数学来证明,当整体平方和最小的时候,质心就不再发生变化了。如此,KMeans的求解过程,就变成了一个最优化问题。

我们的Inertia是基于欧几里得距离的计算公式得来的。实际上,我们也可以使用其他距离,每个距离都有自己对应的Inertia。在过去的经验中,我们总结出不同距离所对应的质心选择方法和Inertia,在KMeans中,只要使用了正确的质心和距离组合,无论使用什么样的距离,都可以达到不错的聚类效果。
在这里插入图片描述

2.3 KMeans算法的时间复杂度

除了模型本身的效果之外,我们还使用另一种角度来度量算法:算法复杂度。算法的复杂度分为时间复杂度和空间复杂度,时间复杂度是指执行算法所需要的计算工作量,常用大O符号表述;而空间复杂度是指执行这个算法所需要的内存空间。如果一个算法的效果很好,但需要的时间复杂度和空间复杂度都很大,那我们将会权衡算法的效果和所需的计算成本。

和KNN一样,KMeans算法是一个计算成本很大的算法,在这里,我们介绍KMeans算法的时间和空间复杂度来加深对KMeans的理解。

KMeans算法的平均复杂度是O(knT),其中k是我们的超参数,所需要输入的簇数,n是整个数据集中的样本量,T是所需要的迭代次数(相对的,KNN的平均复杂度是O(n))。在最坏的情况下,KMeans的复杂度可以写作O( n^((k+2)/p) ),其中n是整个数据集中的样本量,p是特征总数。

3.sklearn.cluster.KMeans

在这里插入图片描述

3.1 重要参数n_clusters

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

3.1.1 先进行一次聚类

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

首先,我们来自己创建一个数据集。这样的数据集是我们自己创建,所以是有标签的。

from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# 自己创建的数据集
# 500个数,2个特征,4个中心,稳定
X, y = make_blobs(n_samples=500, n_features=2, centers=4, random_state=1)

X.shape
>>>(500, 2)

y.shape
>>>(500,)
# 看这个点的分布
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就能够得到聚类结果了
# KMeans也有接口predict和fit_predict,表示学习数据X并对X的类进行预测
# 但所得到的结果和我们不调用predict,直接fit后调用属性labels一模一样
pre = cluster.fit_predict(X)

pre

在这里插入图片描述

pre == y_pred

在这里插入图片描述

# 当数据量太大的时候就需要用predict
# 不必使用所有的数据来寻找质心,少量的数据就可以帮助我们确定质心
# 当我们数据量非常大的时候,我们可以使用部分数据来帮我们确认质心
# 剩下的数据的聚类结果,使用predict来调用

# 重要属性cluster_centers_
centroid = cluster.cluster_centers_
centroid

在这里插入图片描述

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

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

在这里插入图片描述

# 将簇的数量换成4

n_clusters = 4
cluster_ = KMeans(n_clusters=n_clusters, random_state=0).fit(X)
inertia_ = cluster_.inertia_
inertia_

>>>908.3855684760613

# 将簇的数量换成5

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

>>>811.0841324482415

# 将簇的数量换成6

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

>>>733.153835008308

轮廓系数

from sklearn.metrics import silhouette_score
from sklearn.metrics import silhouette_samples

silhouette_score(X, y_pred)
>>>0.5882004012129721

silhouette_score(X, cluster_.labels_)
>>>0.6505186632729437

silhouette_samples(X, y_pred).mean()
0.5882004012129721
3.1.2 聚类算法的模型评估指标

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

KMeans的目标是确保“簇内差异小,簇外差异大”,我们就可以通过衡量簇内差异来衡量聚类的效果。我们刚才说过,Inertia是用距离来衡量簇内差异的指标,因此,我们是否可以使用Inertia来作为聚类的衡量指标呢?

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

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

在这里插入图片描述
那我们可以用什么指标呢?分两种情况来看。

3.1.2.1 当真实标签已知的时候

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

3.1.2.2 当真实标签未知的时候:轮廓系数

在99%的情况下,我们是对没有真实标签的数据进行探索,也就是对不知道真正答案的数据进行聚类。这样的聚类,是完全依赖于评价簇内的稠密程度(簇内差异小)和簇间的离散程度(簇外差异大)来评估聚类的效果。其中轮廓系数是最常用的聚类算法的评价指标,它是对每个样本来定义的,它能够同时衡量:
(1)样本与其自身所在的簇中的其他样本的相似度a,等于样本与同一簇中所有其他点之间的平均距离
(2)样本与其他簇中的样本相似度b,等于样本与下一个最近的簇中的所有点之间的平均距离
根据聚类的要求“簇内差异小,簇外差异大”,我们希望b永远大于a,并且大得越多越好。
在这里插入图片描述
很容易理解轮廓系数范围是(-1,1)其中值越接近1表示样本与自己所在簇中的样本很相似,并且其他簇中的样本不相似,当样本点与簇外的样本更相似的时候,轮廓系数就为负。当轮廓系数为0时,则代表两个簇中的样本相似度一致,两个簇本应该是一个簇。可以总结为轮廓系数越接近于1越好,负数则表示聚类效果非常差。

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

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

轮廓系数有很多优点,它在有限空间中取值,使得我们对模型的聚类效果有一个参考。并且,轮廓系数对数据的分布没有假设,因此在很多数据集上都表现良好,当它在每个簇的分割比较清晰时表现最好。但轮廓系数也有缺陷,它在凸型的类上表现会虚高,比如基于密度进行的聚类,或通过DBSCAN获得的聚类效果,如果使用轮廓系数来衡量,则会表现出比真实聚类效果更高的分数。

3.1.2.3 当真实标签未知的时候:Calinski-Harabaz Index

除了轮廓系数是最常用的,我们还有卡林斯基-哈拉巴斯指数(简称CHI,也被称为方差比标准),戴维斯-布尔丁指数以及权变矩阵可以使用。
在这里插入图片描述
在这里我们重点来了解一下卡林斯基-哈拉巴斯指数。Calinski-Harabaz指数越高越好。对于有k个簇的聚类而言,Calinski-Harabaz指数s(k)写作如下公式:
在这里插入图片描述
其中N为数据集中的样本量,k为簇的个数,Bk是组间离散矩阵,即不同簇之间的协方差矩阵,Wk是簇内离散矩阵,即一个簇内数据的协方差矩阵,而tr表示矩阵的迹。在线性代数中,一个n×n矩阵A的主对角线上各个元素的总和被称为矩阵A的迹,一般记作tr(A)。数据之间的离散程度越高,协方差矩阵的迹就会越大。组内离散程度低,协方差的迹就会越小,Tr(Wk)也就越小,同时,组间离散程度大,协方差的迹也会越大,Tr(Bk)就越大,这正是我们希望的,因此Calinski-Harabaz指数越高越好。

from sklearn.metrics import calinski_harabasz_score

X
y_pred
calinski_harabasz_score(X, y_pred)
>>>1809.991966958033

虽然Calinski-Harabaz指数没有界,在凸型的数据上的聚类也会表现虚高。但是比起轮廓系数,它有一个巨大的优点,就是计算非常快速。之前我们使用过魔法命令%%timeit来计算一个命令的运算时间,今天我们来选择另一种方法:时间戳计算运行时间。

from time import time
t0 = time()
calinski_harabasz_score(X, y_pred)
time() - t0

>>>0.0009620189666748047

t0 = time()
silhouette_score(X, y_pred)
time() - t0

>>>0.031885385513305664

import datetime

datetime.datetime.fromtimestamp(t0).strftime("%Y-%m-%d %H:%M:%S")

可以看得出,Calinski-Harabaz指数比轮廓系数的计算快了一倍不止。

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

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

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_samples, silhouette_score
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import numpy as np
import pandas as pd

# 创建数据集
X, y = make_blobs(n_samples=500, n_features=2, centers=4, random_state=1)

# 基于轮廓系数来选择最佳的n_clusters
# 知道每个聚出来的类的轮廓系数是多少,还想要一个各个类之间的轮廓系数的对比
# 知道聚类完毕后图像的分布是什么样的

def sil(n_clusters):
    # 创建一个画布,画布上共有一行两列两个图
    fig, (ax1, ax2) = plt.subplots(1, 2)

    # 画布尺寸
    fig.set_size_inches(18, 7)

    # 设定X轴的取值在[-0.1, 1]之间
    ax1.set_xlim([-0.1, 1])

    # 在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('n_clusters =', n_clusters, ' silhouette_avg =', 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_lower + size_cluster_i
        
        # 保证颜色不同
        color = cm.nipy_spectral(float(i) / n_clusters)
        
        # fill_betweenx(纵坐标的上下限,值)
        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
    
    # 给图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轴不显示任何刻度
    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,
               facecolor = colors)
    centers = clusterer.cluster_centers_
    ax2.scatter(centers[:, 0],
                centers[:, 1],
                marker = 'x',
                facecolor = '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))

    plt.show()

for n_clusters in range(2, 8):
    sil(n_clusters)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.2 重要参数init & random_state & n_init:初始质心怎么放好?

在KMeans中有一个重要的环节,就是放置初始质心如果有足够的时间,KMeans一定会收敛,但Inertia可能收敛到局部最小值。是否能够收敛到真正的最小值很大程度上取决于质心的初始化。init就是用来帮助我们决定初始化方式的参数。

初始质心放置的位置不同,聚类的结果很可能也会不一样,一个好的质心选择可以让KMeans避免更多的计算,让算法收敛稳定且更快。在之前讲解初始质心的放置时,我们是使用“随机”的方法在样本点中抽取k个样本作为初始质心,这种方法显然不符合“稳定且更快”的需求。为此,我们可以使用random_state参数来控制每次生成的初始质心都在相同位置,甚至可以画学习曲线来确定最优的random_state是哪个整数。

一个random_state对应一个质心随机初始化的随机数种子。如果不指定随机数种子,则sklearn中的KMeans并不会只选择一个随机模式扔出结果,而会在每个随机种子下运行多次,并使用结果最好的一个随机数种子来作为初始质心。我们可以使用参数n_init来选择,每个随机数种子下运行的次数。这个参数不常用到,默认10次,如果我们希望运行的结果更加精确,那我们可以增加这个参数n_init的值来增加每个随机数种子下运行的次数。

“kmeans++”初始化方案,使得初始质心彼此远离,以此来引导出比随机初始化更可靠的结果。在sklearn中,我们使用参数init = 'k-means ++'来选择使用k-mean ++作为质心初始化的方案。通常来说,我建议保留默认的’k-means ++'的方法。
在这里插入图片描述

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

>>>22

random = KMeans(n_clusters=10, init='random', random_state=420).fit(X)
random.n_iter_

>>>19

3.2 重要参数max_iter & tol:让迭代停下来

在之前描述KMeans的基本流程时我们提到过,当质心不再移动,KMeans算法就会停下来。但在完全收敛之前,我们也可以使用max_iter,最大迭代次数,或者tol,两次迭代间Inertia下降的量,这两个参数来让迭代提前停下来。有时候,当我们的n_clusters选择不符合数据的自然分布,或者我们为了业务需求,必须要填入与数据的自然分布不合的n_clusters,提前让迭代停下来反而能提高模型的表现。
在这里插入图片描述

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.3266869793678966

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.3266869793678966

3.4 重要属性与重要接口

在这里插入图片描述

4.聚类降维

KMeans聚类最重要的应用之一是非结构数据(图像、声音)上的矢量量化。非结构化数据往往占用比较多的储存空间,文件本身也会比较大,运算非常缓慢,我们希望能够在保证数据质量的前提下,尽量地缩小非结构化数据的大小,或者简化非结构化数据的结构。矢量量化就可以帮助我们实现这个目的。KMeans聚类的矢量量化本质是一种降维运用,但它与我们之前学过的任何一种降维算法的思路都不同。特征选择的降维是直接选取对模型贡献最大的特征,PCA的降维是聚合信息,而矢量量化的降维是在同等样本量上压缩信息的大小,即不改变特征的数目也不改变样本的数目,只改变在这些特征下的样本的信息量。
对于图像来说,一张图片上的信息可以被聚类如下图所表示:
在这里插入图片描述
这是一组40个样本的数据,分别含有40组不同的信息(x1,x2)。我们将代表所有样本点聚成4类,找出四个质心,我们认为,这些点和他们所属的质心非常相似,因此他们所承载的信息就约等于他们所在簇的质心所承载的信息。于是,我们可以使用每个样本所在的簇的质心来覆盖原有的样本,有点类似四舍五入的感觉,类似于用1来代替0.9和0.8.这样,40个样本带有的40种取值,就被我们压缩成了4组取值,虽然样本量还是40个,但是这40个样本所带的取值其实只有4个,就是分出来的四个簇的质心。

用KMeans聚类中获得的质心来替代原有的数据,可以把数据上信息压缩到非常小,但又不损失太多信息。我们接下来就通过一张图片的矢量量化来看一看KMeans是如何实现压缩数据大小,却不损失太多信息量。
(1)导入需要的库

from PIL import Image
import numpy as np
import pandas as pd
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)导入图片

# 导入图片
img = Image.open('levi.jpg')

# 创建画布
plt.figure(figsize=(10,10))

# 展示图片
plt.imshow(img)

在这里插入图片描述
(3)处理图片

# 获取RGB值
data = img.getdata()
data = np.array(data)
data

在这里插入图片描述

# 查看维数、长度
data3dimension = data.reshape((640, 640, 3))
data3dimension.shape
>>>(640, 640, 3)

len(data)
>>>409600

data = data.astype('uint8')
data3dimension = data3dimension.astype('uint8')
data.dtype, data3dimension.dtype
>>>(dtype('uint8'), dtype('uint8'))

data.shape
>>>(409600, 3)

data[400000]
>>>array([238, 232, 232], dtype=uint8)

pd.DataFrame(data).drop_duplicates().shape
>>>(47678, 3)

plt.figure(figsize=(10, 10))
plt.imshow(data3dimension)

在这里插入图片描述
(4)决定超参数,数据预处理

n_clusters = 10
data3dimension = np.array(data3dimension, dtype=np.float64) / data3dimension.max()
w, h, d = original_shape = tuple(data3dimension.shape)
assert d == 3

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

>>>w
640

>>>h
640

>>>d
3

image_array = np.reshape(image_array, (w * h, d))
image_array.shape
>>>(409600, 3)

(5)对数据进行KMeans的矢量量化

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_

在这里插入图片描述

labels = kmeans.predict(image_array)
labels.shape
>>>(409600,)

image_kmeans = image_array.copy()
for i in range(w*h):
    image_kmeans[i] = kmeans.cluster_centers_[labels[i]]

image_kmeans

在这里插入图片描述

pd.DataFrame(image_kmeans).drop_duplicates().shape
>>>(10, 3)

image_kmeans = image_kmeans.reshape(w, h, d)
image_kmeans.shape
>>>(640, 640, 3)

(6)对数据进行随机的矢量量化

centroid_random = shuffle(image_array, random_state=0)[: n_clusters]
labels_random = pairwise_distances_argmin(centroid_random, image_array, axis=0)
labels_random.shape
>>>(409600,)

len(set(labels_random))
>>>3

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
>>>(640, 640, 3)

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

plt.figure(figsize=(10, 10))
plt.axis('off')
plt.title('Original')
plt.imshow(data3dimension)

在这里插入图片描述

plt.figure(figsize=(10, 10))
plt.axis('off')
plt.title('Quantized 10 KMeans')
plt.imshow(image_kmeans)

在这里插入图片描述

plt.figure(figsize=(10, 10))
plt.axis('off')
plt.title('Quantized 10 random')
plt.imshow(image_random)

在这里插入图片描述

5.附录

5.1 KMeans的参数列表

在这里插入图片描述
在这里插入图片描述

5.2 KMeans属性列表

在这里插入图片描述

5.3 KMeans接口列表

在这里插入图片描述

  • 0
    点赞
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
K-means聚类算法是一种常用的数据聚类算法,它通过计算样本之间的距离来将数据分成K个簇。SPSS是一款统计分析软件,也提供了K-means聚类算法的实现功能。 在SPSS中,使用K-means算法进行聚类分析的步骤如下: 1. 首先,打开数据文件,并选择要进行聚类分析的变量。 2. 然后,选择"分析"菜单下的"分类"选项,再选择"K-均值聚类"。 3. 在弹出的对话框中,将待分析的变量移动到"变量"框中,并设置聚类的数量K。 4. 可以选择对初始聚类中心进行优化,方法是勾选"K-means算法初始化K个聚类中心"选项。 5. 最后,点击"确定"按钮,SPSS会进行计算并生成聚类结果。 K-means算法对分类问题的处理简单、快速,并且在处理大数据集时相对高效。在选择初始聚类中心时,算法的基本原则是让初始聚类中心之间的相互距离尽可能远,以保证聚类结果的准确性。 至于K值的确定,可以使用层次聚类的方法进行讨论和选择。层次聚类是一种将数据层次化分组的方法,它可以帮助确定最佳的K值。 综上所述,K-means聚类算法是一种常用的数据聚类方法,在SPSS中可以方便地进行实现和分析。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [清风数学建模学习笔记——K-means聚类模型详解及SPSS操作流程](https://blog.csdn.net/weixin_43819566/article/details/113794705)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [聚类算法:K-means聚类与系统(层次)聚类SPSS操作](https://blog.csdn.net/yanyanwenmeng/article/details/105794136)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值