机器学习中的数学（3）：PCA的降维（协方差和奇异值分解）

1.协方差

# coding:utf-8

import numpy as np
def testCovariance():
    # 测试协方差
    X = [[2, 0, -1.4],
        [2.2, 0.2, -1.5],
        [2.4, 0.1, -1],
        [1.9, 0, -1.2]]
    # print(type(X))  #
    # print(type(np.array(X).T))   # 
    print(np.mean(X,axis=0))
    print(np.cov(np.array(X).T))
    print(np.array(X).T)

    batch = [128, 28, 28]

    m = np.mean(batch, axis=0)
    print(m)

    print('================')
    x2 = [[1, 2, 3, 4],
        [3, 4, 1, 2],
        [2, 3, 1, 4]]
    print(np.mean(x2,axis=0))
    print(np.cov(np.array(x2).T))
    #print(np.cov(np.array(x2)))

    print('000000000000'+'\n')
    x = [-2.1, -1,  4.3]
    y = [3,  1.1,  0.12]
    X = np.vstack((x,y))
    print(X)

testCovariance()
**#结果**
D:\python35\python3.exe D:/depthStudyWorks/18FirstYear/testPCA/test1_PCA.py
[ 2.125  0.075 -1.275]
[[ 0.04916667  0.01416667  0.01916667]
 [ 0.01416667  0.00916667 -0.00583333]
 [ 0.01916667 -0.00583333  0.04916667]]
[[ 2.   2.2  2.4  1.9]
 [ 0.   0.2  0.1  0. ]
 [-1.4 -1.5 -1.  -1.2]]
61.3333333333
================
[ 2.          3.          1.66666667  3.33333333]
[[ 1.          1.         -1.         -1.        ]
 [ 1.          1.         -1.         -1.        ]
 [-1.         -1.          1.33333333  0.66666667]
 [-1.         -1.          0.66666667  1.33333333]]
000000000000

[[-2.1  -1.    4.3 ]
 [ 3.    1.1   0.12]]

Process finished with exit code 0


# 测试PCA
def test_pca():
    import numpy as np
    w, v = np.linalg.eig(np.array([[1, -2], [2, -3]]))
    print('特征值：{}\n特征向量：{}'.format(w, v))
    print()
    print('============降维============')

    '''这是两维的数据，10个样本
    '''
    # 数组转换矩阵
    m = [[0.9, 2.4, 1.2, 0.5, 0.3, 1.8, 0.5, 0.3, 2.5, 1.3],
                [1, 2.6, 1.7, 0.7, 0.7, 1.4, 0.6, 0.6, 2.6, 1.1]]
    x = np.mat([[0.9, 2.4, 1.2, 0.5, 0.3, 1.8, 0.5, 0.3, 2.5, 1.3],
                [1, 2.6, 1.7, 0.7, 0.7, 1.4, 0.6, 0.6, 2.6, 1.1]])
    print(x)
    x = x.T
    T = x - x.mean(axis=0)
    C = np.cov(x.T)
    print('协方差矩阵array：',np.cov(np.array(m)))  # 上面和下面的结果一样的，
    print('两种不同的方式求得协方差，判断他们的类型一样吗？：', type(np.cov(np.array(m))),type(C))  #  
    print('协方差矩阵：',C)
    print()
    print('========特征值、特征向量========')
    w, v = np.linalg.eig(C)
    print(w)
    print('特征向量')
    print(v)
    v_ = np.mat(v[:, 0])  # 每个特征值对应的是特征矩阵的每个列向量
    print(v_)
    print('00000000000000==========')
    print(T)
    v_ = v_.T  # 默认以行向量保存，转换成公式中的列向量形式
    y = T * v_
    print(y)
#test_pca()

**#结果**
D:\python35\python3.exe D:/depthStudyWorks/18FirstYear/testPCA/test1_PCA.py
特征值：[-0.99999998 -1.00000002]
特征向量：[[ 0.70710678  0.70710678]
 [ 0.70710678  0.70710678]]

============降维============
[[ 0.9  2.4  1.2  0.5  0.3  1.8  0.5  0.3  2.5  1.3]
 [ 1.   2.6  1.7  0.7  0.7  1.4  0.6  0.6  2.6  1.1]]
协方差矩阵array： [[ 0.68677778  0.60666667]
 [ 0.60666667  0.59777778]]
两种不同的方式求得协方差，判断他们的类型一样吗？：  
协方差矩阵： [[ 0.68677778  0.60666667]
 [ 0.60666667  0.59777778]]

========特征值、特征向量========
[ 1.25057433  0.03398123]
特征向量
[[ 0.73251454 -0.68075138]
 [ 0.68075138  0.73251454]]
[[ 0.73251454  0.68075138]]
00000000000000==========
[[-0.27 -0.3 ]
 [ 1.23  1.3 ]
 [ 0.03  0.4 ]
 [-0.67 -0.6 ]
 [-0.87 -0.6 ]
 [ 0.63  0.1 ]
 [-0.67 -0.7 ]
 [-0.87 -0.7 ]
 [ 1.33  1.3 ]
 [ 0.13 -0.2 ]]
[[-0.40200434]
 [ 1.78596968]
 [ 0.29427599]
 [-0.89923557]
 [-1.04573848]
 [ 0.5295593 ]
 [-0.96731071]
 [-1.11381362]
 [ 1.85922114]
 [-0.04092339]]

Process finished with exit code 0

2.scipy.linalg.svd参数信息

scipy.linalg.svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True)[source]  
# 奇异值分解  
# 将矩阵分解为两个酉矩阵和一个1维奇异值向量  
# E.g. a == U*S*Vh  
# 参数选择:   
# a : (M, N) 待分解矩阵  
# full_matrices : bool型变量, 为可选参数 if true 分解出的U Vh矩阵为方阵 if false 矩阵维度为 (M,K) 与 (K,N), K = min(M,N).  
# compute_uv : bool型变量, 为可选参数 在计算出s 同时是否也计算出U 和 Vh if false 只返回s  
# overwrite_a: bool型变量, 为可选参数 是否覆写矩阵a来提升性能  
# check_finite: bool型变量, 为可选参数 是否检查输入矩阵只包含数值有限的数据 禁用会有性能提升 但是可能导致未知的错误  
# 返回值：  
# U: 列为左奇异向量的矩阵 维度取决于full_matrices参数 (M,M) or (M,K)  
# Vh: 同理 (N,N) or (K,N)  
# S: 非升序 奇异值向量 K个元素 K = min(M, N).  
# ERROR:  
# SVD计算未收敛  

3.numpy linalg模块及SVD

# 线性代数
# numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等。

import numpy as np

# 1. 计算逆矩阵
# 创建矩阵
A = np.mat("0 1 2;1 0 3;4 -3 8")
print (A)
#[[ 0 1 2]
# [ 1 0 3]
# [ 4 -3 8]]

# 使用inv函数计算逆矩阵
inv = np.linalg.inv(A)
print (inv)
#[[-4.5 7. -1.5]
# [-2. 4. -1. ]
# [ 1.5 -2. 0.5]]

# 检查原矩阵和求得的逆矩阵相乘的结果为单位矩阵
print (A * inv)
#[[ 1. 0. 0.]
# [ 0. 1. 0.]
# [ 0. 0. 1.]]

# 注：矩阵必须是方阵且可逆，否则会抛出LinAlgError异常。


# 2. 求解线性方程组
# numpy.linalg中的函数solve可以求解形如 Ax = b 的线性方程组，其中 A 为矩阵，b 为一维或二维的数组，x 是未知变量

import numpy as np

#创建矩阵和数组
B = np.mat("1 -2 1;0 2 -8;-4 5 9")
b = np.array([0,8,-9])

# 调用solve函数求解线性方程
x = np.linalg.solve(B,b)
print (x)
#[ 29. 16. 3.]

# 使用dot函数检查求得的解是否正确
print (np.dot(B , x))
# [[ 0. 8. -9.]]


# 3. 特征值和特征向量
# 特征值（eigenvalue）即方程 Ax = ax 的根，是一个标量。其中，A 是一个二维矩阵，x 是一个一维向量。特征向量（eigenvector）是关于特征值的向量
# numpy.linalg模块中，eigvals函数可以计算矩阵的特征值，而eig函数可以返回一个包含特征值和对应的特征向量的元组

import numpy as np

# 创建一个矩阵
C = np.mat("3 -2;1 0")

# 调用eigvals函数求解特征值
c0 = np.linalg.eigvals(C)
print (c0)
# [ 2. 1.]

# 使用eig函数求解特征值和特征向量 (该函数将返回一个元组，按列排放着特征值和对应的特征向量，其中第一列为特征值，第二列为特征向量)
c1,c2 = np.linalg.eig(C)
print (c1)
# [ 2. 1.] 
print (c2)
#[[ 0.89442719 0.70710678]
# [ 0.4472136 0.70710678]]

# 使用dot函数验证求得的解是否正确
for i in range(len(c1)):
print ("left:",np.dot(C,c2[:,i]))
print ("right:",c1[i] * c2[:,i])
#left: [[ 1.78885438]
# [ 0.89442719]]
#right: [[ 1.78885438]
# [ 0.89442719]]
#left: [[ 0.70710678]
# [ 0.70710678]]
#right: [[ 0.70710678]
# [ 0.70710678]]

 

# 4.奇异值分解
# SVD（Singular Value Decomposition，奇异值分解）是一种因子分解运算，将一个矩阵分解为3个矩阵的乘积
# numpy.linalg模块中的svd函数可以对矩阵进行奇异值分解。该函数返回3个矩阵——U、Sigma和V，其中U和V是正交矩阵，Sigma包含输入矩阵的奇异值。

import numpy as np

# 分解矩阵
D = np.mat("4 11 14;8 7 -2")
# 使用svd函数分解矩阵
U,Sigma,V = np.linalg.svd(D,full_matrices=False)
print ("U:",U)
#U: [[-0.9486833 -0.31622777]
# [-0.31622777 0.9486833 ]]
print ("Sigma:",Sigma)
#Sigma: [ 18.97366596 9.48683298]
print ("V",V)
#V [[-0.33333333 -0.66666667 -0.66666667]
# [ 0.66666667 0.33333333 -0.66666667]]
# 结果包含等式中左右两端的两个正交矩阵U和V，以及中间的奇异值矩阵Sigma

# 使用diag函数生成完整的奇异值矩阵。将分解出的3个矩阵相乘
print (U * np.diag(Sigma) * V)
#[[ 4. 11. 14.]
# [ 8. 7. -2.]]

# 5. 广义逆矩阵
# 使用numpy.linalg模块中的pinv函数进行求解,
# 注：inv函数只接受方阵作为输入矩阵，而pinv函数则没有这个限制

import numpy as np

# 创建一个矩阵
E = np.mat("4 11 14;8 7 -2")
# 使用pinv函数计算广义逆矩阵
pseudoinv = np.linalg.pinv(E)
print (pseudoinv)
#[[-0.00555556 0.07222222]
# [ 0.02222222 0.04444444]
# [ 0.05555556 -0.05555556]]

# 将原矩阵和得到的广义逆矩阵相乘
print (E * pseudoinv)
#[[ 1.00000000e+00 -5.55111512e-16]
# [ 0.00000000e+00 1.00000000e+00]]

# 6. 行列式
# numpy.linalg模块中的det函数可以计算矩阵的行列式

import numpy as np

# 计算矩阵的行列式
F = np.mat("3 4;5 6")
# 使用det函数计算行列式
print (np.linalg.det(F))
# -2.0

参考资料：
参考链接
参考链接