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])。
1 numpy.dot(a, b, out=None)
参数说明：
- a : ndarray 数组
- b : ndarray 数组
- out : ndarray, 可选，用来保存dot()的计算结果
实例：
1 import numpy as np 2 # 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积) 3 x = np.arange(1, 5) 4 y = np.arange(2, 6) 5 print('x:\n', x) 6 print('y:\n', y) 7 print('a·b=', np.dot(x, y)) 8 #对于二维数组，计算的是两个数组的矩阵乘积 9 a = np.matrix([[1, 2]]) 10 b = np.matrix('2, 3;4, 5') 11 print('a:\n', a) 12 print('b:\n', b) 13 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() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开
1 import numpy as np 2 a = np.array([[1, 2], [3, 4]]) 3 b = np.array([[11, 12], [13, 14]]) 4 print('a:{}\nb:{}'.format(a, b)) 5 # vdot 将数组展开计算内积 6 print(np.vdot(a, b))
执行结果：130
计算式：
1*11 + 2*12 + 3*13 + 4*14 = 130
3、numpy.inner()
numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积
1 import numpy as np 2 a = np.array([[1, 2], [3, 4]]) 3 print('数组 a：') 4 print(a) 5 b = np.array([[11, 12], [13, 14]]) 6 print('数组 b：') 7 print(b) 8 print('内积：') 9 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 来将其提升为矩阵，并在乘法之后被去除。
对于二维数组，它就是矩阵乘法：
1 import numpy as np 2 # 对于二维数组，它就是矩阵乘法 3 a = np.matrix([[1, 0], [0, 1]]) 4 b = np.matrix([[4, 1], [2, 2]]) 5 print('a:\n{}\nb:\n{}'.format(a, b)) 6 print('a·b=', np.matmul(a, b))
执行结果：
a: [[1 0] [0 1]] b: [[4 1] [2 2]] a·b= [[4 1] [2 2]]
二维和一维运算：
1 import numpy.matlib 2 import numpy as np 3 4 a = [[1,0],[0,1]] 5 b = [1,2] 6 print (np.matmul(a,b)) 7 print (np.matmul(b,a))
执行结果：
[1 2]
[1 2]
维度大于二的数组 ：
1 import numpy as np 2 3 a = np.arange(8).reshape(2,2,2) 4 b = np.arange(4).reshape(2,2) 5 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为单位矩阵。
1 import numpy as np 2 A = np.matrix('0, 1, 2;1, 0, 3;4, -3, 8') 3 print('A=', A) 4 # 使用inv函数计算逆矩阵 5 A_inv = np.linalg.inv(A) 6 print('矩阵A的逆矩阵：\n', A_inv) 7 # 检查原矩阵和求得的逆矩阵相乘的结果为单位矩阵 8 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 是未知变量
1 import numpy as np 2 #创建矩阵和数组 3 A = np.matrix([[1, 1, 1], 4 [4, 2, -5], 5 [2, 8, 7]]) 6 b = np.array([6, -4, 27]) 7 # 求解Ax=b的解 8 x = np.linalg.solve(A, b) 9 print('方程组解为：\n', x) 10 # 验证 11 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函数可以返回一个包含特征值和对应的特征向量的元组
1 import numpy as np 2 # 创建一个矩阵 3 A = np.mat("3 -2;1 0") 4 5 print('调用eigvals函数求解特征值:') 6 a = np.linalg.eigvals(A) 7 print(a) 8 print('使用eig函数求解特征值和特征向量 (该函数将返回一个元组，按列排放着特征值和对应的特征向量，\ 9 其中第一列为特征值，第二列为特征向量)') 10 a1, a2 = np.linalg.eig(A) 11 print(a1) 12 print(a2) 13 print('使用dot函数验证求得的解是否正确:') 14 15 for i in range(len(a1)): 16 print("left:", np.dot(A, a2[:, i])) 17 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包含输入矩阵的奇异值。
1 import numpy as np 2 # 创建矩阵 3 D = np.mat("4 11 14;8 7 -2") 4 # 使用svd函数分解矩阵 5 U, Sigma, V = np.linalg.svd(D, full_matrices=False) 6 print('U:\n', U) 7 print('Sigma\n', Sigma) 8 print('V:\n', V) 9 # 使用diag函数生成完整的奇异值矩阵。将分解出的3个矩阵相乘 10 print('diag(Sigma):\n', np.diag(Sigma)) 11 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 广义逆矩阵
1 import numpy as np 2 # 创建一个矩阵 3 E = np.mat("4 11 14;8 7 -2") 4 print('使用pinv函数计算广义逆矩阵:') 5 pseudoinv = np.linalg.pinv(E) 6 print(pseudoinv) 7 print('将原矩阵和得到的广义逆矩阵相乘:') 8 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]]
numpy.linalg模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等