numpy.linalg–线性代数基础
NumPy提供了线性代数函数库linalg,该库包含了线性代数所需的所有功能,可以看看下面的说明。
方法 | 注释 |
---|---|
dot | 两数组的点积 |
vdot | 两向量的点积 |
inner | 两数组的内积 |
determinant | 数组的行列式 |
matmul | 两数组的矩阵积 |
inv | 求矩阵的逆 |
solve | 求解线性矩阵方程 |
numpy.dot()
对于两个数组(一维),计算的是这两个数组对应下标元素的乘积和(内积)
对于二维数组,计算的是两个数组的矩阵乘积
对于多维数组,结果数组中的每个元素都是:数组a的最后一维上的所有元素与数组b的倒数第二维上的所有元素的乘积和:
dot
(
a
,
b
)
[
i
,
j
,
k
,
m
]
=
sum
(
a
[
i
,
j
,
:
]
∗
b
[
k
,
:
,
m
]
)
\operatorname{dot}(\mathrm{a}, \mathrm{b})[\mathrm{i}, \mathrm{j}, \mathrm{k}, \mathrm{m}]=\operatorname{sum}(\mathrm{a}[\mathrm{i}, \mathrm{j},:] * \mathrm{~b}[\mathrm{k},:, \mathrm{m}])
dot(a,b)[i,j,k,m]=sum(a[i,j,:]∗ b[k,:,m])
参数:np.dot(a,b,out=None)
- a,b:数组
- out:可选,用于存储计算结果
A = [ a 11 a 12 a 21 a 22 ] , B = [ b 11 b 12 b 21 b 22 ] \mathrm{A}=\left[\begin{array}{ll} a 11 & a 12 \\ a 21 & a 22 \end{array}\right], \mathrm{B}=\left[\begin{array}{ll} b 11 & b 12 \\ b 21 & b 22 \end{array}\right] A=[a11a21a12a22],B=[b11b21b12b22]
import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[1, 3], [2, 3]])
print(np.dot(A, B))
c
11
=
a
11
∗
b
11
+
a
12
∗
b
21
c11 = a11 * b11 + a12 * b21
c11=a11∗b11+a12∗b21
c
12
=
a
11
∗
b
12
+
a
12
∗
b
22
c12 = a11 * b12 + a12 * b22
c12=a11∗b12+a12∗b22
c
21
=
a
21
∗
b
11
+
a
21
∗
b
21
c21 = a21 * b11 + a21 * b21
c21=a21∗b11+a21∗b21
c
22
=
a
21
∗
b
12
+
a
21
∗
b
22
c22 = a21 * b12 + a21 * b22
c22=a21∗b12+a21∗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))
c
11
=
a
11
∗
b
11
+
a
12
∗
b
12
c11 = a11 * b11 + a12 * b12
c11=a11∗b11+a12∗b12
c
12
=
a
11
∗
b
21
+
a
12
∗
b
22
c12 = a11 * b21 + a12 * b22
c12=a11∗b21+a12∗b22
c
21
=
a
21
∗
b
11
+
a
22
∗
b
12
c21 = a21 * b11 + a22 * b12
c21=a21∗b11+a22∗b12
c
22
=
a
21
∗
b
21
+
a
22
∗
b
22
c22 = a21 * b21 + a22 * b22
c22=a21∗b21+a22∗b22
numpy.linalg.det()
对于 2 × 2 2\times 2 2×2矩阵,它是左上和右下元素的乘积与其他两个的乘积的差.对于矩阵 [ [ a , b ] , [ c , d ] ] [[a,b],[c,d]] [[a,b],[c,d]],行列式计算为 a d − b c ad-bc ad−bc.较大的方阵被认为是 2 × 2 2\times 2 2×2矩阵的组合。
计算 2 × 2 2 \times 2 2×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 × 3 3\times 3 3×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
A
A是数域上的一个
n
n
n阶矩阵,若在相同数域上存在另一个
n
n
n阶矩阵B,使得:
A
B
=
B
A
=
E
AB=BA=E
AB=BA=E,则我们称
B
B
B是
A
A
A的逆矩阵,而
A
A
A则被称为可逆矩阵。注:
E
E
E为单位矩阵。文章来源:https://www.toymoban.com/news/detail-433139.html
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()
函数用于求解矩阵形式的线性方程的解。
比如线性方程:
2
x
+
2
y
+
2
z
=
5
2
y
+
4
z
=
−
3
2
x
+
5
y
−
2
z
=
26
\begin{aligned} & 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{aligned}
2x+2y+2z=52y+4z=−32x+5y−2z=26
可以使用矩阵进行表示:
[
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]
20222524−2
xyz
=
5−326
即
A
X
=
B
→
X
=
A
−
1
B
A X=B \rightarrow X=\mathrm{A}^{-1} \mathrm{~B}
AX=B→X=A−1 B文章来源地址https://www.toymoban.com/news/detail-433139.html
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]]
到了这里,关于numpy.linalg--线性代数基础的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!