19、NumPy——线性代数

NumPy 线性代数

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明：

函数	描述
dot	两个数组的点积，即元素对应相乘。
vdot	两个向量的点积
inner	两个数组的内积
matmul	两个数组的矩阵积
determinant	数组的行列式
solve	求解线性矩阵方程
inv	计算矩阵的乘法逆矩阵

1、numpy.dot()

numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

 numpy.dot(a, b, out=None)

参数说明：

• a : ndarray 数组
• b : ndarray 数组
• out : ndarray, 可选，用来保存dot()的计算结果

实例：

 import numpy as np
 # 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)
 x = np.arange(1, 5)
 y = np.arange(2, 6)
 print('x:\n', x)
 print('y:\n', y)
 print('a·b=', np.dot(x, y))
 #对于二维数组，计算的是两个数组的矩阵乘积
 a = np.matrix([[1, 2]])
 b = np.matrix('2, 3;4, 5')
 print('a:\n', a)
 print('b:\n', b)
 print(np.dot(a, b))

执行结果：

x:
 [1 2 3 4]
y:
 [2 3 4 5]
a·b= 40
a:
 [[1 2]]
b:
 [[2 3]
 [4 5]]
[[10 13]]

2、numpy.vdot()

numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开

 import numpy as np
 a = np.array([[1, 2], [3, 4]])
 b = np.array([[11, 12], [13, 14]])
 print('a:{}\nb:{}'.format(a, b))
 # vdot 将数组展开计算内积
 print(np.vdot(a, b))

执行结果：130

计算式：

1*11 + 2*12 + 3*13 + 4*14 = 130

3、numpy.inner()

numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积

 import numpy as np
 a = np.array([[1, 2], [3, 4]])
 print('数组 a：')
 print(a)
 b = np.array([[11, 12], [13, 14]])
 print('数组 b：')
 print(b)
 print('内积：')
 print(np.inner(a, b))

执行结果：

数组 a：
[[1 2]
 [3 4]]
数组 b：
[[11 12]
 [13 14]]
内积：
[[35 41]
 [81 95]]

内积计算式为：

1*11+2*12, 1*13+2*14

3*11+4*12, 3*13+4*14

4、numpy.matmul

numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

对于二维数组，它就是矩阵乘法：

 import numpy as np
 # 对于二维数组，它就是矩阵乘法
 a = np.matrix([[1, 0], [0, 1]])
 b = np.matrix([[4, 1], [2, 2]])
 print('a:\n{}\nb:\n{}'.format(a, b))
 print('a·b=', np.matmul(a, b))

执行结果：

a:
[[1 0]
 [0 1]]
b:
[[4 1]
 [2 2]]
a·b= [[4 1]
 [2 2]]

二维和一维运算：

 import numpy.matlib
 import numpy as np 

 a = [[1,0],[0,1]]
 b = [1,2]
 print (np.matmul(a,b))
 print (np.matmul(b,a))

执行结果：

[1  2]
[1  2]

维度大于二的数组 ：

 import numpy as np 

 a = np.arange(8).reshape(2,2,2)
 b = np.arange(4).reshape(2,2)
 print (np.matmul(a,b))

执行结果：

[[[ 2  3]
  [ 6 11]]

 [[10 19]
  [14 27]]]、

6、numpy linalg模块

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

6.1 numpy.linalg.inv()

numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。

逆矩阵（inverse matrix）：设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。

 import numpy as np
 A = np.matrix('0, 1, 2;1, 0, 3;4, -3, 8')
 print('A=', A)
 # 使用inv函数计算逆矩阵
 A_inv = np.linalg.inv(A)
 print('矩阵A的逆矩阵：\n', A_inv)
 # 检查原矩阵和求得的逆矩阵相乘的结果为单位矩阵
 print('A·A_inv=\n', A*A_inv)

执行结果：

A= [[ 0  1  2]
 [ 1  0  3]
 [ 4 -3  8]]
矩阵A的逆矩阵：
 [[-4.5  7.  -1.5]
 [-2.   4.  -1. ]
 [ 1.5 -2.   0.5]]
A·A_inv=
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

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

6.2 numpy.linalg.solve()

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

 import numpy as np
 #创建矩阵和数组
 A = np.matrix([[1, 1, 1],
                 [4, 2, -5],
                 [2, 8, 7]])
 b = np.array([6, -4, 27])
 # 求解Ax=b的解
 x = np.linalg.solve(A, b)
 print('方程组解为：\n', x)
 # 验证
 print(np.dot(A, x))

执行结果：

方程组解为：
 [ 2.97727273 -0.11363636  3.13636364]
[[ 6. -4. 27.]]

6.3   特征值和特征向量

# 特征值（eigenvalue）即方程 Ax = ax 的根，是一个标量。其中，A 是一个二维矩阵，x 是一个一维向量。特征向量（eigenvector）是关于特征值的向量

numpy.linalg模块中，eigvals函数可以计算矩阵的特征值，而eig函数可以返回一个包含特征值和对应的特征向量的元组

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

 print('调用eigvals函数求解特征值:')
 a = np.linalg.eigvals(A)
 print(a)
 print('使用eig函数求解特征值和特征向量 (该函数将返回一个元组，按列排放着特征值和对应的特征向量，\
 其中第一列为特征值，第二列为特征向量)')
 a1, a2 = np.linalg.eig(A)
 print(a1)
 print(a2)
 print('使用dot函数验证求得的解是否正确:')

 for i in range(len(a1)):
     print("left:", np.dot(A, a2[:, i]))
     print("right:", a1[i] * a2[:, i])

执行结果：

调用eigvals函数求解特征值:
[2. 1.]
使用eig函数求解特征值和特征向量 (该函数将返回一个元组，按列排放着特征值和对应的特征向量，其中第一列为特征值，第二列为特征向量)
[2. 1.]
[[0.89442719 0.70710678]
 [0.4472136  0.70710678]]
使用dot函数验证求得的解是否正确:
left: [[1.78885438]
 [0.89442719]]
right: [[1.78885438]
 [0.89442719]]
left: [[0.70710678]
 [0.70710678]]
right: [[0.70710678]
 [0.70710678]]

6.4、numpy.linalg.det()

numpy.linalg.det() 函数计算输入矩阵的行列式。

行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。

换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为 ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。

1 import numpy as np
2 a = np.array([[1,2], [3,4]])
3
4 print (np.linalg.det(a))

输出结果为：-2.0000000000000004

6.5.奇异值分解

# 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:\n', U)
 print('Sigma\n', Sigma)
 print('V:\n', V)
 # 使用diag函数生成完整的奇异值矩阵。将分解出的3个矩阵相乘
 print('diag(Sigma):\n', np.diag(Sigma))
 print(U * np.diag(Sigma) * V)

执行结果：

U:
 [[-0.9486833  -0.31622777]
 [-0.31622777  0.9486833 ]]
Sigma
 [18.97366596  9.48683298]
V:
 [[-0.33333333 -0.66666667 -0.66666667]
 [ 0.66666667  0.33333333 -0.66666667]]
diag(Sigma):
 [[18.97366596  0.        ]
 [ 0.          9.48683298]]
[[ 4. 11. 14.]
 [ 8.  7. -2.]]

6.6 广义逆矩阵

 import numpy as np
 # 创建一个矩阵
 E = np.mat("4 11 14;8 7 -2")
 print('使用pinv函数计算广义逆矩阵:')
 pseudoinv = np.linalg.pinv(E)
 print(pseudoinv)
 print('将原矩阵和得到的广义逆矩阵相乘:')
 print(E * pseudoinv)

执行结果：

使用pinv函数计算广义逆矩阵:
[[-0.00555556  0.07222222]
 [ 0.02222222  0.04444444]
 [ 0.05555556 -0.05555556]]
将原矩阵和得到的广义逆矩阵相乘:
[[ 1.00000000e+00 -9.29811783e-16]
 [-1.66533454e-16  1.00000000e+00]]