[机器学习入门笔记] 3.无监督学习模型部分

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

第 18 章 聚类分析与k均值聚类算法

聚类分析是一类经典的无监督学习算法，再给定样本的情况下，聚类分析通过度量特征相似度或者距离，将样本自动划分为若干类别。

18.1 距离度量和相似度度量方式

为了衡量特征空间中的两个实例的相似度，可以用距离来描述。

闵可夫斯基距离Minkowski distance（闵氏距离），定义为：
$$给定m维向量样本集合X，对于任意x_i，x_j\in X，x_i=(x_{1i}，x_{2i}，...，x_{mi}{)}^T，x_j=(x_{1j}，x_{2j}，...，x_{mj}{)}^T，样本x_i与样本x_j之间的闵氏距离可定义为：给定m维向量样本集合X，对于任意x_i，x_j\in X，x_i=(x_{1i}，x_{2i}，...，x_{mi}{)}^T，x_j=(x_{1j}，x_{2j}，...，x_{mj}{)}^T，样本x_i与样本x_j之间的闵氏距离可定义为：$$

$$d_{ij}=\sum _{k=1}^m{|x_{ki}-x_{kj}{|}^p}^{\frac{1}{p}}，p\ge 1$$

当p=1时，闵氏距离称为曼哈顿距离（Manhatan distance）:
$$d_{ij}=\sum _{k=1}^m|x_{ki}-x_{kj}|$$

当p=2时，闵氏距离称为欧氏距离（Euclidean distance）：
$$d_{ij}=\sum _{k=1}^m{|x_{ki}-x_{kj}{|}^2}^{\frac{1}{2}}$$
当p=∞时，闵氏距离称为切比雪夫距离（Chebyshev distance）：
$$d_{ij}=max|x_{ki}-x_{kj}|$$
马哈诺比斯距离（Mahalanobis distance），即马氏距离，是一种衡量各个特征之间相关性的距离度量方式。d当S为单位矩阵时，即样本各特征之间相互独立且方差为1时，马氏距离就是欧氏距离。
$$给定一个样本集合X=(x_{ij}{)}_{m\times n}，其协方差矩阵为S，那么样本x_i与样本x_j之间的马氏距离定义为：$$

$$d_{ij}=[(x_i-x_j{)}^T{S}^{-1}(x_i-x_j){]}^{\frac{1}{2}}$$

**相关系数（correlation coefficient）**是度量样本相似度最常用的方式。相关系数越接近1，表示两个样本越相似；相关系数越接近0，表示两个样本越不相似。样本$x_i$与样本$x_j$之间的相关系数定义为：
$$r_{ij}=\frac{{\sum }_{k=1}^m(x_{ki}-\overline{x_i})(x_{kj}-\overline{x_j})}{[{\sum }_{k=1}^m(x_{ki}-\overline{x_j}{)}^2{\sum }_{k=1}^m(x_{kj}-\overline{x_j}{)}^2{]}^{\frac{1}{2}}}$$
**夹角余弦（angle cosine）**也是度量两个样本相似度的方式。夹角余弦越接近1，表示两个样本越相似；夹角余弦越接近0，表示两个样本越不相似。样本$x_i$与样本$x_j$之间的夹角余弦定义为；
$$A{C}_{ij}=\frac{{\sum }_{k=1}^m{x}_{ki}{x}_{kj}}{[{\sum }_{k=1}^m{x_{ki}}^2{\sum }_{k=1}^m{x}_{kj}^2{]}^{\frac{1}{2}}}$$

18.2 K均值聚类算法的原理推导

给定$m\times n$维度大小的看看样本集合$X=\{x_1,x_2,...,x_n\}$，$k$均值聚类是将$n$个样本划分到$k$个类别区域，通常$k<n$。所以$k$均值聚类总结为对样本集合$X$的划分，其学习策略是通过最小化损失函数来选取最优划分。

假设使用欧式距离作为$k$均值聚类算法的距离度量方式，则样本间的距离$d_{ij}$定义为：
$$d_{ij}=\sum _{k=1}^m(x_{ki-x_{k}j}{)}^2=||x_i-x_j|{|}^2$$
定义样本与其所属类中心之间的距离总和为最终损失函数：
$$L(C)=\sum _{i=1}^k\sum _{C(i)=l}||x_i-\overline{x_l}|{|}^2$$
其中，$\overline{x}={\overline{x}}_{1l},...,{\overline{x}}_{ml}$为第$l$个类的质心，即类的中心点；$n_l={\sum }_{i=1}^{n}I(L(i)=l)$中的$(L(i)=l)$表示指示函数，取值为1或0。函数$L(C)$表示相同类中样本的相似度。所以$k$均值聚类规约为一个优化问题进行求解：
$$C^{\ast }=arg\underset{C}{\min }L(C)=arg\underset{C}{\min }\sum _{l=1}^k\sum _{C(i)=l}||x_i-x_j|{|}^2$$
根据前述过程，梳理$k$均值聚类算法的主要流程：

• step 1 初始化质心。即在第0次迭代时随机选择$k$个样本点作为初始化聚类质心$m^{(0)}=(m_1^{(0)},...,m_l^{(0)},...,m_k^{(0)}$
• step 2 按照样本与质心的距离对样本进行聚类。对固定的质心$m^{(t)}=(m_1^{(t)},...,m_l^{(t)},...,m_k^{(t)}$，其中$m_t^{(t)}$为类$G_t$的质心，计算每个样本到质心的距离，将每个样本划分到与其最近的质心所在的类，构成初步的聚类结果$C^{(t)}$
• step 3 计算上一步聚类结果的新的质心。对聚类结果$C^{(t)}$计算当前各个类中的样本的均值，并作为新的质心$m^{(t+1)}=(m_1^{(t+1)},...,m_l^{(t+1)},...,m_k^{(t+1)}$
• step 4 如果迭代收敛或者满足迭代停止条件，则输出最后的聚类结果$C^{\ast }=C^{(t)}$，否则令$t=t+1$，返回step2重新计算

18.3 k均值聚类算法实现

k均值聚类代码编写思路

Numpy：

• 欧氏距离计算
• k均值聚类流程
  • 质心初始化
  • 迭代求解
  • 根据欧式距离判断类别
  • 构建簇
  • 重新计算质心
  • 预测样本所属类别
• 数据测试

sklearn：

• sklearn.cluster.KMeans

18.3.1 基于Numpy的k均值聚类算法实现

定义欧式距离

# 导入numpy库
import numpy as np

### 定义欧式距离
def euclidean_distance(x1, x2):
    '''
     输入：
     x：向量x
     y：向量y
     输出：
        np.sqrt(distance)：欧式距离
    '''
    # 初始化距离
    distance = 0
    # 遍历并对距离的平方进行累加
    for i in range(len(x1)):
        distance += pow((x1[i] - x2[i]), 2)
    return np.sqrt(distance)

质心初始化

### 定义质心初始化函数
def centroids_init(k, X):
    '''
    输入：
    X：训练样本，Numpy数组
    k：质心个数，也是聚类个数
    输出：
    centroids：质心矩阵
    '''
    # 样本数和特征数
    m, n = X.shape
    # 初始化质心矩阵，大小为质心个数×特征数
    centroids = np.zeros((k, n))
    # 遍历
    for i in range(k):
        # 每一次循环随机选择一个类别中心作为质心向量
        centroid = X[np.random.choice(range(m))]
        # 将质心向量分配给质心矩阵
        centroids[i] = centroid
    return centroids

根据质心和距离判断所属质心索引

### 定义样本的最近质心点所属的类别索引
def closest_centroid(sample, centroids):
    '''
    输入：
    x：单个样本实例
    centroids：质心矩阵
    输出：
    closest_i：
    '''
    # 初始化最近索引和最近距离
    closest_i = 0
    closest_dist = float('inf')
    # 遍历质心矩阵
    for i, centroid in enumerate(centroids):
        # 计算欧式距离
        distance = euclidean_distance(sample, centroid)
        # 根据欧式距离判断并选择最近质心的索引
        if distance < closest_dist:
            closest_i = i
            closest_dist = distance
    return closest_i

为每个样本分配簇

### 分配样本与构建簇
def build_clusters(centroids, k, X):
    '''
    输入：
    centroids：质心矩阵
    k：质心个数，也是聚类个数
    X：训练样本，Numpy数组
    输出：
    clusters：聚类簇
    '''
    # 初始化簇列表
    clusters = [[] for _ in range(k)]
    # 遍历训练样本
    for x_i, x in enumerate(X):
        # 获取样本所属最近质心的索引
        centroid_i = closest_centroid(x, centroids)
        # 将当前样本添加到所属类簇中
        clusters[centroid_i].append(x_i)
    return clusters

计算当前质心

# 计算质心
def calculate_centroids(clusters, k, X):
    '''
    输入：
    clusters：上一步的聚类簇
    k：质心个数，也就是聚类个数
    X：训练样本，numpy数组
    输出：
    centroids：更新后的质心矩阵
    '''
    # 特征数
    n = X.shape[1]
    # 初始化质心矩阵，大小为质心个数×特征数
    centroids = np.zeros((k, n))
    # 遍历当前簇
    for i, cluster in enumerate(clusters):
        # 计算每个簇的均值作为新的质心
        centroid = np.mean(X[cluster], axis=0)
        # 将质心向量分配给质心矩阵
        centroids[i] = centroid
    return centroids

获取样本的所属聚类类别

# 获取每个样本所属的聚类类别
def get_cluster_labels(clusters, X):
    '''
    输入：
    clusters：当前的聚集簇
    X：训练样本，NUmpy数组
    输出：
    y_pred：预测类别
    '''
    # 预测结果初始化
    y_pred = np.zeros(X.shape[0])
    # 遍历聚类簇
    for cluster_i, cluster in enumerate(clusters):
        # 遍历当前簇
        for X_i in cluster:
            # 为每个样本分配类别簇
            y_pred[X_i] = cluster_i
    return y_pred

k均值聚类算法封装过程

### k均值聚类算法流程封装
def kmeans(X, k, max_iterations):
    '''
    输入：
    X：训练样本，Numpy数组
    k：质心个数（聚类个数）
    max_iterations：最大迭代次数
    输出：
    预测类别列表
    '''
    # 1.初始化质心
    centroids = centroids_init(k, X)
    # 遍历迭代求解
    for _ in range(max_iterations):
        # 2.根据当前质心进行聚类
        clusters = build_clusters(centroids, k, X)
        # 保存当前质心
        prev_centroids = centroids
        # 3.根据聚类结果计算新的质心
        centroids = calculate_centroids(clusters, k, X)
        # 4.设定收敛条件为质心是否发生变化
        diff = centroids - prev_centroids
        if not diff.any():
            break
    # 返回最终的聚类标签
    return get_cluster_labels(clusters, X)

基于Numpy的k均值聚类算法测试

# 创建测试数据
X = np.array([[0,2],[0,0],[1,0],[5,0],[5,2]])
# 设定聚类类别为2个，最大迭代次数为10次
labels = kmeans(X, 2, 10)
# 打印每个样本所属的类别标签
print(labels)

18.3.2 基于sklearn的k均值聚类算法实现

# 导入KMeans模块
from sklearn.cluster import Kmeans
# 创建k均值聚类实例并进行数据拟合
kmeans = KMeans(n_cluster=2,random_state=0).fit(x)
# 打印拟合标签
print(kmeans.labels_)

18.4 小结

• 聚类算法属于无监督学习算法
• 聚类算法建立在距离度量方式的基础上，常用的距离度量方式包括闵氏距离和马氏距离，常用的相似度度量方式包括相关系数和夹角余弦
• k均值聚类算法的主要步骤包括质心初始化、根据距离度量进行初步聚类、根据聚类结果计算新的质心、不断迭代聚类直至满足停止条件

第 19 章 主成分分析

降维是一种无监督学习算法，而主成分分析 PCA是一种经典的降维算法。PCA通过正交变换将一组由线性相关变量表示的数据转换为几个由线性无关变量表示的数据，该线性无关变量就是主成分。

19.1 PCA原理推导

PCA基本思路

• 首先将需要降维的数据的各个变量标准化（规范化）为均值0，方差为1的数据集
• 然后对标准化后的数据进行正交变换，将原来的数据转换为由若干线性无关向量表示的新数据。这些新向量表示的数据不仅要求相互线性无关，而且需要所包含的信息量最大

假设原始数据$m$维随机变量$x=(x_1,x_2,...,x_m{)}^T$，其均值向量$\mu ：\mu =E(x)=({\mu }_1,{\mu }_2,...,{\mu }_m{)}^T$，协方差矩阵为
$$\Sigma =cov(x,x)=E[(x-\mu )(x-\mu {)}^T]$$
由$m$维随机变量$x$到$m$维随机变量$y=(y_1,y_2,...,y_m{)}^T$的线性变换：
$$y_i={\alpha }_i^{T}x=a_{1i}{x}_1+a_{2i}{x}_2+...+a_{mi}{x}_m，其中{\alpha }_i^T=({\alpha }_{1i},{\alpha }_{2i},...,{\alpha }_{mi})$$
经过线性变换后的随机变量$y_i$的均值、方差和协方差统计量可以表示为：
$$\begin{gathered} E(y_i)={\alpha }_i^T{\mu }_i,i=1,...,m \\ var(y_i)={\alpha }_i^T\Sigma {\alpha }_i,i=1,...,m \\ cov(y_i,y_j)={\alpha }_i^T\Sigma {\alpha }_j,i=1,...,m \end{gathered}$$
当随机变量$x$到随机变量$y$的线性变换满足如下条件时，变换后的$y_1,y_2,...,y_m$分别为随机变量$x$的第一主成分、第二主成分、…、第m主成分。

• 线性变换的系数向量${\alpha }_i^T$为单位向量，有${\alpha }_i^T{\alpha }_i=1,i=1,...,m$
• 线性变换后的变量$y_i$与$y_j$线性无关，即$cov(y_i,y_j)\ne 0(i\ne j)$
• 变量$y_1$是随机变量$x$所有线性变换中方差最大的，$y_2$是与$y_1$无关的所有线性变换中的方差最大的。

上述三个条件给出求解主成分的基本方法。根据优化目标和约束条件，使用拉格朗日乘子法求解主成分。以第一主成分为例，第一主成分的优化问题数学表达为：
$$\begin{gathered} \max {\alpha }_1^T\Sigma {\alpha }_1 \\ s.t.{\alpha }_1^T{\alpha }_1=1 \end{gathered}$$
定义拉格朗日函数：
$$L={\alpha }_1^T\Sigma {\alpha }_1-\lambda ({\alpha }_1^T{\alpha }_1-1)$$
对${\alpha }_1$求导并令拉格朗日函数等于0，有：
$$\frac{\partial L}{\partial {\alpha }_1}=\Sigma {\alpha }_1-\lambda {\alpha }_1=0$$
根据矩阵特征值与特征向量的关系，由上式知$\lambda$为$\Sigma$的特征值，${\alpha }_1$为对应的单位特征向量。假设${\alpha }_1$是$\Sigma$的最大特征值${\lambda }_1$对应的特征向量，那么${\alpha }_1$和${\lambda }_1$均为上述优化问题的最优解。因此${\alpha }_1^{T}x$为第一主成分，其方差为对应协方差矩阵的最大特征值:
$$var({\alpha }_1^{T}x)={\alpha }_1^T\Sigma {\alpha }_1={\lambda }_1$$
同理，第$k$主成分的方差的第$k$个特征值为：
$$var({\alpha }_k^{T}x)={\alpha }_k^T\Sigma {\alpha }_k={\lambda }_k$$

PCA计算流程

• 对$m$行$n$列的数据$X$按照列均值为0、方差为1进行标准化处理
• 计算标准化后的$X$的协方差矩阵$C=\frac{1}{m}X{X}^T$
• 计算协方差矩阵$C$的特征值和对应的特征向量
• 将特征向量按照对应特征值大小排列成矩阵、取前$k$行构成的矩阵$P$
• 计算$Y=PX$即可得到经过PCA降维后的$k$维数据

19.2 PCA算法实现

19.2.1 基于Numpy的PCA算法实现

PCA算法实现

import numpy as np
### PCA算法类
class PCA():
    # 定义协方差矩阵计算方法
    def calc_cov(self, X):
        # 样本量
        m = X.shape[0]
        # 数据标准化
        X = (X - np.mean(X, axis=0)) / np.var(X, axis=0)
        return 1 / m * np.matmul(X.T, X)

    # PCA 算法实现
    # 输入为要进行PCA的矩阵和指定的主成分个数
    def pca(self, X, n_components):
        # 计算协方差矩阵，对应step1和step2
        cov_matrix = self.calc_cov(X)
        # 计算协方差矩阵的特征值和对应特征向量
        # 对应step3
        eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
        # 对特征值排序，对应step4
        idx = eigenvalues.argsort()[::-1]
        # 取最大的前n_component组，对应step4
        eigenvectors = eigenvectors[:, idx]
        eigenvectors = eigenvectors[:, :n_components]
        # Y=PX转换，对应step5
        return np.matmul(X, eigenvectors)

PCA算法数据测试

from sklearn import datasets
import matplotlib.pyplot as plt

# 导入sklearn数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 将数据降维到3个主成分
X_trans = PCA().pca(X, 3)
# 颜色列表
colors = ['navy', 'turquoise', 'darkorange']

# 绘制不同类别
for c, i, target_name in zip(colors, [0,1,2], iris.target_names):
    plt.scatter(X_trans[y == i, 0], X_trans[y == i, 1],
            color=c, lw=2, label=target_name)
# 添加图例
plt.legend()
plt.show();

19.2.2 基于sklearn的PCA算法实现

# 导入sklearn降维模块
from sklearn import decomposition
# 创建pca模型实例，主成分个数为3个
pca = decomposition.PCA(n_components=3)
# 模型拟合
pca.fit(X)
# 拟合模型并将模型应用于数据X
X_trans = pca.transform(X)

# 颜色列表
colors = ['navy', 'turquoise', 'darkorange']
# 绘制不同类别
for c, i, target_name in zip(colors, [0,1,2], iris.target_names):
    plt.scatter(X_trans[y == i, 0], X_trans[y == i, 1], 
            color=c, lw=2, label=target_name)
# 添加图例
plt.legend()
plt.show();

19.3 小结

• PCA是经典的无监督学习和降维算法
• PCA核心思想：将规范化后的数据正交变换为若干线性无关的新编看，并且这些新变量所含的信息量最大
• PCA实现方式：1. 求样本协方差矩阵的特征值和特征向量 2. 基于奇异值分解