当前位置：首页 > news >正文

2025-04-18 李沐深度学习3 —— 线性代数

news 2025/4/26 21:27:02

文章目录

1 线性代数
- 1.1 标量、向量与矩阵
- 1.2 矩阵概念
- 1.3 按特定轴求和
2 实战：线性代数
- 2.1 标量
- 2.2 向量
- 2.3 矩阵
- 2.4 张量
- 2.5 降维
- 2.6 点积
- 2.7 矩阵-向量积
- 2.8 矩阵-矩阵乘法
- 2.9 范数
- 2.10 练习

1 线性代数

1.1 标量、向量与矩阵

标量（Scalar）

定义：单个数值（如 $a = 3$ ），是 0 维张量。
运算规则：
- 加减乘除： $c = a + b$ 。
- 绝对值（长度）： $∣ a ∣$ ，满足三角不等式 $∣ a + b ∣ \leq ∣ a ∣ + ∣ b ∣$ 。

向量（Vector）

定义：一维数组（如 $[1, 2, 3]$ ），是 1 维张量。
操作：
- 按元素运算： $c = a + b$ （ $c_i = a_i + b_i$ ）。
- 标量乘法： $c = α \cdot b$ （ $c_i = α·b_i$ ）。
- 向量长度（L2 范数）： $\sqrt{(∑a_i²)}$ 。
- 点积（内积）： $a·b = ∑a_i·b_i$ ，正交时 $a \cdot b = 0$ 。
几何意义：
- 向量加法：平行四边形法则（如图，蓝 + 黄 = 绿向量）
- 标量乘法：向量缩放（拉伸或压缩）

矩阵（Matrix）

定义：二维数组（如 $[[1, 2], [3, 4]]$ ），是 2 维张量。
核心运算：
- 按元素运算：同向量（如 $C = A + B$ ）。
- 矩阵乘法： $C = A \cdot B$ 。（行乘列内积）
  - 几何意义：空间线性变换（扭曲空间，如旋转/缩放）。
  - 示例：若 $A$ 将蓝/绿向量映射为新方向，则 $A$ 代表该变换。
- 转置： $A^T$ （行列互换），对称矩阵满足 $A = A^T$ 。

1.2 矩阵概念

范数（Norm）

向量范数：L2 范数（欧氏距离）最常用。
矩阵范数：
- Frobenius范数： $||A||_{Fro} = \sqrt{(∑∑A_ij²)}$ （类似向量 L2 范数）
诱导范数：最小化 $∣∣ A \cdot x ∣∣/∣∣ x ∣∣$ （用于理论分析）

特殊矩阵

类型	定义	深度学习应用
对称矩阵	$A = A^T$	参数优化（如 Hessian 矩阵）
正交矩阵	$U·U^T = I$ （行/列正交）	初始化（避免梯度消失/爆炸）
置换矩阵	每行/列只有一个 1，其余为 0	数据重排（如 ShuffleNet）

特征分解

特征向量/值： $A \cdot v = λ \cdot v$ （ $v$ 方向不变，仅缩放 $λ$ 倍）
意义：
- 对称矩阵总能特征分解（PCA 降维基础）
- 非对称矩阵可能无实数特征值（需复数域分析）

1.3 按特定轴求和

张量 shape 属性

描述张量在每个维度的长度，例如shape=[5,4]表示 5 行 4 列的矩阵。
轴编号：从 0 开始，axis=0对应第一个维度（行），axis=1对应第二个维度（列）。

沿轴求和

操作定义：沿指定轴对元素求和，结果会消除该轴（除非设置keepdims=True）。
几何意义：
- axis=0：将每一列压缩为一个值（纵向压缩）。
- axis=1：将每一行压缩为一个值（横向压缩）。

2 实战：线性代数

2.1 标量

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

import torchx = torch.tensor(3.0)
y = torch.tensor(2.0)x + y, x * y, x / y, x**y

2.2 向量

向量可以被视为标量值组成的列表。这些标量值被称为向量的元素（element）或分量（component）。

在数学表示法中，向量通常记为粗体、小写的符号（例如， $\mathbf{x}$ 、 $\mathbf{y}$ 和 $\mathbf{z}$ ）。

x = torch.arange(4)
x

在数学中，向量 $\mathbf{x}$ 可以写为：

$\mathbf{x} =\begin{bmatrix}x_{1} \\x_{2} \\ \vdots \\x_{n}\end{bmatrix}$
其中 $x_1,\ldots,x_n$ 是向量的元素。在代码中，我们通过张量的索引来访问任一元素。

注意，元素 $x_i$ 是一个标量，所以我们在引用它时不会加粗。

x[3]

长度、维度和形状

长度

向量中元素的个数。
形状

是一个元素组，列出了张量沿每个轴的长度（维数）。对于只有一个轴的张量，形状只有一个元素。
维度

在不同上下文时往往会有不同的含义，这经常会使人感到困惑。为了清楚起见，我们在此明确一下：
- 向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量。
- 张量的维度用来表示张量具有的轴数。
在这个意义上，张量的某个轴的维数就是这个轴的长度。

在数学表示法中，如果我们想说一个向量 $\mathbf{x}$ 由 $n$ 个实值标量组成，可以将其表示为 $\mathbf{x}\in\mathbb{R}^n$ 。
向量的长度通常称为向量的维度（dimension）。

len(x), x.shape  # 长度，形状

2.3 矩阵

我们通常用粗体、大写字母来表示矩阵（例如， $\mathbf{X}$ 、 $\mathbf{Y}$ 和 $\mathbf{Z}$ ），在代码中表示为具有两个轴的张量。

数学表示法使用 $\mathbf{A} \in \mathbb{R}^{m \times n}$ 来表示矩阵 $\mathbf{A}$ ，其由 $m$ 行和 $n$ 列的实值标量组成。其中每个元素 $a_{ij}$ 属于第 $i$ 行第 $j$ 列：

$\mathbf{A}=\begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \\ \end{bmatrix}$
对于任意 $\mathbf{A} \in \mathbb{R}^{m \times n}$ ， $\mathbf{A}$ 的形状是（ $m ， n$ ）或 $\times n$ 。当矩阵具有相同数量的行和列时，其形状将变为正方形，因此被称为方阵（square matrix）。

A = torch.arange(20).reshape(5, 4)
A

使用 A.T 访问矩阵 $\mathbf{A}$ 的转置：

A.T

2.4 张量

张量就像向量是标量的推广，矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构。

X = paddle.reshape(paddle.arange(24), (2, 3, 4))
X

任何按元素的一元运算都不会改变其操作数的形状。同样，给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。例如，将两个相同形状的矩阵相加，会在这两个矩阵上执行元素加法。

A = paddle.reshape(paddle.arange(20, dtype=paddle.float32), (5, 4))
B = A.clone()  # 通过分配新内存，将A的一个副本分配给B
A, A + B

两个矩阵的按元素乘法称为 Hadamard 积（Hadamard product，数学符号 $\odot$ ）。

对于矩阵 $\mathbf{B} \in \mathbb{R}^{m \times n}$ ，矩阵 $\mathbf{A}$ 和 $\mathbf{B}$ 的 Hadamard 积为：
$\mathbf{A} \odot \mathbf{B} = \begin{bmatrix} a_{11} b_{11} & a_{12} b_{12} & \dots & a_{1n} b_{1n} \\ a_{21} b_{21} & a_{22} b_{22} & \dots & a_{2n} b_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} b_{m1} & a_{m2} b_{m2} & \dots & a_{mn} b_{mn} \end{bmatrix}$

A * B

将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘。

a = 2
X = paddle.reshape(paddle.arange(24), (2, 3, 4))
a + X, (a * X).shape

2.5 降维

在代码中调用计算求和的函数：

x = torch.arange(4, dtype=torch.float32)
x, x.sum()

我们可以表示任意形状张量的元素和。例如，矩阵 $\mathbf{A}$ 中元素的和可以记为 $\sum_{i=1}^{m} \sum_{j=1}^{n} a_{ij}$ 。

A.shape, A.sum()

默认情况下，调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量。我们还可以指定张量沿哪一个轴来通过求和降低维度。

以矩阵为例，为了通过求和所有行的元素来降维（轴 0），可以在调用函数时指定axis=0。
由于输入矩阵沿 0 轴降维以生成输出向量，因此输入轴 0 的维数在输出形状中消失。

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

沿着行和列对矩阵求和，等价于对矩阵的所有元素进行求和。

A.sum(axis=[0, 1])  # 结果和A.sum()相同

一个与求和相关的量是平均值（mean 或 average）。通过将总和除以元素总数来计算平均值。在代码中，我们可以调用函数来计算任意形状张量的平均值。

A.mean(), A.sum() / A.numel()  # 等价

非降维求和

有时在调用函数来计算总和或均值时保持轴数不变会很有用。

sum_A = A.sum(axis=1, keepdims=True)
sum_A

例如，由于sum_A在对每行进行求和后仍保持两个轴，我们可以通过广播将A除以sum_A。

A / sum_A

如果我们想沿某个轴计算A元素的累积总和，比如axis=0（按行计算），可以调用cumsum函数。此函数不会沿任何轴降低输入张量的维度。

A.cumsum(axis=0)

2.6 点积

给定两个向量 $\mathbf{x},\mathbf{y}\in\mathbb{R}^d$ ，它们的点积（dot product） $\mathbf{x}^\top\mathbf{y}$ （或 $\langle\mathbf{x},\mathbf{y}\rangle$ ）是相同位置的按元素乘积的和： $\mathbf{x}^\top \mathbf{y} = \sum_{i=1}^{d} x_i y_i$ 。

y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)

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

torch.sum(x * y)

2.7 矩阵-向量积

回顾分别矩阵 $\mathbf{A} \in \mathbb{R}^{m \times n}$ 和向量 $\mathbf{x} \in \mathbb{R}^n$ ，将矩阵 $\mathbf{A}$ 用它的行向量表示：

$\mathbf{A}= \begin{bmatrix} \mathbf{a}^\top_{1} \\ \mathbf{a}^\top_{2} \\ \vdots \\ \mathbf{a}^\top_m \\ \end{bmatrix}$

其中每个 $\mathbf{a}^\top_{i} \in \mathbb{R}^n$ 都是行向量，表示矩阵的第 $i$ 行。
矩阵向量积 $\mathbf{A}\mathbf{x}$ 是一个长度为 $m$ 的列向量，其第 $i$ 个元素是点积 $\mathbf{a}^\top_i \mathbf{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}$

我们可以把一个矩阵 $\mathbf{A} \in \mathbb{R}^{m \times n}$ 乘法看作一个从 $\mathbb{R}^{n}$ 到 $\mathbb{R}^{m}$ 向量的转换。

通常，使用矩阵-向量积来描述在给定前一层的值时，求解神经网络每一层所需的复杂计算。

A.shape, x.shape, torch.mv(A, x)

2.8 矩阵-矩阵乘法

假设有两个矩阵 $\mathbf{A} \in \mathbb{R}^{n \times k}$ 和 $\mathbf{B} \in \mathbb{R}^{k \times 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}$
用行向量 $\mathbf{a}^\top_{i} \in \mathbb{R}^k$ 表示矩阵 $\mathbf{A}$ 的第 $i$ 行，并让列向量 $\mathbf{b}_{j} \in \mathbb{R}^k$ 作为矩阵 $\mathbf{B}$ 的第 $j$ 列。要生成矩阵积 $\mathbf{C} = \mathbf{A}\mathbf{B}$ ，最简单的方法是考虑 $\mathbf{A}$ 的行向量和 $\mathbf{B}$ 的列向量:

$\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}$

当我们简单地将每个元素 $c_{ij}$ 计算为点积 $\mathbf{a}^\top_i \mathbf{b}_j$ :

$\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}$

可以将矩阵-矩阵乘法 $\mathbf{AB}$ 看作执行 $m$ 次矩阵-向量积，并将结果拼接在一起，形成一个 $\times m$ 矩阵。
在下面的代码中，我们在A和B上执行矩阵乘法。这里的A是一个 5 行 4 列的矩阵，B是一个 4 行 3 列的矩阵。两者相乘后，我们得到了一个 5 行 3 列的矩阵。

B = torch.ones(4, 3)
torch.mm(A, B)

2.9 范数

向量的范数表示一个向量有多大。这里考虑的大小（size）概念不涉及维度，而是分量的大小。在线性代数中，向量范数是将向量映射到标量的函数 $f$ 。
给定任意向量 $\mathbf{x}$ ，向量范数要满足一些属性：

如果按常数因子 $\alpha$ 缩放向量的所有元素，其范数也会按相同常数因子的绝对值缩放：
$f(\alpha \mathbf{x}) = |\alpha| f(\mathbf{x})$
满足三角不等式:
$f(\mathbf{x} + \mathbf{y}) \leq f(\mathbf{x}) + f(\mathbf{y})$
范数必须是非负的:
$f(\mathbf{x}) \geq 0$
因为在大多数情况下，任何东西的最小的大小是 0。
要求范数最小为 0，当且仅当向量全由 0 组成：
$\forall i, [\mathbf{x}]_i = 0 \Leftrightarrow f(\mathbf{x})=0$

范数很像距离的度量。

$L_2$ 范数
假设 $n$ 维向量 $\mathbf{x}$ 中的元素是 $x_1,\ldots,x_n$ ，其 $L_2$ 范数是向量元素平方和的平方根：
$\|\mathbf{x}\|_2 = \sqrt{\sum_{i=1}^n x_i^2},$
其中，在 $L_2$ 范数中常常省略下标 $2$ ，即 $\|\mathbf{x}\|$ 等同于 $\|\mathbf{x}\|_2$ 。

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

u = torch.tensor([3.0, -4.0])
torch.norm(u)

$L_1$ 范数

$L_1$ 范数将绝对值函数和按元素求和组合起来。
$\|\mathbf{x}\|_1 = \sum_{i=1}^n \left|x_i \right|$
$L_1$ 范数受异常值的影响较小。

torch.abs(u).sum()

Frobenius 范数（Frobenius norm）

矩阵 $\mathbf{X} \in \mathbb{R}^{m \times n}$ 的 Frobenius 范数是矩阵元素平方和的平方根：

$\|\mathbf{X}\|_F = \sqrt{\sum_{i=1}^m \sum_{j=1}^n x_{ij}^2}$
Frobenius 范数满足向量范数的所有性质，它就像是矩阵形向量的 $L_2$ 范数。

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

torch.norm(torch.ones((4, 9)))

2.10 练习

证明一个矩阵 $\mathbf{A}$ 的转置的转置是 $\mathbf{A}$ ，即 $(\mathbf{A}^\top)^\top = \mathbf{A}$ 。
```
 A.T.T == A
```
给出两个矩阵 $\mathbf{A}$ 和 $\mathbf{B}$ ，证明“它们转置的和”等于“它们和的转置”，即 $\mathbf{A}^\top + \mathbf{B}^\top = (\mathbf{A} + \mathbf{B})^\top$ 。
```
 A = torch.arange(20).reshape(5, 4)B = torch.arange(20).reshape(5, 4) + 1A.T + B.T, (A + B).T
```
给定任意方阵 $\mathbf{A}$ ， $\mathbf{A} + \mathbf{A}^\top$ 总是对称的吗?为什么?

答：是的。由前两问可知， $(\mathbf{A}+\mathbf{A}^T)^T = \mathbf{A}^T+(\mathbf{A}^T)^T=\mathbf{A}^T+\mathbf{A}$ ，且矩阵加法满足交换律。
$\mathbf{A}+\mathbf{A}^T=\begin{bmatrix} a_{11}+ a_{11} & a_{12}+ a_{21} & \cdots & a_{1n}+ a_{n1} \\ a_{21}+ a_{12} & a_{22}+ a_{22} & \cdots & a_{2n}+ a_{n2} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1}+ a_{1n} & a_{n2}+ a_{n2} & \cdots & a_{nk}+ a_{nn} \\ \end{bmatrix}$
本节中定义了形状 $(2, 3, 4)$ 的张量X。len(X)的输出结果是什么？
```
len(X), X.shape
```
对于任意形状的张量X,len(X)是否总是对应于X特定轴的长度?这个轴是什么?

答：是的，总是对应轴 0 的长度。
```
X1 = torch.ones(4)
X2 = torch.ones(3, 3)
X3 = torch.ones(2, 3, 4)len(X1), len(X2), len(X3)
```
运行A/A.sum(axis=1)，看看会发生什么。请分析一下原因？

答：发生报错，因为长度 4 和 5 不匹配。

考虑一个具有形状 $(2, 3, 4)$ 的张量，在轴 0、1、2 上的求和输出是什么形状?

sum_axis_0 = X3.sum(axis=0)
sum_axis_1 = X3.sum(axis=1)
sum_axis_2 = X3.sum(axis=2)sum_axis_0.shape, sum_axis_1.shape, sum_axis_2.shape

为linalg.norm函数提供 3 个或更多轴的张量，并观察其输出。对于任意形状的张量这个函数计算得到什么?

# 创建一个 3D 张量（形状：2x3x4）
x = torch.arange(24, dtype=torch.float32).reshape(2, 3, 4)
print("原始张量:\n", x)# 沿不同轴计算 L2 范数
norm_dim0 = torch.linalg.norm(x, dim=0)  # 沿第0轴（2消失）
norm_dim1 = torch.linalg.norm(x, dim=1)  # 沿第1轴（3消失）
norm_dim2 = torch.linalg.norm(x, dim=2)  # 沿第2轴（4消失）
norm_dims = torch.linalg.norm(x, dim=(1, 2))  # 沿第1和第2轴（3和4消失）print("\n沿 dim=0 的范数（形状 3x4）:\n", norm_dim0)
print("\n沿 dim=1 的范数（形状 2x4）:\n", norm_dim1)
print("\n沿 dim=2 的范数（形状 2x3）:\n", norm_dim2)
print("\n沿 dim=(1,2) 的范数（形状 2）:\n", norm_dims)