1. 为什么学 AI 必须懂线性代数
很多人学 AI 的时候,上来就学 PyTorch、调模型、跑训练。结果一遇到梯度爆炸、维度不匹配、模型不收敛,就懵了。根本原因往往是:线性代数没学好。
一个类比
学 AI 不懂线性代数,就像学做菜不懂火候。你可以照着菜谱一步步来,但盐放多了不知道为什么咸,火开大了不知道为什么糊。只有理解了火候,你才能真正掌控菜品。
线性代数就是 AI 的"火候"——它决定了你是在用 AI,还是在理解 AI。
AI 中到处都是矩阵和向量
打开任何一个深度学习框架的代码,你会发现到处都是矩阵运算:
输入数据
一张图片 = 一个矩阵——28×28 的灰度图就是一个 28×28 的矩阵,每个元素是 0-255 的像素值。彩色图是 3 个矩阵叠加(RGB 三通道)。
模型权重
一层神经网络 = 一个矩阵——一个有 784 个输入和 128 个输出的全连接层,本质上就是一个 784×128 的矩阵。训练就是在调整这个矩阵里的数字。
前向传播
推理过程 = 矩阵乘法——输入向量 × 权重矩阵 + 偏置向量 = 输出向量。每一层都是这样,整个网络就是一连串的矩阵乘法。
反向传播
训练过程 = 矩阵求导——计算损失函数对每个权重的梯度,本质就是矩阵微积分。不懂矩阵求导,就无法理解梯度下降在做什么。
词向量
一个词 = 一个向量——"国王"是 [0.2, 0.8, -0.1, ...],"王后"是 [0.3, 0.7, -0.2, ...]。意思相近的词,向量也相近。这就是 Word2Vec 和 GPT 的基础。
不懂线性代数会怎样
| 场景 | 不懂线性代数 | 懂线性代数 |
| 维度报错 | 看不懂 error,瞎试 reshape | 立刻知道哪个矩阵维度不匹配 |
| 梯度爆炸 | 不知道为什么 loss 变 NaN | 理解条件数和数值稳定性,知道怎么修 |
| 模型不收敛 | 无脑加 epoch、换 optimizer | 从权重矩阵的特征值分析问题 |
| PCA 降维 | 调包侠,不知道在干什么 | 理解特征值分解的几何意义 |
| Transformer | 知道 Q、K、V 三个字母 | 理解为什么注意力是 softmax(QKᵀ/√d)V |
| LoRA 微调 | 照着教程抄参数 | 理解低秩分解为什么有效 |
好消息:你不需要成为数学家
AI 工程师需要的线性代数,和数学专业的侧重点不同。你不需要证明定理,不需要推导公式。你需要的是:直觉(这个操作在几何上是什么意思)+ 应用(它在 AI 里怎么用)+ 动手(用 NumPy 能跑通)。这本教程就是按这个思路写的。
学习路线建议
1
第 1-6 章:基础运算——向量、矩阵、方程组、行列式、逆矩阵。这些是所有后续内容的地基。大概需要 1-2 周。
2
第 7-12 章:核心概念——向量空间、特征值、矩阵分解、SVD、正交性、线性变换。这些是理解 AI 算法的关键。大概需要 2-3 周。
3
第 13-18 章:AI 专题——范数、正定矩阵、概率、矩阵微积分、张量、数值问题。这些直接对接深度学习。大概需要 2 周。
4
第 19 章:动手实战——用 NumPy 把前面学的全部跑一遍。做完了,线性代数就真正内化了。
2. 向量 — AI 世界的基本粒子
向量是线性代数最基本的元素,也是 AI 中数据的基本表示形式。一张图片、一段文字、一个用户画像,在计算机里都是向量。
一个类比
想象你站在地图上的某个点。要描述你的位置,你需要说"往东走 3 公里,往北走 5 公里"。这两个数字合在一起 (3, 5) 就是一个二维向量——它既有大小(走了多远),又有方向(往哪走)。
向量的数学定义
一个 n 维向量就是 n 个数字排成一列(或一行):
v = [v₁, v₂, v₃, ..., vₙ]ᵀ = (v₁, v₂, v₃, ..., vₙ)
比如三维空间中的一个点 (2, 3, 1) 就是一个三维向量。在 AI 中,向量的维度可能是几百甚至几千——GPT 的词向量通常是 768 维或 1536 维。
列向量 vs 行向量
约定俗成:向量默认是列向量(竖着排)。写成行的形式时,用转置符号 T 表示:v = [1, 2, 3]ᵀ 表示这是一个列向量。在代码里,NumPy 不严格区分,但数学公式里要注意。
向量加法和数乘
两种最基本的向量运算:
1
向量加法——对应分量相加。[1, 2] + [3, 4] = [4, 6]。几何意义:把两个箭头首尾相连,从第一个的起点指向第二个的终点。
2
数乘(标量乘法)——每个分量乘以同一个数。2 × [1, 2] = [2, 4]。几何意义:把向量拉伸(或压缩)。乘以负数会翻转方向。
类比:走路
加法 = 你先往东走 1 步、往北走 2 步,再往东走 3 步、往北走 4 步。最终你往东走了 4 步、往北走了 6 步。
数乘 = 你原来往东走 1 步,现在走 2 倍,就变成往东走 2 步。方向不变,距离变了。
向量的模(长度)
向量的"长度"叫模(也叫 L2 范数),用勾股定理计算:
‖v‖ = √(v₁² + v₂² + ... + vₙ²)
比如 [3, 4] 的模 = √(9 + 16) = √25 = 5。几何上就是从原点到这个点的直线距离。
归一化:让向量变成"方向"
把一个向量除以它的模,就得到一个单位向量(长度为 1 的向量):
v̂ = v / ‖v‖
归一化保留了向量的方向,但去掉了大小。这在 AI 中非常重要——当你只关心方向(比如两个词向量的方向是否相似)而不关心大小时,就需要归一化。
AI 应用:为什么 Transformer 要除以 √d
Transformer 的注意力公式中有一个 / √d_k,本质上就是在做一种近似归一化——防止向量的点积过大导致 softmax 输出极端化(全变成 0 或 1)。
点积(内积):相似度的度量
点积是 AI 中最常用的向量运算之一。两个向量的点积定义为:
u · v = u₁v₁ + u₂v₂ + ... + uₙvₙ = ‖u‖ ‖v‖ cos θ
其中 θ 是两个向量之间的夹角。这个公式告诉我们一个关键信息:
θ = 0°
方向完全相同——cos θ = 1,点积最大。两个向量"完全一致"。
θ = 90°
互相垂直——cos θ = 0,点积为零。两个向量"毫无关系"。
θ = 180°
方向完全相反——cos θ = -1,点积最小(负值最大)。两个向量"完全对立"。
类比:投票
两个人对同一个问题的看法可以用向量表示。点积就像"共识度"——方向越一致,共识越高(点积越大);方向越相反,分歧越大(点积越小);垂直就是"无所谓"。
余弦相似度:去掉长度影响的点积
点积有一个问题:它受向量长度的影响。一个很长的向量和一个很短的向量,即使方向完全不同,点积也可能很大。
余弦相似度解决了这个问题——只看方向,不看长度:
cosine(u, v) = (u · v) / (‖u‖ ‖v‖)
余弦相似度的值域是 [-1, 1]:1 表示完全相同,0 表示无关,-1 表示完全相反。
AI 应用:向量数据库检索
当你用向量数据库(如 Pinecone、Milvus)搜索"和这句话最相似的文档"时,底层做的就是余弦相似度计算——把查询和每个文档都表示为向量,然后计算余弦相似度,返回最相似的 top-k 个。
Word2Vec 的经典例子:vector("国王") - vector("男人") + vector("女人") ≈ vector("王后")。这就是向量运算在语义空间中的魔力。
向量在 AI 中的表示
| 数据类型 | 怎么变成向量 | 维度 |
| 一张 28×28 灰度图 | 把 784 个像素值排成一列 | 784 维 |
| 一个英文单词 | Word2Vec / GloVe 编码 | 300 维 |
| 一句话(BERT) | Transformer 最后一层的 [CLS] token | 768 维 |
| 一段文本(GPT) | 最后一个 token 的隐藏状态 | 1536 维 |
| 一个用户 | 年龄、收入、消费习惯等特征 | 几十到几百维 |
| 一个商品 | 价格、类别、评分等特征 | 几十到几百维 |
💡 思考题- 两个向量的点积为零,说明什么几何关系?
- 归一化后的向量有什么特殊性质?它的模是多少?
✏️ 计算练习- 给定向量 v = [3, 4, 0] 和 u = [1, 0, 1]:(a) 求点积 v·u (b) 求夹角余弦 (c) 将 v 归一化为单位向量
💻 代码练习- 用 NumPy 实现一个向量归一化函数 normalize(v),输入任意维度向量,返回单位向量。验证 normalize([3,4]) = [0.6, 0.8]
3. 矩阵 — AI 的核心运算单元
如果说向量是 AI 的"原子",那矩阵就是 AI 的"分子"。神经网络的每一层权重是一个矩阵,前向传播的核心运算是矩阵乘法,训练的本质是调整矩阵中的数字。
一个类比
向量是一个学生的成绩单(各科分数排成一列)。矩阵是整个班级的成绩表——每个学生一列,每个科目一行。矩阵的每个元素 aᵢⱼ 表示第 i 个科目的第 j 个学生的分数。
矩阵的基本概念
一个 m × n 矩阵有 m 行 n 列,共 m×n 个元素:
A = [aᵢⱼ] = | a₁₁ a₁₂ ... a₁ₙ |
| a₂₁ a₂₂ ... a₂ₙ |
| ... |
| aₘ₁ aₘ₂ ... aₘₙ |
几个重要术语:
- 方阵——行数等于列数(m = n)。神经网络中正方形的权重矩阵就是方阵。
- 对角矩阵——只有对角线上有非零元素。单位矩阵 I 是特殊的对角矩阵(对角线全是 1)。
- 对称矩阵——A = Aᵀ,即 aᵢⱼ = aⱼᵢ。协方差矩阵就是对称矩阵。
- 零矩阵——所有元素都是 0。
矩阵转置
转置就是把矩阵的行和列互换:Aᵀ 的第 i 行第 j 列等于 A 的第 j 行第 i 列。
如果 A = | 1 2 3 |
| 4 5 6 |
则 Aᵀ = | 1 4 |
| 2 5 |
| 3 6 |
几何直觉:转置就是沿着对角线"翻转"矩阵。在 AI 中,权重矩阵的转置在反向传播中频繁出现。
矩阵加法和数乘
和向量类似:
- 加法——对应元素相加。两个矩阵必须同型(行数和列数都相同)。
- 数乘——每个元素乘以同一个标量。
矩阵乘法:AI 中最重要的运算
矩阵乘法是 AI 中出现频率最高的运算。一个 m×k 矩阵 A 和一个 k×n 矩阵 B 相乘,得到一个 m×n 矩阵 C:
C = AB, 其中 cᵢⱼ = Σₖ aᵢₖ × bₖⱼ (k 从 1 到 A 的列数,即 B 的行数)
简单说:C 的第 i 行第 j 列 = A 的第 i 行和 B 的第 j 列的点积。
关键:矩阵乘法不满足交换律!
AB ≠ BA(一般情况下)。这是初学者最容易犯的错误。矩阵乘法的顺序很重要——先 A 再 B 和先 B 再 A,结果完全不同。在神经网络中,W₂(W₁x) 和 W₁(W₂x) 是不同的网络。
类比:变换的叠加
矩阵乘法就像变换的叠加。先旋转(矩阵 A),再缩放(矩阵 B),和先缩放再旋转,结果当然不同——你把一张照片先旋转 45° 再放大 2 倍,和先放大 2 倍再旋转 45°,效果不一样。
矩阵乘法的计算过程
1
取 A 的第 i 行——比如第 1 行 [1, 2]
2
取 B 的第 j 列——比如第 1 列 [5, 7]ᵀ
3
做点积——1×5 + 2×7 = 19。这就是 C 的第 1 行第 1 列。
4
重复——对所有 (i, j) 组合都做一遍。m×n 个元素,每个要做 k 次乘法和 k-1 次加法。
计算复杂度
两个 n×n 矩阵相乘,朴素算法的复杂度是 O(n³)。对于 AI 中动辄几千维的矩阵,这个开销很大。这就是为什么 GPU 擅长 AI——GPU 有几千个核心,可以并行计算矩阵乘法中的各个元素。
迹(Trace):对角线上的秘密
矩阵的迹是对角线元素之和:
tr(A) = a₁₁ + a₂₂ + a₃₃ + ... + aₙₙ = Σ aᵢᵢ
迹看起来很简单,但在 AI 中非常重要。它有以下性质:
- tr(A) = tr(Aᵀ)——转置不改变迹
- tr(AB) = tr(BA)——矩阵乘法的迹满足交换律(虽然矩阵本身不满足!)
- tr(A) = 所有特征值之和——迹和特征值有直接关系
AI 应用:迹在哪里出现
- 注意力机制——Transformer 中的缩放因子 √d 就是从矩阵维度来的
- KL 散度——两个高斯分布的 KL 散度公式中包含迹运算
- 矩阵微积分——对矩阵求导时,迹是核心工具。比如 ∂tr(AB)/∂A = Bᵀ
- 白化——让协方差矩阵的迹等于维度数
逐元素运算 vs 矩阵乘法:别搞混了
除了矩阵乘法,还有一种常见运算是逐元素运算(Hadamard 积),记作 A ⊙ B 或直接用 * 表示:
(A ⊙ B)ᵢⱼ = aᵢⱼ × bᵢⱼ
就是两个同型矩阵的对应元素相乘。注意:这和矩阵乘法完全不同!
| 矩阵乘法 AB | 逐元素乘法 A ⊙ B |
| 要求 | A 的列数 = B 的行数 | A 和 B 同型 |
| 结果大小 | m×k × k×n → m×n | 和输入一样大 |
| 每个元素 | 一行和一列的点积 | 对应位置直接相乘 |
| 交换律 | 不满足(AB ≠ BA) | 满足(A⊙B = B⊙A) |
逐元素运算在 AI 中用得非常多
- LSTM/GRU 门控——
σ(gate) ⊙ cell_state,门控信号逐元素地"过滤"记忆
- Dropout——
mask * activations,随机把一些神经元的输出变成 0
- Attention mask——把不该看的位置的注意力分数乘以 -∞(实际是乘以 0 再加 -∞)
- 残差连接中的缩放——
α * residual,逐元素缩放残差
神经网络的一层就是一个矩阵乘法
一个全连接层(Linear Layer / Dense Layer)的计算过程:
y = Wx + b
其中:
- x——输入向量(比如 784 维的图片像素)
- W——权重矩阵(比如 128×784,表示 128 个神经元,每个有 784 个权重)
- b——偏置向量(128 维,每个神经元一个偏置)
- y——输出向量(128 维)
把一批 N 个样本同时送入(batch processing),就变成了矩阵乘矩阵:
Y = WX + b (其中 X 的每一列是一个样本)
这就是为什么 GPU 做 AI 训练快——它特别擅长并行计算大规模矩阵乘法。
💡 思考题- 为什么矩阵乘法不满足交换律?用一个几何变换的例子解释。
- 逐元素乘法 A⊙B 和矩阵乘法 AB 的本质区别是什么?
✏️ 计算练习- 已知 A = [[1,2],[3,4]], B = [[5,6],[7,8]],求 AB、BA、A⊙B,并验证 AB ≠ BA
💻 代码练习- 用 Python 循环手动实现矩阵乘法 matmul_manual(A, B),然后用 A @ B 验证结果一致
4. 线性方程组 — 从方程到矩阵
线性方程组是线性代数的起点,也是理解"矩阵在解什么问题"的关键。AI 中的很多问题最终都可以归结为解线性方程组。
一个类比
你去水果店买了苹果和橘子。苹果 3 块一斤,橘子 2 块一斤。你一共花了 13 块,买了 5 斤。列方程:
3x + 2y = 13(总花费)
x + y = 5(总重量)
这就是一个二元一次方程组。用矩阵写出来就是:
| 3 2 | | x | | 13 |
| 1 1 | | y | = | 5 |
简写为 Ax = b。
矩阵形式 Ax = b
任何线性方程组都可以写成 Ax = b 的形式:
- A——系数矩阵(m×n),每一行是一个方程,每一列是一个变量的系数
- x——未知数向量(n×1),我们要求解的量
- b——常数向量(m×1),方程右边的已知数
高斯消元法:手算解方程
高斯消元法的核心思想是:通过行变换,把方程组变成上三角形式,然后从下往上逐个求解。
1
构造增广矩阵——把 A 和 b 合在一起写:[A | b]。比如 [3 2 | 13; 1 1 | 5]。
2
消元——用第一行消去下面行的第一个元素。用第二行消去下面行的第二个元素……直到变成上三角。
3
回代——从最后一行开始,逐个求出每个未知数。最后一行只有一个未知数,倒数第二行有两个……
允许的三种行变换
- 交换两行
- 某一行乘以非零常数
- 某一行加上另一行的倍数
这三种变换不会改变方程组的解。
解的存在性和唯一性
一个方程组可能有三种情况:
唯一解
方程组"恰好"够用——消元后得到一个漂亮的上三角,每个变量都能确定。对应矩阵 A 是满秩的。
无穷多解
方程组"不够用"——消元后某些行全为 0(出现了自由变量)。对应矩阵 A 不满秩。解空间是一个子空间。
无解
方程组"自相矛盾"——消元后出现了 0 = 非零 的行。方程之间互相矛盾。比如 x + y = 3 和 x + y = 5。
AI 应用:最小二乘法
当方程组无解时(现实中数据有噪声,经常无解),我们找一个"最接近"的解——使得 ‖Ax - b‖² 最小。这就是最小二乘法,线性回归的基础。解为:
x = (AᵀA)⁻¹Aᵀb
这个公式在统计学和机器学习中无处不在。
线性方程组的几何意义
每个线性方程在几何上对应一个超平面。解方程组就是找这些超平面的交点:
- 两个方程、两个未知数 → 两条直线的交点
- 三个方程、三个未知数 → 三个平面的交点
- n 个方程、n 个未知数 → n 个超平面的交点
如果这些超平面恰好交于一点,就有唯一解。如果它们互相平行或重合,就无解或无穷多解。
矩阵的秩与方程组解的关系
矩阵的秩(Rank)决定了方程组解的情况:
rank(A) = rank([A|b]) = n
唯一解——方程组恰好有 n 个独立方程,能唯一确定 n 个未知数。
rank(A) = rank([A|b]) < n
无穷多解——方程组有冗余(自由变量),解空间是一个 (n - rank) 维的子空间。
rank(A) < rank([A|b])
无解——方程组自相矛盾。增广矩阵引入了新的"方向",原方程组无法覆盖。
Rouché–Capelli 定理
线性方程组 Ax = b 有解 ⟺ rank(A) = rank([A|b])。如果有解,解的个数 = n - rank(A) 个自由变量决定的无穷多个。这个定理把方程组的可解性和矩阵的秩直接联系起来了。
完整手算示例
解方程组:
2x + y - z = 8
-3x - y + 2z = -11
-2x + y + 2z = -3
1
写增广矩阵——[A|b] = [2,1,-1,8; -3,-1,2,-11; -2,1,2,-3]
2
R₂ ← R₂ + 1.5R₁——[2,1,-1,8; 0,0.5,0.5,1; -2,1,2,-3]。消去第二行第一个元素。
3
R₃ ← R₃ + R₁——[2,1,-1,8; 0,0.5,0.5,1; 0,2,1,5]。消去第三行第一个元素。
4
R₃ ← R₃ - 4R₂——[2,1,-1,8; 0,0.5,0.5,1; 0,0,-1,1]。消去第三行第二个元素,得到上三角。
5
回代——从第三行:-z=1 → z=-1。代入第二行:0.5y+0.5(-1)=1 → y=3。代入第一行:2x+3-(-1)=8 → x=2。
AI 应用:批量推理的矩阵形式
当你需要同时推理 N 个样本时,不需要写循环。把 N 个输入向量排成矩阵 X(每列一个样本),一次矩阵乘法 WX + b 就能得到所有结果。这就是 batch processing 的数学本质——把 N 个方程组合并成一个矩阵方程。
代码示例:
X = np.random.randn(784, 32) # 32个样本,每个784维
W = np.random.randn(128, 784) # 权重矩阵
Y = W @ X + b[:, np.newaxis] # 一次算完32个样本
齐次方程组 Ax = 0 的特殊意义
当 b = 0 时,方程组变成 Ax = 0。这个方程组总是有解(x = 0 是平凡解)。我们更关心的是非零解:
- 如果 rank(A) = n(列满秩),只有零解——矩阵没有"塌缩"
- 如果 rank(A) < n,有无穷多非零解——解空间是零空间(Null Space)
零空间在 AI 中的意义
权重矩阵 W 的零空间是被它"压缩掉"的方向——输入在这些方向上的变化不会影响输出。如果零空间很大,说明模型丢失了很多输入信息。这就是为什么我们希望权重矩阵是满秩的。
💡 思考题- 什么条件下线性方程组一定无解?用几何直觉解释。
- 矩阵的秩和自由变量有什么关系?
✏️ 计算练习- 用高斯消元法手动求解:x + 2y = 5, 3x + 4y = 11
💻 代码练习- 用 np.linalg.solve 求解一个 3 元一次方程组,验证 Ax = b
5. 行列式 — 矩阵的"体积"
行列式是一个从矩阵中提取出来的单个数字,它包含了关于矩阵的丰富信息。虽然在 AI 中行列式不像矩阵乘法那样频繁出现,但理解它对后续学习特征值、逆矩阵、概率论都至关重要。
一个类比
想象你有一个平行四边形,由两个向量张成。行列式就是这个平行四边形的面积。如果是在三维空间,三个向量张成一个平行六面体,行列式就是它的体积。
如果行列式为零,说明这些向量"塌缩"了——平行四边形变成了一条线,平行六面体变成了一个面。体积为零 = 维度不够。
二阶行列式
2×2 矩阵的行列式:
det(A) = |a b| = ad - bc
|c d|
几何意义:由向量 (a, c) 和 (b, d) 张成的平行四边形的有向面积。
三阶行列式
3×3 矩阵的行列式用"对角线法则"或展开公式计算:
det(A) = a(ei - fh) - b(di - fg) + c(dh - eg)
几何意义:三个向量张成的平行六面体的有向体积。
行列式的关键性质
- det(AB) = det(A) × det(B)——乘积的行列式等于行列式的乘积
- det(Aᵀ) = det(A)——转置不改变行列式
- det(A) = 0 ⟺ A 不可逆——行列式为零意味着矩阵是"奇异"的
- det(A) = 所有特征值的乘积——行列式和特征值有直接关系
- 行列式的绝对值 = 变换的体积缩放因子——矩阵 A 对空间的"拉伸程度"
行列式为零意味着什么?
- 矩阵不可逆(没有逆矩阵)
- 方程组 Ax = b 要么无解,要么无穷多解
- 矩阵的列向量线性相关(某些列可以用其他列表示)
- 矩阵把空间"压缩"到了更低的维度
在 AI 中,如果权重矩阵的行列式接近零,说明模型的某些方向"塌缩"了——信息丢失。
AI 应用:Normalizing Flows 中的行列式
Normalizing Flows 是一种生成模型,它通过一系列可逆变换把简单分布变成复杂分布。变换的雅可比矩阵的行列式决定了概率密度的变化——这就是为什么 Normalizing Flows 需要高效地计算行列式。
行列式的计算方法
二阶行列式:对角线法则
三阶行列式:萨吕法则
把矩阵复制两列放到右边,然后沿对角线求和:
| a₁₁ a₁₂ a₁₃ | a₁₁ a₁₂
| a₂₁ a₂₂ a₂₃ | a₂₁ a₂₂
| a₃₁ a₃₂ a₃₃ | a₃₁ a₃₂
det = (a₁₁a₂₂a₃₃ + a₁₂a₂₃a₃₁ + a₁₃a₂₁a₃₂)
- (a₁₃a₂₂a₃₁ + a₁₂a₂₁a₃₃ + a₁₁a₂₃a₃₂)
高阶行列式:按行/列展开
对于 n×n 矩阵,按第 i 行展开:
det(A) = Σⱼ (-1)^(i+j) × aᵢⱼ × Mᵢⱼ
其中 Mᵢⱼ 是去掉第 i 行第 j 列后的 (n-1)×(n-1) 子矩阵的行列式(余子式)。这就是递归计算——把 n 阶行列式转化为 n 个 n-1 阶行列式。
实际计算建议
手算行列式时,选择零元素最多的行或列展开——零元素对应的项直接跳过,减少计算量。在代码中,np.linalg.det(A) 用 LU 分解计算,复杂度 O(n³),比递归展开快得多。
行列式的几何意义详解
行列式的绝对值代表变换后的"体积缩放因子",符号代表是否翻转了空间的"手性":
det > 0
保持手性——变换后"右手系"还是"右手系"。旋转就属于这种情况。
det < 0
翻转手性——变换后"右手系"变成"左手系"。镜像反射就属于这种情况。
|det| > 1
放大体积——变换后体积变大了。比如 2×2 矩阵的 det=4,面积变成原来的 4 倍。
|det| < 1
缩小体积——变换后体积变小了。比如 det=0.5,面积变成原来的一半。
det = 0
塌缩——空间被压扁到更低维度。3D 变 2D 或 1D。体积为零,不可逆。
行列式的性质详解
| 性质 | 公式 | 直觉解释 |
| 乘法性 | det(AB) = det(A)×det(B) | 两次变换的体积缩放 = 各自缩放的乘积 |
| 转置不变 | det(Aᵀ) = det(A) | 行列互换不影响体积 |
| 行交换变号 | 交换两行 → det 变号 | 翻转了手性(右手变左手) |
| 行倍乘 | 某行乘 k → det 乘 k | 某个方向拉伸 k 倍,体积变 k 倍 |
| 行相加不变 | 某行加上另一行的倍数 → det 不变 | 剪切变换不改变体积(平行六面体底不变高不变) |
| 三角矩阵 | det = 对角线元素之积 | 三角变换 = 各坐标轴独立缩放 |
行列式和特征值的关系
det(A) = λ₁ × λ₂ × ... × λₙ(所有特征值的乘积)。这个关系非常有用:
• det = 0 ⟺ 至少有一个特征值为 0 ⟺ 矩阵不可逆
• det = 1 ⟺ 特征值的乘积为 1(体积不变的变换,如旋转)
• det = -1 ⟺ 手性翻转且体积不变(如镜像反射)
💡 思考题- 行列式为零意味着矩阵的哪些性质?列举至少 3 个。
- 为什么 det(Aᵀ) = det(A)?从几何角度解释。
✏️ 计算练习- 求 det([[2,1],[5,3]]) 和 det([[1,2,3],[0,1,4],[5,6,0]])
💻 代码练习- 用 np.linalg.det 验证上面的手算结果,并生成随机矩阵验证 det(AB) = det(A)×det(B)
6. 逆矩阵 — "除法"的推广
在普通代数中,除法是乘法的逆运算——a × (1/a) = 1。在线性代数中,逆矩阵扮演了类似的角色:A × A⁻¹ = I(单位矩阵)。
一个类比
矩阵 A 代表一个变换(比如旋转 + 缩放)。逆矩阵 A⁻¹ 代表"反变换"——先做 A,再做 A⁻¹,就回到了原点。就像先走 10 步往东,再走 10 步往西,回到原位。
逆矩阵的定义
对于方阵 A,如果存在矩阵 A⁻¹ 使得:
A × A⁻¹ = A⁻¹ × A = I
则 A⁻¹ 是 A 的逆矩阵。
什么矩阵可逆
可逆
det(A) ≠ 0——行列式非零。等价于:A 满秩、列向量线性无关、Ax = b 有唯一解。
不可逆(奇异)
det(A) = 0——行列式为零。矩阵"塌缩"了,信息丢失,无法恢复。就像你把 3D 物体压成 2D,无法从 2D 恢复 3D。
用高斯消元法求逆矩阵
1
构造增广矩阵——[A | I],把 A 和单位矩阵拼在一起。
2
行变换——用高斯消元法把左边变成 I。同时对右边做同样的行变换。
3
得到结果——当左边变成 I 时,右边就变成了 A⁻¹。因为 [A | I] → [I | A⁻¹]。
实际中不要自己算逆矩阵
在 AI 中,我们几乎从不手动求逆矩阵。原因是:
1. 计算复杂度高——O(n³)
2. 数值不稳定——大矩阵求逆容易产生精度问题
3. 有更好的替代——解方程 Ax = b 时,用 LU 分解比求逆更快更稳
但理解逆矩阵的概念很重要——它是很多理论推导的基础。
AI 应用:白化(Whitening)
白化是一种数据预处理技术,把数据变换成均值为 0、协方差为单位矩阵的形式。公式为:
x_white = Σ⁻¹/² (x - μ)
其中 Σ⁻¹/² 是协方差矩阵的"逆平方根"。白化后的数据各维度之间不相关、方差相同,有助于加速训练。
逆矩阵的性质
| 性质 | 公式 | 直觉解释 |
| 逆的逆 | (A⁻¹)⁻¹ = A | "撤销的撤销" = 回到原点 |
| 乘积的逆 | (AB)⁻¹ = B⁻¹A⁻¹ | 先撤销 B,再撤销 A(顺序反转!) |
| 转置的逆 | (Aᵀ)⁻¹ = (A⁻¹)ᵀ | 转置和求逆可交换 |
| 逆的行列式 | det(A⁻¹) = 1/det(A) | 体积缩放因子取倒数 |
| 正交矩阵的逆 | Q⁻¹ = Qᵀ | 正交矩阵的逆 = 转置,计算非常便宜 |
注意:(AB)⁻¹ = B⁻¹A⁻¹,不是 A⁻¹B⁻¹!
矩阵乘法不满足交换律,所以求逆时顺序要反转。类比:穿衣服时先穿衬衫再穿外套,脱衣服时要先脱外套再脱衬衫。
2×2 矩阵的逆公式
对于 2×2 矩阵,有直接公式:
A = | a b |, A⁻¹ = (1/det(A)) × | d -b |
| c d | | -c a |
其中 det(A) = ad - bc。注意:det(A) ≠ 0 时才有逆。
手算示例
A = [3,1;2,4],det = 3×4 - 1×2 = 10
A⁻¹ = (1/10) × [4,-1;-2,3] = [0.4,-0.1;-0.2,0.3]
验证:A × A⁻¹ = [3×0.4+1×(-0.2), 3×(-0.1)+1×0.3; 2×0.4+4×(-0.2), 2×(-0.1)+4×0.3] = [1,0;0,1] = I ✓
伪逆(Pseudoinverse):不可逆时的救星
在 AI 中,我们经常遇到非方阵或奇异矩阵——它们没有传统意义上的逆。这时候用Moore-Penrose 伪逆:
A⁺ = (AᵀA)⁻¹Aᵀ (当 A 的列满秩时)
伪逆是最小二乘解的核心——Ax ≈ b 的最小范数解是 x = A⁺b。
AI 应用:伪逆的用途
- 线性回归——w = (XᵀX)⁻¹Xᵀy 就是用伪逆求解。不需要梯度下降,直接解析解。
- 最小二乘拟合——数据点比参数多时,用伪逆找最佳拟合。
- 超定方程组——方程比未知数多时,用伪逆找"最接近"的解。
在 NumPy 中,
np.linalg.pinv(A) 计算伪逆。
逆矩阵在 AI 中的其他应用
应用 1:自然语言处理中的 TF-IDF
TF-IDF 矩阵的逆可以用来做"反向索引"——给定一个词向量,找到最相关的文档。
应用 2:高斯过程回归
高斯过程需要计算协方差矩阵的逆 K⁻¹ 来做预测。矩阵求逆的复杂度 O(n³) 是高斯过程的主要瓶颈。
应用 3:Fisher 判别分析
LDA(线性判别分析)需要计算类内散度矩阵的逆 S_w⁻¹ 来找最佳投影方向。
💡 思考题- 什么矩阵不可逆?列出等价条件。
- 为什么 (AB)⁻¹ = B⁻¹A⁻¹ 而不是 A⁻¹B⁻¹?
✏️ 计算练习- 用 2×2 逆矩阵公式求 [[3,1],[2,4]] 的逆,并验证 AA⁻¹ = I
💻 代码练习- 用 np.linalg.pinv 计算一个 3×2 矩阵的伪逆,验证 A⁺A ≈ I(列满秩时)
7. 向量空间 — 理解维度和基
前面几章我们一直在做运算。这一章退一步,从更高的视角看:向量住在哪里?向量空间就是向量的"家"——它定义了向量能有多大、能往哪些方向走。
一个类比
你在一张无限大的方格纸上走路。方格纸的每个点可以用 (x, y) 表示。这张方格纸就是一个二维向量空间——所有二维向量的"家"。
如果你在一个球面上走路,那不是向量空间——因为球面上的点不能随意相加(两个球面上的点相加可能不在球面上)。
向量空间的定义
一个向量空间需要满足两个基本操作的封闭性:
- 加法封闭——任意两个向量相加,结果还在空间内
- 数乘封闭——任意向量乘以任意标量,结果还在空间内
最常见的向量空间是 ℝⁿ——所有 n 维实数向量构成的空间。
子空间
向量空间中的一部分,如果它本身也构成向量空间,就叫子空间。比如:
- 三维空间中,过原点的平面是二维子空间
- 三维空间中,过原点的直线是一维子空间
- 原点本身是零维子空间
注意:子空间必须过原点
过原点的平面是子空间,不过原点的平面不是。因为不过原点的平面对数乘不封闭——把平面中的向量乘以 0,得到零向量,零向量不在平面上(除非平面过原点)。
线性无关和基
一组向量是线性无关的,如果没有任何一个向量可以被其他向量的线性组合表示。直觉上说:每个向量都贡献了"新的方向"。
1
线性无关——[1,0] 和 [0,1] 线性无关。你不能用 [1,0] 的倍数得到 [0,1]——它们指向不同方向。
2
线性相关——[1,0]、[0,1] 和 [1,1] 线性相关。因为 [1,1] = [1,0] + [0,1],它是"多余的"。
3
基——一组线性无关的向量,能"张成"整个空间。二维空间的基需要恰好 2 个线性无关的向量。三维空间需要 3 个。n 维空间需要 n 个。
秩(Rank):矩阵包含多少信息
矩阵的秩是它的列向量(或行向量)中线性无关的最大个数。秩告诉我们矩阵"真正"的维度:
满秩
秩 = min(m, n)——矩阵"信息量最大"。列向量全部线性无关。方阵满秩 ⟺ 可逆。
秩亏
秩 < min(m, n)——矩阵有"冗余"。某些列(或行)可以用其他列(行)表示。信息有丢失。
AI 应用:降维的本质
PCA 降维的核心就是找到数据矩阵的"有效秩"——数据虽然有 100 个维度,但真正的信息可能只存在于 10 个方向上(秩为 10)。把数据投影到这 10 个方向上,就是降维。
LoRA 的低秩分解也是这个原理——微调时权重矩阵的变化量是"低秩"的,用两个小矩阵就能近似表示。
零空间和列空间
对于矩阵 A:
- 列空间——A 的列向量张成的空间。就是 Ax 能到达的所有位置。
- 零空间(核)——所有满足 Ax = 0 的向量 x 构成的空间。就是被 A "消灭"的所有方向。
秩 + 零空间的维度 = 列数(秩-零化度定理)。这意味着:矩阵能保留多少信息(秩),就会丢失多少信息(零空间)。
基变换:换个角度看数据
同一个向量在不同基下有不同的坐标。基变换矩阵 P 把旧坐标变成新坐标:
x_new = P⁻¹ x_old
其中 P 的列是新基在旧坐标系下的表示。
例子:旋转坐标系
原来用标准基 [1,0] 和 [0,1]。现在换到旋转 45° 的基 [cos45°, sin45°] 和 [-sin45°, cos45°]。
点 (3,4) 在新基下的坐标 = P⁻¹ × [3,4]ᵀ。这就是坐标变换——同一个点,不同的"语言"描述。
AI 应用:为什么特征值分解是"最佳基变换"
特征值分解 A = PDP⁻¹ 可以理解为:
1. P⁻¹ 把数据变换到特征向量基下(新坐标系)
2. D 在新坐标系下做简单的缩放(每个方向独立缩放)
3. P 变换回原来的坐标系
在特征向量基下,矩阵 A 的行为最简单——每个方向独立,互不干扰。这就是为什么特征向量是矩阵的"骨架"。
维度的直觉理解
维度是向量空间的"自由度"——你需要多少个独立的数字来描述空间中的一个点:
n 维
抽象空间——n 个自由度。AI 中常见 768 维、1536 维。
高维空间的反直觉
在高维空间中,很多低维的直觉不再成立:
• 高维球体的体积集中在"表面"附近
• 高维正态分布的采样点几乎都在"壳"上
• 随机向量几乎两两正交(维度越高越明显)
这就是"维度灾难"——高维空间太"大"了,数据变得极其稀疏。
向量空间在 AI 中的意义
| 概念 | AI 中的对应 | 例子 |
| 向量空间 | 所有可能的输入/输出 | 所有 784 维的图片 |
| 子空间 | 数据实际占据的空间 | MNIST 数字只占 784 维空间的一小部分 |
| 基 | 表示数据的基本模式 | PCA 的主成分、字典学习的原子 |
| 秩 | 数据的有效维度 | 100 维数据可能秩只有 10 |
| 零空间 | 被模型忽略的方向 | 权重矩阵的零空间 = 不影响输出的输入方向 |
💡 思考题- 为什么子空间必须过原点?不过原点的集合为什么不满足向量空间定义?
- 矩阵的秩和列空间的维度有什么关系?
✏️ 计算练习- 判断向量组 {[1,0,1], [0,1,1], [1,1,2]} 是否线性相关
💻 代码练习- 用 np.linalg.matrix_rank 计算不同矩阵的秩,观察秩亏矩阵的特点
8. 特征值与特征向量 — 矩阵的灵魂
特征值和特征向量是线性代数中最重要的概念之一。PCA、谱聚类、PageRank、稳定性分析……无数 AI 和数学问题的核心都是特征值分解。
一个类比
想象你站在一个变形空间里——空间被一个矩阵"扭曲"了。大多数方向在这个扭曲下都会改变方向。但有一些特殊的方向,扭曲只是把它们拉伸或压缩了,方向不变。这些特殊的方向就是特征向量,拉伸的倍数就是特征值。
定义
对于方阵 A,如果存在非零向量 v 和标量 λ,使得:
Av = λv
则 v 是 A 的特征向量,λ 是对应的特征值。
直觉理解:矩阵 A 对向量 v 做变换,结果只是把 v 拉伸了 λ 倍,方向没有变。这说明 v 是 A 的"天然方向"——在这个方向上,A 的行为最简单。
怎么求特征值
1
从 Av = λv 出发——移项得 (A - λI)v = 0。
2
非零解的条件——v ≠ 0 时有解,当且仅当 det(A - λI) = 0。
3
解特征方程——det(A - λI) = 0 是一个关于 λ 的 n 次多项式,解出来就是所有特征值。
4
求特征向量——对每个特征值 λ,解方程 (A - λI)v = 0,得到对应的特征向量。
特征值的几何意义
|λ| > 1
拉伸——在这个方向上,向量被放大了。|λ| 越大,放大越厉害。
|λ| = 1
保持——在这个方向上,向量长度不变(可能是旋转或反射)。
0 < |λ| < 1
压缩——在这个方向上,向量被缩小了。
λ = 0
消灭——在这个方向上,向量被压缩成零。这个方向在零空间中。
λ < 0
翻转——向量方向被反转。负号表示"反向"。
对角化
如果一个 n×n 矩阵 A 有 n 个线性无关的特征向量,它可以被"对角化":
A = PDP⁻¹
其中 D 是对角矩阵(对角线上是特征值),P 的列是对应的特征向量。
对角化的威力在于:对角矩阵的幂很容易计算——对角线元素各自取幂。所以:
Aᵏ = PDᵏP⁻¹
这就把复杂的矩阵幂运算变成了简单的数的幂运算。
AI 应用:PCA 主成分分析
PCA 的核心步骤:
1. 计算数据的协方差矩阵 Σ
2. 对 Σ 做特征值分解
3. 按特征值从大到小排序,取前 k 个特征向量
4. 把数据投影到这 k 个特征向量上
特征值大的方向是数据变化最大的方向(信息量最多),特征值小的方向变化小(可以忽略)。这就是降维的数学原理。
AI 应用:PageRank
Google 的 PageRank 算法本质就是求网页链接矩阵的最大特征值对应的特征向量。特征向量中每个分量的值就是对应网页的"重要性"分数。
AI 应用:训练稳定性
权重矩阵的最大特征值(谱半径)决定了梯度在多层网络中的传播行为。如果最大特征值远大于 1,梯度会指数级增长(梯度爆炸);如果远小于 1,梯度会指数级衰减(梯度消失)。这就是为什么权重初始化和归一化如此重要。
💡 思考题- 特征向量的几何意义是什么?它在矩阵变换下有什么特殊行为?
- 为什么对称矩阵的特征值一定是实数?
✏️ 计算练习- 求矩阵 [[2,1],[1,2]] 的特征值和特征向量,验证 tr(A) = λ₁+λ₂
💻 代码练习- 用 np.linalg.eig 求随机对称矩阵的特征值,验证特征值之和 = 迹,特征值之积 = 行列式
9. 矩阵分解 — LU 和 QR
矩阵分解的核心思想是:把一个复杂的矩阵拆成几个简单矩阵的乘积。就像把一个大数分解成质因数的乘积——每个质因数都更容易处理。
一个类比
你有一道复杂的菜谱(矩阵 A)。如果把它拆成几个简单步骤:先切菜(矩阵 L),再炒菜(矩阵 U),每一步都容易理解和执行。矩阵分解就是把"一道大菜"拆成"几个简单步骤"。
LU 分解
LU 分解把矩阵 A 拆成一个下三角矩阵 L 和一个上三角矩阵 U 的乘积:
A = LU
其中 L 的对角线以下有非零元素(下三角),U 的对角线及以上有非零元素(上三角)。
1
为什么有用——解方程 Ax = b 变成 L(Ux) = b。先解 Ly = b(前向代入),再解 Ux = y(回代)。两步都是三角方程,非常快。
2
计算复杂度——LU 分解本身是 O(n³),但分解一次之后,解不同 b 的方程只需 O(n²)。如果要解很多方程(同一个 A,不同的 b),LU 分解非常高效。
3
和高斯消元的关系——LU 分解本质上就是高斯消元的"矩阵形式"。L 记录了消元过程中用到的乘数,U 是消元后的上三角结果。
QR 分解
QR 分解把矩阵 A 拆成一个正交矩阵 Q 和一个上三角矩阵 R 的乘积:
A = QR
其中 Q 的列向量是正交的(QᵀQ = I),R 是上三角矩阵。
QR 分解的优势
QR 分解比 LU 分解更数值稳定——因为 Q 是正交矩阵,它不改变向量的长度,不会放大误差。在求解最小二乘问题和特征值计算中,QR 分解是首选方法。
AI 应用
- 最小二乘法——Ax = b 的最小二乘解可以通过 QR 分解高效计算:x = R⁻¹Qᵀb
- QR 算法——计算特征值的标准算法,核心就是反复做 QR 分解
- 正交化——Gram-Schmidt 过程本质上就是 QR 分解
LU 分解详解
LU 分解的计算过程
以 3×3 矩阵为例,LU 分解的过程就是高斯消元的"记录版":
1
第一列消元——用第一行消去下面行的第一个元素。记录消元系数 l₂₁, l₃₁ 到 L 矩阵。
2
第二列消元——用第二行消去下面行的第二个元素。记录 l₃₂ 到 L 矩阵。
4
构造 L——下三角矩阵,对角线为 1,其他位置是消元系数。
手算示例
A = | 2 1 -1 |
|-3 -1 2 |
|-2 1 2 |
1
消元——R₂ ← R₂ - (-3/2)R₁ = R₂ + 1.5R₁,得到 l₂₁ = -1.5
R₃ ← R₃ - (-2/2)R₁ = R₃ + R₁,得到 l₃₁ = -1
2
继续消元——R₃ ← R₃ - (2/0.5)R₂ = R₃ - 4R₂,得到 l₃₂ = 2
3
结果——L = [1,0,0; -1.5,1,0; -1,2,1],U = [2,1,-1; 0,0.5,0.5; 0,0,-1]
带部分主元的 LU 分解(PLU)
实际计算中,如果主对角线上出现 0(或很小的数),需要交换行。这引入一个置换矩阵 P:
PA = LU
PLU 分解是数值稳定的——它避免了除以接近 0 的数。NumPy 的 scipy.linalg.lu(A) 返回 P, L, U。
LU 分解解方程的完整流程
解 Ax = b 变成解 L(Ux) = b:
1
前向代入解 Ly = b——L 是下三角,从上往下逐个求 y₁, y₂, y₃。因为 L 的对角线是 1,每步只需要做减法和除法。
2
回代解 Ux = y——U 是上三角,从下往上逐个求 x₃, x₂, x₁。每步只需要做减法和除法。
两步都是 O(n²),加上 LU 分解的 O(n³),总复杂度 O(n³)。但如果要解 k 个方程(同一个 A,不同的 b),只需分解一次,之后每次只做 O(n²) 的代入。
Cholesky 分解
如果 A 是对称正定矩阵,有更高效的分解:
A = LLᵀ
其中 L 是下三角矩阵。Cholesky 分解比 LU 分解快约 2 倍(因为利用了对称性)。
AI 应用:高斯过程和多元高斯采样
高斯过程的核心运算是解 K⁻¹y(K 是协方差矩阵,对称正定)。用 Cholesky 分解:
1. K = LLᵀ
2. 解 Lz = y(前向代入)
3. 解 Lᵀx = z(回代)
从多元高斯 N(μ, Σ) 采样:z = μ + Lε,其中 ε ~ N(0, I),L 是 Σ 的 Cholesky 因子。这比直接用 Σ 的平方根更高效。
三种分解的对比
| 分解 | 形式 | 要求 | 主要用途 |
| LU | A = LU | 方阵(可加置换 P) | 解方程、求行列式 |
| QR | A = QR | 任意矩阵 | 最小二乘、特征值 |
| Cholesky | A = LLᵀ | 对称正定 | 高斯过程、采样 |
实际选择建议
- 解方程 Ax = b——如果 A 是普通方阵,用 LU;如果 A 对称正定,用 Cholesky;如果 A 是矩形或病态,用 QR。
- 求行列式——用 LU,det(A) = det(L) × det(U) = U 对角线元素之积。
- 求逆矩阵——用 LU 或 QR,但实际中尽量避免显式求逆。
💡 思考题- LU 分解和高斯消元法的关系是什么?
- 为什么 QR 分解比 LU 分解更数值稳定?
✏️ 计算练习- 对矩阵 [[4,3],[6,3]] 做 LU 分解,写出 L 和 U
💻 代码练习- 用 scipy.linalg.lu 做 LU 分解,验证 PA = LU
10. SVD 奇异值分解 — 线性代数的"瑞士军刀"
SVD(Singular Value Decomposition,奇异值分解)是线性代数中最重要的矩阵分解之一。它能把任何矩阵(不要求方阵)分解成三个特殊矩阵的乘积。在 AI 中,SVD 无处不在——推荐系统、降维、数据压缩、LoRA 微调……
一个类比
任何一种变换(旋转、缩放、剪切……)都可以拆解为三步:
1. 旋转(或反射)——Vᵀ
2. 沿坐标轴缩放——Σ
3. 再旋转(或反射)——U
就像任何复杂的动作都可以拆解为"转身 → 伸手 → 抓取"这样简单的步骤。
SVD 的定义
对于任意 m×n 矩阵 A,SVD 把它分解为:
A = UΣVᵀ
其中:
- U(m×m 正交矩阵)——左奇异向量,A 的列空间的正交基
- Σ(m×n 对角矩阵)——奇异值 σ₁ ≥ σ₂ ≥ ... ≥ 0,沿对角线排列
- Vᵀ(n×n 正交矩阵的转置)——右奇异向量,A 的行空间的正交基
奇异值的含义
每个奇异值 σᵢ 告诉我们 A 在第 i 个"重要方向"上的拉伸程度。奇异值从大到小排列,所以:
σ₁
最大奇异值——A 在"最重要方向"上的拉伸程度。对应数据变化最大的方向。
σ₂
第二大奇异值——A 在"第二重要方向"上的拉伸程度。和第一个方向正交。
...
依次递减——后面的奇异值越来越小,对应越来越不重要的方向。
σᵣ
最后一个非零奇异值——r 就是矩阵的秩。后面的奇异值都是 0。
低秩近似:用更少的信息表达矩阵
SVD 最强大的应用是低秩近似——只保留前 k 个最大的奇异值和对应的奇异向量,丢弃其余部分:
A ≈ Aₖ = Uₖ Σₖ Vₖᵀ
这在信息论中是最优的——在所有秩为 k 的矩阵中,Aₖ 是最接近 A 的(在 Frobenius 范数意义下)。
类比:图片压缩
一张 1000×1000 的图片有 100 万个数字。但 SVD 可能告诉你:前 50 个奇异值就包含了 95% 的信息。那你只需要存储 50 个奇异值和对应的奇异向量(约 10 万个数字),就能得到一张几乎一样清晰的图片。信息量压缩了 90%。
AI 应用 1:推荐系统
用户-物品评分矩阵通常是稀疏的(很多空缺)。用 SVD 分解后,低秩近似能"补全"缺失的评分——预测用户会对没看过的电影打几分。这就是 Netflix 推荐算法的核心思想。
AI 应用 2:LoRA 的低秩分解
LoRA 微调的核心假设:微调时权重矩阵的变化量 ΔW 是"低秩"的。所以 ΔW 可以分解为两个小矩阵的乘积:
ΔW = BA(B 是 d×r,A 是 r×d,r 远小于 d)
这和 SVD 的低秩近似原理相同——用更少的参数表达核心信息。70B 模型的 LoRA 权重只有 50-200MB,就是低秩的威力。
深入理解 LoRA:为什么低秩假设成立?
LoRA 的成功不仅仅是一个工程技巧,它有深刻的线性代数解释:
- 微调的"变化量"确实是低秩的——预训练模型已经学到了丰富的表示,微调只需要在少数方向上做微调。研究表明,ΔW 的奇异值快速衰减,前几十个奇异值就包含了 90%+ 的信息。
- 参数效率——原始权重 d×d 有 d² 个参数。LoRA 的 B(d×r) + A(r×d) 只有 2dr 个参数。当 r=16, d=4096 时,参数量从 1600 万降到 13 万,压缩比 123 倍。
- 合并推理——训练完成后,W' = W + BA 可以直接合并回原权重,推理时没有额外开销。这就是低秩分解的优雅之处。
- 和 SVD 的关系——如果对 ΔW 做 SVD 并保留前 r 个奇异值,得到的就是最优的秩-r 近似。LoRA 直接学习 B 和 A,避免了 SVD 的计算开销,效果类似。
AI 应用 3:模型压缩
对权重矩阵做 SVD 低秩近似,可以把大矩阵拆成两个小矩阵,减少参数量和计算量。这是模型压缩和加速推理的常用技术。
SVD 与特征值分解的区别
| 特征值分解 | SVD |
| 适用范围 | 只适用于方阵 | 适用于任意矩阵 |
| 分解形式 | A = PDP⁻¹ | A = UΣVᵀ |
| 矩阵要求 | P 的列是特征向量 | U 和 V 都是正交矩阵 |
| 对角元素 | 特征值(可负、可复数) | 奇异值(非负实数) |
| 数值稳定性 | 可能不稳定 | 更稳定 |
实际建议
在 AI 中,优先用 SVD。它适用范围更广(不要求方阵)、数值更稳定、而且奇异值总是非负实数,解释更直观。特征值分解主要用于理论推导和对称矩阵的特殊场景。
矩阵分解决策树:该用哪种分解?
面对一个矩阵分解问题,按以下思路选择:
1
矩阵是方阵吗?
不是 → 用 SVD(适用于任意矩阵)
是 → 继续下一步
2
矩阵是对称的吗?
是 → 用 特征值分解 A = QΛQᵀ(对称矩阵的特征值都是实数,数值稳定)
不是 → 继续下一步
3
需要解方程 Ax = b 吗?
A 对称正定 → 用 Cholesky 分解(最快,O(n³/3))
A 是普通方阵 → 用 LU 分解(通用,O(2n³/3))
A 是矩形或病态 → 用 QR 分解(最稳定)
4
需要低秩近似或压缩?
→ 用 SVD 截断(保留前 k 个奇异值,最优低秩近似)
→ 或用 LoRA(直接学习低秩因子,避免 SVD 计算)
💡 思考题- SVD 和特征值分解的核心区别是什么?为什么 SVD 适用范围更广?
- Eckart-Young 定理为什么说 SVD 低秩近似是最优的?
✏️ 计算练习- 对矩阵 [[1,0],[0,2],[1,1]] 做 SVD,找出三个奇异值
💻 代码练习- 用 np.linalg.svd 对一张模拟的 100×100 图片做低秩近似,分别保留 k=5, 20, 50 个奇异值,比较重建效果
11. 正交性与投影
正交性是线性代数中最直觉的概念之一——两个向量"垂直"就是正交。投影则是把一个向量"贴"到一个子空间上。这两个概念在 AI 中有广泛应用。
一个类比
太阳在你头顶,你的影子就是你身体在地面上的投影。影子保留了你在地面上的"分量",丢掉了高度上的"分量"。投影做的就是这件事——保留某个方向上的信息,丢掉其他方向上的信息。
正交向量和正交矩阵
两个向量正交 ⟺ 它们的点积为零。几何上就是互相垂直。
正交矩阵是一个方阵,它的列向量(和行向量)两两正交且都是单位向量:
QᵀQ = QQᵀ = I (等价于 Q⁻¹ = Qᵀ)
正交矩阵的性质:
- 保长度——‖Qx‖ = ‖x‖。正交变换不改变向量的长度。
- 保角度——两个向量之间的夹角在正交变换后不变。
- 行列式为 ±1——正交变换不改变体积(只可能翻转)。
- 逆就是转置——Q⁻¹ = Qᵀ,求逆非常便宜。
旋转矩阵是正交矩阵
2D 旋转矩阵 R = [cos θ, -sin θ; sin θ, cos θ] 是正交矩阵。它旋转了方向,但不改变长度。在 AI 中,一些模型架构(如旋转位置编码 RoPE)就利用了正交矩阵的这个性质。
投影
把向量 b 投影到向量 a 上的公式:
proj_a(b) = (a · b / a · a) × a = (aᵀb / aᵀa) × a
直觉:b 在 a 方向上的"影子"有多长。投影保留了 b 在 a 方向上的分量,去掉了垂直于 a 的分量。
投影到子空间
把向量 b 投影到矩阵 A 的列空间上的公式:
proj(b) = A(AᵀA)⁻¹Aᵀb
矩阵 P = A(AᵀA)⁻¹Aᵀ 叫投影矩阵。它的性质:
- P² = P(投影两次和投影一次一样——影子的影子还是影子)
- Pᵀ = P(对称矩阵)
AI 应用:最小二乘法的几何解释
最小二乘法 Ax ≈ b 的解,几何上就是把 b 投影到 A 的列空间上。投影后的点 Ax̂ 是 A 的列空间中最接近 b 的点,残差 b - Ax̂ 垂直于 A 的列空间。
这就是为什么最小二乘的法方程是 AᵀAx̂ = Aᵀb——残差垂直于列空间意味着 Aᵀ(b - Ax̂) = 0。
AI 应用:Batch Normalization
Batch Norm 的核心操作是把每个特征维度减去均值、除以标准差。几何上,这就是把数据中心化(减去均值 = 投影到"去均值"子空间),然后缩放到单位方差。
Gram-Schmidt 正交化
给定一组线性无关的向量,Gram-Schmidt 过程可以把它们变成一组正交的向量(方向两两垂直):
2
第二个向量——从 v₂ 中减去它在 u₁ 方向上的分量:u₂ = v₂ - proj_u₁(v₂)。这样 u₂ 就和 u₁ 垂直了。
3
第三个向量——从 v₃ 中减去它在 u₁ 和 u₂ 方向上的分量。这样 u₃ 和 u₁、u₂ 都垂直。
4
以此类推——对每个新向量,减去它在所有已有正交向量上的投影。
Gram-Schmidt 过程本质上就是 QR 分解——Q 的列是正交化后的向量,R 记录了每一步的投影系数。
正交基的重要性
在正交基下,很多计算变得极其简单:
求坐标
直接点积——在正交基 {e₁, e₂, ..., eₙ} 下,向量 v 的第 i 个坐标 = v · eᵢ。不需要解方程组。
求投影
逐个投影再求和——proj(v) = Σ (v · eᵢ)eᵢ。每个方向独立计算,互不干扰。
求长度
勾股定理——‖v‖² = (v·e₁)² + (v·e₂)² + ... + (v·eₙ)²。各分量的平方和就是长度的平方。
傅里叶变换的本质
傅里叶变换就是把信号投影到正交的正弦/余弦基上。每个频率分量 = 信号和对应基函数的内积。这就是为什么正交基如此重要——它让各个分量"解耦",可以独立计算。
QR 分解的 Gram-Schmidt 推导
给定矩阵 A = [a₁, a₂, ..., aₙ](列向量),Gram-Schmidt 过程构造正交矩阵 Q:
1
u₁ = a₁,q₁ = u₁/‖u₁‖。Q 的第一列。
2
u₂ = a₂ - (a₂·q₁)q₁,q₂ = u₂/‖u₂‖。减去在 q₁ 方向上的投影,得到正交分量。
3
u₃ = a₃ - (a₃·q₁)q₁ - (a₃·q₂)q₂,q₃ = u₃/‖u₃‖。减去在 q₁ 和 q₂ 方向上的投影。
4
以此类推——每个新向量减去它在所有已有正交基上的投影,再归一化。
R 矩阵记录了每一步的投影系数:
R = | (a₁·q₁) (a₂·q₁) (a₃·q₁) |
| 0 (a₂·q₂) (a₃·q₂) |
| 0 0 (a₃·q₃) |
投影的更多应用
应用 1:主成分分析(PCA)的投影
PCA 找到数据的主方向(特征向量)后,把数据投影到前 k 个主方向上:
x_proj = Qₖᵀx
Qₖ 是前 k 个特征向量组成的矩阵。投影后的坐标就是降维后的表示。这就是为什么 PCA 是"投影"——它把高维数据"影子"投到低维子空间上。
应用 2:注意力机制中的投影
Transformer 的 Q、K、V 矩阵本质上是把输入投影到三个不同的子空间:
• Q = XW_Q ——投影到"查询"空间
• K = XW_K ——投影到"键"空间
• V = XW_V ——投影到"值"空间
注意力分数 softmax(QKᵀ/√d)V 就是在"键"空间中找到最相关的"查询",然后用对应的"值"加权求和。
应用 3:残差连接的投影解释
残差连接 y = F(x) + x 可以理解为:F(x) 是 x 在某个子空间中的"变化量",加上原始 x 就是把变化量"加回去"。这保证了梯度可以直接流过(恒等映射),缓解了梯度消失。
Gram 矩阵:衡量向量组的"内积结构"
给定一组向量 v₁, v₂, ..., vₙ,Gram 矩阵 G 是它们两两内积组成的矩阵:
G = VᵀV, 其中 Gᵢⱼ = vᵢ · vⱼ
Gram 矩阵的性质:
- 对称半正定——所有特征值 ≥ 0
- 秩 = 向量组的秩——如果向量线性无关,G 正定(可逆)
- 对角线 = 各向量的长度平方——Gᵢᵢ = ‖vᵢ‖²
AI 中的应用:
- 风格迁移(Neural Style Transfer)——Gram 矩阵衡量特征图之间的"风格"(不关心空间位置,只关心特征之间的相关性)。两个图片的风格差异 = Gram 矩阵的 Frobenius 范数之差。
- 核方法——核矩阵 K(xᵢ, xⱼ) = φ(xᵢ)·φ(xⱼ) 就是特征空间中的 Gram 矩阵。它必须半正定,才能保证数据在高维空间中有意义。
- 正交性检测——如果 G = I,说明向量组是标准正交的。
正交投影 vs 非正交投影
| 正交投影 | 非正交投影(斜投影) |
| 投影方向 | 垂直于子空间 | 不垂直于子空间 |
| 最短距离 | 是(投影点最近) | 不是 |
| 投影矩阵 | P = A(AᵀA)⁻¹Aᵀ(对称) | 不对称 |
| AI 中的使用 | 最小二乘、PCA、Batch Norm | 少见 |
为什么 AI 中几乎只用正交投影?
正交投影给出"最短距离"——在最小二乘问题中,正交投影的残差最小。非正交投影在某些特殊场景(如某些类型的降维)中有用,但远不如正交投影常见。
💡 思考题- 正交矩阵为什么保持向量长度不变?从 QᵀQ = I 推导。
- 投影矩阵 P² = P 的几何意义是什么?
✏️ 计算练习- 将向量 [3,4] 投影到 [1,0] 方向上,结果是什么?投影到 [1,1] 方向上呢?
💻 代码练习- 实现 Gram-Schmidt 正交化过程,输入一组向量,输出正交化的向量组
12. 线性变换 — 从矩阵看几何
前面我们一直在"算"矩阵。这一章换个视角——从几何角度看矩阵到底在做什么。每个矩阵都对应一个线性变换,理解了变换的几何意义,矩阵就不再是抽象的数字表格了。
一个类比
矩阵就像一台"变形机器"。你把一个图形放进去,它会拉伸、旋转、剪切、投影……然后从另一头出来。不同的矩阵就是不同的变形方式。
线性变换的定义
一个变换 T 是线性的,当且仅当:
- T(u + v) = T(u) + T(v)——先加再变换 = 先变换再加
- T(cv) = cT(v)——先缩放再变换 = 先变换再缩放
几何上,线性变换的特征是:直线变换后还是直线,原点不动,平行线变换后仍然平行。
常见的线性变换
缩放
沿坐标轴拉伸或压缩——对角矩阵。[2,0;0,3] 把 x 方向拉伸 2 倍,y 方向拉伸 3 倍。
旋转
绕原点旋转角度 θ——正交矩阵。[cos θ, -sin θ; sin θ, cos θ] 逆时针旋转 θ。
剪切
把矩形变成平行四边形——[1,k;0,1] 沿 x 方向剪切。水平线不动,垂直线变斜。
投影
把空间"压扁"到低维——[1,0;0,0] 把 2D 空间投影到 x 轴上。y 分量消失了。
反射
关于某条线"翻转"——[1,0;0,-1] 关于 x 轴反射。y 坐标取反。
变换的复合:矩阵乘法就是变换叠加
两个矩阵相乘 AB 对应的几何意义是:先做 B 变换,再做 A 变换。注意顺序——矩阵乘法从右向左读。
比如旋转 45° 再缩放 2 倍:
A = 缩放矩阵 × 旋转矩阵 = [2,0;0,2] × [cos45°,-sin45°;sin45°,cos45°]
AI 应用:神经网络每层做什么
一个全连接层 y = Wx + b 中,Wx 就是一个线性变换。整个神经网络就是一连串线性变换(矩阵乘法)和非线性激活函数的交替。
如果没有非线性激活函数,整个网络就等价于一个线性变换(因为矩阵乘法的复合还是矩阵乘法)。这就是为什么激活函数必不可少——它打破了线性性,让网络能学习复杂的非线性映射。
特征值和变换的关系
回到上一章的特征值:特征向量就是变换中"方向不变"的那些向量,特征值就是它们被拉伸的倍数。理解了线性变换的几何意义,特征值就不再是一个抽象定义了——它是变换的"骨架"。
线性变换的矩阵表示
任何线性变换 T: ℝⁿ → ℝᵐ 都可以用一个 m×n 矩阵表示。怎么找这个矩阵?答案是:看基向量变换后去了哪。
1
取标准基——e₁ = [1,0,0,...], e₂ = [0,1,0,...], ...
2
变换基向量——T(e₁), T(e₂), ..., T(eₙ) 是变换后的新向量。
3
组成矩阵——A = [T(e₁) | T(e₂) | ... | T(eₙ)]。矩阵的第 i 列就是 T(eᵢ)。
例子:旋转变换
2D 旋转 90° 的变换:e₁ = [1,0] → [0,1],e₂ = [0,1] → [-1,0]
所以旋转矩阵 A = [0,-1; 1,0]。
验证:A × [3,4]ᵀ = [0×3+(-1)×4; 1×3+0×4] = [-4,3]ᵀ。确实把 (3,4) 逆时针旋转了 90°。
常见线性变换的矩阵
| 变换 | 2×2 矩阵 | 效果 |
| 缩放 | [sₓ,0; 0,sᵧ] | x 方向缩放 sₓ 倍,y 方向缩放 sᵧ 倍 |
| 旋转 θ | [cosθ,-sinθ; sinθ,cosθ] | 逆时针旋转 θ 角 |
| 水平剪切 | [1,k; 0,1] | x 坐标加上 k 倍的 y 坐标 |
| 垂直剪切 | [1,0; k,1] | y 坐标加上 k 倍的 x 坐标 |
| x 轴反射 | [1,0; 0,-1] | y 坐标取反 |
| y 轴反射 | [-1,0; 0,1] | x 坐标取反 |
| 投影到 x 轴 | [1,0; 0,0] | y 坐标变成 0 |
| 投影到 y=x | [0.5,0.5; 0.5,0.5] | 投影到 45° 线上 |
非线性变换:为什么需要激活函数
线性变换有一个致命缺陷:线性变换的复合还是线性变换。
如果 T₁(x) = A₁x, T₂(x) = A₂x
那么 T₂(T₁(x)) = A₂(A₁x) = (A₂A₁)x = Ax
这意味着:不管你叠多少层线性变换,最终效果等价于一个线性变换。这就是为什么神经网络需要非线性激活函数——它打破了线性性。
ReLU
max(0, x)——负值变 0,正值不变。在原点处"折弯",引入非线性。最常用。
Sigmoid
1/(1+e⁻ˣ)——把实数压缩到 (0,1)。输出可解释为概率。二分类的输出层。
Tanh
(eˣ-e⁻ˣ)/(eˣ+e⁻ˣ)——把实数压缩到 (-1,1)。零中心化,比 sigmoid 更好。
GELU
x · Φ(x)——Φ 是标准正态 CDF。Transformer 中常用,比 ReLU 更平滑。
万能近似定理
一个有足够多神经元的单隐藏层网络(带非线性激活)可以近似任意连续函数。但"足够多"可能是指数级别的——所以实际中用多层网络更高效。层数越深,表达能力越强,这就是深度学习的理论基础。
线性变换在 AI 中的应用汇总
| 应用 | 变换类型 | 矩阵特点 |
| 全连接层 | 仿射变换 y=Wx+b | 任意矩阵 W |
| 卷积层 | 局部线性变换 | 稀疏、共享权重 |
| 自注意力 | 投影 + 加权求和 | 低秩投影矩阵 |
| 位置编码 | 旋转(RoPE) | 正交矩阵 |
| LoRA | 低秩更新 | W + BA(B,A 是小矩阵) |
| PCA | 正交投影 | 前 k 个特征向量 |
💡 思考题- 为什么神经网络必须使用非线性激活函数?如果全部去掉会怎样?
- 旋转矩阵的行列式为什么一定是 1?
✏️ 计算练习- 写出旋转 60° 的 2×2 矩阵,计算 [1,0] 和 [0,1] 经过变换后的坐标
💻 代码练习- 用 matplotlib 画出单位正方形经过不同线性变换(旋转、缩放、剪切)后的效果
13. 范数与距离 — AI 中无处不在的"度量"
范数(Norm)是向量"长度"的推广,距离是"远近"的度量。在 AI 中,范数和距离无处不在——正则化、归一化、梯度裁剪、损失函数、相似度搜索……
一个类比
你住在北京,朋友住在上海。你们之间的"距离"是多少?
直线距离(欧氏距离)≈ 1068 公里
沿经纬度走(曼哈顿距离)≈ 经度差 + 纬度差
坐高铁的时间≈ 4.5 小时
同样是"距离",不同的度量方式给出不同的答案。选择哪种度量,取决于你关心什么。
向量范数
范数是衡量向量"大小"的函数,满足三个条件:非负性、齐次性、三角不等式。
L1 范数
‖x‖₁ = |x₁| + |x₂| + ... + |xₙ|——各分量绝对值之和。几何意义:出租车距离(沿坐标轴走)。在 AI 中用于 L1 正则化,产生稀疏解。
L2 范数
‖x‖₂ = √(x₁² + x₂² + ... + xₙ²)——欧几里得距离。几何意义:直线距离。在 AI 中用于 L2 正则化(权重衰减)、梯度裁剪。
L∞ 范数
‖x‖∞ = max(|x₁|, |x₂|, ..., |xₙ|)——最大分量的绝对值。几何意义:切比雪夫距离。在 AI 中用于梯度裁剪的另一种方式。
Lp 范数
‖x‖p = (|x₁|ᵖ + |x₂|ᵖ + ... + |xₙ|ᵖ)^(1/p)——L1、L2 都是 Lp 的特例。p 越大,范数越关注最大分量。
矩阵范数
Frobenius
‖A‖F = √(Σᵢⱼ aᵢⱼ²)——把矩阵当成一个长向量,算 L2 范数。在 AI 中常用于衡量权重矩阵的"大小"。
谱范数
‖A‖₂ = σ₁(最大奇异值)——矩阵对向量的最大拉伸倍数。在 AI 中用于谱归一化(Spectral Normalization),稳定 GAN 训练。
L1 正则化 vs L2 正则化
| L1 正则化(Lasso) | L2 正则化(Ridge) |
| 惩罚项 | λ‖w‖₁ | λ‖w‖₂² |
| 效果 | 产生稀疏解(很多权重变成 0) | 权重趋近于 0 但不等于 0 |
| 几何直觉 | 约束区域是"菱形",容易在角上相切 | 约束区域是"圆形",相切点一般不在轴上 |
| 适用场景 | 特征选择(自动去掉不重要的特征) | 防止过拟合(所有权重都缩小) |
| AI 中叫法 | L1 正则化 | 权重衰减(Weight Decay) |
AI 应用:梯度裁剪
训练 RNN/Transformer 时,梯度可能突然变得很大(梯度爆炸)。梯度裁剪的做法是:如果梯度的 L2 范数超过阈值(比如 1.0),就按比例缩小:
if ‖g‖₂ > threshold: g = threshold × g / ‖g‖₂
这保证了梯度的方向不变,但大小被限制在合理范围内。
距离度量:AI 中衡量"远近"的五种方式
欧氏距离
d(u,v) = ‖u - v‖₂——直线距离。最直觉的距离。用于 KNN、K-Means、MSE 损失。高维时可能失效(维度灾难)。
曼哈顿距离
d(u,v) = ‖u - v‖₁——沿坐标轴走的距离。对异常值更鲁棒。L1 正则化的几何直觉就来自曼哈顿距离。
余弦距离
d(u,v) = 1 - cosine(u,v)——只看方向不看大小。文本检索、向量数据库的标准距离。对向量长度不敏感。
马氏距离
d(u,v) = √((u-v)ᵀΣ⁻¹(u-v))——考虑数据分布的"真实距离"。考虑了各维度的相关性和方差。用于异常检测。
KL 散度
D_KL(P‖Q) = Σ P(x)log(P(x)/Q(x))——衡量两个概率分布的"距离"。不是严格的距离(不对称),但在 AI 中广泛用于损失函数。
什么时候用哪种距离?
- 数据各维度同等重要、没有相关性——欧氏距离
- 想忽略向量大小,只看方向——余弦距离(文本、词向量)
- 数据有相关性(某些维度一起变化)——马氏距离
- 想要稀疏解——L1 距离(曼哈顿距离)
- 衡量概率分布的差异——KL 散度或交叉熵
💡 思考题- L1 正则化为什么能产生稀疏解?从约束区域的形状解释。
- 余弦距离和欧氏距离在什么场景下表现不同?
✏️ 计算练习- 求向量 [1, -2, 3] 的 L1 范数、L2 范数、L∞ 范数
💻 代码练习- 实现带 L2 正则化(权重衰减)的梯度下降更新规则,对比有无正则化的参数变化
14. 正定矩阵与二次型 — 优化的数学基础
正定矩阵是优化理论的核心概念。当你训练神经网络时,损失函数的曲面形状决定了梯度下降能不能找到好的解。正定矩阵就是描述"碗形曲面"的数学工具。
一个类比
想象一个碗——正定矩阵对应的二次型就是碗的形状。
正定——碗口朝上,有一个最低点。从任何方向出发,梯度下降都能滑到碗底。
不定——像一个马鞍,某些方向是碗口朝上,某些方向是碗口朝下。梯度下降可能在鞍点卡住。
负定——碗口朝下,有一个最高点。没有最低点。
二次型
对于方阵 A 和向量 x,二次型定义为:
f(x) = xᵀAx
这是一个关于 x 的二次函数。展开来看,对于 2×2 的情况:
f(x,y) = a₁₁x² + (a₁₂+a₂₁)xy + a₂₂y²
二次型描述了一个曲面的形状——碗形、马鞍形、或更复杂的形状。
正定、半正定、负定的定义
正定
对所有非零 x,xᵀAx > 0——碗口朝上。所有特征值都是正数。最理想的优化目标。
半正定
对所有非零 x,xᵀAx ≥ 0——碗口朝上但底部可能是平的。所有特征值非负。协方差矩阵就是半正定的。
负定
对所有非零 x,xᵀAx < 0——碗口朝下。所有特征值都是负数。
不定
有些 x 使 xᵀAx > 0,有些使 < 0——马鞍形。特征值有正有负。这是神经网络中最常见的曲面形状。
如何判定正定
判定矩阵 A 是否正定的几种方法:
- 特征值法——所有特征值 > 0 ⟺ 正定
- 顺序主子式法——所有顺序主子式 > 0 ⟺ 正定
- Cholesky 分解——能分解成 LLᵀ(L 是下三角)⟺ 正定
AI 应用 1:损失函数的凸性
如果损失函数的 Hessian 矩阵(二阶导数矩阵)是正定的,那损失函数是严格凸的——只有一个全局最优解,梯度下降一定能找到。这是凸优化的理想情况。
但神经网络的损失函数几乎从不是凸的——Hessian 矩阵通常是不定的,有大量鞍点和局部最小值。
AI 应用 2:核方法(Kernel Methods)
核函数 K(x,y) 对应的核矩阵必须是半正定的。这是核方法的数学基础——半正定保证了数据可以被映射到一个高维空间中,且在那个空间中的内积是有意义的。
AI 应用 3:二阶优化方法
Newton 法使用 Hessian 矩阵的逆来更新参数:
x_{new} = x - H⁻¹∇f
如果 H 是正定的,Newton 法保证下降。但神经网络中 H 往往不定,所以需要用拟 Newton 法(如 L-BFGS)或加阻尼项来修正。
二次型的几何意义
二次型 f(x) = xᵀAx 描述了一个曲面。在 2D 情况下,等高线是椭圆(或双曲线):
正定
椭圆形等高线——有一个最低点(碗底)。从任何方向出发都能滑到底部。
半正定
退化的椭圆——某些方向是平的(没有曲率)。最低点是一条线而不是一个点。
不定
双曲线形等高线——马鞍点。某些方向是碗口朝上,某些方向是碗口朝下。
Hessian 矩阵与优化景观
损失函数 L(θ) 的 Hessian 矩阵 H 是二阶导数矩阵:
Hᵢⱼ = ∂²L / ∂θᵢ∂θⱼ
Hessian 矩阵决定了损失曲面的局部形状:
- H 正定——局部是碗形,当前点是局部最小值
- H 负定——局部是倒碗形,当前点是局部最大值
- H 不定——局部是马鞍形,当前点是鞍点
- H 有零特征值——某些方向是平的(退化)
神经网络的优化景观
神经网络的损失曲面非常复杂:
• 大量鞍点——Hessian 有正有负,梯度为零但不是极值点
• 少量局部最小值——但通常和全局最小值差不多好
• 平坦区域——梯度接近零,训练变慢
这就是为什么 SGD 能工作——它用随机性"跳出"鞍点和局部最小值。
Cholesky 分解与正定性
正定矩阵有一个高效分解:A = LLᵀ,其中 L 是下三角矩阵。这叫 Cholesky 分解。
Cholesky 分解的用途
- 判定正定——如果 Cholesky 分解成功,矩阵就是正定的;如果失败(出现负数的平方根),就不是。
- 解方程——比 LU 分解快约 2 倍,因为利用了对称性。
- 采样——从 N(0, A) 采样:z = Lε,其中 ε ~ N(0, I)。
正定矩阵的性质汇总
| 性质 | 公式 | 说明 |
| 特征值 | 所有 λ > 0 | 正定的充要条件 |
| 顺序主子式 | 全部 > 0 | 判定正定的另一种方法 |
| Cholesky | A = LLᵀ 存在 | 正定的充要条件 |
| 逆矩阵 | A⁻¹ 也是正定 | 正定矩阵的逆仍正定 |
| 加法 | A+B 正定 | 两个正定矩阵之和仍正定 |
| 数乘 | cA 正定(c>0) | 正数乘正定仍正定 |
💡 思考题- 正定矩阵的所有特征值有什么特点?
- 为什么协方差矩阵一定是半正定的?
✏️ 计算练习- 用特征值法和顺序主子式法判断 [[2,1],[1,2]] 是否正定
💻 代码练习- 用 np.linalg.cholesky 验证矩阵的正定性,尝试对非正定矩阵做 Cholesky 分解观察报错
15. 概率与线性代数的交汇
概率论和线性代数在 AI 中深度融合。协方差矩阵、多元高斯分布、KL 散度——这些概念同时需要概率和线性代数的知识。
一个类比
一个班级的考试成绩:语文平均 80,数学平均 70,英语平均 90。均值向量 = [80, 70, 90]。但光知道均值不够——语文和数学的成绩是一起高一起低(正相关),还是语文高数学低(负相关)?协方差矩阵描述的就是这种"相关性结构"。
协方差矩阵
对于 n 维随机变量 X,协方差矩阵 Σ 是一个 n×n 的对称矩阵:
Σ = E[(X - μ)(X - μ)ᵀ]
其中:
- 对角线 Σᵢᵢ——第 i 个维度的方差(数据在这个维度上有多分散)
- 非对角线 Σᵢⱼ——第 i 和第 j 个维度的协方差(这两个维度是否一起变化)
协方差矩阵的性质:
- 对称——Σᵢⱼ = Σⱼᵢ
- 半正定——所有特征值 ≥ 0(方差不能是负数)
- 对角矩阵——当各维度不相关时,协方差矩阵是对角矩阵
多元高斯分布
多元高斯分布是 AI 中最重要的概率分布。它的概率密度函数为:
p(x) = (1/√((2π)ⁿ|Σ|)) × exp(-½(x-μ)ᵀΣ⁻¹(x-μ))
均值 μ 决定分布的"中心",协方差矩阵 Σ 决定分布的"形状"。
协方差矩阵决定分布的形状
- Σ = I(单位矩阵)——各维度独立、方差相同。分布是圆形/球形。
- Σ 是对角矩阵——各维度独立,但方差不同。分布是椭圆形,轴与坐标轴对齐。
- Σ 不是对角矩阵——各维度相关。分布是椭圆形,但可能倾斜。
Σ 的特征向量决定了椭圆的轴方向,特征值决定了轴的长度。
马氏距离
欧氏距离没有考虑数据的分布——如果某个维度的方差很大,那在这个维度上差很多可能很正常;如果方差很小,差一点就很异常。马氏距离修正了这个问题:
d_M(x, y) = √((x-y)ᵀΣ⁻¹(x-y))
它先用 Σ⁻¹ "标准化"了各个维度,然后再算距离。直觉上,马氏距离衡量的是"这个点在分布中有多异常"。
AI 应用
- VAE(变分自编码器)——编码器输出一个均值向量 μ 和一个方差向量 σ²,然后从 N(μ, diag(σ²)) 中采样。重建损失 + KL 散度损失。
- 扩散模型——前向过程逐步向数据添加高斯噪声,反向过程学习去噪。每一步都是高斯分布之间的变换。
- 贝叶斯神经网络——权重不是确定值,而是从高斯分布中采样。训练就是学习每个权重的均值和方差。
- 异常检测——用马氏距离衡量数据点是否异常。
协方差矩阵的直观理解
协方差矩阵 Σ 是一个"相关性表格"——它告诉你各个维度之间的关系:
Σ = | σ₁² σ₁₂ σ₁₃ |
| σ₂₁ σ₂² σ₂₃ |
| σ₃₁ σ₃₂ σ₃² |
- 对角线 σᵢ²——第 i 个维度的方差。越大说明这个维度的数据越分散。
- 非对角线 σᵢⱼ——第 i 和第 j 个维度的协方差。正 = 一起变大变小,负 = 一个变大另一个变小,零 = 无关。
协方差矩阵的特征值分解
协方差矩阵是对称半正定的,所以可以做特征值分解:Σ = QΛQᵀ。
• Q 的列(特征向量)= 数据的主方向(方差最大的方向)
• Λ 的对角线(特征值)= 各主方向上的方差
这就是 PCA 的数学基础——特征向量给出"数据变化的方向",特征值给出"变化的幅度"。
多元高斯分布详解
多元高斯分布 N(μ, Σ) 的等高线是椭球:
中心
均值 μ——椭球的中心点。数据最密集的地方。
方向
Σ 的特征向量——椭球的轴方向。数据变化最大的方向。
形状
Σ 的特征值——椭球各轴的长度。特征值越大,椭球在该方向越"扁"。
一个关键性质:多元高斯的边缘分布和条件分布仍然是高斯分布。这使得高斯分布在概率推理中非常方便。
KL 散度详解
KL 散度衡量两个概率分布的"差异"。对于两个多元高斯分布:
D_KL(P‖Q) = ½[tr(Σ_Q⁻¹Σ_P) + (μ_Q-μ_P)ᵀΣ_Q⁻¹(μ_Q-μ_P) - k + ln(det(Σ_Q)/det(Σ_P))]
其中 k 是维度。这个公式看起来复杂,但每一项都有明确含义:
- tr(Σ_Q⁻¹Σ_P)——协方差结构的差异
- (μ_Q-μ_P)ᵀΣ_Q⁻¹(μ_Q-μ_P)——均值的马氏距离
- ln(det(Σ_Q)/det(Σ_P))——分布"体积"的差异
AI 应用:VAE 的损失函数
VAE 的 KL 散度损失:
D_KL(N(μ, σ²) ‖ N(0, 1)) = ½(μ² + σ² - 1 - log σ²)
这个损失鼓励编码器输出的分布接近标准正态分布——防止编码器"作弊"(把所有输入映射到很小的区域)。
主成分分析(PCA)完整推导
PCA 的目标:找到数据变化最大的方向,把数据投影到这些方向上。
1
中心化——x ← x - μ。让数据均值为 0。
2
计算协方差矩阵——Σ = (1/n) XᵀX。Σᵢⱼ 衡量第 i 和第 j 个特征的相关性。
3
特征值分解——Σ = QΛQᵀ。Q 的列是主方向,Λ 的对角线是各方向的方差。
4
选择前 k 个主成分——按特征值从大到小排序,取前 k 个。保留的方差比例 = Σ(前k个特征值) / Σ(所有特征值)。
5
投影——x_proj = Qₖᵀx。Qₖ 是前 k 个特征向量组成的矩阵。
PCA 的局限性
PCA 是线性降维——它只能找到线性的主方向。如果数据的真实结构是非线性的(比如瑞士卷形状),PCA 就失效了。这时候需要核 PCA、t-SNE、UMAP 等非线性方法。
💡 思考题- 协方差矩阵的对角线和非对角线元素分别表示什么?
- PCA 为什么选择特征值最大的方向作为主成分?
✏️ 计算练习- 给定数据点 (1,2), (3,4), (5,6),手动计算 2×2 协方差矩阵
💻 代码练习- 用 sklearn 的 PCA 对 iris 数据集降维到 2D,用 matplotlib 可视化结果
16. 矩阵微积分 — 反向传播的数学基础
这是整本教程中最关键的章节之一。反向传播(Backpropagation)——深度学习训练的核心算法——本质就是矩阵微积分。不理解矩阵求导,就无法真正理解梯度下降在做什么。
一个类比
标量函数的导数告诉你"函数值随输入变化有多快"。矩阵微积分做的事情一样——只是输入不再是单个数字,而是一个向量或矩阵。比如损失函数 L 对权重矩阵 W 的导数 ∂L/∂W 告诉你:"W 中每个元素变化一点点,L 会变化多少。"
标量对向量求导:梯度
如果 f 是一个标量函数,x 是一个向量,梯度 ∇f 是一个和 x 同型的向量:
∇f(x) = [∂f/∂x₁, ∂f/∂x₂, ..., ∂f/∂xₙ]ᵀ
梯度的方向是函数增长最快的方向,梯度的大小是增长的速率。
梯度下降就是沿梯度反方向走
x_{new} = x - η∇f(x)
η 是学习率。沿梯度反方向走,函数值下降最快。这就是优化的核心。
标量对矩阵求导
如果 L 是标量(比如损失函数),W 是一个 m×n 矩阵,∂L/∂W 也是一个 m×n 矩阵:
(∂L/∂W)ᵢⱼ = ∂L/∂wᵢⱼ
就是 L 对 W 中每个元素分别求偏导。结果矩阵和 W 同型——这很直觉:"每个权重对应一个梯度"。
常用矩阵微积分公式
| 表达式 | 对 x 的导数 | AI 中的应用 |
| aᵀx | a | 线性层的梯度 |
| xᵀAx | (A + Aᵀ)x | 二次型的梯度 |
| ‖Ax - b‖² | 2Aᵀ(Ax - b) | 最小二乘的梯度 |
| tr(AB) 对 A | Bᵀ | 矩阵微积分的核心公式 |
| tr(AᵀB) 对 A | B | 矩阵微积分的核心公式 |
| log det(A) 对 A | (A⁻¹)ᵀ | 高斯分布的对数似然 |
链式法则的矩阵形式
标量微积分的链式法则:dy/dx = (dy/dz)(dz/dx)。矩阵微积分也有链式法则,但要注意维度匹配和矩阵乘法顺序。
对于神经网络:L = loss(y), y = W₂h, h = σ(W₁x),链式法则展开为:
1
∂L/∂y——损失函数对输出的梯度。根据损失函数的定义直接算。
2
∂L/∂W₂ = (∂L/∂y) × hᵀ——链式法则。输出层权重的梯度 = 上游梯度 × 输入的转置。
3
∂L/∂h = W₂ᵀ × (∂L/∂y)——梯度"回传"到隐藏层。注意这里用的是 W₂ 的转置。
4
∂L/∂W₁ = (∂L/∂h ⊙ σ'(W₁x)) × xᵀ——隐藏层权重的梯度。⊙ 是逐元素乘法(激活函数的导数)。
反向传播的本质
反向传播就是链式法则的高效实现。它从损失函数开始,沿着计算图反向传播梯度,每一步用矩阵乘法把梯度从输出层传回输入层。
为什么叫"反向"?因为梯度是从输出(损失)往输入(参数)方向传播的——和前向传播(从输入到输出)方向相反。
为什么矩阵微积分对 AI 工程师重要
- 理解梯度形状——∂L/∂W 和 W 同型,所以每个参数都有对应的梯度
- 理解维度匹配——链式法则中矩阵乘法的维度必须匹配,不匹配就是 bug
- 理解梯度爆炸/消失——多层链式乘法中,如果每层的 Jacobian 矩阵的谱范数 > 1,梯度会指数增长
- 自定义层——写自定义 PyTorch 层时,需要手写 backward 函数,本质就是矩阵求导
Jacobian 矩阵:向量对向量的导数
当函数 f: ℝⁿ → ℝᵐ 的输入和输出都是向量时,导数是一个矩阵——Jacobian 矩阵:
J = ∂f/∂x = | ∂f₁/∂x₁ ∂f₁/∂x₂ ... ∂f₁/∂xₙ |
| ∂f₂/∂x₁ ∂f₂/∂x₂ ... ∂f₂/∂xₙ |
| ... |
| ∂fₘ/∂x₁ ∂fₘ/∂x₂ ... ∂fₘ/∂xₙ |
Jacobian 矩阵的每个元素 Jᵢⱼ = ∂fᵢ/∂xⱼ——第 i 个输出对第 j 个输入的偏导。
Jacobian 在反向传播中的作用
反向传播的每一步都是乘以一个 Jacobian 矩阵(或其转置)。比如从隐藏层 h 到输出层 y:
∂L/∂h = (∂y/∂h)ᵀ × ∂L/∂y = Jᵀ × ∂L/∂y
如果 J 的谱范数(最大奇异值)> 1,梯度会被放大;如果 < 1,梯度会被衰减。这就是梯度爆炸/消失的根源。
JVP 与 VJP:前向模式 vs 反向模式自动微分
自动微分(Autograd)有两种模式,它们本质上是 Jacobian 矩阵的不同乘法方式:
1
JVP(Jacobian-Vector Product)——前向模式。计算 J × v,其中 v 是输入扰动方向。一次前向传播就能得到"沿方向 v 的变化率"。适合输入维度少、输出维度多的场景。
2
VJP(Vector-Jacobian Product)——反向模式。计算 vᵀ × J,其中 v 是上游梯度。一次反向传播就能得到"所有输入参数的梯度"。适合输入维度多(参数多)、输出维度少(损失是标量)的场景。
神经网络有几百万到几十亿个参数(输入维度),但损失函数只有一个值(输出维度 1)。所以 VJP(反向模式)是唯一可行的选择——一次反向传播就能得到所有参数的梯度。这就是为什么深度学习框架(PyTorch、JAX)都用反向模式自动微分。
数学上,VJP 的核心操作是:vᵀ × J = vᵀ × (∂f/∂x)。在计算图中,这通过逐层乘以 Jacobian 转置来实现——和手写反向传播的链式法则完全一致。
常见激活函数的 Jacobian
| 激活函数 | 导数 | Jacobian 特点 |
| ReLU | f'(x) = 1 if x>0, else 0 | 对角矩阵,对角线是 0 或 1。谱范数 ≤ 1。 |
| Sigmoid | f'(x) = f(x)(1-f(x)) | 对角矩阵,对角线 ∈ (0, 0.25)。谱范数 < 0.25,梯度衰减。 |
| Tanh | f'(x) = 1 - f(x)² | 对角矩阵,对角线 ∈ (0, 1)。比 sigmoid 好。 |
| Softmax | ∂fᵢ/∂xⱼ = fᵢ(δᵢⱼ - fⱼ) | 满矩阵,不是对角的。复杂但有优美结构。 |
为什么 ReLU 比 Sigmoid 好?
Sigmoid 的导数最大只有 0.25,经过多层链式乘法后,梯度指数级衰减(0.25¹⁰ ≈ 0.0001)。ReLU 的导数是 0 或 1,不会衰减梯度。这就是为什么 ReLU 是深度网络的默认选择。
向量函数的链式法则详解
对于复合函数 L = loss(y), y = f(z), z = Wx + b:
1
∂L/∂z——损失对线性层输出的梯度。取决于 loss 和 f 的选择。
2
∂L/∂W = (∂L/∂z) × xᵀ——上游梯度 × 输入的转置。结果和 W 同型。
3
∂L/∂b = ∂L/∂z——偏置的梯度 = 上游梯度(因为 ∂z/∂b = I)。
4
∂L/∂x = Wᵀ × (∂L/∂z)——梯度回传到输入。用的是 W 的转置。
维度检查技巧
每次写梯度公式时,检查维度是否匹配:
• ∂L/∂W 的形状 = W 的形状(每个参数对应一个梯度)
• ∂L/∂z 的形状 = z 的形状
• 矩阵乘法的维度必须匹配(A 的列数 = B 的行数)
如果维度不匹配,一定是公式写错了。这是调试反向传播 bug 的最快方法。
常用梯度公式速查
| 函数 | 对 x 的梯度 | 维度 |
| xᵀa | a | n×1 |
| aᵀx | a | n×1 |
| xᵀx | 2x | n×1 |
| xᵀAx | (A + Aᵀ)x | n×1 |
| ‖x‖² | 2x | n×1 |
| log(xᵀx) | 2x/(xᵀx) | n×1 |
| σ(Wx) | Wᵀ diag(σ') 1 | n×1 |
💡 思考题- 为什么 ReLU 比 Sigmoid 更适合深层网络?从梯度传播角度解释。
- 反向传播的数学本质是什么?
✏️ 计算练习- 求 f(x) = xᵀAx 对 x 的梯度,其中 A = [[1,2],[3,4]],x = [1,1]ᵀ
💻 代码练习- 手动实现两层网络的反向传播(不用 autograd),用 PyTorch 的 loss.backward() 验证梯度一致
17. 张量 — 从矩阵到高维
张量(Tensor)是向量和矩阵的高维推广。在深度学习框架中(PyTorch、TensorFlow),所有的数据都是张量——标量是 0 阶张量,向量是 1 阶张量,矩阵是 2 阶张量,更高维的数据是高阶张量。
一个类比
标量(0 阶张量)= 一个数字,如 3.14
向量(1 阶张量)= 一排数字,如 [1, 2, 3]
矩阵(2 阶张量)= 一张表格,如 [[1,2],[3,4]]
3 阶张量 = 一摞表格,像一本每页都是表格的书
4 阶张量 = 一堆这样的书
每增加一阶,就多一个"维度"。
张量的形状和维度
张量的"形状"(shape)描述了每个维度的大小。比如:
标量
shape = ()——0 维。一个数字。如损失函数的值 L = 0.35。
向量
shape = (n,)——1 维。如词向量 shape = (768,)。
矩阵
shape = (m, n)——2 维。如权重矩阵 shape = (128, 784)。
3D 张量
shape = (batch, seq_len, d_model)——3 维。如 Transformer 的隐藏状态。一批 32 个句子,每个 128 个 token,每个 token 768 维 → (32, 128, 768)。
4D 张量
shape = (batch, channels, height, width)——4 维。如卷积网络的输入。一批 64 张 RGB 图片,224×224 → (64, 3, 224, 224)。
Reshape:改变张量的形状
Reshape 是 AI 中最常用的操作之一——不改变数据本身,只改变数据的"组织方式"。就像同一堆积木,可以摆成 2×6 的矩形,也可以摆成 3×4 的矩形。
Reshape 的约束
Reshape 前后的总元素个数必须相同。shape = (2, 6) 的矩阵有 12 个元素,可以 reshape 成 (3, 4) 或 (12,) 或 (2, 3, 2),但不能 reshape 成 (5, 3)(15 个元素)。
广播机制(Broadcasting)
广播是 NumPy 和 PyTorch 中的"智能对齐"机制——当两个张量形状不同时,自动扩展较小的张量使其能和较大的张量运算。
1
标量和张量——shape=(3,4) 的矩阵 + 标量 5 = 每个元素都加 5。标量被"广播"成了 (3,4) 的矩阵。
2
向量和矩阵——shape=(3,4) 的矩阵 + shape=(4,) 的向量 = 每一行都加上这个向量。向量被"广播"成了 (3,4)。
3
规则——从最后一维开始对齐。如果某一维是 1,就自动扩展到和另一个一样大。如果某一维既不是 1 也不相等,就报错。
AI 应用:偏置的广播
神经网络的前向传播 y = Wx + b 中,b 是一个向量。当 x 是一个矩阵(batch of samples)时,b 会自动广播到每一行。这就是为什么你不需要手动把 b 复制 batch_size 次——广播机制帮你做了。
张量操作在 AI 中的应用
| 操作 | 代码 | 用途 |
| 矩阵乘法 | A @ B | 全连接层、注意力计算 |
| 逐元素乘法 | A * B | 门控、Dropout、mask |
| 转置 | A.T 或 A.permute(...) | 维度重排、注意力中的 Kᵀ |
| Reshape | A.reshape(...) | 多头注意力的头拆分/合并 |
| Squeeze/Unsqueeze | A.unsqueeze(0) | 增加/去掉大小为 1 的维度 |
| Concatenate | torch.cat([A, B], dim=0) | 拼接特征、残差连接 |
| Reduce | A.mean(dim=0) | 池化、归一化、聚合 |
多头注意力中的张量操作
Transformer 的多头注意力是张量操作的绝佳示例:
1. Q, K, V 的 shape = (batch, seq_len, d_model)
2. Reshape 成 (batch, seq_len, n_heads, d_head) 再 permute → (batch, n_heads, seq_len, d_head)
3. 每个头独立做注意力:Q @ Kᵀ → softmax → @ V
4. permute + reshape 回 (batch, seq_len, d_model)
整个过程就是一系列 reshape、permute、矩阵乘法的组合。
稀疏矩阵:大部分元素是 0
在 AI 中,很多矩阵是稀疏的——大部分元素是 0。比如:
- 词袋模型——文档-词矩阵,每个文档只包含词表中的一小部分词
- 推荐系统——用户-物品矩阵,每个用户只评价过少量物品
- 注意力掩码——Transformer 中的因果掩码,上三角全是 -∞
- 图神经网络——邻接矩阵,大部分节点不相连
稀疏矩阵的存储
稀疏矩阵不需要存储所有元素。常见格式:
• COO——只存 (行, 列, 值) 三元组
• CSR——按行压缩,适合行切片
• CSC——按列压缩,适合列切片
在 PyTorch 中,torch.sparse_coo_tensor(indices, values, shape) 创建稀疏张量。
AI 应用:稀疏矩阵的效率
一个 10000×10000 的矩阵有 1 亿个元素。如果只有 1% 是非零的(稀疏度 99%),用稀疏存储只需要 100 万个元素的内存,矩阵乘法也可以跳过零元素,快 100 倍。
这就是为什么 GPT 的注意力机制用因果掩码——它让一半的注意力分数变成 0,可以用稀疏运算加速。
Einstein 求和约定:简洁表达张量运算
当张量运算变得复杂时,用普通的矩阵乘法符号很难表达。Einstein 求和约定(einsum)提供了一种极其简洁的表示法——用下标来描述运算规则,重复的下标表示"求和"。
1
矩阵乘法——C = AB 写成 C[i,k] = A[i,j] * B[j,k],einsum 表示为 ij,jk->ik。j 出现两次,自动求和。
2
转置——Aᵀ 写成 ij->ji。只是交换下标。
3
迹——tr(A) 写成 ii->。对角线元素求和,结果是标量。
4
逐元素乘法——A ⊙ B 写成 ij,ij->ij。没有求和,对应位置相乘。
为什么 einsum 重要?
- 通用性——几乎所有张量运算都可以用 einsum 表达,不需要记各种特殊函数
- 可读性——einsum 字符串直接告诉你"输入的哪些维度如何组合成输出"
- 效率——NumPy 和 PyTorch 的 einsum 实现会自动优化计算顺序
- 注意力机制——Transformer 的注意力可以用 einsum 完整表达:
np.einsum('bqd,bkd->bqk', Q, K) 计算注意力分数
在代码中:np.einsum('ij,jk->ik', A, B) 等价于 A @ B,但 einsum 能表达更复杂的运算,如批量矩阵乘法、张量缩并等。
分块矩阵:矩阵的"模块化"
分块矩阵把一个大矩阵看成若干个小矩阵的组合:
A = | A₁₁ A₁₂ |
| A₂₁ A₂₂ |
其中 A₁₁, A₁₂, A₂₁, A₂₂ 都是子矩阵。分块矩阵的运算规则和普通矩阵一样——把子矩阵当成"元素"来算。
AI 应用:多头注意力的分块视角
多头注意力可以理解为对 Q, K, V 做分块:
• Q = [Q₁; Q₂; ...; Qₕ](h 个头)
• 每个头独立计算:Attention(Qᵢ, Kᵢ, Vᵢ)
• 最后拼接:Concat(head₁, head₂, ..., headₕ)
这就是分块矩阵的思想——把大矩阵拆成小块,每块独立处理,最后合并。
💡 思考题- 广播机制的规则是什么?shape (3,4) 和 (4,) 能相加吗?(3,4) 和 (3,) 呢?
- 为什么用 reshape 比循环更高效?
✏️ 计算练习- shape 为 (2,3,4) 的张量,reshape 成 (6,4) 和 (2,12) 是否合法?(5,3) 呢?
💻 代码练习- 用 np.einsum 分别实现矩阵乘法、转置、迹运算,对比标准写法
17B. Transformer 的线性代数全景
Transformer 是当今 AI 最核心的架构——GPT、BERT、LLaMA、Diffusion 全都基于它。这一章把前面所有线性代数知识串起来,完整拆解 Transformer 中的每一步运算。
一个类比
Transformer 就像一个高效的会议室:
每个人(token)都带着三张名片:Query(我想找什么样的人)、Key(我能提供什么)、Value(我的具体内容)。
会议开始时,每个人拿着自己的 Query 去和所有人的 Key 匹配,找到最相关的人,然后收集他们的 Value。这就是注意力机制。
第一步:输入嵌入 + 位置编码
输入 token 先通过嵌入矩阵变成向量,再加上位置编码:
X = TokenEmbedding(tokens) + PositionalEncoding
shape 变化:token IDs (seq_len,) → 嵌入矩阵 E (vocab_size × d_model) → X (seq_len × d_model)
线性代数视角
嵌入本质是查表——从矩阵 E 中取出对应行。位置编码用正弦/余弦函数生成固定向量,利用了三角函数的正交性质。RoPE(旋转位置编码)则直接用正交旋转矩阵来编码位置信息。
第二步:Q、K、V 投影
输入 X 通过三个不同的线性变换生成 Q、K、V:
Q = XW_Q, K = XW_K, V = XW_V
其中 W_Q, W_K, W_V 都是 (d_model × d_k) 的权重矩阵。这是三个独立的线性变换(第 3 章和第 12 章),把输入投影到三个不同的子空间。
为什么需要三个不同的投影?
- Q(查询)——"我在找什么信息"
- K(键)——"我能提供什么信息"
- V(值)——"我的具体内容是什么"
三个不同的投影让模型能在不同的"语义空间"中匹配和聚合信息。如果 Q=K=V,注意力就退化为简单的相似度加权。
第三步:注意力分数 QKᵀ/√d_k
注意力分数的计算是 Transformer 最核心的运算:
Attention(Q, K, V) = softmax(QKᵀ / √d_k) V
拆解每一步:
1
QKᵀ——(seq_len × d_k) × (d_k × seq_len) = (seq_len × seq_len)。每个元素 (i,j) 是第 i 个 token 的 Query 和第 j 个 token 的 Key 的点积(第 2 章)。衡量"第 i 个 token 有多关注第 j 个 token"。
2
/ √d_k——缩放因子。当 d_k 很大时,点积的方差也很大,导致 softmax 输出极端化。除以 √d_k 让方差回到 1(第 18 章数值稳定性)。
3
softmax——逐行归一化,让每一行的和为 1(第 18 章)。现在每一行是一个概率分布——"第 i 个 token 对所有 token 的注意力权重"。
4
× V——(seq_len × seq_len) × (seq_len × d_k) = (seq_len × d_k)。用注意力权重对 Value 做加权求和——每个 token 的输出是所有 token 的 Value 的加权组合。
因果掩码(Causal Mask)
在 GPT 等自回归模型中,token i 不能看到后面的 token。所以 QKᵀ 矩阵的上三角部分被设为 -∞,softmax 后变成 0。这是一个稀疏矩阵操作(第 17 章)——让一半的注意力权重变成 0。
第四步:多头注意力
多头注意力把 d_model 拆成 h 个头,每个头独立做注意力:
1
拆分——Q (seq_len × d_model) reshape 成 (seq_len × h × d_head),再 permute 成 (h × seq_len × d_head)。这是张量操作(第 17 章)。
2
独立计算——每个头用不同的 W_Q, W_K, W_V 投影,在不同的子空间中做注意力。这是分块矩阵的思想(第 17 章)。
3
合并——concat 所有头,再通过一个线性层投影回 d_model 维。
多头注意力的线性代数本质
多头注意力可以理解为:在 h 个不同的低维子空间中并行做注意力,然后把结果拼接起来。每个头只看到 d_head = d_model/h 维的信息,但不同的头关注不同的模式(语法、语义、位置等)。这是子空间分解(第 7 章)的实际应用。
第五步:前馈网络(FFN)
注意力输出经过一个两层的前馈网络:
FFN(x) = GELU(xW₁ + b₁)W₂ + b₂
这是两个矩阵乘法(第 3 章)加上一个非线性激活函数(第 12 章)。W₁ 把维度从 d_model 扩展到 d_ff(通常是 4 倍),W₂ 再压缩回 d_model。
FFN 的"记忆"假说
有研究表明,FFN 层像一个"键值记忆"——W₁ 的行是"键"(匹配输入模式),W₂ 的列是"值"(对应的知识)。这和注意力机制有异曲同工之妙。
第六步:残差连接 + 层归一化
x = LayerNorm(x + Attention(x))
x = LayerNorm(x + FFN(x))
残差连接(第 11 章):x + F(x) 保证梯度可以直接流过,缓解梯度消失。层归一化:把每个 token 的向量归一化到均值 0、方差 1(第 15 章),稳定训练。
完整数据流:shape 变化追踪
| 步骤 | 操作 | 输出 shape | 用到的线性代数 |
| 嵌入 | 查表 + 位置编码 | (batch, seq, d_model) | 向量加法 |
| QKV 投影 | 三个矩阵乘法 | (batch, seq, d_k) ×3 | 线性变换 |
| 注意力分数 | QKᵀ/√d_k | (batch, seq, seq) | 矩阵乘法、点积 |
| Softmax | 逐行归一化 | (batch, seq, seq) | 逐元素运算、数值稳定 |
| 加权求和 | softmax × V | (batch, seq, d_k) | 矩阵乘法 |
| 多头合并 | concat + 线性投影 | (batch, seq, d_model) | 张量操作、矩阵乘法 |
| FFN | 两层 MLP | (batch, seq, d_model) | 矩阵乘法、非线性变换 |
| 残差 + Norm | 加法 + 归一化 | (batch, seq, d_model) | 投影、归一化 |
计算瓶颈
Transformer 的计算瓶颈在两个地方:
1. 注意力矩阵 QKᵀ——shape 是 (seq_len × seq_len),随序列长度平方增长。这就是为什么长文本处理很贵。
2. FFN 的大矩阵——W₁ 是 (d_model × 4d_model),参数量很大。
FlashAttention 通过分块计算(第 17 章分块矩阵)优化了注意力的内存访问;MoE(混合专家)通过稀疏激活减少了 FFN 的计算量。
线性代数知识在 Transformer 中的完整映射
- 矩阵乘法(第 3 章)——无处不在:QKV 投影、注意力计算、FFN
- 点积与余弦相似度(第 2 章)——注意力分数的本质
- Softmax(第 18 章)——注意力权重归一化
- 正交投影(第 11 章)——QKV 是到不同子空间的投影
- 子空间与基(第 7 章)——多头注意力的子空间分解
- 张量操作(第 17 章)——reshape、permute、广播
- 残差连接(第 11 章)——恒等映射保证梯度流
- 归一化(第 15 章)——均值、方差、标准化
- 低秩分解(第 10 章)——LoRA 微调的数学基础
- 数值稳定性(第 18 章)——缩放因子、混合精度
18. 数值计算的现实问题
数学理论假设一切都是精确的。但计算机用浮点数表示实数,天然有精度限制。理解数值问题,是避免 AI 训练中各种诡异 bug 的关键。
一个类比
你用一把只有厘米刻度的尺子量一张桌子——能量到 120cm,但量不到 120.35cm。如果你用这个不精确的测量结果做进一步计算(比如计算面积),误差会越来越大。浮点数精度就是计算机的"刻度"——它限制了计算的精确程度。
浮点数精度
FP32
32 位浮点数(单精度)——约 7 位有效数字。深度学习的传统默认精度。
FP16
16 位浮点数(半精度)——约 3-4 位有效数字。显存减半,计算更快,但可能溢出。
BF16
Brain Float 16——8 位指数 + 7 位尾数。比 FP16 范围更大,不容易溢出。Google TPU 的默认精度。
FP8
8 位浮点数——最新一代 GPU(H100)支持。显存再减半,但精度很低,需要精细的缩放策略。
0.1 + 0.2 ≠ 0.3?
在 Python 中 0.1 + 0.2 = 0.30000000000000004。这不是 Python 的 bug,而是浮点数的固有限制——0.1 在二进制中是无限循环小数,无法精确表示。在 AI 训练中,这种微小误差会随着大量计算累积。
数值稳定性
数值稳定性是指:输入的微小扰动是否会导致输出的巨大变化。不稳定的算法会放大误差,导致结果不可信。
1
条件数——矩阵 A 的条件数 κ(A) = σ₁/σₙ(最大奇异值/最小奇异值)。条件数越大,矩阵越"病态"——解方程时误差被放大越严重。条件数接近 1 时最"健康"。
2
梯度爆炸——深层网络中,梯度经过多层链式乘法,如果每层的 Jacobian 矩阵的谱范数 > 1,梯度会指数级增长,最终变成 NaN。
3
梯度消失——反过来,如果谱范数 < 1,梯度会指数级衰减,最终变成 0。网络前面的层几乎学不到东西。
AI 中的数值稳定性技巧
- 梯度裁剪——限制梯度的 L2 范数不超过阈值
- Layer Normalization / Batch Normalization——每层输出归一化,防止数值越来越大
- 残差连接——让梯度可以直接"跳过"中间层传回去,缓解梯度消失
- 合适的权重初始化——Xavier/He 初始化让每层输出的方差保持稳定
- 混合精度训练——前向用 FP16 加速,反向用 FP32 保精度
- log-sum-exp 技巧——计算 softmax 时先减去最大值,防止 exp 溢出
softmax 的数值稳定性
softmax 是 AI 中最常用的操作之一,但它有一个数值问题:
softmax(zᵢ) = exp(zᵢ) / Σ exp(zⱼ)
如果 z 的某个分量很大(比如 1000),exp(1000) 会溢出变成 inf。解决方法是减去最大值:
softmax(zᵢ) = exp(zᵢ - max(z)) / Σ exp(zⱼ - max(z))
数学上等价,但数值上稳定——exp 的输入最大为 0,不会溢出。PyTorch 和所有深度学习框架内部都用这种技巧。
💡 思考题- 为什么 Python 中 0.1 + 0.2 ≠ 0.3?这是 bug 吗?
- 条件数大的矩阵在求解方程组时会出现什么问题?
✏️ 计算练习- 估算矩阵 [[1,1],[1,1.0001]] 的条件数。如果用它解方程,误差会被放大多少倍?
💻 代码练习- 比较 np.linalg.inv(A) @ b 和 np.linalg.solve(A, b) 对病态矩阵的精度差异
19. 动手实战 — 用 NumPy 实现神经网络
前面 18 章讲了理论。这一章用 NumPy 把所有知识串起来——从零实现一个简单的两层神经网络,包括前向传播和反向传播。做完这一章,线性代数就真正内化了。
NumPy 基础
1
创建数组——np.array([1,2,3]) 创建向量,np.zeros((3,4)) 创建零矩阵,np.random.randn(3,4) 创建随机矩阵。
2
矩阵乘法——A @ B 或 np.dot(A, B)。这是神经网络的核心运算。
3
逐元素运算——A * B 逐元素乘,A + B 逐元素加,np.maximum(A, 0) ReLU。
4
线性代数——np.linalg.eig(A) 特征值分解,np.linalg.svd(A) SVD,np.linalg.inv(A) 求逆。
从零实现一个两层神经网络
我们要实现的网络结构:
- 输入层——784 维(28×28 的图片展平)
- 隐藏层——128 个神经元,ReLU 激活
- 输出层——10 个神经元(10 个数字类别),softmax
第一步:初始化权重
用 He 初始化(适合 ReLU):权重从均值为 0、标准差为 √(2/n_in) 的正态分布中采样。
为什么 He 初始化?
如果权重太大,激活值会爆炸;如果太小,激活值会消失。He 初始化保证了每层输出的方差大约为 1,让信号在网络中稳定传播。这和第 8 章讲的特征值/谱半径直接相关。
第二步:前向传播
前向传播就是一系列矩阵乘法和激活函数:
1
隐藏层——z₁ = W₁x + b₁, a₁ = ReLU(z₁)。W₁ 是 (128, 784) 的矩阵,x 是 (784, batch_size) 的矩阵。
2
输出层——z₂ = W₂a₁ + b₂, ŷ = softmax(z₂)。W₂ 是 (10, 128) 的矩阵。
3
损失函数——交叉熵损失 L = -Σ yᵢlog(ŷᵢ)。y 是真实标签的 one-hot 编码。
第三步:反向传播
反向传播用链式法则计算每个参数的梯度。这是第 16 章矩阵微积分的实战:
1
输出层梯度——∂L/∂z₂ = ŷ - y(softmax + 交叉熵的梯度,非常简洁!)
2
W₂ 梯度——∂L/∂W₂ = (∂L/∂z₂) × a₁ᵀ。一个 (10, batch) 矩阵乘 (batch, 128) 矩阵 = (10, 128)。
3
隐藏层梯度——∂L/∂a₁ = W₂ᵀ × (∂L/∂z₂)。梯度"回传"到隐藏层。
4
W₁ 梯度——∂L/∂W₁ = (∂L/∂a₁ ⊙ ReLU'(z₁)) × xᵀ。注意 ReLU 的导数:正值为 1,负值为 0。
第四步:参数更新
W = W - η × ∂L/∂W (对每个参数都执行)
η 是学习率。重复前向 → 计算损失 → 反向 → 更新,直到收敛。
用到的线性代数知识汇总
| 操作 | 用到的线性代数 | 对应章节 |
| 前向传播 | 矩阵乘法、广播 | 第 3、17 章 |
| ReLU 激活 | 逐元素运算 | 第 3 章 |
| softmax | 逐元素运算、数值稳定性 | 第 3、18 章 |
| 反向传播 | 矩阵微积分、链式法则 | 第 16 章 |
| 梯度裁剪 | L2 范数 | 第 13 章 |
| 权重初始化 | 特征值、谱半径 | 第 8 章 |
| Batch Norm | 均值、方差、归一化 | 第 11、15 章 |
| PCA 降维 | 特征值分解、SVD | 第 8、10 章 |
| LoRA 微调 | 低秩分解 | 第 10 章 |
| Attention | 矩阵乘法、softmax、转置 | 第 3、17 章 |
完整代码示例
以下代码可以直接复制到 Jupyter Notebook 中运行
1. 数据准备
import numpy as np
# 生成模拟数据:1000个样本,784维(模拟28x28图片)
np.random.seed(42)
X_train = np.random.randn(784, 1000) # 每列一个样本
y_train = np.random.randint(0, 10, 1000) # 0-9的标签
# One-hot编码
def one_hot(y, num_classes=10):
m = y.shape[0]
Y = np.zeros((num_classes, m))
Y[y, np.arange(m)] = 1
return Y
Y_train = one_hot(y_train) # shape: (10, 1000)
2. 权重初始化
# He初始化(适合ReLU)
def init_weights(n_out, n_in):
return np.random.randn(n_out, n_in) * np.sqrt(2.0 / n_in)
W1 = init_weights(128, 784) # 第一层:784→128
b1 = np.zeros((128, 1))
W2 = init_weights(10, 128) # 第二层:128→10
b2 = np.zeros((10, 1))
3. 激活函数
def relu(Z):
return np.maximum(0, Z)
def relu_derivative(Z):
return (Z > 0).astype(float)
def softmax(Z):
# 数值稳定版本(第18章的技巧)
exp_Z = np.exp(Z - np.max(Z, axis=0, keepdims=True))
return exp_Z / np.sum(exp_Z, axis=0, keepdims=True)
4. 前向传播
def forward(X, W1, b1, W2, b2):
Z1 = W1 @ X + b1 # 矩阵乘法(第3章)
A1 = relu(Z1) # 逐元素运算(第3章)
Z2 = W2 @ A1 + b2 # 矩阵乘法
A2 = softmax(Z2) # 逐元素运算 + 归一化
return Z1, A1, Z2, A2
5. 损失函数
def cross_entropy_loss(A2, Y):
m = Y.shape[1]
# 数值稳定的交叉熵
log_probs = np.log(A2 + 1e-8) # 避免log(0)
loss = -np.sum(Y * log_probs) / m # 逐元素乘法(第3章)
return loss
6. 反向传播(第16章的核心应用)
def backward(X, Y, Z1, A1, Z2, A2, W2):
m = X.shape[1]
# 输出层梯度(softmax + 交叉熵的简洁形式)
dZ2 = A2 - Y # shape: (10, m)
dW2 = (1/m) * dZ2 @ A1.T # 矩阵乘法,shape: (10, 128)
db2 = (1/m) * np.sum(dZ2, axis=1, keepdims=True)
# 隐藏层梯度(链式法则)
dA1 = W2.T @ dZ2 # 梯度回传,shape: (128, m)
dZ1 = dA1 * relu_derivative(Z1) # 逐元素乘法
dW1 = (1/m) * dZ1 @ X.T # shape: (128, 784)
db1 = (1/m) * np.sum(dZ1, axis=1, keepdims=True)
return dW1, db1, dW2, db2
7. 参数更新
def update_params(W1, b1, W2, b2, dW1, db1, dW2, db2, lr=0.01):
W1 = W1 - lr * dW1 # 梯度下降(第16章)
b1 = b1 - lr * db1
W2 = W2 - lr * dW2
b2 = b2 - lr * db2
return W1, b1, W2, b2
8. 训练循环
# 训练参数
epochs = 100
lr = 0.01
losses = []
for epoch in range(epochs):
# 前向传播
Z1, A1, Z2, A2 = forward(X_train, W1, b1, W2, b2)
# 计算损失
loss = cross_entropy_loss(A2, Y_train)
losses.append(loss)
# 反向传播
dW1, db1, dW2, db2 = backward(X_train, Y_train, Z1, A1, Z2, A2, W2)
# 梯度裁剪(第13章)
for dW in [dW1, dW2]:
norm = np.linalg.norm(dW)
if norm > 5.0:
dW[:] = dW * 5.0 / norm # 原地修改
# 更新参数
W1, b1, W2, b2 = update_params(W1, b1, W2, b2, dW1, db1, dW2, db2, lr)
if (epoch + 1) % 10 == 0:
print(f"Epoch {epoch+1}, Loss: {loss:.4f}")
9. 预测和评估
def predict(X, W1, b1, W2, b2):
_, _, _, A2 = forward(X, W1, b1, W2, b2)
return np.argmax(A2, axis=0)
# 训练集准确率
predictions = predict(X_train, W1, b1, W2, b2)
accuracy = np.mean(predictions == y_train)
print(f"训练集准确率: {accuracy * 100:.2f}%")
练习题
动手练习(建议全部完成)
- 修改网络结构——把隐藏层改成 256 个神经元,观察损失变化。
- 添加 L2 正则化——在损失函数中加上 λ‖W‖₂²,在梯度中加上 λW。
- 实现 Batch Normalization——在隐藏层后添加归一化,观察训练是否更快收敛。
- 用真实数据——加载 sklearn 的 digits 数据集(8×8 的手写数字),训练这个网络。
- 实现 Adam 优化器——用动量和自适应学习率替代简单的梯度下降。
从 NumPy 到 PyTorch
理解了 NumPy 实现后,PyTorch 的对应关系就很清楚了:
| NumPy | PyTorch | 说明 |
np.array | torch.tensor | 创建张量 |
A @ B | A @ B 或 torch.matmul | 矩阵乘法(支持批量) |
np.dot | torch.matmul | 批量矩阵乘法 |
np.linalg.svd | torch.linalg.svd | SVD 分解 |
np.linalg.eig | torch.linalg.eig | 特征值分解 |
np.random.randn | torch.randn | 正态分布采样 |
| 手写 backward | loss.backward() | 自动微分(autograd) |
PyTorch 的 autograd 做了什么
你手写的 backward 函数,PyTorch 用计算图自动完成了。每次前向传播时,PyTorch 记录所有操作构建计算图;调用 loss.backward() 时,它自动沿着计算图反向传播梯度。
本质是一样的——都是链式法则。只是 PyTorch 帮你自动实现了,不需要手写梯度公式。
恭喜你!
如果你走到了这里,并且用 NumPy 实现了一个能训练的神经网络,那你已经掌握了 AI 所需的线性代数核心知识。接下来学习 PyTorch/TensorFlow 时,你会发现那些 API 背后的数学原理你都理解了——调参不再是盲人摸象,而是有理论依据的工程决策。
📚 推荐学习资源
| 资源 | 类型 | 推荐理由 |
| 3Blue1Brown — Essence of Linear Algebra | 视频系列 | 最直觉的线性代数可视化讲解,必看 |
| MIT 18.06 Gilbert Strang | 公开课 | 经典线性代数课程,讲解清晰透彻 |
| Mathematics for Machine Learning | 书籍(免费PDF) | 专门为 ML 写的数学教材,覆盖线代+优化+概率 |
| The Matrix Cookbook | 参考手册 | 矩阵微积分公式速查手册,写反向传播时的救星 |
| NumPy 官方教程 | 文档 | 动手练习的最佳伴侣 |
| PyTorch Linear Algebra Tutorials | 教程 | 把线性代数知识应用到深度学习框架中 |
线性代数是 AI 的语言。学会它,你就能"读懂" AI 在做什么。
面向深度学习和 AI 工程师 · 2026
仅供学习与参考