跟李沐学AI-深度学习课程05线性代数

线性代数

🏷sec_linear-algebra

在介绍完如何存储和操作数据后，接下来将简要地回顾一下部分基本线性代数内容。

这些内容有助于读者了解和实现本书中介绍的大多数模型。

本节将介绍线性代数中的基本数学对象、算术和运算，并用数学符号和相应的代码实现来表示它们。

标量

如果你曾经在餐厅支付餐费，那么应该已经知道一些基本的线性代数，比如在数字间相加或相乘。

例如，北京的温度为 5 2 ∘ F 52^{\circ}F 52∘F（华氏度，除摄氏度外的另一种温度计量单位）。

严格来说，仅包含一个数值被称为标量（scalar）。

如果要将此华氏度值转换为更常用的摄氏度，

则可以计算表达式 c = 5 9 ( f − 32 ) c=\frac{5}{9}(f-32) c=95(f−32)，并将 f f f赋为 52 52 52。

在此等式中，每一项（ 5 5 5、 9 9 9和 32 32 32）都是标量值。

符号 c c c和 f f f称为变量（variable），它们表示未知的标量值。

本书采用了数学表示法，其中标量变量由普通小写字母表示（例如， x x x、 y y y和 z z z）。

本书用 R \mathbb{R} R表示所有（连续）实数标量的空间，之后将严格定义空间（space）是什么，

但现在只要记住表达式 x ∈ R x\in\mathbb{R} x∈R是表示 x x x是一个实值标量的正式形式。

符号 ∈ \in ∈称为"属于"，它表示"是集合中的成员"。

例如 x , y ∈ { 0 , 1 } x, y \in \{0,1\} x,y∈{0,1}可以用来表明 x x x和 y y y是值只能为 0 0 0或 1 1 1的数字。

(标量由只有一个元素的张量表示 )。

下面的代码将实例化两个标量，并执行一些熟悉的算术运算，即加法、乘法、除法和指数。

{.python 复制代码

from mxnet import np, npx
npx.set_np()

x = np.array(3.0)
y = np.array(2.0)

x + y, x * y, x / y, x ** y

{.python 复制代码

#@tab pytorch
import torch

x = torch.tensor(3.0)
y = torch.tensor(2.0)

x + y, x * y, x / y, x**y

{.python 复制代码

#@tab tensorflow
import tensorflow as tf

x = tf.constant(3.0)
y = tf.constant(2.0)

x + y, x * y, x / y, x**y

{.python 复制代码

#@tab paddle
import warnings
warnings.filterwarnings(action='ignore')
import paddle

x = paddle.to_tensor([3.0])
y = paddle.to_tensor([2.0])

x + y, x * y, x / y, x**y

向量

{.python 复制代码

y = np.ones(4)
x, y, np.dot(x, y)

{.python 复制代码

#@tab pytorch
y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)

{.python 复制代码

#@tab tensorflow
y = tf.ones(4, dtype=tf.float32)
x, y, tf.tensordot(x, y, axes=1)

{.python 复制代码

#@tab paddle
y = paddle.ones(shape=[4], dtype='float32')
x, y, paddle.dot(x, y)

注意，(我们可以通过执行按元素乘法，然后进行求和来表示两个向量的点积)：

{.python 复制代码

np.sum(x * y)

{.python 复制代码

#@tab pytorch
torch.sum(x * y)

{.python 复制代码

#@tab tensorflow
tf.reduce_sum(x * y)

{.python 复制代码

#@tab paddle
paddle.sum(x * y)

点积在很多场合都很有用。

例如，给定一组由向量 x ∈ R d \mathbf{x} \in \mathbb{R}^d x∈Rd表示的值，

和一组由 w ∈ R d \mathbf{w} \in \mathbb{R}^d w∈Rd表示的权重。
x \mathbf{x} x中的值根据权重 w \mathbf{w} w的加权和，

可以表示为点积 x ⊤ w \mathbf{x}^\top \mathbf{w} x⊤w。

当权重为非负数且和为1（即 ( ∑ i = 1 d w i = 1 ) \left(\sum_{i=1}^{d}{w_i}=1\right) (∑i=1dwi=1)）时，

点积表示加权平均 （weighted average）。

将两个向量规范化得到单位长度后，点积表示它们夹角的余弦。

本节后面的内容将正式介绍长度（length）的概念。

矩阵-向量积

现在我们知道如何计算点积，可以开始理解矩阵-向量积 （matrix-vector product）。

回顾分别在 :eqref:eq_matrix_def和 :eqref:eq_vec_def中定义的矩阵 A ∈ R m × n \mathbf{A} \in \mathbb{R}^{m \times n} A∈Rm×n和向量 x ∈ R n \mathbf{x} \in \mathbb{R}^n x∈Rn。

让我们将矩阵 A \mathbf{A} A用它的行向量表示：

A = [ a 1 ⊤ a 2 ⊤ ⋮ a m ⊤ ] , \mathbf{A}= \begin{bmatrix} \mathbf{a}^\top_{1} \\ \mathbf{a}^\top_{2} \\ \vdots \\ \mathbf{a}^\top_m \\ \end{bmatrix}, A= a1⊤a2⊤⋮am⊤ ,

其中每个 a i ⊤ ∈ R n \mathbf{a}^\top_{i} \in \mathbb{R}^n ai⊤∈Rn都是行向量，表示矩阵的第 i i i行。

**矩阵向量积 A x \\mathbf{A}\\mathbf{x} Ax是一个长度为 m m m的列向量， 其第 i i i个元素是点积 a i ⊤ x \\mathbf{a}\^\\top_i \\mathbf{x} ai⊤x**\]： A x = \[ a 1 ⊤ a 2 ⊤ ⋮ a m ⊤ \] x = \[ a 1 ⊤ x a 2 ⊤ x ⋮ a m ⊤ x \] . \\mathbf{A}\\mathbf{x} = \\begin{bmatrix} \\mathbf{a}\^\\top_{1} \\\\ \\mathbf{a}\^\\top_{2} \\\\ \\vdots \\\\ \\mathbf{a}\^\\top_m \\\\ \\end{bmatrix}\\mathbf{x} = \\begin{bmatrix} \\mathbf{a}\^\\top_{1} \\mathbf{x} \\\\ \\mathbf{a}\^\\top_{2} \\mathbf{x} \\\\ \\vdots\\\\ \\mathbf{a}\^\\top_{m} \\mathbf{x}\\\\ \\end{bmatrix}. Ax= a1⊤a2⊤⋮am⊤ x= a1⊤xa2⊤x⋮am⊤x . 我们可以把一个矩阵 A ∈ R m × n \\mathbf{A} \\in \\mathbb{R}\^{m \\times n} A∈Rm×n乘法看作一个从 R n \\mathbb{R}\^{n} Rn到 R m \\mathbb{R}\^{m} Rm向量的转换。 这些转换是非常有用的，例如可以用方阵的乘法来表示旋转。 后续章节将讲到，我们也可以使用矩阵-向量积来描述在给定前一层的值时， 求解神经网络每一层所需的复杂计算。 :begin_tab:`mxnet` 在代码中使用张量表示矩阵-向量积，我们使用与点积相同的`dot`函数。 当我们为矩阵`A`和向量`x`调用`np.dot(A,x)`时，会执行矩阵-向量积。 注意，`A`的列维数（沿轴1的长度）必须与`x`的维数（其长度）相同。 :end_tab: :begin_tab:`pytorch` 在代码中使用张量表示矩阵-向量积，我们使用`mv`函数。 当我们为矩阵`A`和向量`x`调用`torch.mv(A, x)`时，会执行矩阵-向量积。 注意，`A`的列维数（沿轴1的长度）必须与`x`的维数（其长度）相同。 :end_tab: :begin_tab:`tensorflow` 在代码中使用张量表示矩阵-向量积，我们使用与点积相同的`matvec`函数。 当我们为矩阵`A`和向量`x`调用`tf.linalg.matvec(A, x)`时，会执行矩阵-向量积。 注意，`A`的列维数（沿轴1的长度）必须与`x`的维数（其长度）相同。 :end_tab: ```{.python A.shape, x.shape, np.dot(A, x) ``` ```{.python #@tab pytorch A.shape, x.shape, torch.mv(A, x) ``` ```{.python #@tab tensorflow A.shape, x.shape, tf.linalg.matvec(A, x) ``` ```{.python #@tab paddle A.shape, x.shape, paddle.mv(A, x) ``` ### 矩阵-矩阵乘法 在掌握点积和矩阵-向量积的知识后， 那么**矩阵-矩阵乘法**（matrix-matrix multiplication）应该很简单。 假设有两个矩阵 A ∈ R n × k \\mathbf{A} \\in \\mathbb{R}\^{n \\times k} A∈Rn×k和 B ∈ R k × m \\mathbf{B} \\in \\mathbb{R}\^{k \\times m} B∈Rk×m： A = \[ a 11 a 12 ⋯ a 1 k a 21 a 22 ⋯ a 2 k ⋮ ⋮ ⋱ ⋮ a n 1 a n 2 ⋯ a n k \] , B = \[ b 11 b 12 ⋯ b 1 m b 21 b 22 ⋯ b 2 m ⋮ ⋮ ⋱ ⋮ b k 1 b k 2 ⋯ b k m \] . \\mathbf{A}=\\begin{bmatrix} a_{11} \& a_{12} \& \\cdots \& a_{1k} \\\\ a_{21} \& a_{22} \& \\cdots \& a_{2k} \\\\ \\vdots \& \\vdots \& \\ddots \& \\vdots \\\\ a_{n1} \& a_{n2} \& \\cdots \& a_{nk} \\\\ \\end{bmatrix},\\quad \\mathbf{B}=\\begin{bmatrix} b_{11} \& b_{12} \& \\cdots \& b_{1m} \\\\ b_{21} \& b_{22} \& \\cdots \& b_{2m} \\\\ \\vdots \& \\vdots \& \\ddots \& \\vdots \\\\ b_{k1} \& b_{k2} \& \\cdots \& b_{km} \\\\ \\end{bmatrix}. A= a11a21⋮an1a12a22⋮an2⋯⋯⋱⋯a1ka2k⋮ank ,B= b11b21⋮bk1b12b22⋮bk2⋯⋯⋱⋯b1mb2m⋮bkm . 用行向量 a i ⊤ ∈ R k \\mathbf{a}\^\\top_{i} \\in \\mathbb{R}\^k ai⊤∈Rk表示矩阵 A \\mathbf{A} A的第 i i i行，并让列向量 b j ∈ R k \\mathbf{b}_{j} \\in \\mathbb{R}\^k bj∈Rk作为矩阵 B \\mathbf{B} B的第 j j j列。要生成矩阵积 C = A B \\mathbf{C} = \\mathbf{A}\\mathbf{B} C=AB，最简单的方法是考虑 A \\mathbf{A} A的行向量和 B \\mathbf{B} B的列向量: A = \[ a 1 ⊤ a 2 ⊤ ⋮ a n ⊤ \] , B = \[ b 1 b 2 ⋯ b m \] . \\mathbf{A}= \\begin{bmatrix} \\mathbf{a}\^\\top_{1} \\\\ \\mathbf{a}\^\\top_{2} \\\\ \\vdots \\\\ \\mathbf{a}\^\\top_n \\\\ \\end{bmatrix}, \\quad \\mathbf{B}=\\begin{bmatrix} \\mathbf{b}_{1} \& \\mathbf{b}_{2} \& \\cdots \& \\mathbf{b}_{m} \\\\ \\end{bmatrix}. A= a1⊤a2⊤⋮an⊤ ,B=\[b1b2⋯bm\]. 当我们简单地将每个元素 c i j c_{ij} cij计算为点积 a i ⊤ b j \\mathbf{a}\^\\top_i \\mathbf{b}_j ai⊤bj: C = A B = \[ a 1 ⊤ a 2 ⊤ ⋮ a n ⊤ \] \[ b 1 b 2 ⋯ b m \] = \[ a 1 ⊤ b 1 a 1 ⊤ b 2 ⋯ a 1 ⊤ b m a 2 ⊤ b 1 a 2 ⊤ b 2 ⋯ a 2 ⊤ b m ⋮ ⋮ ⋱ ⋮ a n ⊤ b 1 a n ⊤ b 2 ⋯ a n ⊤ b m \] . \\mathbf{C} = \\mathbf{AB} = \\begin{bmatrix} \\mathbf{a}\^\\top_{1} \\\\ \\mathbf{a}\^\\top_{2} \\\\ \\vdots \\\\ \\mathbf{a}\^\\top_n \\\\ \\end{bmatrix} \\begin{bmatrix} \\mathbf{b}_{1} \& \\mathbf{b}_{2} \& \\cdots \& \\mathbf{b}_{m} \\\\ \\end{bmatrix} = \\begin{bmatrix} \\mathbf{a}\^\\top_{1} \\mathbf{b}_1 \& \\mathbf{a}\^\\top_{1}\\mathbf{b}_2\& \\cdots \& \\mathbf{a}\^\\top_{1} \\mathbf{b}_m \\\\ \\mathbf{a}\^\\top_{2}\\mathbf{b}_1 \& \\mathbf{a}\^\\top_{2} \\mathbf{b}_2 \& \\cdots \& \\mathbf{a}\^\\top_{2} \\mathbf{b}_m \\\\ \\vdots \& \\vdots \& \\ddots \&\\vdots\\\\ \\mathbf{a}\^\\top_{n} \\mathbf{b}_1 \& \\mathbf{a}\^\\top_{n}\\mathbf{b}_2\& \\cdots\& \\mathbf{a}\^\\top_{n} \\mathbf{b}_m \\end{bmatrix}. C=AB= a1⊤a2⊤⋮an⊤ \[b1b2⋯bm\]= a1⊤b1a2⊤b1⋮an⊤b1a1⊤b2a2⊤b2⋮an⊤b2⋯⋯⋱⋯a1⊤bma2⊤bm⋮an⊤bm . \[**我们可以将矩阵-矩阵乘法 A B \\mathbf{AB} AB看作简单地执行 m m m次矩阵-向量积，并将结果拼接在一起，形成一个 n × m n \\times m n×m矩阵** \]。 在下面的代码中，我们在`A`和`B`上执行矩阵乘法。 这里的`A`是一个5行4列的矩阵，`B`是一个4行3列的矩阵。 两者相乘后，我们得到了一个5行3列的矩阵。 ```{.python B = np.ones(shape=(4, 3)) np.dot(A, B) ``` ```{.python #@tab pytorch B = torch.ones(4, 3) torch.mm(A, B) ``` ```{.python #@tab tensorflow B = tf.ones((4, 3), tf.float32) tf.matmul(A, B) ``` ```{.python #@tab paddle B = paddle.ones(shape=[4, 3], dtype='float32') paddle.mm(A, B) ``` 矩阵-矩阵乘法可以简单地称为**矩阵乘法**，不应与"Hadamard积"混淆。 ### 范数 🏷`subsec_lin-algebra-norms` 线性代数中最有用的一些运算符是*范数* （norm）。 非正式地说，向量的*范数* 是表示一个向量有多大。 这里考虑的*大小*（size）概念不涉及维度，而是分量的大小。 在线性代数中，向量范数是将向量映射到标量的函数 f f f。 给定任意向量 x \\mathbf{x} x，向量范数要满足一些属性。 第一个性质是：如果我们按常数因子 α \\alpha α缩放向量的所有元素， 其范数也会按相同常数因子的*绝对值*缩放： f ( α x ) = ∣ α ∣ f ( x ) . f(\\alpha \\mathbf{x}) = \|\\alpha\| f(\\mathbf{x}). f(αx)=∣α∣f(x). 第二个性质是熟悉的三角不等式: f ( x + y ) ≤ f ( x ) + f ( y ) . f(\\mathbf{x} + \\mathbf{y}) \\leq f(\\mathbf{x}) + f(\\mathbf{y}). f(x+y)≤f(x)+f(y). 第三个性质简单地说范数必须是非负的: f ( x ) ≥ 0. f(\\mathbf{x}) \\geq 0. f(x)≥0. 这是有道理的。因为在大多数情况下，任何东西的最小的*大小* 是0。 最后一个性质要求范数最小为0，当且仅当向量全由0组成。 ∀ i , \[ x \] i = 0 ⇔ f ( x ) = 0. \\forall i, \[\\mathbf{x}\]_i = 0 \\Leftrightarrow f(\\mathbf{x})=0. ∀i,\[x\]i=0⇔f(x)=0. 范数听起来很像距离的度量。 欧几里得距离和毕达哥拉斯定理中的非负性概念和三角不等式可能会给出一些启发。 事实上，欧几里得距离是一个 L 2 L_2 L2范数： 假设 n n n维向量 x \\mathbf{x} x中的元素是 x 1 , ... , x n x_1,\\ldots,x_n x1,...,xn，其\[**L 2 L_2 L2*范数*是向量元素平方和的平方根：**

(∥ x ∥ 2 = ∑ i = 1 n x i 2 , \|\mathbf{x}\|2 = \sqrt{\sum{i=1}^n x_i^2}, ∥x∥2=i=1∑nxi2 ,)

其中，在 L 2 L_2 L2范数中常常省略下标 2 2 2，也就是说 ∥ x ∥ \|\mathbf{x}\| ∥x∥等同于 ∥ x ∥ 2 \|\mathbf{x}\|_2 ∥x∥2。

在代码中，我们可以按如下方式计算向量的 L 2 L_2 L2范数。

{.python 复制代码

u = np.array([3, -4])
np.linalg.norm(u)

{.python 复制代码

#@tab pytorch
u = torch.tensor([3.0, -4.0])
torch.norm(u)

{.python 复制代码

#@tab tensorflow
u = tf.constant([3.0, -4.0])
tf.norm(u)

{.python 复制代码

#@tab paddle
u = paddle.to_tensor([3.0, -4.0])
paddle.norm(u)

深度学习中更经常地使用 L 2 L_2 L2范数的平方，也会经常遇到[L 1 L_1 L1范数，它表示为向量元素的绝对值之和：]

(∥ x ∥ 1 = ∑ i = 1 n ∣ x i ∣ . \|\mathbf{x}\|1 = \sum{i=1}^n \left|x_i \right|. ∥x∥1=i=1∑n∣xi∣.)

与 L 2 L_2 L2范数相比， L 1 L_1 L1范数受异常值的影响较小。

为了计算 L 1 L_1 L1范数，我们将绝对值函数和按元素求和组合起来。

{.python 复制代码

np.abs(u).sum()

{.python 复制代码

#@tab pytorch
torch.abs(u).sum()

{.python 复制代码

#@tab tensorflow
tf.reduce_sum(tf.abs(u))

{.python 复制代码

#@tab paddle
paddle.abs(u).sum()

L 2 L_2 L2范数和 L 1 L_1 L1范数都是更一般的 L p L_p Lp范数的特例：

∥ x ∥ p = ( ∑ i = 1 n ∣ x i ∣ p ) 1 / p . \|\mathbf{x}\|p = \left(\sum{i=1}^n \left|x_i \right|^p \right)^{1/p}. ∥x∥p=(i=1∑n∣xi∣p)1/p.

类似于向量的 L 2 L_2 L2范数，[矩阵 ] X ∈ R m × n \mathbf{X} \in \mathbb{R}^{m \times n} X∈Rm×n(的Frobenius范数（Frobenius norm）是矩阵元素平方和的平方根：)

(∥ X ∥ F = ∑ i = 1 m ∑ j = 1 n x i j 2 . \|\mathbf{X}\|F = \sqrt{\sum{i=1}^m \sum_{j=1}^n x_{ij}^2}. ∥X∥F=i=1∑mj=1∑nxij2 .)

Frobenius范数满足向量范数的所有性质，它就像是矩阵形向量的 L 2 L_2 L2范数。

调用以下函数将计算矩阵的Frobenius范数。

{.python 复制代码

np.linalg.norm(np.ones((4, 9)))

{.python 复制代码

#@tab pytorch
torch.norm(torch.ones((4, 9)))

{.python 复制代码

#@tab tensorflow
tf.norm(tf.ones((4, 9)))

{.python 复制代码

#@tab paddle
paddle.norm(paddle.ones(shape=[4, 9], dtype='float32'))

范数和目标

🏷subsec_norms_and_objectives

在深度学习中，我们经常试图解决优化问题：
最大化 分配给观测数据的概率;
最小化 预测和真实观测之间的距离。

用向量表示物品（如单词、产品或新闻文章），以便最小化相似项目之间的距离，最大化不同项目之间的距离。

目标，或许是深度学习算法最重要的组成部分（除了数据），通常被表达为范数。

关于线性代数的更多信息

仅用一节，我们就教会了阅读本书所需的、用以理解现代深度学习的线性代数。

线性代数还有很多，其中很多数学对于机器学习非常有用。

例如，矩阵可以分解为因子，这些分解可以显示真实世界数据集中的低维结构。

机器学习的整个子领域都侧重于使用矩阵分解及其向高阶张量的泛化，来发现数据集中的结构并解决预测问题。

当开始动手尝试并在真实数据集上应用了有效的机器学习模型，你会更倾向于学习更多数学。

因此，这一节到此结束，本书将在后面介绍更多数学知识。

如果渴望了解有关线性代数的更多信息，可以参考线性代数运算的在线附录或其他优秀资源 :cite:Strang.1993,Kolter.2008,Petersen.Pedersen.ea.2008。

小结

标量、向量、矩阵和张量是线性代数中的基本数学对象。
向量泛化自标量，矩阵泛化自向量。
标量、向量、矩阵和张量分别具有零、一、二和任意数量的轴。
一个张量可以通过sum和mean沿指定的轴降低维度。
两个矩阵的按元素乘法被称为他们的Hadamard积。它与矩阵乘法不同。
在深度学习中，我们经常使用范数，如 L 1 L_1 L1范数、 L 2 L_2 L2范数和Frobenius范数。
我们可以对标量、向量、矩阵和张量执行各种操作。

练习

证明一个矩阵 A \mathbf{A} A的转置的转置是 A \mathbf{A} A，即 ( A ⊤ ) ⊤ = A (\mathbf{A}^\top)^\top = \mathbf{A} (A⊤)⊤=A。
给出两个矩阵 A \mathbf{A} A和 B \mathbf{B} B，证明"它们转置的和"等于"它们和的转置"，即 A ⊤ + B ⊤ = ( A + B ) ⊤ \mathbf{A}^\top + \mathbf{B}^\top = (\mathbf{A} + \mathbf{B})^\top A⊤+B⊤=(A+B)⊤。
给定任意方阵 A \mathbf{A} A， A + A ⊤ \mathbf{A} + \mathbf{A}^\top A+A⊤总是对称的吗?为什么?
本节中定义了形状 ( 2 , 3 , 4 ) (2,3,4) (2,3,4)的张量X。len(X)的输出结果是什么？
对于任意形状的张量X,len(X)是否总是对应于X特定轴的长度?这个轴是什么?
运行A/A.sum(axis=1)，看看会发生什么。请分析一下原因？
考虑一个具有形状 ( 2 , 3 , 4 ) (2,3,4) (2,3,4)的张量，在轴0、1、2上的求和输出是什么形状?
为linalg.norm函数提供3个或更多轴的张量，并观察其输出。对于任意形状的张量这个函数计算得到什么?

:begin_tab:mxnet
Discussions

:end_tab:

:begin_tab:pytorch
Discussions

:end_tab:

:begin_tab:tensorflow
Discussions

:end_tab:

:begin_tab:paddle
Discussions

:end_tab: