Python矩阵基本运算之Jupyter记录

一、矩阵

• 定义
  由 m × n 个数aij排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵。记作：

A = [ a ₁ ₁ a ₁ ₂ ⋯ a 1 n a ₂ ₁ a ₂ ₂ ⋯ a 2 n ⋮ ⋮ ⋱ ⋮ a m 1 a m 2 ⋯ a m n ] A= \left[ \begin{matrix}a₁₁ & a₁₂ & \cdots & a_{1n} \\ a₂₁ & a₂₂ & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn}\end{matrix} \right] A=⎣⎢⎢⎢⎡​a₁₁a₂₁⋮am1​​a₁₂a₂₂⋮am2​​⋯⋯⋱⋯​a1n​a2n​⋮amn​​⎦⎥⎥⎥⎤​

这m×n 个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数 aij为(i,j)元的矩阵可记为(aij)或(aij)m × n，m×n矩阵A也记作Amn。它的基本运算包括矩阵的加法，减法，数乘，转置，共轭和共轭转置。

二、在jupyter notebook中进行矩阵的运算

1、Python矩阵操作

1.首先引入numpy

>import numpy as np

2.使用mat函数创建一个2x3的矩阵

>a=np.mat([[1,2,3],[4,5,6]])

>a

3.使用shape获取矩阵大小

>a.shape

4.使用下标读取矩阵中的元素

>a.T

matrix([[1, 4],
        [2, 5],
        [3, 6]])

5.进行行列转换

>a.transpose()

matrix([[1, 4],
        [2, 5],
        [3, 6]])

>a.T

matrix([[1, 4],
        [2, 5],
        [3, 6]])

2、python矩阵乘法

1.引入numpy包

>import numpy as np

2.使用二维数组创建两个矩阵A B

>A=np.array([[1,2,3],[4,5,6]])

>A

array([[1, 2, 3],
       [4, 5, 6]])

>B=A.T

>B

array([[1, 4],
       [2, 5],
       [3, 6]])

3.矩阵的数乘

>2*A

array([[ 2,  4,  6],
       [ 8, 10, 12]])

>2*B

array([[ 2,  8],
       [ 4, 10],
       [ 6, 12]])

4.使用dot函数进行矩阵之间的乘法运算

>np.dot(A,B)

array([[14, 32],
       [32, 77]])

>np.dot(B,A)

array([[17, 22, 27],
       [22, 29, 36],
       [27, 36, 45]])

可以看到交换矩阵的前后位置会导致不同的结果

5.再创建一个二维数组

>C=np.array([[1,2],[1,3]])

>C

array([[1, 2],
       [1, 3]])

6.验证矩阵乘法的结合性 （AB)C=A(BC)

>np.dot(np.dot(A,B),C)

array([[ 46, 124],
       [109, 295]])

>np.dot(A,np.dot(B,C))

array([[ 46, 124],
       [109, 295]])

7.接着验证矩阵加法的分配性 (A+B)C=AC+BC,C(A+B)=CA+CB

>D=B-1

>D

array([[0, 3],
       [1, 4],
       [2, 5]])

>np.dot(A,B+D)

array([[ 22,  58],
       [ 49, 139]])

>np.dot(A,B)+np.dot(A,D)

array([[ 22,  58],
       [ 49, 139]])

8.矩阵数乘的结合性也是一样的

>2*(np.dot(A,B))

array([[ 28,  ],
       [ , 154]])

>np.dot(A,2*B)

array([[ 28,  ],
       [ , 154]])

>np.dot(2*A,B)

array([[ 28,  ],
       [ , 154]])

9.使用EYE创建一个3x3的单位矩阵

>I=np.eye(3)

>I

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

10.现在我们来看一下一个矩阵A乘以一个单位矩阵，还是他本身吗

>np.dot(A,I)

array([[1., 2., 3.],
       [4., 5., 6.]])

结果显然易见

3、Python矩阵转置

1.求到A的转置矩阵

>A.T

array([[1, 4],
       [2, 5],
       [3, 6]])

2.验证矩阵转置的第一个性质 (A’)’=A

>A.T.T

array([[1, 2, 3],
       [4, 5, 6]])

可以看到A的转置矩阵的转置还是A本身

3.创建一个和B尺寸相同的矩阵D

>D

array([[0, 3],
       [1, 4],
       [2, 5]])

4.验证第二个性质 (A±B)’=A’±B’

>(B+D).T

array([[ 1,  3,  5],
       [ 7,  9, 11]])

>B.T+D.T

array([[ 1,  3,  5],
       [ 7,  9, 11]])

5.验证第三个性质 (KA)’=KA’

>10*A.T

array([[10, 40],
       [20, 50],
       [30, 60]])

>(10*A).T

array([[10, 40],
       [20, 50],
       [30, 60]])

6.验证第四个性质 (AxB)’=B’x A’

>np.dot(A,B).T

array([[14, 32],
       [32, 77]])

>np.dot(A.T,B.T)

array([[17, 22, 27],
       [22, 29, 36],
       [27, 36, 45]])

>np.dot(B.T,A.T)

array([[14, 32],
       [32, 77]])

4、方程的迹

方程的迹是主对角元素之和

1.创建一个方阵（即行数等于列数的矩阵）

>E=np.array([[1,2,3],[4,5,6],[7,8,9]])

2.用trace函数计算方阵的迹

>np.trace(E)

15

3.再创建一个方阵F

>F=E-2

>F

array([[-1,  0,  1],
       [ 2,  3,  4],
       [ 5,  6,  7]])

4.下面来验算以下方阵的迹等于方阵转置的迹

>np.trace(E)

15

>np.trace(E.T)

15

5.再来验算两个交换了位置方阵的乘积的迹相等

>np.trace(np.dot(E,F))

171

>np.trace(np.dot(F,E))

171

6.最后来验算以下方阵的和的迹等于方阵迹的和

>np.trace(E+F)

24

>np.trace(E)+np.trace(F)

24

5、方阵的行列式计算

1.行列式的算法

①二阶方阵行列示

②三阶方阵行列式

2.引用上述方正E,F,使用det方法求得两方阵的行列式

>E,F

(array([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]]),
 array([[-1,  0,  1],
        [ 2,  3,  4],
        [ 5,  6,  7]]))

>np.linalg.det(E)

-9.51619735392994e-16

>np.linalg.det(F)

1.06581410301459e-15

6、求逆矩阵和伴随矩阵

逆矩阵：
设A是数域上的一个N阶方阵，若在相同数域上存在；另一个n阶矩阵B，使得AB=BA=E。则我们称B是A的逆矩阵，而A则被称为可逆矩阵。当矩阵A的行列式|A|不等于0时才存在可逆矩阵。

伴随矩阵：

1.新创建一个方阵A

>A=np.array([[1,-2,1],[0,2,-1],[1,1,-2]])

>A

array([[ 1, -2,  1],
       [ 0,  2, -1],
       [ 1,  1, -2]])

2.使用linalg求得方阵的行列式

>A_abs=np.linalg.det(A)

>A_abs

-2.9999999999999996

3.使用linalg.inv求得方阵A的逆矩阵

>B=np.linalg.inv(A)

>B

array([[ 1.00000000e+00,  1.00000000e+00, -1.11022302e-16],
       [ 3.33333333e-01,  1.00000000e+00, -3.33333333e-01],
       [ 6.66666667e-01,  1.00000000e+00, -6.66666667e-01]])

4.利用公式 A*=|A|A^-1求得方阵A的伴随矩阵

>A_bs=B*A_abs

>A_bs

array([[-3.00000000e+00, -3.00000000e+00,  3.33066907e-16],
       [-1.00000000e+00, -3.00000000e+00,  1.00000000e+00],
       [-2.00000000e+00, -3.00000000e+00,  2.00000000e+00]])

7、解多元一次方程

1.方程如下:
$$\{\begin{array}{rlr}x+2y+z& =& 7\\ 2x-y+3z& =& 7\\ 3x+y+2z& =& 18\end{array}$$

2.把未知数的系数写下来，排列成矩阵a

>a=np.array([[1,2,1],[2,-1,3],[3,1,2]])

>a

array([[ 1,  2,  1],
       [ 2, -1,  3],
       [ 3,  1,  2]])

3.常数项构成一个一维数组（向量）

>b=np.array([7,7,18])

>b

array([ 7,  7, 18])

4.使用linalg.solve方法解方程

>x=np.linalg.solve(a,b)

>x

array([ 7.,  1., -2.])

5.使用点乘的方法验证以下结果是否正确。系数乘以未知数可以得到常数项

>np.dot(a,x)

array([ 7.,  7., 18.])

可以看到这个常数项数组与前面的常数项数组相同，即结果正确。

三、总结

复习了以前学习的线性代数。没想到代数是机器学习的基础…
还有就是第二部分是从jupyter notebook导入的，所以代码和结果不太好分辨。