AI算法工程师 | 07机器学习-无监督学习（一）聚类系列算法_谱聚类 动图

前言

本阶段将开启 无监督机器学习 的旅程。对于无监督机器学习问题，主要有两种：聚类、降维

聚类 Clustering

• 本质：根据样本和样本之间的相似度归堆
• 目标：将一批数据划分到多个组
• 应用：用户分组、异常检测、前景背景分离

降维 Dimensionality Reduction

• 本质：去掉冗余信息量或噪声
• 目标：将数据的维度减少
• 应用：数据的预处理、可视化、提高模型计算速度

小贴士：
① 聚类就是分组（归堆）；降维类似于换个角度去审视原来的数据。
② 由于维度越多，速度越慢。所以，为提高模型运行速度，通常会做降维的任务。

---

导图 - 文章框架

机器学习 - 无监督学习 之 聚类系列算法

一、聚类的基本介绍

1. 了解聚类任务

什么是聚类任务？

• 属于：无监督机器学习的一种
• 目标：将已有数据根据相似度划分到不同的簇（组） custer
• 待达到的效果：簇内样本彼此之间越相似，不同簇的样本之间越不相似，就越好（即：尽可能让组内的相似程度大，组与组之间的相似程度小）

什么情况下要用到聚类？

1. 希望把已知的无标签的数据，划分到不同组中时，可用聚类任务去做
2. 聚类不仅仅可以把已知的数据划分到组中，对未来数据也可进行预测
3. 通过聚类，做异常检测（如：设置一个阈值 Threshold，若某样本点到所有中心点的距离都比阈值大，则该样本点为异常点）

2. 聚类算法

从图中可以看出，不同的聚类算法，对于不同的数据分布场景，其聚类效果有所不同。

本文将针对 K-Means 聚类、层次聚类、密度聚类以及谱聚类展开介绍。

小贴士

• scikit-learn：是针对 Python 编程语言的免费软件机器学习库
• 关于 scikit-learn 的社区地址：外语：scikit-learn.org； 中文：scikit-learn.org.cn

3. 相似度 与 数据间的相似度

3.1 相似度

对于相似度的判断，站在不同的角度会有不同的结果：

• 不同测量相似度的方式，会得到不同的结果
• 不同提特征的方式（即：注意力不同），结果不同
• 计算方式不同，相似度也不同

举例：

• 看图说话 image caption

3.2 数据间的相似度

概念：

• 每一条数据都可以理解为多维空间中的一个点
• 可以根据点和点之间的距离来评价数据间的相似度

欧氏距离、闵mǐn可夫斯基距离：

图解：

小贴士

• 这些距离可用 “向量的范数” 进行表示，感兴趣的伙伴可阅读：04人工智能基础-高等数学知识强化（三）线性代数基础之向量 —— 文中的 “向量到原点的范式” 部分

4. 欧氏距离测度 与 余弦距离测度

如何计算样本到中心点的距离？通常有两种方式：① 欧氏距离测度、② 余弦距离测度

4.1 欧氏距离测度 Euclidean Distance Measure

公式：（也就是上文中的欧式距离）

$$euclidean(A,B)=\sqrt{\sum _{i=1}^n(A_i-B_i{)}^2}$$

说明：欧氏距离越大，相似度越低

4.2 余弦距离测度 Cosine Similarity Measure

步骤:

• 将数据映射为高维空间中的点（向量）
• 计算向量间的余弦值
• 余弦相似度的取值范围 [-1,+ 1]，它判断的是向量之间的方向而不是大小
  • 越趋近于 1 代表越相似（两向量方向相同），越趋近于 -1 代表方向相反，0 代表正交（两向量方向相对成90°）

公式：（余弦相似度）

$$similarity=cos(\theta )=\frac{A\cdot B}{\Vert A\Vert \Vert B\Vert }=\frac{{\sum }_{i=1}^n{A}_i{B}_i}{\sqrt{{\sum }_{i=1}^n{A}_i^2}\sqrt{{\sum }_{i=1}^n{B}_i^2}}$$

说明：夹角越大，余弦值越小，相似度越低

小贴士

• 余弦距离 = 1 - 余弦相似度
• ∴ 余弦距离的取值范围：[0, 2]

4.3 选择欧氏距离还是余弦距离？

总结：

• 欧氏距离：体现数值上的绝对差异；
• 余弦距离：体现方向上的相对差异。

举例：

• 示例1：统计两部剧的用户观看行为
  • 假设用户 A 的观看向量为（0，1），用户 B 为（1，0）；
  • 此时二者的余弦距离很大，而欧氏距离很小；
  • 我们分析两个用户对于不同视频的偏好，更关注相对差异，显然应当使用余弦距离。
• 示例2：分析用户活跃度
  • 当以登陆次数（单位:次）和平均观看时长（单位:分钟）作为特征时，
  • 余弦距离会认为（1，10）、（10，100）两个用户距离很近；
  • 但显然这两个用户活跃度是有着极大差异的，此时我们更关注数值绝对差异，应当使用欧氏距离。

小贴士

• 欧氏距离测度是常用的距离测度
• 余弦距离测度更适用于文本：余弦相似度可以评价文章的相似度，从而实现对文章，进行分类

4.4 归一化后欧氏距离与余弦距离在效果上等效

概述：

• 如果向量的模长是经过归一化的，可以理解为此时向量被投影到了一个长度为 1 的球面上
• 这时欧氏距离和余弦距离有着单调的关系，即
  $$||\frac{A}{\Vert \begin{array}{c}A\end{array}\Vert }-\frac{B}{\Vert \begin{array}{c}B\end{array}\Vert }|{|}_2=\sqrt{2\ast (1-cos(A,B))}$$

推导：

说明：

• 在向量的模长归一化的场景下，谁距离最小（相似度最大）就是近邻，那么使用余弦相似度和欧氏距离的查找近邻结果是相同的。

小贴士

• 参考：余弦相似度和余弦距离的推导与理解

二、K-Means 聚类

❥ K-Means 聚类属于聚类任务的算法之一

1. K-Means 算法具体流程

为什么叫 K-Means 聚类？

• 也叫：K均值聚类
• K：是最终簇数量（即：K 往往代表类别的个数），它是超参数，需要预先设定
• 在算法计算中会涉及到求均值

K-Means 算法的流程

1. 随机选择 K 个簇中心点（可以选已有的数据作为中心点，也可直接选高维空间中的位置）
2. 样本被分配到离其最近的中心点
3. K 个簇中心点根据所在簇样本，以求平均值的方式重新计算
4. 开始迭代，重复第2步和第3步直到所有样本的分配不再改变

举例

K-Means 必须首先知道要分为几个组（即：K 需要预先设定）

假设 K = 3，这三个类别的位置，开始是不知道的：

• 随机选择三个样本点，作为三个类别的初始中心点
• 通过机器学习算法，不断的迭代，逼近最优结果
• 迭代：求样本点分别距离这三个中心点的距离，把各样本归入距离中心点最近的那组

问：K-Means 要干的事情是什么？

答：求平均

• 每个样本点相加 除以 组中样本个数 → 得到中心位置
• 当中心点位置变了时，各样本点到中心点的距离便会变，需再次求平均
• 以此往复，直到中心点位置不变 → 即：收敛了

问：迭代终止条件是什么？

答：没有新的样本点被划分进某组（即：所有样本的分配不再改变；也可以理解为：中心点的位置不再变化）

2. K-Means 的特点

优点：

• 简单，效果不错（对于大部分数据集而言）

缺点：

• 对异常值敏感（若有异常值，无论划分到哪个组，均会影响该组内的平均值计算）
• 对初始值敏感（若随机的中心点距离较近，多次得到的结果极可能不同，可能是局部最优解）
  • K-Means 算法不保证找到最好的解（即：不保证收敛全局最优）
  • 通常的做法：运行 K-Means 很多次，每次随机初始化不同的初始中心点，然后从多次运行结果中选择最好的局部最优解
• 对某些分布聚类效果不好（如：当样本的方差不相等时聚类效果不好）

3. K-Means 的损失函数

目标函数

• 聚类问题的损失函数：求各个样本点到对应簇的中心点的误差平方和

小贴士

• 参考1：K-Means算法详细介绍(SSE、轮廓分析)
• 参考2：参数误差统计：SSE、SSR、SST、R_square、MSE、RMSE

4. K-Means 算法 K 的选择

对于聚类数 K 的选择，其中一种方式便是肘部法（elbow method）

肘部法

目标：（找到最合适的点——拐点）

• 找到一个 K，使得高于该值之后的收益会发生递减；
• 这个 K 值，称为肘部点（elbow point），因为它看起来像一个人的肘部。

如何判断拐点？

• 求幅度差（收益 gain），找收益最大的点（如上图所示），也就是一开始下降最快的点

动图-演示：

小贴士

• 没有所谓最好的选择聚类数的方法，通常是需要根据不同的问题，人工进行选择的。

三、K-Means 的变形

下面介绍一些由 K-Means 所衍生出来的算法，它们针对 K-Means 所暴露出来的不足进行了优化，如：① K-Medoids、② 二分 K-Means、③ K-Means++、④ Mini-batch Kmeans 算法等

本节还会介绍一个 Canopy 聚类算法，虽然不是 K-Means 所衍生出来的算法，但它很少单独使用，会结合 K-Means 一起使用。

1. K-Medoids

• 计算新的簇中心的时候不再选择均值，而是选择中位数
• 抗噪能力得到加强

说明：

• 若为中位数，每次得到的点一定是某个样本
• K-Medoids 主要针对解决噪音和异常点比较敏感问题

2. 二分 K-Means

步骤：

• ① 将所有点作为一个簇；
• ② 将该簇使用 K-Means 算法（K=2）一分为二；
• ③ 选择其中一个簇继续进行二分，选择哪一个簇进行二分取决于哪个簇有更大得 SSE（误差平方和） 值；
• ④ 不断重复第③步，直到得到用户指定的簇数目 K 为止。

小贴士

• 参考：机器学习 K-Means 方面的算法

3. K-Means++

优化：

• 若 K-Means 的初始中心点分布不够均匀，往往会导致聚类效果不好；
• 为了克服上面的缺点，K-Means++ 通过一个更聪明的初始化中心点方法（通过概率化选择初始中心点）确保改进聚类的质量。
  • 除了初始化，该算法其它和标准的 K-Means 算法一样
  • 所以，K-Means++ 相当于 => 标准的 K-Means 算法 + 一个更好的初始化中心点的方法

目标：

• 初始化簇中心点稍微远一些

初始化中心点的步骤：

• ① 从数据集中随机选择第一个中心点
• ② 对于每个数据点（样本）计算到它最近邻的已知中心点的距离
• ③ 将距离转化为概率，进行概率化选择：从数据集中选择下一个中心点，是一个概率化选择，被选择的概率和上一步计算出来的距离成正比
  • 例如：某个点到最近邻的已知中心点距离最远，它有最大的可能性被选为下一个中心点
• ④ 重复第②步和第③步直到 K 个中心点被采样

K-Means++ 用到的范围比较广，如：

• sklean（全称 Scikit-Learn）中默认使用的便是 K-Means++；
• Spark（分布式计算框架）中 MLlib 模块 默认的 K-Means 也是 K-Means++。

小贴士：K-Means++ 的初始化中心点

• K-Means++ 是一个一个中心点依次选取出来的
• 概率化选择时，其概率为均匀分布，在（0,1）间随机取值，由于将距离转化为概率，而距离远的其在数轴中的长度间隔会更大，所以更有可能被选中

4. Mini Batch K-Means

该算法的迭代步骤有两步：

• ① 从数据集中随机抽取一些数据形成小批量，把他们分配给最近的质心
• ② 更新质心

区别：

• 与 K 均值算法相比，Mini Batch K-Means 数据的更新是在每一个小的样本集上。
  • 对于每一个小批量，通过计算平均值得到更新质心，并把小批量里的数据分配给该质心，
  • 随着迭代次数的增加，这些质心的变化是逐渐减小的，
  • 直到质心稳定或达到指定的迭代次数，停止计算。

5. Canopy 聚类

特点：一次迭代，出 k 个中心点的结果

Canopy 聚类的步骤：

• 设置两个距离 T1 T2，作为超参数；其中 T1>T2
• WHILE D 非空∶（ D 为所有点的集合，不断遍历 D，直至所有点都被划分到某簇的 T2 内或成为某簇中心，也就是 D 为空 ）
  • 随机产生 d 属于 D，作为中心点
  • 计算所有点到 d 的距离
  • 所有距离 <T1 的点，归属于 d 对应的簇（也就是这些点都可属于当前簇）
  • 从 D 中删除 d 及距离小于 T2 的点（删除的这些点不能作为其他簇的中心，D 中剩余的点进行重复前面的操作）

Canopy 聚类的说明：

• Canopy 聚类很少单独使用，会结合 K-Means 一起使用
  • Canopy 聚类 可以作为 K-Means 中第一步初始中心点的选择
  • 即：K-Means 中的随机中心值 → 变为使用 Canopy 聚类获得中心值
• 该聚类一定会把样本划分到某个簇中，且很可能一个样本属于多个类别
• 与 K-Means++ 类似，其中心点是一个一个找出来的，处理第一个中心点是随机的

K-Means 在初始中心点时，使用 Canopy 聚类的好处：

• 可以帮助我们得出 k 为多少
• 能让中心点尽可能远离些

小贴士

• 参考1：Canopy 聚类、层次聚类、密度聚类-DBSCAN
• 参考2：Canopy 聚类算法分析

6. K-Means 代码测试不同情况下的聚类效果

下面是基于 sklearn 库做的聚类，使用的算法为 K-Means++

代码：（ 工具：PyCharm，基于：python3）

各步骤说明：

• 导入模块

import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as ds  # 通过datasets，帮我们创建一些数据集
import matplotlib.colors  # 关于颜色的
from sklearn.cluster import KMeans  # k-means 聚类
1
2
3
4
5

• 数据准备

   N = 400  # 一共想创建400个数据（样本）
   centers = 4  # 告诉函数，要创建4个组（共4个中心点）

   # -----下面创建了三组不同的数据，1、第一组：根据高斯分布，创建同方差的数据（400样本，4个组，每组100个）；2、第二组：高斯分布的方差不同；3、第三组：同方差，但只选择了175条数据（且各组数据个数不同） ------

   # make_blobs 创建数据，括号中的参数：① 创建多少样本，② 每条样本的维度（这里：400行2列），③ 样本分到多少个组中，④ 创建随机种子
   data, y = ds.make_blobs(N, n_features=2, centers=centers, random_state=2)  # 得到每组中的数据data 及 label标签y（每个样本在哪个组）

   # 此处多了个 cluster_std —— 每组对应的方差（此处设置成了不同的），上面那条代码默认同方差的
   data2, y2 = ds.make_blobs(N, n_features=2, centers=centers, cluster_std=(1, 2.5, 0.5, 2), random_state=2)

   # vstack：竖的堆叠，括号中个参数含义：① 将标签y为0的该组中，所有数据取出（100条）；② 组别为1的样本，只取50条；③ 组别为2的样本，只取20条；④ 3的：5条
   data3 = np.vstack((data[y == 0][:], data[y == 1][:50], data[y == 2][:20], data[y == 3][:5]))
   # 这里的 标签y 需要自己写。说明：[0] * 100 这种 —— 是原生的python - 将列表扩展，得：一个列表中有100个0； 加号代表：将列表元素拼在一起
   # 下列代码结果：用列表装数据，前100个为0，50个1,20个2，最后5个为3
   y3 = np.array([0] * 100 + [1] * 50 + [2] * 20 + [3] * 5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• K-Means++ 聚类（核心代码）

	# ----- K-means++ 算法 （核心代码：调用 k-means++ 训练和预测，得到相应的 ŷ 结果）-----

    cls = KMeans(n_clusters=4, init='k-means++')  # 创建k-means对象，括号中参数：① n_clusters：指定K的个数；② init：初始化 k-means 算法的超参数=
    y_hat = cls.fit_predict(data)  # 对对象进行聚类，得到聚类的结果（fit_predict 返回的是：数据的类别号）
    y2_hat = cls.fit_predict(data2)
    y3_hat = cls.fit_predict(data3)

    # 下面：通过矩阵，将原来的数据做了高维空间的线性变换，将其映射到新的维度中（相当于 做了旋转）
    m = np.array(((1, 1), (1, 3)))  # 把元组变为了2行2列的矩阵。矩阵能干的事情：高维空间的线性变换
    data_r = data.dot(m)  # 点乘：用 原始数据data 点乘 矩阵m → 相当于 把数据中的每个向量点，全部进行相对于的旋转，投影到另外一个轴中
    y_r_hat = cls.fit_predict(data_r)
1
2
3
4
5
6
7
8
9
10
11

• 可视化展示

def expand(a, b): # 后续画图时会用到的自定义函数
    d = (b - a) * 0.1
    return a - d, b + d
1
2
3

    # ----- 以下是画图的内容，共画了8个子图 ------------------------------

    matplotlib.rcParams['font.sans-serif'] = [u'SimHei']  # 可展示中文（黑体）
    matplotlib.rcParams['axes.unicode_minus'] = False  # 让负号可以正常显示
    cm = matplotlib.colors.ListedColormap(list('rgbm'))

    plt.figure(figsize=(9, 10), facecolor='w')
    plt.subplot(421)  # 8个子图中的：第一个子图
    plt.title(u'原始数据')  # u：表示unicode字符串
    plt.scatter(data[:, 0], data[:, 1], c=y, s=30, cmap=cm, edgecolors='none')  # 散点图，传真实结果 y
    x1_min, x2_min = np.min(data, axis=0)
    x1_max, x2_max = np.max(data, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))  # x 轴
    plt.ylim((x2_min, x2_max))  # y 轴
    plt.grid(True)  # 网格

    plt.subplot(422)
    plt.title(u'KMeans++聚类')
    plt.scatter(data[:, 0], data[:, 1], c=y_hat, s=30, cmap=cm, edgecolors='none')  # 散点图，传预测结果 ŷ
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(423)
    plt.title(u'旋转后数据')
    plt.scatter(data_r[:, 0], data_r[:, 1], c=y, s=30, cmap=cm, edgecolors='none')
    x1_min, x2_min = np.min(data_r, axis=0)
    x1_max, x2_max = np.max(data_r, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(424)
    plt.title(u'旋转后KMeans++聚类')
    plt.scatter(data_r[:, 0], data_r[:, 1], c=y_r_hat, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(425)
    plt.title(u'方差不相等数据')
    plt.scatter(data2[:, 0], data2[:, 1], c=y2, s=30, cmap=cm, edgecolors='none')
    x1_min, x2_min = np.min(data2, axis=0)
    x1_max, x2_max = np.max(data2, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(426)
    plt.title(u'方差不相等KMeans++聚类')
    plt.scatter(data2[:, 0], data2[:, 1], c=y2_hat, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(427)
    plt.title(u'数量不相等数据')
    plt.scatter(data3[:, 0], data3[:, 1], s=30, c=y3, cmap=cm, edgecolors='none')
    x1_min, x2_min = np.min(data3, axis=0)
    x1_max, x2_max = np.max(data3, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(428)
    plt.title(u'数量不相等KMeans++聚类')
    plt.scatter(data3[:, 0], data3[:, 1], c=y3_hat, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.suptitle(u'数据分布对KMeans聚类的影响', fontsize=18)  # 总标题
    plt.tight_layout()  # 会自动调整子图参数,使之填充整个图像区域（防止重叠）

    plt.savefig('cluster_kmeans')  # 将绘图结果保存为png图片
    plt.show()  # 展示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

小贴士

• 若对于 python 中 matplotlib 绘图不太了解的伙伴，可参考文章：AI算法工程师 | 03人工智能基础-Python科学计算和可视化（二）Matplotlib

整体代码：

# !/usr/bin/python
# -*- coding:utf-8 -*-

"""
基于 sklearn 库做聚类：K-Means++
"""

# 导入包
import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as ds  # 通过datasets，帮我们创建一些数据集
import matplotlib.colors  # 关于颜色的
from sklearn.cluster import KMeans  # k-means 聚类


def expand(a, b):
    d = (b - a) * 0.1
    return a - d, b + d


if __name__ == "__main__":
    N = 400  # 一共想创建400个数据（样本）
    centers = 4  # 告诉函数，要创建4个组（共4个中心点）

    # -----下面创建了三组不同的数据，1、第一组：根据高斯分布，创建同方差的数据（400样本，4个组，每组100个）；2、第二组：高斯分布的方差不同；3、第三组：同方差，但只选择了175条数据（且各组数据个数不同） ------

    # make_blobs 创建数据，括号中的参数：① 创建多少样本，② 每条样本的维度（这里：400行2列），③ 样本分到多少个组中，④ 创建随机种子
    data, y = ds.make_blobs(N, n_features=2, centers=centers, random_state=2)  # 得到每组中的数据data 及 label标签y（每个样本在哪个组）

    # 此处多了个 cluster_std —— 每组对应的方差（此处设置成了不同的），上面那条代码默认同方差的
    data2, y2 = ds.make_blobs(N, n_features=2, centers=centers, cluster_std=(1, 2.5, 0.5, 2), random_state=2)

    # vstack：竖的堆叠，括号中个参数含义：① 将标签y为0的该组中，所有数据取出（100条）；② 组别为1的样本，只取50条；③ 组别为2的样本，只取20条；④ 3的：5条
    data3 = np.vstack((data[y == 0][:], data[y == 1][:50], data[y == 2][:20], data[y == 3][:5]))
    # 这里的 标签y 需要自己写。说明：[0] * 100 这种 —— 是原生的python - 将列表扩展，得：一个列表中有100个0； 加号代表：将列表元素拼在一起
    # 下列代码结果：用列表装数据，前100个为0，50个1,20个2，最后5个为3
    y3 = np.array([0] * 100 + [1] * 50 + [2] * 20 + [3] * 5)

    # ----- K-means 算法 （核心代码：调用 k-means 训练和预测，得到相应的 ŷ 结果）-----

    cls = KMeans(n_clusters=4, init='k-means++')  # 创建k-means对象，括号中参数：① n_clusters：指定K的个数；② init：初始化 k-means 算法的超参数
    y_hat = cls.fit_predict(data)  # 对对象进行聚类，得到聚类的结果（fit_predict 返回的是：数据的类别号）
    y2_hat = cls.fit_predict(data2)
    y3_hat = cls.fit_predict(data3)

    # 下面：通过矩阵，将原来的数据做了高维空间的线性变换，将其映射到新的维度中（相当于 做了旋转）
    m = np.array(((1, 1), (1, 3)))  # 把元组变为了2行2列的矩阵。矩阵能干的事情：高维空间的线性变换
    data_r = data.dot(m)  # 点乘：用 原始数据data 点乘 矩阵m → 相当于 把数据中的每个向量点，全部进行相对于的旋转，投影到另外一个轴中
    y_r_hat = cls.fit_predict(data_r)

    # ----- 以下是画图的内容，共画了8个子图 ------------------------------

    matplotlib.rcParams['font.sans-serif'] = [u'SimHei']  # 可展示中文（黑体）
    matplotlib.rcParams['axes.unicode_minus'] = False  # 让负号可以正常显示
    cm = matplotlib.colors.ListedColormap(list('rgbm'))

    plt.figure(figsize=(9, 10), facecolor='w')
    plt.subplot(421)  # 8个子图中的：第一个子图
    plt.title(u'原始数据')  # u：表示unicode字符串
    plt.scatter(data[:, 0], data[:, 1], c=y, s=30, cmap=cm, edgecolors='none')  # 散点图，传真实结果 y
    x1_min, x2_min = np.min(data, axis=0)
    x1_max, x2_max = np.max(data, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))  # x 轴
    plt.ylim((x2_min, x2_max))  # y 轴
    plt.grid(True)  # 网格

    plt.subplot(422)
    plt.title(u'KMeans++聚类')
    plt.scatter(data[:, 0], data[:, 1], c=y_hat, s=30, cmap=cm, edgecolors='none')  # 散点图，传预测结果 ŷ
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(423)
    plt.title(u'旋转后数据')
    plt.scatter(data_r[:, 0], data_r[:, 1], c=y, s=30, cmap=cm, edgecolors='none')
    x1_min, x2_min = np.min(data_r, axis=0)
    x1_max, x2_max = np.max(data_r, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(424)
    plt.title(u'旋转后KMeans++聚类')
    plt.scatter(data_r[:, 0], data_r[:, 1], c=y_r_hat, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(425)
    plt.title(u'方差不相等数据')
    plt.scatter(data2[:, 0], data2[:, 1], c=y2, s=30, cmap=cm, edgecolors='none')
    x1_min, x2_min = np.min(data2, axis=0)
    x1_max, x2_max = np.max(data2, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(426)
    plt.title(u'方差不相等KMeans++聚类')
    plt.scatter(data2[:, 0], data2[:, 1], c=y2_hat, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(427)
    plt.title(u'数量不相等数据')
    plt.scatter(data3[:, 0], data3[:, 1], s=30, c=y3, cmap=cm, edgecolors='none')
    x1_min, x2_min = np.min(data3, axis=0)
    x1_max, x2_max = np.max(data3, axis=0)
    x1_min, x1_max = expand(x1_min, x1_max)
    x2_min, x2_max = expand(x2_min, x2_max)
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.subplot(428)
    plt.title(u'数量不相等KMeans++聚类')
    plt.scatter(data3[:, 0], data3[:, 1], c=y3_hat, s=30, cmap=cm, edgecolors='none')
    plt.xlim((x1_min, x1_max))
    plt.ylim((x2_min, x2_max))
    plt.grid(True)

    plt.suptitle(u'数据分布对KMeans聚类的影响', fontsize=18)  # 总标题
    plt.tight_layout()  # 会自动调整子图参数,使之填充整个图像区域（防止重叠）

    plt.savefig('cluster_kmeans')  # 将绘图结果保存为png图片
    plt.show()  # 展示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

结果展示：

四、层次聚类

层次聚类解决了 K-Means 中 K 值选择和初始中心点选择的问题。

其聚类方式分为：① 分裂法、② 凝聚法

层次聚类对比 K-Means：

• K-Means 这种扁平聚类产出一个聚类结果（都是独立的）
• 层次聚类能够根据你的聚类程度不同，有不同的结果
• K-Means 需要指定聚类个数 K，层次聚类不用（可以根据距离的远近设置阈值，达到该阈值时不再分裂/合并）
• K-Means 比层次聚类要快一些（通常说来）
• K-Means（K-均值聚类）用的多，有些时候可以用 K-Median（K-中值聚类）

1. 分裂法

像一棵树一样，不断的分裂

算法步骤：

• 将所有样本归为一个簇
• While 不足 k 个簇或距离阈值（距离阈值作用：表示相似度）：
  • 在同一个簇 C 中计算样本间距离，选最远的距离的两个样本 a、b（终止条件检测）
  • 将样本 a， b 划入 C1、C2（终止条件检测）
  • 计算原簇 C 中样本离谁近，划入谁

说明：二分 K-Means 本质上是层次聚类中的分裂法，它通过不断分裂直到达到预设的簇类个数。

2. 凝聚法

原理：

• 最初将每个对象看成一个簇，
• 然后将这些簇根据某种规则被一步步合并，
• 就这样不断合并直到达到预设的簇类个数。

算法步骤：

• 将所有点看做一个独立的簇
• While 多于 k 个簇或距离阈值︰
  • 计算两两簇之间的距离（关键：如何计算聚类簇之间的距离？），找到最小距离的簇 C1 和 C2（多种计算方式，如：欧式距离与余弦距离算出来的不一样）
  • 合并 C1、C2

合并 C1、C2 的方式可以有所差别︰（两个簇之间距离的度量）

1. 两个簇间距离最小的样本距离
2. 两个簇间最远的两个点的距离
3. 两个簇之间两两求距离的平均值
4. 两个簇之间两两求距离的中位数
5. 求每个集合的中心点，用中心点的距离代表簇的距离

五、密度聚类

与层次聚类的异同：

• 同：与层次聚类一样无需设置 K 值

• 异：

  • 层次聚类：有包含关系；算的是距离；
  • 密度聚类：无包含关系；算的是密度。

密度聚类最参见的算法为：DBSCAN 算法

1. DBSCAN 密度聚类算法

概述：

• DBSCAN ( Density-Based Spatial Clustering of Applications
  with Noise）
• 一个基于密度聚类的算法。它将簇定义为密度相连的点的最大集合，能够把具有高密度的区域划分为簇，并可有效地对抗噪声

什么叫密度相连？

先来了解几个概念：

• 对象的 $\epsilon$ 邻域： 给定对象（某个点）在半径 $\epsilon$ 内的区域；
• 核心对象： 给定一个数目 $m$， 如果对象（某个点）的 $\epsilon$ 领域内， 至少含有 $m$个对象（点）， 该对象就是核心对象；
  • 白话：在样本点中间被包围的点，比较具有代表性，是核心对象
• 直接密度可达： 给定一个对象集合 $D$， 如果 $p$ 在 $q$ 的 $\epsilon$ 邻域内，而 $q$ 是一个核心对象， $p$ 从 $q$ 出发是直接密度可达的；
  • 白话： 直接密度可达就是他俩直接够得着
• 密度可达：它是在直接密度可达的基础上的。如果存在一个对象链 $p_1{p}_2...p_n$ ，令 $p_1=p，p_n=q，p_{i+1}$ 是关于 $\epsilon 、m$是直接密度可达的， 那么对象 $p$ 是从对象 $q$ 关于 $\epsilon 、m$ 密度可达的；
  • 即：密度可达满足传递性（对于核心对象而言），但不满足对称性
• 密度相连：它是在密度可达的基础之上的。如果集合 $D$ 中存在一个对象 $o$，使 $o\to p$ 密度可达， $o\to q$ 密度可达，那么 $p$ 和 $q$ 就是关于 $\epsilon 、m$ 密度相连的。
  • 即：密度相连满足对称性

从上述可知，密度聚类有两个超参数：$\epsilon$ 、$m$

密度可达 和 密度相连有什么用？

• 密度可达：相关对象（点）划分到同一个簇
• 密度相连：也划分到同一个簇

算法步骤：

DBSCAN 通过检查数据集中每个对象的 $\epsilon$ 邻域来寻找聚类

步骤：（下面是更新一个簇的思路）

• 如果一个点 $p$ 的 $\epsilon$ 邻域中多余 $m$ 个对象，则创建一个 $p$ 为核心对象的新簇；
• 依据 $p$ 来反复寻找密度相连的集合（有可能合并原有已经生成的簇）；
• 当没有任何新的点可以被添加到簇中的时候，寻找结束。

根据半径（ $\epsilon$ 邻域）、最少点数（ $m$ ）区分核心点、边界点、噪声点：

• 核心点：核心点的半径范围（ $\epsilon$ 邻域））内的样本个数 $\ge m$ ；
  • 每个簇至少包含一个核心点（核心对象）
• 边界点：边界点的半径范围内的样本个数 $＜m$ ，但 $＞0$；
  • 非核心对象可以是簇的一部分，构成簇的边缘
• 噪声点：噪声点的半径范围的样本个数为 $=0$。
  • 包含过少对象的簇被认为是噪声

小贴士

• List item
• 参考1：密度聚类（DBSCAN / MDCA） by loveliuzz
• 参考2：六种常见聚类算法（参考的文中密度聚类部分） by TingXiao-Ul

2. 基于 sklearn 的密度聚类代码

下面是基于 sklearn 库做的聚类，感受超参数 $\epsilon$ 、$m$ 不同的情况 DBSCAN 聚类的效果

代码：（ 工具：PyCharm，基于：python3）

# ----- 导入模块 ----- 
import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as ds  # 通过datasets，帮我们创建一些数据集
import matplotlib.colors  # 关于颜色的
from sklearn.cluster import DBSCAN  # 密度聚类
from sklearn.preprocessing import StandardScaler

def expand(a, b):
    d = (b - a) * 0.1
    return a - d, b + d


if __name__ == "__main__":
    # ----- 数据准备 ----------------------
    N = 1000
    centers = [[1, 2], [-1, -1], [1, -1], [-1, 1]]  # 指明簇中心的位置
    # make_blobs 函数：生成数据集。—— 创建1000个样本点，每个样本点有2个特征，指定了4个簇中心，默认使用正态分布-随机初始化数据，random_state:为了保证程序每次运行都分割一样的训练集和测试集
    data, y = ds.make_blobs(N, n_features=2, centers=centers, cluster_std=[0.5, 0.25, 0.7, 0.5], random_state=0)
    data = StandardScaler().fit_transform(data)  # 进行归一化
    # 数据的参数：(epsilon, min_sample) —— 半径，最少的样本的个数。下面创建了六组超参数
    params = ((0.2, 5), (0.2, 10), (0.2, 15), (0.3, 5), (0.3, 10), (0.3, 15))

    # ----- 以下是画图的内容，画了6个子图（因为设置了 6 组超参数，每次循环取出一组进行密度聚类） ------------------------------

    matplotlib.rcParams['font.sans-serif'] = [u'SimHei']  # 可展示中文（黑体）
    matplotlib.rcParams['axes.unicode_minus'] = False  # 让负号可以正常显示

    plt.figure(figsize=(12, 8), facecolor='w')  # 设置画布大小和颜色
    plt.suptitle(u'DBSCAN聚类', fontsize=20)  # 主标题

    for i in range(6):
        # ----- 下面进行密度聚类（核心代码）--------------
        eps, min_samples = params[i]  # 取出每组超参数
        """ 调用 DBSCAN 密度聚类算法
        参数含义:
        · eps: 半径，表示以给定点 p 为中心的圆形部域的范围
        · min_samples: 以点 p 为中心的邻域内最少点的数量
        如果满足 以点 p 为中心,半径为 eps 的领域内，点的个数不少 min_samples ,则称点 p 为【核心点】
        """
        model = DBSCAN(eps=eps, min_samples=min_samples)  # DBSCAN 密度聚类算法
        model.fit(data)  # 训练 DBSCAN 模型
        y_hat = model.labels_  # 拿到每个样本对应的类别聚类的结果。无论核心点还是边界点，只要是同一个簇的都被赋予同样的label，噪声点为-1.

        core_indices = np.zeros_like(y_hat, dtype=bool)  # 生成数据类型和形状和 y_hat 一致的初始化为0的数组。dtype=bool：会覆盖原数据类型，∴是一个布尔数组
        core_indices[model.core_sample_indices_] = True  # model.core_ sample_ 核心点的索引。由于labels_无法区分核心点与边界点，所以要用该索引确定核心点。

        y_unique = np.unique(y_hat)  # 统计总共有几类，其中为 -1 的：表示未分类样本。unique 函数：去除其中重复的元素
        n_clusters = y_unique.size - (1 if -1 in y_hat else 0)  # 得到聚类簇的个数
        print(y_unique, '聚类簇的个数为：', n_clusters)

        plt.subplot(2, 3, i + 1)  # 共6张子图（2行3列），绘制第 i+1 张
        clrs = plt.cm.Spectral(np.linspace(0, 0.8, y_unique.size))  # plt.cm.Spectral 作用：在画图时为不同类别的样本分别分配不同的颜色
        print(clrs)
        for k, clr in zip(y_unique, clrs): # zip() 函数：将可迭代的对象作为参数，把对象中对应的元素打包成一个个元组，并返回由这些元组组成的对象
            cur = (y_hat == k)
            cur = (y_hat == k)
            if k == -1:
                plt.scatter(data[cur, 0], data[cur, 1], s=20, c='k')  # 散点图，用于绘制未分类样本。c='k'：黑色
                continue
            plt.scatter(data[cur, 0], data[cur, 1], s=30, c=clr, edgecolors='k')  # 散点图，绘制正常节点
            plt.scatter(data[cur & core_indices][:, 0], data[cur & core_indices][:, 1], s=60, c=clr, marker='o',
                        edgecolors='k')  # 绘制边界点
        x1_min, x2_min = np.min(data, axis=0)  # 分别找到数据的两列中的最小值
        x1_max, x2_max = np.max(data, axis=0)  # 分别找到数据的两列中的最大值
        x1_min, x1_max = expand(x1_min, x1_max)
        x2_min, x2_max = expand(x2_min, x2_max)
        plt.xlim((x1_min, x1_max))  # 设置 x 轴的数值显示范围
        plt.ylim((x2_min, x2_max))  # 设置 y 轴的数值显示范围
        plt.grid(True)  # 网格
        plt.title(u'epsilon = %.1f  m = %d，聚类数目：%d' % (eps, min_samples, n_clusters), fontsize=16)  # 子图的标题
    plt.tight_layout()  # 会自动调整子图参数,使之填充整个图像区域（防止重叠）
    plt.subplots_adjust(top=0.9)
    plt.savefig('cluster_DBSCAN')  # 将绘图结果保存为png图片
    plt.show()  # 展示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

结果展示：

从图中可看出，密度聚类存在的一个问题：

• 有些点无法聚到任何簇中，即：离群点（噪声点）

离群点为什么聚不进来？

• 半径够不到、或者 m（最少样本个数）设置的比较大——密度不可达

六、谱聚类（了解即可）

谱聚类的本质：先做降维，再用 K-Means

谱聚类的特点

优点：

• 对数据的结构没有假设（适应性广）
• 经过特殊的构图处理后计算很快
• 不会像 K-Means 一样将一些离散的小簇聚在一起

缺点：

• 对于不同的构图方式比较敏感
• 对于超参数设置比较敏感

谱聚类整体思路

• 先构图，后切图

1. 构图

一个典型的实现由三个基本步骤组成：

• 根据训练集，计算相似度矩阵 $S$
• 根据相似度矩阵，采用某种构图方法计算 $W$ 权重矩阵
• 根据 $W$ 权重矩阵，计算 $D$ 矩阵和拉普拉斯矩阵

∴ 构图：通过 $S$ 相似矩阵 → 得到 $W$ 构图矩阵（构图方式有多种） → $D$ 对角矩阵 → $L$ 拉普拉斯矩阵

步骤一：相似度矩阵 $S$

• 根据 $n$ 个样本彼此之间的距离（可以选择：欧氏距离 或 高斯距离）生成一个 $N\times N$ 的相似度矩阵
  • 欧式距离: $s_{i,j}={\Vert x_i-x_j\Vert }^2$
  • 高斯距离: $s_{i,j}=e^{\frac{-{\Vert x_i-x_j\Vert }^2}{2{\sigma }^2}}$
• 得到了 $S$ 矩阵
  • $S$ 矩阵：样本与样本间，两两求相似度，把所有数据都填起来的矩阵

步骤二：根据构图方式计算 $W$ 矩阵（邻接矩阵）

$W$ 矩阵：想表达的是——如何构建的

常见构图方式：

• ① ε-neighborhood（$\epsilon$-邻近法）

  • 选取一个阈值 $\epsilon$
  • 根据一个规则，生成 $W$ 矩阵
    • 每一个点连接到与其 $\epsilon$ 半径内的所有点；
    • 如果在半径内，权重就是 $\epsilon$ ，否则就是0，没有其他的信息了。
  • 说明： 距离远近度量很不精确，因此在实际应用中，我们很少使用

• ② k-nearest neighborhood（K 近邻法）

  • 一个参数 k 首先固定下来
  • 利用 KNN 算法（K 近邻）遍历所有的样本点，取每个样本最近的 k 个点作为邻近，只有和样本距离最近的 k 个点之间的 $w_{ij}>0$
    • 但是这种方法会造成邻接矩阵 $W$ 非对称，后面的算法需要对称邻接矩阵。
  • 为了解决上述问题，一般采取下面两种方法其一：
    • a）K 近邻法是只要一个点在另一个点的 K 近邻中，则保留 $s_{i,j}$；
    • b）K 近邻法是必须两个点互为 K 近邻，才能保留 $s_{i,j}$。

• ③ fully connected（全连接法）

  • 直接保留相似度矩阵作为权重矩阵
  • 说明：实际应用中，建立邻接矩阵中最普遍的使用全连接法来建立

步骤三：计算 $D$ 矩阵和拉普拉斯矩阵

2. 切图

切图的过程，就是聚类的过程

内容：

• 对于原始图的任意两个子图 $A、B$ 满足 $A\cap B=\varnothing$（即：两图无相交部分）
• 定义切图权重为：$W(A,B)=\sum w_{ij}，i\in A，j\in B$
• 衡量最终切图结果：
  • 假设原始图 $V$ 切为了 $k$ 个子图（$A_1,A_2,...,A_K$），有$A_1\cup A_2\cup ...\cup A_K=V$ 且 $A_1\cap A_2\cap ...\cap A_K=\varnothing$ ，
  • 定义 $cut(A_1,A_2,...,A_K)=\frac{1}{2}{\sum }_i^{k}W(A_i,\overline{A_i})$ （其中，$\overline{A_i}$ 为 $A_i$ 的补集），为该种切法的切边权重和

切图的目的：

• 每个子图内部：连边的权重平均都较大
• 每个子图之间：尽量没有边相连，或者连边的权重很低

思考：

• 如何切图可以让子图内的点权重之和高，子图间的点权重之和低呢？
• 一个自然的想法就是最小化 $cut(A_1,A_2,\dots ,A_k)$，但是可以发现，这种极小化的切图存在问题

切图的问题：

切图方法 ☞ RatioCut：

• 对于 $L$ 矩阵（拉普拉斯矩阵）取最小的 $k_1$ 个特征值对应的特征向量（每个向量的形状是是 $1\ast n$ )
  • 说明：求特征值、特征向量：相当于 降维
    • 特征向量：相当于方向
    • 特征值：方向上的信息量
• 将 $k_1$ 个列向量拼成一个 $N$ 行 $k_1$ 列的矩阵 $H$
• 对这个 $H$ 矩阵按行做标准化
• 设定超参数 $k_2$，对标准化后的 $H$ 矩阵进行 K-Means 聚类，得到的结果便是按照 RatioCut 标准划分出来的子集
  • 白话：把原来的点，在不同的坐标系上进行相对应的投影，把投影完后的结果，通过 K-means 进行聚类

3. 基于 sklearn 的谱聚类代码

下面是基于 sklearn 库做的聚类，感受不同超参数下的谱聚类效果

代码：（ 工具：PyCharm，基于：python3）

# 导入模块
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors
from sklearn.cluster import spectral_clustering  # 谱聚类
from sklearn.metrics import euclidean_distances  # 欧式距离


def expand(a, b):
    d = (b - a) * 0.1
    return a-d, b+d


if __name__ == "__main__":
    # -----创建数据-----
    t = np.arange(0, 2*np.pi, 0.1)
    data1 = np.vstack((np.cos(t), np.sin(t))).T
    data2 = np.vstack((2*np.cos(t), 2*np.sin(t))).T
    data3 = np.vstack((3*np.cos(t), 3*np.sin(t))).T
    data = np.vstack((data1, data2, data3))

    n_clusters = 3
    m = euclidean_distances(data, squared=True)  # 欧式距离的开根号（矩阵）
    sigma = np.median(m)  # 中位数

    # ------------- 绘图 --------------

    matplotlib.rcParams['font.sans-serif'] = [u'SimHei']  # 可展示中文（黑体）
    matplotlib.rcParams['axes.unicode_minus'] = False  # 让负号可以正常显示

    plt.figure(figsize=(12, 8), facecolor='w')
    plt.suptitle(u'谱聚类', fontsize=20)
    clrs = plt.cm.Spectral(np.linspace(0, 0.8, n_clusters))
    for i, s in enumerate(np.logspace(-2, 0, 6)):
        print(s)
        af = np.exp(-m ** 2 / (s ** 2)) + 1e-6   # 此处 s 用来判断高斯距离；‘+ 1e-6’：是为了防止值为0
        y_hat = spectral_clustering(af, n_clusters=n_clusters, assign_labels='kmeans', random_state=1)
        plt.subplot(2, 3, i+1)
        for k, clr in enumerate(clrs):
            cur = (y_hat == k)
            plt.scatter(data[cur, 0], data[cur, 1], s=40, c=clr, edgecolors='k')
        x1_min, x2_min = np.min(data, axis=0)
        x1_max, x2_max = np.max(data, axis=0)
        x1_min, x1_max = expand(x1_min, x1_max)
        x2_min, x2_max = expand(x2_min, x2_max)
        plt.xlim((x1_min, x1_max))
        plt.ylim((x2_min, x2_max))
        plt.grid(True)  # 网格
        plt.title(u'sigma = %.2f' % s, fontsize=16)  # 子图的标题
    plt.tight_layout()  # 会自动调整子图参数,使之填充整个图像区域（防止重叠）
    plt.subplots_adjust(top=0.9)
    plt.savefig('cluster_spectral')  # 将绘图结果保存为png图片
    plt.show()  # 展示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

结果展示：

---

—— 说明：本文写于 2022.9.2 和 9.18~9.28 ，文中内容基于 python3，使用工具 PyCharm 编写的代码