numpy.linalg–线性代数基础

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

numpy.dot()

对于两个数组(一维)，计算的是这两个数组对应下标元素的乘积和(内积)
对于二维数组，计算的是两个数组的矩阵乘积
对于多维数组，结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二维上的所有元素的乘积和： $\mathrm{dot}(\mathrm{a},\mathrm{b})[\mathrm{i},\mathrm{j},\mathrm{k},\mathrm{m}]=\mathrm{sum}(\mathrm{a}[\mathrm{i},\mathrm{j},:]\ast \mathrm{b}[\mathrm{k},:,\mathrm{m}])$

参数：np.dot(a,b,out=None)

• a,b：数组
• out：可选，用于存储计算结果

$$\mathrm{A}=\left[\begin{array}{ll}a11& a12\\ a21& a22\end{array}\right],\mathrm{B}=\left[\begin{array}{ll}b11& b12\\ b21& b22\end{array}\right]$$

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[1, 3], [2, 3]])
print(np.dot(A, B))

$c11=a11\ast b11+a12\ast b21$
$c12=a11\ast b12+a12\ast b22$
$c21=a21\ast b11+a21\ast b21$
$c22=a21\ast b12+a21\ast b22$

numpy.vdot()

vdot(a, b) 函数处理复数的方式与 dot(a, b) 不同。如果第一个参数是复数，则第一个参数的复共轭用于计算点积。
注意numpy.vdot处理多维数组的方式不同于numpy.dot: 确实不是执行矩阵乘积，但首先将输入参数展平为一维向量。因此，它应该只用于向量。
参数：

• a： array_like
  如果 a 是复数，则在计算点积之前取复共轭。

• b： array_like
  点积的第二个参数。

返回：

• output： ndarray
  a 和 b 的点积。可以是 int 浮点数，也可以是复数，具体取决于 a 和 b 的类型。

a = np.array([1+2j,3+4j])
b = np.array([5+6j,7+8j])
np.vdot(a, b)
(70-8j)
np.vdot(b, a)
(70+8j)

numpy.inner()

从字面上来看是矩阵的内积，但是在运算方法上来看却不是，我们先来代码实践一下：

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[1, 3], [2, 3]])
print(np.inner(A, B))

$c11=a11\ast b11+a12\ast b12$
$c12=a11\ast b21+a12\ast b22$
$c21=a21\ast b11+a22\ast b12$
$c22=a21\ast b21+a22\ast b22$

numpy.linalg.det()

对于$2\times 2$矩阵，它是左上和右下元素的乘积与其他两个的乘积的差.对于矩阵$[[a，b]，[c，d]]$，行列式计算为$ad-bc$.较大的方阵被认为是$2\times 2$矩阵的组合。

计算$2\times 2$矩阵的行列式

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

计算$3\times 3$矩阵的行列

b = np.array([[6, 1, 1], [4, -2, 5], [2, 8, 7]])
ans = np.linalg.det(b)
print(ans)
print(6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))
----------------
-306.0
-306

numpy.matmul()

numpy.matmul()函数返回两个数组的矩阵乘积：

• 如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
• 如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，矩阵相乘之后会将为1的维数去掉。

matmul与dot的差异主要在两个方面：

• 不允许乘标量,只能用*代替
• matmul操作的矩阵允许将最后两个索引的矩阵的栈广播

import numpy as np
a=np.array([[1,2],[3,4]])
b=np.array([[1,2],[3,4]])
ans=np.matmul(a,b)
print(ans)

numpy.inv()

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

import numpy as np 
a=np.array([[1,2],[3,4]])
b=np.linalg.inv(a)
print("矩阵a:",'\n',a)
print("矩阵b:",'\n',b)
print(np.dot(a,b))
-----------------------
矩阵a: 
 [[1 2]
 [3 4]]
矩阵b: 
 [[-2.   1. ]
 [ 1.5 -0.5]]
[[1.0000000e+00 0.0000000e+00]
 [8.8817842e-16 1.0000000e+00]]

numpy.solve()

函数用于求解矩阵形式的线性方程的解。
比如线性方程：
$\begin{array}{rl}& 2\mathrm{x}+2\mathrm{y}+2\mathrm{z}=5\\ & 2\mathrm{y}+4\mathrm{z}=-3\\ & 2\mathrm{x}+5\mathrm{y}-2\mathrm{z}=26\end{array}$
可以使用矩阵进行表示：
[ 2 2 2 0 2 4 2 5 − 2 ] [ x y z ] = [ 5 − 3 26 ] \left[\begin{array}{ccc} 2 & 2 & 2 \\ 0 & 2 & 4 \\ 2 & 5 & -2 \end{array}\right]\left[\begin{array}{l} \mathrm{x} \\ \mathrm{y} \\ \mathrm{z} \end{array}\right]=\left[\begin{array}{c} 5 \\ -3 \\ 26 \end{array}\right] ​202​225​24−2​ ​ ​xyz​ ​= ​5−326​ ​
即 $AX=B\to X={\mathrm{A}}^{-1}\mathrm{B}$

a = np.array([[2,2,2],[0,2,4],[2,5,-2]])
b = np.array([[5], [-3], [26]])
print("A^-1B", np.linalg.solve(a,b))
-------------------
A^-1B:
 [[ 1.45]
 [ 3.6 ]
 [-2.55]]