人工智能-线性代数之向量篇

线性代数之向量篇

在机器学习中线性代数是及其重要的数学工具，因为训练数据时会进行大量的矩阵运算，所有的线性方程计算都会转化成矩阵的计算，训练模型时所需要的计算量是巨大的，而全部转化为矩阵会缩短计算的时间，极大的提升计算速度，而且很多方程只能通过向量化的形式来解，代数与几何密不可分，可以相互的转化，这也正是数学的魅力所在。

1. 向量

1.1 定义

在数学中，向量（也称为欧几里得向量、几何向量、矢量），指具有大小和方向的量。
代数表示：$\vec{a} \quad \vec{b}$
矩阵表示：
$a=\begin{bmatrix} x_1 \\ x_2 \\ \end{bmatrix} =\left \langle x_1,x_2 \right \rangle \tag{1}$
向量的模：向量的大小称为向量的模，是个标量，没有方向。
表示为：$|a|=\sqrt{x_1^2+x_2^2}$

n维空间：用 $R^n$表示，向量在某一个维度上的值称为向量在该维度上的分量。如$R^3$空间的向量 $a=\left \langle1,3,5 \right \rangle$，则a在三个维度上的分量分别是 1,3,5。

零向量：所有分量都为0的向量，单位向量：模长等于1的向量 ，计算公式 一个非零向量除以它的模,即 $N=\frac{a}{|a|}$

1.2 向量的运算

加法：
$a=\begin{bmatrix} -1 \\ 2 \\ \end{bmatrix},b=\begin{bmatrix} 3 \\ 4 \\ \end{bmatrix}，a+b=\begin{bmatrix} -1+3 \\ 2+4 \\ \end{bmatrix}=\begin{bmatrix} 2 \\ 6 \\ \end{bmatrix} \tag{2}$

数乘：
$a=\begin{bmatrix} 1 \\ 2 \\ \end{bmatrix}, a\times3=\begin{bmatrix} 3 \\ 6 \\ \end{bmatrix}, a\times(-3)=\begin{bmatrix} -3 \\ -6 \\ \end{bmatrix} \tag{3}$
减法：
$a=\begin{bmatrix} 3 \\ 3 \\ \end{bmatrix},b=\begin{bmatrix} -1 \\ -1 \\ \end{bmatrix}，a-b=a+(-1)\times b=\begin{bmatrix} 4 \\ 4 \\ \end{bmatrix}\tag{4}$

1.3 向量与方程组

一个方程组可以分解为一个向量的混合运算。例如：
$\left\{ \begin{aligned} 3x+2y =7 \\ -6x+6y=6 \\ \end{aligned} \right.\Rightarrow \underbrace{\begin{bmatrix} 3 \\ -6 \\ \end{bmatrix}}_ax+ \underbrace{\begin{bmatrix} 2 \\ 6 \\ \end{bmatrix}}_by= \underbrace{\begin{bmatrix} 7 \\ 6 \\ \end{bmatrix}}_c\Rightarrow ax+by=c \tag{5}$

$\left\{\begin{aligned} x =1 \\ y=2 \\ \end{aligned} \right.\Rightarrow a+2b=c \tag{6}$

1.4 向量的点积

如果A和B都是n维向量，它们的点积就是二者的分量的乘积之和。
代数意义：$A\cdot B=\sum_{i=1}^na_ib_i$
几何意义：$A=\left\langle a_1,a_2\right\rangle，B=\left\langle b_1,b_2\right\rangle \;A \cdot B=a_1b_1+a_2b_2=|A||B|\cos\theta$
点积的作用：1.计算向量间的夹角，2.判断正交性，3.求向量的分量

1.5 向量的叉积

二维空间内定义：$A=\begin{bmatrix} a1 \\ a2 \\ \end{bmatrix},B=\begin{bmatrix} b1 \\ b2 \\ \end{bmatrix}, A\times B=\begin{array}{|clr|} a_1 &a_2\\ b_1 &b_2\\ \end{array}=a_1b_2-a_2b_1$
三维空间内定义：
$A=\begin{bmatrix} a1 \\ a2 \\ a3 \\ \end{bmatrix},B=\begin{bmatrix} b1 \\ b2 \\ b3 \\ \end{bmatrix}, A\times B=\begin{array}{|clr|} \hat{i} &\hat{j} &\hat{k} \\ a_1 &a_2 &a_3\\ b_1 &b_2 &b_3\\ \end{array}=a_1b_2-a_2b_1=\left\langle \hat{i} \begin{array}{|clr|} a_2 &a_3\\ b_2 &b_3\\ \end{array} , -\hat{j} \begin{array}{|clr|} a_1 &a_3\\ b_1 &b_3\\ \end{array},\hat{k} \begin{array}{|clr|} a_1 &a_2\\ b_1 &b_2\\ \end{array}\right\rangle$
&\hat{i},&\hat{j},&\hat{k}代表每个维度的单位向量，行列式是一个函数，它的代表的是一个标量。叉积的结果是一个向量，这点要非常清晰。
几何意义：$|A\times B|=|A||B|\sin\theta$，即两个向量的叉积的模长等于这两个向量模长的积乘以二者夹角的正弦。
叉积的作用：1.计算平行六面体的体积，2.判断点是否共面，3.计算法向量

2. 行列式

2.1 定义

定义：对于n维空间的行列式，可以表示为：$D_n=|A_{n\times n}|=det(A_{n\times n})$，其中A是一个n阶方阵。

2.2 性质

• 单位矩阵的行列式为1
• 如果$D_n=det(A)$的某行的元素全为0，那么$D_n=0$
• 如果$D_n=det(A)$中某两行元素对应成比例，那么$D_n=0$
• 如果$D_n=det(A)$中某两行元素互换，那么互换后的行列式变号，即$det(A)=-det(A)$
• 倍乘性质 ,行列式A中某行(或列)用同一数k乘,其结果等于kA，$det(kA_{n\times n})=k^ndet(A_{n\times n})$
• 倍加性质：
  $\begin{array}{|clr|} a_1 &a_2\\ b_1 &b_2\\ \end{array}=\begin{array}{|clr|} a_1 &a_2\\ b_1+ka_1 &b_2+ka_2\\ \end{array}$
• 单行可拆性：从左到右是加，从右到左是拆
  $\begin{array}{|clr|} a_1 &a_2\\ b_1 &b_2\\ \end{array}+ \begin{array}{|clr|} a_1 &a_2\\ c_1 &b_c\\ \end{array}=\begin{array}{|clr|} a_1 &a_2\\ c_1+b_1 &c_2+b_2\\ \end{array}$
• 以上所有作用于行的性质都可以适用于列上
• 两个矩阵相乘的行列式，等于这个两个矩阵的行列式相乘 det(AB)=det(A)det(B)

2.3 行列式的意义

行列式是由向量组成的，当$det(A)\not=0$时，组成det(A)的向量全部独立，此时，方程组有唯一解。
$\begin{array}{|clr|} 1 &2\\ 3 &4\\ \end{array} \not=0\rightarrow \left\{ \begin{aligned} x_1+x_2 =0 \\ 3x_1+4x_2=0 \\ \end{aligned} \right.$

2.4 行列式的计算

$det(U)=d_1d_2d_3\ldots d_n=\prod^n_{i=1}d_i$

$det(A)=\sum _{n!}\pm a_{1\alpha}a_{2\beta}a_{3\gamma}\cdots a_{n\varpi}$

2.5 代数余子式

代数余子式的核心思想是把一个复杂的高阶行列式转换为多个简单的低阶行列式

$det(A)=a_{11}(a_{22}a_{33}-a_{23}a_{32})-a_{12}(a_{21}a_{33}-a_{23}a_{31})+a_{13}(a_{21}a_{32}-a_{22}a_{31})$
$det(A)=a_{11}C_{11}+a_{12}C_{12}+\cdots +a_{1n}C_{1n}=\sum _{i=1}^na_{1i}C_{1i}$

3. python代码

import numpy as np

if __name__ == '__main__':
    a = np.array([-1, 2, 3])
    b = np.array([3, 1, 4])
    a_add_b = a + b
    a_sub_b = a - b
    a_mul_b = a * b
    # 计算点积
    a_inner_b = np.inner(a, b)
    # 计算叉积
    a_cross_b = np.cross(a, b)

    print(a_add_b, a_sub_b, a_mul_b, a_inner_b, a_cross_b)

    c = np.mat('1 2;3 3')
    d = np.mat('2 2 1; 1 0 1; 0 2 1')
    # 计算两个行列式
    det_c = np.linalg.det(c)
    det_d = np.linalg.det(d)
    print('c={0}\n D(c)={1}'.format(c,np.round(det_c)))
    print('d={0}\n D(d)={1}'.format(d,np.round(det_d)))

• 执行结果截图