如果把 AI 数学压缩一下，主要就是这 5 类：
AI 数学
│
├── ① 线性代数
│ ├── 向量
│ ├── 矩阵
│ ├── 张量
│ ├── 矩阵乘法
│ └── 特征值/特征向量
│
├── ② 微积分
│ ├── 函数
│ ├── 导数
│ ├── 偏导数
│ └── 梯度
│
├── ③ 概率
│ ├── 概率
│ ├── 条件概率
│ ├── 随机变量
│ └── 概率分布
│
├── ④ 统计
│ ├── 均值
│ ├── 方差
│ ├── 协方差
│ └── 相关性
│
└── ⑤ 优化
├── Loss
├── Gradient Descent
└── Adam
不用怕。
这里面很多东西你以前其实学过，只是现在忘了。
而且我们真正需要的数学深度，远没有大学数学系那么夸张。
这是后面所有东西的基础。
先别管 AI。
假设有一个程序：
输入 CPU 温度
↓
某个计算公式
↓
输出风扇转速
例如：
风扇转速 = 10 × 温度
数学上写成：
y = 10x
这就是一个函数。
可以理解成：
**函数 = 一个输入 → 按某种规则 → 得到一个输出**
例如：
x = 20 ↓ y = 10 × 20 ↓ y = 200
所以：
f(x) = 10x
和：
y = 10x
本质上是一回事。
因为神经网络本质上就是：
输入 ↓ 函数 ↓ 函数 ↓ 函数 ↓ 输出
例如：
输入 x ↓ f₁(x) ↓ f₂(x) ↓ f₃(x) ↓ 预测结果
所以可以把神经网络粗略理解成：
**一个非常复杂的函数。**
例如：
图片 ↓ 神经网络 ↓ 猫的概率 = 0.97
数学上其实就是：
y = f(x)
这个更简单。
x = 10
这里：
就是变量。
它可以换：
x = 20 x = 30 x = 100
在 AI 中：
可能代表：
所以看到：
不要害怕。
它通常就是：
**某个我们暂时不知道具体数值的东西。**
—
这个是你接下来必须重点理解的。
假设我们测试一台服务器，记录：
CPU = 80% Memory = 60% GPU = 90% Temperature = 70℃
可以写成：
x =
[
80
60
90
70
]
这就是一个向量（Vector）。
你也可以把它理解成：
**一组有顺序的数字。**
例如：
[1, 2, 3]
就是一个 3 维向量。
[1, 2, 3, 4, 5]
就是 5 维向量。
因为计算机最擅长处理数字。
例如：
一个人
计算机不知道这个人是什么。
但是我们可以把一些特征数字化：
年龄 = 30 身高 = 175 体重 = 70 收入 = 10000
变成：
[30, 175, 70, 10000]
于是：
**现实世界的信息 → 数字 → 向量**
这就是 AI 数学非常重要的一步。
以后你会经常看到：
Embedding
例如：
"苹果"
经过模型：
Embedding ↓ [0.12, -0.43, 0.82, 0.11, ...]
可能是 768 维：
[ 0.12, -0.43, 0.82, ... ]
于是计算机就可以通过数学方法比较：
苹果 香蕉 汽车 电脑
之间的“相似程度”。
所以你以后看到：
**Embedding = 把东西变成向量**
先记住这个直觉。
如果一个向量是一行数据：
[1, 2, 3]
那么很多向量放在一起：
[ 1 2 3 4 5 6 7 8 9 ]
就是：
**矩阵 Matrix**
可以简单理解：
向量 = 一排数字 矩阵 = 很多排数字
比如：
CPU Memory GPU 80 60 90 70 50 80 90 70 95
就是一个矩阵。
这是非常重要的问题。
假设：
输入： [1, 2, 3]
神经网络需要把它变换成：
[4, 5]
于是可以使用一个矩阵：
W = [ 1 2 3 4 5 6 ]
然后做：
X × W
得到：
这就是神经网络最核心的计算之一：
Y = XW + b
你以后会发现：
**深度学习里面大量计算，本质上就是矩阵运算。**
而这也正是为什么 GPU 对 AI 如此重要。
这个是后面 Transformer、CUDA、GPU 性能测试的基础。
假设：
A = [ 1 2 3 4 ]
B = [ 5 6 7 8 ]
那么：
A × B
结果：
[ 1×5 + 2×7 1×6 + 2×8 3×5 + 4×7 3×6 + 4×8 ]
得到：
[ 19 22 43 50 ]
你不需要现在死记。
但是一定要形成一个意识：
**矩阵乘法不是“对应位置直接相乘”，而是“行 × 列”。**
—
看一下刚才的计算：
1×5 + 2×7
实际上就是：
乘 + 乘 + 乘 + 乘 ...
如果矩阵非常大：
4096 × 4096
就会产生海量乘加操作。
AI 模型里面这种计算可能达到：
数十亿 数万亿
次。
而 GPU 特别擅长：
**同时进行大量简单的乘加计算。**
所以：
Transformer ↓ 大量矩阵乘法 ↓ GPU ↓ Tensor Core
这条链你以后会经常看到。
你以后看 PyTorch 会疯狂看到：
Tensor
Tensor 不需要把它想得很复杂。
可以先这么理解：
标量 Scalar
↓
向量 Vector
↓
矩阵 Matrix
↓
多维数组 Tensor
例如：
10
是标量。
[1, 2, 3]
是向量。
[ [1,2,3], [4,5,6] ]
是矩阵。
再往上：
[ [ [1,2,3], [4,5,6] ], [ [7,8,9], [10,11,12] ] ]
就是更高维的 Tensor。
所以你可以简单记：
**Tensor = 多维数字容器。**
—
因为 AI 数据经常不是二维。
例如一批图片：
Batch × Channel × Height × Width
可能是：
32 × 3 × 224 × 224
这已经是 4 维数据。
所以：
x.shape
可能返回：
[32, 3, 224, 224]
这就是 Tensor。
假设：
A = [1, 2] B = [4, 6]
A 和 B 离得多远？
你应该还记得初中数学：
√((4-1)² + (6-2)²)
也就是：
√(3² + 4²) = √25 = 5
这就是向量之间的欧氏距离。
为什么 AI 需要这个？
例如：
Embedding A Embedding B
如果两个向量距离比较近：
语义可能比较相似
于是：
Embedding ↓ Vector ↓ Distance / Similarity ↓ 判断相似程度
这就是 RAG、向量数据库的基础之一。
再看：
A = [1, 2, 3] B = [4, 5, 6]
点积：
A · B = 1×4 + 2×5 + 3×6 = 32
你会发现：
**点积本质上也是乘法 + 加法。**
它可以用来衡量两个向量之间的某种“方向一致程度”。
这就非常重要了。
因为 Transformer 的 Attention：
QKᵀ
本质上就在大量做：
**向量之间的点积。**
所以你现在理解：
向量 ↓ 点积 ↓ 矩阵乘法 ↓ Attention
以后学 Transformer 会轻松很多。
这个名字很吓人。
实际上先理解一个非常简单的问题：
**一个东西变化的时候，另一个东西变化得有多快？**
例如：
时间 → CPU温度
假设：
10秒：50℃ 20秒：60℃ 30秒：70℃
温度变化速度：
10℃ / 10秒 = 1℃/秒
这个“变化速度”的概念，就是导数最核心的直觉。
这是 AI 最关键的问题之一。
假设：
模型参数 W
↓
模型
↓
预测结果
↓
Loss
我们希望：
**Loss 越来越小。**
那么我们需要知道：
W 改一点，Loss 会怎么变化？
也就是：
Loss 对 W 的变化率
这就是导数。
如果只有一个参数：
我们可以：
dLoss / dW
但是神经网络可能有：
10亿个参数
于是：
W1 W2 W3 ... W1000000000
每个参数都有一个变化方向。
于是把这些导数放在一起：
**梯度 Gradient**
可以理解成：
Gradient = [ ∂Loss/∂W1 ∂Loss/∂W2 ∂Loss/∂W3 ... ]
想象你站在一座山上。
目标：
**走到山谷最低点。**
你需要知道：
哪个方向是下坡？
梯度就是在告诉你：
**当前这个位置，哪个方向 Loss 增长最快。**
所以我们反过来走：
参数 ↓ 计算梯度 ↓ 朝梯度反方向走 ↓ Loss下降
这就是：
梯度下降。
你现在应该开始把前面的知识串起来：
输入数据 ↓ Tensor ↓ 神经网络 ↓ 矩阵运算 ↓ 预测结果 ↓ Loss ↓ 计算 Gradient ↓ 修改参数 ↓ 再次计算 ↓ Loss越来越小
所以你以后看到：
loss.backward()
不要觉得这是什么神秘魔法。
它本质上是在：
**计算损失函数对模型参数的梯度。**
—
这个也非常重要。
假设模型看到一张图片：
猫？ 狗？ 兔子？
模型可能输出：
猫：0.80 狗：0.15 兔子：0.05
这里：
0.80 0.15 0.05
就是概率。
所以 AI 很多时候不是：
一定是猫
而是：
P(猫) = 80% P(狗) = 15% P(兔) = 5%
这个以后也非常重要。
例如：
已知一个词前面出现了“北京”，后面出现“天气”的概率是多少？
写成：
P(天气 | 北京)
读作：
在已知北京的条件下，天气出现的概率。
LLM 本质上就在不断做类似的事情：
P(next token | previous tokens)
也就是：
**根据前面的 Token，预测下一个 Token 的概率。**
这句话非常重要。
因为：
这个最简单。
例如 GPU 温度：
60 65 70 75
平均值：
(60+65+70+75)/4 =67.5
AI 里面到处都是均值。
例如：
Batch Mean Dataset Mean Loss Mean
这个非常值得理解。
假设两组测试数据：
A： 50 50 50 50
B： 20 50 80 50
两组平均值都是：
50
但是：
B 的波动明显更大。
这个“数据有多分散”，就是：
标准差：
Standard Deviation
就是方差开平方。
你以后做 AI 性能测试，会大量用到：
Mean Median P95 P99 Standard Deviation
所以统计学对测试工程师其实非常重要。
为了避免你重新掉进“大学数学大坑”，这些暂时不用深入：
❌ 复杂积分 ❌ 微分方程 ❌ 实分析 ❌ 抽象代数 ❌ 群论 ❌ 拓扑
甚至：
特征值 SVD 概率分布 贝叶斯
现在也只需要先建立概念。
后面学 Transformer、机器学习的时候再回来补。
你可以把下面这张图当作接下来学习的主线：
AI
│
┌──────────┴──────────┐
│ │
数据表示 模型训练
│ │
Vector Loss
│ │
Matrix Gradient
│ │
Tensor Derivative
│ │
Dot Product Optimization
│ │
└──────────┬──────────┘
│
Neural Network
│
Transformer
│
LLM
不要一次学几十个。
按照这个顺序：
① 函数 ② 变量 ③ 向量 ④ 矩阵 ⑤ 矩阵乘法 ⑥ Tensor ⑦ 点积 ⑧ 导数 ⑨ 梯度 ⑩ 概率
其中我尤其建议：
**向量 → 矩阵 → 矩阵乘法 → 点积**
这四个一定要真正理解。
因为后面：
Neural Network
↓
Transformer
↓
Attention
↓
LLM
↓
GPU
↓
CUDA
会不断出现它们。