机器学习基础与实践（三）----数据降维之PCA

时间 2019-11-14

标签机器学习基础实践数据 pca 繁體版

原文原文链接

写在前面：原本这篇应该是上周四更新，可是上周四写了一篇深度学习的反向传播法的过程，就推迟更新了。原本想参考PRML来写，可是发现里面涉及到比较多的数学知识，写出来可能很差理解，我决定仍是用最通俗的方法解释PCA，并举一个实例一步步计算，而后再进行数学推导，最后再介绍一些变种以及相应的程序。（数学推导及变种下次再写好了）html

正文：python

　　在数据处理中，常常会遇到特征维度比样本数量多得多的状况，若是拿到实际工程中去跑，效果不必定好。一是由于冗余的特征会带来一些噪音，影响计算的结果；二是由于无关的特征会加大计算量，耗费时间和资源。因此咱们一般会对数据从新变换一下，再跑模型。数据变换的目的不只仅是降维，还能够消除特征之间的相关性，并发现一些潜在的特征变量。spring

　　1、PCA的目的并发

　　PCA是一种在尽量减小信息损失的状况下找到某种方式下降数据的维度的方法。一般来讲，咱们指望获得的结果，是把原始数据的特征空间（n个d维样本）投影到一个小一点的子空间里去，并尽量表达的很好（就是说损失信息最少）。常见的应用在于模式识别中，咱们能够经过减小特征空间的维度，抽取子空间的数据来最好的表达咱们的数据，从而减小参数估计的偏差。注意，主成分分析一般会获得协方差矩阵和相关矩阵。这些矩阵能够经过原始数据计算出来。协方差矩阵包含平方和与向量积的和。相关矩阵与协方差矩阵相似，可是第一个变量，也就是第一列，是标准化后的数据。若是变量之间的方差很大，或者变量的量纲不统一，咱们必须先标准化再进行主成分分析。dom

　　2、PCA VS MDA函数

　　提到PCA，可能有些人会想到MDA（Multiple Discriminate Analysis,多元判别分析法），这二者都是线性变换，并且很类似。只不过在PCA中，咱们是找到一个成分（方向）来把咱们的数据最大化方差，而在MDA中，咱们的目标是最大化不一样类别之间的差别（好比说，在模式识别问题中，咱们的数据包含多个类别，与两个主成分的PCA相比，这就忽略了类别标签）。学习

换句话说，经过PCA，咱们把整个数据集（不含类别标签）投射到一个不一样的子空间中，在MDA中，咱们试图决定一个合适的子空间来区分不一样类别。再换种方式说，PCA是找到数据传播最广的时候的最大方差的轴axis，MDA是最大化类别与类别之间的区别。spa

　　上文咱们提到了子空间，那么怎么样去寻找“好的”子空间呢？3d

　　假设咱们的目标是减小d维的数据集，将其投影到k维的子空间上（看k<d）。因此，咱们如何来肯定k呢？如何知道咱们选择的特征空间可以很好的表达原始数据呢？code

　　下文中咱们会计算数据中的特征向量（主成分），而后计算散布矩阵（scatter_matrix）中（也能够从协方差矩阵中计算）。每一个特征向量与特征值相关，即特征向量的“长度”或“大小”。若是发现每一个特征值都很小，那就能够说明咱们的原始数据就已是一个“好的”空间了。可是，若是有些特征值比其余值要大得多，咱们只须要关注那些特别大的特征值，由于这些值包含了数据分布状况的绝大部分信息。反之，那些接近于0的特征值包含的信息几乎没有，在新的特征空间里咱们能够忽略不计。

　　3、PCA的过程

　　一般来讲有如下六步：

　　1.数据准备----生成三维样本向量

　　首先随机生成40*3维的数据，符合多元高斯分布。假设数据被分为两类，其中一半类别为w1，另外一半类别为w2

 1 #coding:utf-8
 2 import numpy as np
 3 
 4 np.random.seed(4294967295) 
 5 
 6 mu_vec1 = np.array([0,0,0])
 7 cov_mat1 = np.array([[1,0,0],[0,1,0],[0,0,1]])
 8 class1_sample = np.random.multivariate_normal(mu_vec1, cov_mat1, 20).T
 9 assert class1_sample.shape == (3,20)#检验数据的维度是否为3*20，若不为3*20，则抛出异常
10 
11 mu_vec2 = np.array([1,1,1])
12 cov_mat2 = np.array([[1,0,0],[0,1,0],[0,0,1]])
13 class2_sample = np.random.multivariate_normal(mu_vec2, cov_mat2, 20).T
14 assert class1_sample.shape == (3,20)#检验数据的维度是否为3*20，若不为3*20，则抛出异常

　　运行这段代码后，咱们就生成了包含两个类别的样本数据，其中每一列都是一个三维的向量，全部数据是这样的矩阵：

　　结果：

　　2.做图查看原始数据的分布

 1 from matplotlib import pyplot as plt
 2 from mpl_toolkits.mplot3d import Axes3D
 3 from mpl_toolkits.mplot3d import proj3d
 4 
 5 fig = plt.figure(figsize=(8,8))
 6 ax = fig.add_subplot(111, projection='3d')
 7 plt.rcParams['legend.fontsize'] = 10   
 8 ax.plot(class1_sample[0,:], class1_sample[1,:], class1_sample[2,:], 'o', markersize=8, color='blue', alpha=0.5, label='class1')
 9 ax.plot(class2_sample[0,:], class2_sample[1,:], class2_sample[2,:], '^', markersize=8, alpha=0.5, color='red', label='class2')
10 
11 plt.title('Samples for class 1 and class 2')
12 ax.legend(loc='upper right')
13 
14 plt.show()

　　结果：

　　3.去掉数据的类别特征

1 all_samples = np.concatenate((class1_sample, class2_sample), axis=1)
2 assert all_samples.shape == (3,40)#检验数据的维度是否为3*20，若不为3*20，则抛出异常

　　4.计算d维向量均值

1 mean_x = np.mean(all_samples[0,:])
2 mean_y = np.mean(all_samples[1,:])
3 mean_z = np.mean(all_samples[2,:])
4 
5 mean_vector = np.array([[mean_x],[mean_y],[mean_z]])
6 
7 print('Mean Vector:\n', mean_vector)

　　结果：

1 print('Mean Vector:\n', mean_vector)
2 Mean Vector:, 
3 array([[ 0.68047077],
4        [ 0.52975093],
5        [ 0.43787182]]))

　　5.计算散步矩阵或者协方差矩阵

　　a.计算散步矩阵

　　散布矩阵公式：

　　其中m是向量的均值：（第4步已经算出来是mean_vector）

1 scatter_matrix = np.zeros((3,3))
2 for i in range(all_samples.shape[1]):
3     scatter_matrix += (all_samples[:,i].reshape(3,1) - mean_vector).dot((all_samples[:,i].reshape(3,1) - mean_vector).T)
4 print('Scatter Matrix:\n', scatter_matrix)

　　结果：

1  print('Scatter Matrix:\n', scatter_matrix)
2 ('Scatter Matrix:, 
3 array([[ 46.81069724,  13.95578062,  27.08660175],
4        [ 13.95578062,  48.28401947,  11.32856266],
5        [ 27.08660175,  11.32856266,  50.51724488]]))

　　b.计算协方差矩阵

　　若是不计算散布矩阵的话，也能够用python里内置的numpy.cov()函数直接计算协方差矩阵。由于散步矩阵和协方差矩阵很是相似，散布矩阵乘以（1/N-1）就是协方差，因此他们的特征空间是彻底等价的（特征向量相同，特征值用一个常数（1/N-1，这里是1/39）等价缩放了）。协方差矩阵以下所示：

1 cov_mat = np.cov([all_samples[0,:],all_samples[1,:],all_samples[2,:]])
2 print('Covariance Matrix:\n', cov_mat)

　　结果：

1 >>> print('Covariance Matrix:\n', cov_mat)
2 Covariance Matrix:,
3  array([[ 1.20027429,  0.35784053,  0.69452825],
4        [ 0.35784053,  1.23805178,  0.29047597],
5        [ 0.69452825,  0.29047597,  1.29531397]]))

　　6.计算相应的特征向量和特征值

 1 # 经过散布矩阵计算特征值和特征向量
 2 eig_val_sc, eig_vec_sc = np.linalg.eig(scatter_matrix)
 3 
 4 # 经过协方差矩阵计算特征值和特征向量
 5 eig_val_cov, eig_vec_cov = np.linalg.eig(cov_mat)
 6 
 7 for i in range(len(eig_val_sc)):
 8     eigvec_sc = eig_vec_sc[:,i].reshape(1,3).T
 9     eigvec_cov = eig_vec_cov[:,i].reshape(1,3).T
10     assert eigvec_sc.all() == eigvec_cov.all()
11 
12 print('Eigenvector {}: \n{}'.format(i+1, eigvec_sc))
13 print('Eigenvalue {} from scatter matrix: {}'.format(i+1, eig_val_sc[i]))
14 print('Eigenvalue {} from covariance matrix: {}'.format(i+1, eig_val_cov[i]))
15 print('Scaling factor: ', eig_val_sc[i]/eig_val_cov[i])
16 print(40 * '-')

　　结果：

 1 Eigenvector 1:
 2     [[-0.84190486]
 3      [-0.39978877]
 4      [-0.36244329]]
 5     Eigenvalue 1 from scatter matrix: 55.398855957302445
 6     Eigenvalue 1 from covariance matrix: 1.4204834860846791
 7     Scaling factor:  39.0
 8     ----------------------------------------
 9     Eigenvector 2:
10     [[-0.44565232]
11      [ 0.13637858]
12      [ 0.88475697]]
13     Eigenvalue 2 from scatter matrix: 32.42754801292286
14     Eigenvalue 2 from covariance matrix: 0.8314755900749456
15     Scaling factor:  39.0
16     ----------------------------------------
17     Eigenvector 3:
18     [[ 0.30428639]
19      [-0.90640489]
20      [ 0.29298458]]
21     Eigenvalue 3 from scatter matrix: 34.65493432806495
22     Eigenvalue 3 from covariance matrix: 0.8885880596939733
23     Scaling factor:  39.0
24     ----------------------------------------

　　其实从上面的结果就能够发现，经过散布矩阵和协方差矩阵计算的特征空间相同，协方差矩阵的特征值*39 = 散布矩阵的特征值

　　固然，咱们也能够快速验证一下特征值-特征向量的计算是否正确，是否是知足方程（其中为协方差矩阵，v为特征向量，lambda为特征值）

1 for i in range(len(eig_val_sc)):
2     eigv = eig_vec_sc[:,i].reshape(1,3).T
3     np.testing.assert_array_almost_equal(scatter_matrix.dot(eigv), eig_val_sc[i] * eigv,decimal=6, err_msg='', verbose=True)

　　得出结果未返回异常，证实计算正确

　　注：np.testing.assert_array_almost_equal计算得出的结果不同会返回一下结果：

 1 >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
 2 ...                                      [1.0,2.33339,np.nan], decimal=5)
 3 ...
 4 <type 'exceptions.AssertionError'>:
 5 AssertionError:
 6 Arrays are not almost equal
 7 
 8 (mismatch 50.0%)
 9  x: array([ 1.     ,  2.33333,      NaN])
10  y: array([ 1.     ,  2.33339,      NaN])

　　可视化特征向量

 1 from matplotlib import pyplot as plt
 2 from mpl_toolkits.mplot3d import Axes3D
 3 from mpl_toolkits.mplot3d import proj3d
 4 from matplotlib.patches import FancyArrowPatch
 5 
 6 
 7 class Arrow3D(FancyArrowPatch):
 8     def __init__(self, xs, ys, zs, *args, **kwargs):
 9         FancyArrowPatch.__init__(self, (0,0), (0,0), *args, **kwargs)
10         self._verts3d = xs, ys, zs
11 
12     def draw(self, renderer):
13         xs3d, ys3d, zs3d = self._verts3d
14         xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)
15         self.set_positions((xs[0],ys[0]),(xs[1],ys[1]))
16         FancyArrowPatch.draw(self, renderer)
17 
18 fig = plt.figure(figsize=(7,7))
19 ax = fig.add_subplot(111, projection='3d')
20 
21 ax.plot(all_samples[0,:], all_samples[1,:], all_samples[2,:], 'o', markersize=8, color='green', alpha=0.2)
22 ax.plot([mean_x], [mean_y], [mean_z], 'o', markersize=10, color='red', alpha=0.5)
23 for v in eig_vec_sc.T:
24     a = Arrow3D([mean_x, v[0]], [mean_y, v[1]], [mean_z, v[2]], mutation_scale=20, lw=3, arrowstyle="-|>", color="r")
25     ax.add_artist(a)
26 ax.set_xlabel('x_values')
27 ax.set_ylabel('y_values')
28 ax.set_zlabel('z_values')
29 
30 plt.title('Eigenvectors')
31 
32 plt.show()

　　结果：

　　7.根据特征值对特征向量降序排列

1 for ev in eig_vec_sc:
2     numpy.testing.assert_array_almost_equal(1.0, np.linalg.norm(ev))

　　所以，对于低维的子空间来讲，决定丢掉哪一个特征向量，就必须参考特征向量相应的特征值。通俗来讲，若是一个特征向量的特征值特别小，那它所包含的数据分布的信息也不多，那么这个特征向量就能够忽略不计了。经常使用的方法是根据特征值对特征向量进行降序排列，选出前k个特征向量

1 # 生成（特征向量，特征值）元祖
2 eig_pairs = [(np.abs(eig_val_sc[i]), eig_vec_sc[:,i]) for i in range(len(eig_val_sc))]
3 
4 #对（特征向量，特征值）元祖按照降序排列
5 eig_pairs.sort(key=lambda x: x[0], reverse=True)
6 
7 #输出值
8 for i in eig_pairs:
9     print(i[0])

　　结果：

 1 84.5729942896
 2 39.811391232     
 3 21.2275760682

　　8.选出前k个特征值最大的特征向量

　　本文的例子是想把三维的空间降维成二维空间，如今咱们把前两个最大特征值的特征向量组合起来，生成d*k维的特征向量矩阵W

1 matrix_w = np.hstack((eig_pairs[0][1].reshape(3,1), eig_pairs[1][1].reshape(3,1)))
2 print('Matrix W:\n', matrix_w)

　　结果：

1 >>> print('Matrix W:\n', matrix_w)
2 Matrix W:,
3  array([[-0.62497663,  0.2126888 ],
4        [-0.44135959, -0.88989795],
5        [-0.643899  ,  0.40354071]]))

　　9.将样本转化为新的特征空间

　　最后一步，把2*3维的特征向量矩阵W带到公式中，将样本数据转化为新的特征空间

 1 matrix_w = np.hstack((eig_pairs[0][1].reshape(3,1), eig_pairs[1][1].reshape(3,1)))
 2 print('Matrix W:\n', matrix_w)
 3 
 4 
 5 transformed = matrix_w.T.dot(all_samples)
 6 assert transformed.shape == (2,40), "The matrix is not 2x40 dimensional."
 7 
 8 
 9 plt.plot(transformed[0,0:20], transformed[1,0:20], 'o', markersize=7, color='blue', alpha=0.5, label='class1')
10 plt.plot(transformed[0,20:40], transformed[1,20:40], '^', markersize=7, color='red', alpha=0.5, label='class2')
11 plt.xlim([-4,4])
12 plt.ylim([-4,4])
13 plt.xlabel('x_values')
14 plt.ylabel('y_values')
15 plt.legend()
16 plt.title('Transformed samples with class labels')
17 
18 plt.show()

　　结果：

　　到这一步，PCA的过程就结束了。其实python里有已经写好的模块，能够直接拿来用，可是我以为无论什么模块，都要懂得它的原理是什么。matplotlib有matplotlib.mlab.PCA()，sklearn也有专门一个模块Dimensionality reduction专门讲PCA，包括传统的PCA，也就是我上文写的，以及增量PCA，核PCA等等，除了PCA之外，还有ZCA白化等等，在图像处理中也常常会用到，内容太多，下次再写。

　　最后推荐一个博客，动态展现了PCA的过程：http://setosa.io/ev/principal-component-analysis/ 写的也很清楚，能够看一下；再推荐一个维基百科的，讲的真的是详细啊https://en.wikipedia.org/wiki/Principal_component_analysis

------------------------------------本博客全部内容以学习、研究和分享为主，如需转载，请联系本人，标明做者和出处，而且是非商业用途，谢谢！--------------------------------