AI算法工程师 | 04人工智能基础-高等数学知识强化（三）线性代数基础之向量

数学知识 之 线性代数基础

🗨 向量及其运算

向量的概念及其意义

ღ 向量的概念

向量是线性代数里面最基本的概念，它其实就是一维数组，由 $N$ 个数构成的，$X=(X_1,X_2,...,X_n)$

• $X_i$ 称为向量 $X$ 的第 $i$ 个分量，向量的分量称之为维度
• $n$ 维向量集合的全体就构成了 $n$ 维欧式空间，符号表示为 $R^n$

ღ 向量的意义

几何意义：表示空间中的点

物理意义：可以看成是速度或者力这样的矢量（向量是矢量 → 是有方向的。如：力有方向，速度也有方向）

• 即：向量可表达高维空间中的一个点，但从原点出发，它是有方向的

机器学习中的意义：每个向量可以表达一个样本

• 即：向量可以表达机器学习或深度学习中的每条样本

行向量和列向量

在线性代数中，

• 行向量是一个 1×n 的矩阵，即矩阵由一个含有n个元素的行所组成；
• 列向量是一个 n×1 的矩阵，即矩阵由一个含有n个元素的列所组成。

-_-

—— 摘自： 行向量-百度百科、列向量-百度百科

ღ 相关概念

行向量是按行把向量排开：
$$\left(\begin{array}{cccc}{X}_1,& X_2,& ...& ,X_n\end{array}\right)$$
列向量是按列把向量排开:
$$\left(\begin{array}{c}{X}_1\\ X_2\\ .\\ .\\ .\\ X_n\end{array}\right)$$
为了方便书写，列向量也可写成如下形式：（即行向量的转置）
$${\left(\begin{array}{cccc}{X}_1,& X_2,& ...& ,X_n\end{array}\right)}^T$$

说明：在数学中，数据更多的被写成列向量；而在编程语言中，数据更多的被存成行向量

ღ 转置 Transpose

• 把列向量变成行向量
  $${\left(\begin{array}{c}1\\ 2\\ 3\\ 4\end{array}\right)}^T=\left(\begin{array}{cccc}1,& 2,& 3,& 4\end{array}\right)$$
• 把行向量变成列向量
  $${\left(\begin{array}{cccc}1,& 2,& 3,& 4\end{array}\right)}^T=\left(\begin{array}{c}1\\ 2\\ 3\\ 4\end{array}\right)$$

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口：

>>> import numpy as np # 导入模块
>>> a = np.array([1,2,3]) # 创建一维数组
>>> a  # 行向量形式
array([1, 2, 3])
>>> a.T # 通过转置的方式，呈现出来的依旧是行向量
array([1, 2, 3])
>>> a.reshape(3,1) # 3：3行；1：1列（reshape：变形状）
array([[1],
       [2],
       [3]])
>>> a.reshape(-1,1) # -1 代表具体行数由计算机自己算，但必须是1列
array([[1],
       [2],
       [3]])

图解：

向量的运算及对应的意义

ღ 加减法运算

• 加法运算等于它们的分量分别相加（对应位置相加），显然两个向量的长度得是相等的
• 减法运算同加法的类似，在此不再列举
  $$\left(\begin{array}{c}1\\ 2\\ 3\\ 4\end{array}\right)+\left(\begin{array}{c}5\\ 6\\ 7\\ 8\end{array}\right)=\left(\begin{array}{c}6\\ 8\\ 10\\ 12\end{array}\right)$$

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> import numpy as np
>>> a = np.array([1,2,3,4])
>>> b = np.array([5,6,7,8])
>>> a
array([1, 2, 3, 4])
>>> b
array([5, 6, 7, 8])
>>> a + b   # 两个行向量相加
array([ 6,  8, 10, 12])
>>> a2 = a.reshape(-1,1) # 行向量转为列向量形式
>>> a2
array([[1],
       [2],
       [3],
       [4]])
>>> b2 = b.reshape(-1,1) # 转成列向量形式
>>> b2
array([[5],
       [6],
       [7],
       [8]])
>>> a2 + b2  # 两个列向量相加
array([[ 6],
       [ 8],
       [10],
       [12]])
>>> a - b    # 两个行向量相减
array([-4, -4, -4, -4])
>>> a2 - b2  # 两个列向量相减
array([[-4],
       [-4],
       [-4],
       [-4]])

图解：

ღ 数乘运算

• 它是一个数和这个向量每个分量相乘
  $$2\times \left(\begin{array}{c}1\\ 2\\ 3\\ 4\end{array}\right)=\left(\begin{array}{c}2\\ 4\\ 6\\ 8\end{array}\right)$$

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> a   # 接着前面所给的值
array([1, 2, 3, 4])
>>> 2 * a  # 数乘（行向量）
array([2, 4, 6, 8])
>>> a * 2 
array([2, 4, 6, 8])
>>> a2
array([[1],
       [2],
       [3],
       [4]])
>>> 2 * a2  # 数乘（列向量）
array([[2],
       [4],
       [6],
       [8]])
>>> a2 / 2  # 除法运算
array([[0.5],
       [1. ],
       [1.5],
       [2. ]])
>>> b
array([5, 6, 7, 8])
>>> b2
array([[5],
       [6],
       [7],
       [8]])
>>> a * b      # 两个行向量相乘
array([ 5, 12, 21, 32])
>>> a2 * b2    # 两个列向量相乘
array([[ 5],
       [12],
       [21],
       [32]])

图解：

ღ 向量的内积

• 两个列向量，$X^{T}Y$，等于对应位置相乘再相加（内积也叫点乘）
• 两个向量的内积的本质是变成一个标量
  $$\left(\begin{array}{cccc}1,& 2,& 3,& 4\end{array}\right)\left(\begin{array}{c}1\\ 1\\ 2\\ 4\end{array}\right)=1\times 1+2\times 1+3\times 2+4\times 4=25$$

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> a   # 变量 a、b、a2、b2 接着前面所给的值
array([1, 2, 3, 4])
>>> b
array([5, 6, 7, 8])
>>> a2
array([[1],
      [2],
      [3],
      [4]])
>>> b2
array([[5],
      [6],
      [7],
      [8]])
>>> np.dot(a,b) # np.dot函数进行内积：编程中无需写成行向量与列向量，两行向量也可
70
>>> np.dot(a,a2)  # 1*1+2*2+3*3+4*4=30
array([30])
>>> np.dot(b,b2)  # 5*5+6*6+7*7+8*8=174
array([174])
>>> np.dot(a2,b2) # 报错
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 File "<__array_function__ internals>", line 180, in dot
ValueError: shapes (4,1) and (4,1) not aligned: 1 (dim 1) != 4 (dim 0)

图解：

ღ 运算法则

可以理解为：向量的运算满足交换律、分配律
$$A+B+C=A+(B+C)；K\ast (X+Y)=KX+KY$$

ღ 各运算对于机器学习的意义

小贴士

• 误差（Error）：在机器学习中，要评价一个预测算法的优劣，误差是简单且直观的衡量标准。 —— 参考：谈谈机器学习中的误差与损失
• 在梯度下降算法中，学习率是最影响优化性能的超参数之一。 —— 参考：梯度下降学习率的设定策略

向量到原点的范式

ღ 向量的范数

• 范数的公式：先计算向量每个分量绝对值的 P 次方 的总和，再用幂函数计算 P 分之一（这里 P 是整数，如 1，2，3…到正无穷都是可以的）
• 范数的本质：把向量变成一个标量
• 范数的表示：两个竖线来表示，然后右下角写上 P
  $${\Vert x\Vert }_p={\left(\sum _{i=1}^n{\left|x_i\right|}^p\right)}^{\frac{1}{p}}$$

1-范数

• 即绝对值加和，1-范数写成 L1
• L1范数的几何意义：向量到原点的曼哈顿距离
  $${\Vert x\Vert }_1=\sum _{i=1}^n\left|x_i\right|$$

2-范数

• 即平方加和开根号，代表向量的长度，2-范数写成 L2
• L2范数的几何意义：空间中的向量点到原点的欧式距离（欧式距离：两点之间连直线的距离）
  $${\Vert x\Vert }_2=\sqrt{\sum _{i=1}^n{\left(x_i\right)}^2}$$

图解

小贴士
出租车几何或曼哈顿距离（Manhattan Distance）是由十九世纪的赫尔曼·闵可夫斯基所创词汇 ，是种使用在几何度量空间的几何学用语，用以标明两个点在标准坐标系上的绝对轴距总和。—— 摘自：百度百科-曼哈顿距离

ღ 范数与正则项的关系

范数在后面是非常有用的，在后面的正则项中会用到

L1正则项

• 就是L1范数的公式，求的是到原点的曼哈顿距离
  $$\sum _{i=0}^n\left|w_i\right|$$

L2正则项

• 相当于L2范数的平方，求的是欧式距离的平方
  $$\sum _{i=0}^n{\left(w_i\right)}^2$$

在机器学习或深度学习中，所求的模型为 $w$ 。一般会希望 $w$ 向量所对应的 L1、 L2 范数尽可能的小。（好处：$w$ 越小，说明模型的容错能力或泛化能力就越强，越可以防止过拟合）

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> import numpy as np
>>> W = np.array([3,5,6,-7,2,1])
>>> np.abs(W)
array([3, 5, 6, 7, 2, 1])
>>> np.sum(np.abs(W))
24
>>> L1 = np.sum(np.abs(W))  # 绝对值的加和（ L1正则项 或 L1范数 ）
>>> L1
24
>>> np.square(W)
array([ 9, 25, 36, 49,  4,  1])
>>> np.sum(np.square(W))
124
>>> L2 = np.sum(np.square(W))  # 平方的加和（ L2正则项 ）
>>> L2
124
>>> np.sqrt(np.sum(np.square(W)))  # 平方加和，开根号（ L2范数 ）
11.135528725660043

图解：

特殊的向量

ღ 0 向量

概念：0 向量是分量全为 0 的向量。如 $\left(\begin{array}{cccc}0,& 0,& ...& ,0\end{array}\right)$

意义：在机器学习中，对 bias 偏置项进行初始化时，会全部初始为0

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> import numpy as np
>>> np.zeros(10) # 获取长度为 10 的，全为 0 的向量
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

ღ 全为1的向量

概念：分量全为 1 的向量。如 $\left(\begin{array}{cccc}1,& 1,& ...& ,1\end{array}\right)$

意义

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> np.ones(10) # 获取长度为 10 的，全为 1 的向量
array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

小贴士

• 深度学习中的使用：python 中可使用 import tensorflow as tf
• TensorFlow是使用广泛的一个深度学习框架，其中也有像 numpy 中 zeros、ones 这类的API

ღ 稀疏向量与稠密向量

稀疏向量（Sparse Vector）

概念：大部分为0，少部分非0。如 $\left(\begin{array}{ccccccccc}0,& 0,& 1,& 0,& 2,& 0& 0,& 0,& 0\end{array}\right)$

稠密向量（Dense Vector）

概念：大部分有值，少部分为0。如 $\left(\begin{array}{ccccccccc}4,& 0,& 1,& 0,& 5,& 1& 1,& 1,& 2\end{array}\right)$

存储时的区别

主要体现在占空间多少的差异，在计算机存储时：

• 稀疏向量只需存储：向量长度 length，非0数据的索引号 index 及对应值 value
• 稠密向量需要存储：向量长度 length，所有数据的索引号 index 及对应值 value

ღ 独热编码（One-Hot 编码）

概念：它是一种特殊的稀疏向量，单独有一个为1，其他为0。如 $\left(\begin{array}{cccccccc}0,& 0,& 1,& 0,& 0,& 0,& 0,& 0\end{array}\right)$

小贴士
独热编码即 One-Hot 编码，又称一位有效编码，其方法是使用N位状态寄存器来对N个状态进行编码，每个状态都有它独立的寄存器位，并且在任意时候，其中只有一位有效。—— 摘自：百度百科-独热编码

意义：在机器学习中，可通过 One-Hot 编码对离散型数据做离散化，如↓↓↓

Sunny	Rainy	Cloudy	说明
0	1	0	若这天为雨天，则雨天位置写1，其他位置写0
1	0	0	若这天为晴天，则晴天位置写1，其他位置写0

ღ 单位向量

概念：单位向量是 L2 范数为1、模为1、长度为1 的向量

计算：单位向量 = 向量 除以 对应的模
$$e=\frac{x}{\Vert x\Vert }$$
向量的模：向量 $\overrightarrow{AB}$ 的大小，也就是向量 $\overrightarrow{AB}$ 的长度（或称模），记作 $\left|\overrightarrow{AB}\right|$。 —— 参考：百度百科-向量的模

• 空间向量 $(x,y,z)$，其中 $x,y,z$ 表示三个轴上的坐标，模长为：$\sqrt{x^2+y^2+z^2}$
• 平面向量 $(x,y)$，模长为：$\sqrt{x^2+y^2}$
• 其中，L2 范数 ${\Vert x\Vert }_2=\sqrt{{\sum }_{i=1}^n{\left(x_i\right)}^2}$ ：代表的就是 向量的模

用途：单位向量可更好的代表一个方向

• 通过两向量的单位向量可以知道这两个向量的方向是否一致
• 向量可以由它所对应的单位向量再乘以一定的值（模）得到

Pyhton中的表示

以下是 cmd 命令端中输入python，所进入的 python 交互窗口

>>> import numpy as np
>>> W = np.array([3,5,6,-7,2,1])
>>> L2 = np.sqrt(np.sum(np.square(W)))  # L2 范数（模）
>>> e = W/L2 # 单位向量 = 向量 除以 模
>>> e
array([ 0.26940795,  0.44901326,  0.53881591, -0.62861856,  0.1796053 ,
        0.08980265])
>>> np.sqrt(np.sum(np.square(e))) # e 的模为 1，说明 e 是单位向量
1.0
>>> L2
11.135528725660043
>>> e * L2  # 单位向量 乘以 模 可得 原向量
array([ 3.,  5.,  6., -7.,  2.,  1.])

—— 说明：本文代码基于 python3.0，文章写于 2022.5.20~5.24