人工智能-线性代数之矩阵篇_几何矩阵算法在人工智能中的应用 文献研究

线性代数之矩阵篇

继续接着上一篇《人工智能-线性代数之向量篇》的内容来学习汇总下一篇，在这一篇中，我们开始汇总学习人工智能中线性代数最最最重要的一部分，那就是矩阵的运算，几乎所有人工智能机器学习的算法都离不开矩阵的运算，换句话说，就是所有的人工智能都是基于大量的数据在矩阵中进行各种庞杂而基础的运算和变换，从而找出其中的规律，最后训练出数学模型的。

1. 矩阵的定义

在数学中，矩阵是一个按照长方阵列排列的复数或实数集合，最早来自于方程组的系数及常数所构成的方阵。例如： A = [ − 1 3 2 4 ] A=

$$\begin{bmatrix} -1 &3\\ 2 &4\\ \end{bmatrix}$$ A=[−12​34​] ，这是一个两行两列矩阵，其中的元素可以用小写字母加下标来表示，如$a_{11}=-1,a_{12}=3$

2. 矩阵的计算

2.1 加法

A = [ 2 − 1 2 0 ] , B = [ 2 2 3 5 ] A=

$$\begin{bmatrix} 2 &-1\\ 2 &0\\ \end{bmatrix}$$ , B= $$\begin{bmatrix} 2 &2\\ 3 &5\\ \end{bmatrix}$$ A=[22​−10​],B=[23​25​]
$$A+B=\left[\begin{array}{cc}2+2& (-1)+2\\ 2+3& 0+5\end{array}\right]=\left[\begin{array}{cc}4& 1\\ 5& 5\end{array}\right]$$
符合加法交换律：$A+B=B+A$

2.2 与数相乘

A = [ 2 − 1 2 0 ] , λ ∈ R , A λ = [ 2 λ − 1 λ 2 λ 0 λ ] A=

$$\begin{bmatrix} 2 &-1\\ 2 &0\\ \end{bmatrix}$$ ,\lambda \in R, A\lambda = $$\begin{bmatrix} 2\lambda &-1\lambda\\ 2\lambda &0\lambda\\ \end{bmatrix}$$ A=[22​−10​],λ∈R,Aλ=[2λ2λ​−1λ0λ​]

2.3 乘法

矩阵A和矩阵B相乘，必须满足A的列数等于B的行数，否则无法相乘。规律：$A_{m\times n}{B}_{p\times q}=C_{m\times q}$，例如[两行三列] X [三行两列] = [两行两列] 即：$A_{2\times 3}{B}_{3\times 2}=C_{2\times 2}$

A = [ 3 2 2 − 2 0 5 ] , B = [ − 1 3 1 2 2 5 ] A=

$$\begin{bmatrix} 3 &2&2\\ -2 &0&5\\ \end{bmatrix}$$ ,B= $$\begin{bmatrix} -1 &3\\ 1 &2\\ 2 &5\\ \end{bmatrix}$$ A=[3−2​20​25​],B=⎣⎡​−112​325​⎦⎤​
$$A\times B=\left[\begin{array}{cc}3\times (-1)+2\times 1+2\times 2& 3\times 3+2\times 2+2\times 5\\ (-2)\times (-1)+0\times 1+5\times 2& (-2)\times 3+0\times 2+5\times 5\end{array}\right]=\left[\begin{array}{cc}3& 23\\ 12& 19\end{array}\right]$$
满足结合律和分配率。

2.4 转置

矩阵的转置就是行列互换，用$A^T$表示A的转置矩阵。
A = [ 1 2 3 4 5 6 ] , A T = [ 1 4 2 5 3 6 ] A=

$$\begin{bmatrix} 1 &2&3\\ 4 &5&6\\ \end{bmatrix}$$ ,A^T= $$\begin{bmatrix} 1 &4\\ 2 &5\\ 3 &6\\ \end{bmatrix}$$ A=[14​25​36​],AT=⎣⎡​123​456​⎦⎤​
转置的运算规则
$$(A^T{)}^T=A(AB{)}^T=B^T{A}^T(A+B{)}^T=A^T+B^T$$

3. 特殊的矩阵

3.1 对称矩阵

• 一个矩阵转置后等于原矩阵，就是对称矩阵。
• 一个矩阵的转置和这个矩阵的乘积就是一个对称矩阵
• 两个对称矩阵相加，仍然得到对称矩阵

3.2 单位矩阵

一个nxn矩阵，主对角线上的元素都是1，其余元素都是0的，就是单位矩阵。
A = [ 1 0 0 1 ] , B = [ 1 0 0 0 1 0 0 0 1 ] A=

$$\begin{bmatrix} 1 &0\\ 0 &1\\ \end{bmatrix}$$ , B= $$\begin{bmatrix} 1 &0 &0\\ 0 &1 &0\\ 0 &0 &1\\ \end{bmatrix}$$ A=[10​01​],B=⎣⎡​100​010​001​⎦⎤​
一个矩阵与其对应的单位矩阵的乘积仍然是这个矩阵。$A_{m\times n}{I}_{n\times n}=A_{m\times n}$，$A_{m\times n}{I}_{m\times m}=A_{m\times n}$，其中I为单位矩阵。

3.3 逆矩阵

一个矩阵A，它的倒数记作$A^{-1}$，只有方阵才有逆矩阵，$A$与$A^{-1}$的乘积是单位矩阵。
计算公式，假设A和B都可逆，则$(AB{)}^{-1}=B^{-1}{A}^{-1}$
如果A是可逆矩阵，则A转置的逆等于逆的转置。

3.4 奇异矩阵

一句话，就是没有逆矩阵的矩阵。 A = [ 1 1 2 2 ] A=

$$\begin{bmatrix} 1 &1\\ 2 &2\\ \end{bmatrix}$$ A=[12​12​]，它就没有逆矩阵。

4. 线性方程组

方程组可以化成增广矩阵，用消元法或向量法求解方程组，消元法类似常规解代数方程无区别。向量法通过求逆矩阵的方式求解。
{ x + 2 y + z = 8 3 x + 7 y + 2 z = 23 2 x + 2 y + z = 9 ⟹ [ 1 2 1 8 3 7 2 23 2 2 1 9 ] \left\{

$$\begin{aligned} x+2y+z =8 \\ 3x+7y+2z =23 \\ 2x+2y+z =9 \\ \end{aligned}$$ \right.\Longrightarrow \left[ $$\begin{array}{ccc|c} 1 & 2 & 1 & 8\\ 3 & 7 & 2 & 23\\ 2 & 2 & 1 & 9\\ \end{array}$$ \right] ⎩⎪⎨⎪⎧​x+2y+z=83x+7y+2z=232x+2y+z=9​⟹⎣⎡​132​272​121​8239​⎦⎤​
向量法求解推导：
$$\underset{A}{\underbrace{\left[\begin{array}{ccc}1& 2& 1\\ 3& 7& 2\\ 2& 2& 1\end{array}\right]}}\underset{x}{\underbrace{\left[\begin{array}{c}x\\ y\\ z\end{array}\right]}}\underset{b}{\underbrace{\left[\begin{array}{c}8\\ 23\\ 9\end{array}\right]}}$$
从而得出推导出：$Ax=b\Rightarrow A^{-1}Ax=A^{-1}b\Rightarrow x=A^{-1}b$

然后就可以通过除法运算得出方程的解了 x = A − 1 b = b A = [ 1 2 3 ] x=A^{-1}b=\frac{b}{A}=

$$\begin{bmatrix} 1 \\ 2 \\ 3 \\ \end{bmatrix}$$ x=A−1b=Ab​=⎣⎡​123​⎦⎤​

由此我们可以得出，如果A是奇异矩阵，则它没有逆矩阵，所以方程组将无解。

4.1 行阶梯矩阵

满足一下条件的成为行阶梯矩阵：

1. 如果有全零行，则全0行在最下方。
2. 从行上看，从走边起，出现连续0的个数自上而下严格递增
   如果还满足，台角位置元素为1，台角正上方元素全为0，则称为最简行阶梯矩阵。
   $$A=\left[\begin{array}{ccccc}2& 0& 1& 3& -4\\ 0& -5& 1& 8& -4\\ 0& 0& 0& 7& 11\\ 0& 0& 0& 0& 0\end{array}\right],A=\left[\begin{array}{ccccc}1& 0& 1& 3& -4\\ 0& 1& 1& 8& 2\\ 0& 0& 0& 1& 11\\ 0& 0& 0& 0& 0\end{array}\right]$$

4.2 矩阵的轶

台角的个数，或者阶梯数，就是矩阵的轶，如果矩阵的轶是3，则记作r(A)=3，矩阵的阶梯数就是矩阵中独立向量的个数，如果矩阵的轶是3，那么通过一系列变换，就能转换为有3个阶梯的行阶矩阵，进而转换为最简行阶矩阵。独立向量，就是矩阵中一个不能通过其他向量的线性组合表示的向量。
对于$A_{n\times n}$，若r(A)=n，则称A为满轶矩阵，则A是可逆矩阵，是非奇异矩阵，满轶矩阵或矩阵可逆是方程组有唯一解的判断依据。

5. 线性组合和线性相关

• 线性组合
  如果$v_1,v_2,\cdots ,v_n$是n维向量，且$v_i\in R^n$，那么$t_1{v}_1+t_2{v}_2+\cdots t_n{v}_n$就是$v_1,v_2,\cdots ,v_n$的线性组合。线性组合包括数乘和加法，且只有同阶向量，才涉及线性组合。
• 线性相关
  如果两个向量是线性相关的，则它们中的一个可以用另一个的线性组合表示。
  如果存在一个集合$S=v_1,v_2,\cdots ,v_n$，当这个集合满足$t_1{v}_1+t_2{v}_2+\cdots +t_n{v}_n=O$时，S中的向量是线性相关的。，其中O是零向量，$t_i\in R,t_i$不全为0.

6. python计算代码

数学归根结底其实是一种思想，像计算这种累活儿就可以全交给计算机了，你只要把思想怎么算告诉它就可以了。

import numpy as np

if __name__ == '__main__':
    # 生成4x3矩阵，默认[0,1)随机浮点数
    a_4_3 = np.random.random((4, 3))
    # 生成4x3矩阵，范围[1,12)
    a_4_3int = np.random.randint(1, 12, (4, 3))
    # 生成4x3矩阵，元素都是1
    a_1 = np.ones((4, 3))
    # 生成4x3矩阵，元素都是0
    a_0 = np.zeros((4, 3))
    # 生成4x3矩阵，范围[2,25)，步长是2
    a_range = np.mat(np.arange(2, 25, 2)).reshape(4, 3)
    # 自定义3x3矩阵
    a_self = np.mat('1 2 3;4 5 6; 7 8 9')

    # 矩阵输出
    print('a=\n{}'.format(a_4_3))
    print('a=\n{}'.format(a_4_3int))
    print('a=\n{}'.format(a_1))
    print('a=\n{}'.format(a_0))
    print('a=\n{}'.format(a_range))
    print('a=\n{}'.format(a_self))

    # 获取矩阵的行列数
    m, n = np.shape(a_self)
    print('this is a %d x %d matrix' % (m, n))
    # 访问第一行第一列，访问第2行第3列
    a_11, a_23 = a_self[0, 0], a_self[1, 2]
    print(a_11, a_23)
    # 访问第2行
    a_row2 = a_self[1]
    print(a_row2)
    # 访问第二列
    a_col2 = a_self[:, 2]
    print(a_col2)

    a = np.mat('3 2 2; -2 0 5')
    b = np.mat('-1 3;1 2; 2 5')

    # 加法
    result = np.add(a, a)
    print(result)
    # 减法
    result = np.subtract(a, a)
    print(result)
    # 数乘
    result = np.multiply(b, 2)
    print(result)
    # 乘法
    result = np.dot(a, b)
    print(result)
    # 转置
    c = np.transpose(b)
    print(c)

    # 定义一个4x4的单位矩阵
    e = np.eye(4, 4)
    print(e)

    a = np.mat('1 2;3 4')
    # 求a的逆矩阵
    a_ni = np.linalg.inv(a)
    print(a_ni)
    result = np.dot(a, a_ni)
    result = np.around(result, decimals=1)
    print(result)

    # 求解方程组
    A = np.mat(' 1 2 1; 3 7 2; 2 2 1')
    b = np.mat('8;23;9')
    result = np.dot(A**-1, b)
    print(result)

    # 求矩阵的轶
    result = np.linalg.matrix_rank(A)
    print(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78