时间可能不存在

本页面只读。您可以查看源文件，但不能更改它。如果您觉得这是系统错误，请联系管理员。
# 一、AI 需要哪些数学？

如果把 AI 数学压缩一下，主要就是这 5 类：

```text
AI 数学
│
├── ① 线性代数
│   ├── 向量
│   ├── 矩阵
│   ├── 张量
│   ├── 矩阵乘法
│   └── 特征值/特征向量
│
├── ② 微积分
│   ├── 函数
│   ├── 导数
│   ├── 偏导数
│   └── 梯度
│
├── ③ 概率
│   ├── 概率
│   ├── 条件概率
│   ├── 随机变量
│   └── 概率分布
│
├── ④ 统计
│   ├── 均值
│   ├── 方差
│   ├── 协方差
│   └── 相关性
│
└── ⑤ 优化
    ├── Loss
    ├── Gradient Descent
    └── Adam
```

**不用怕。**

这里面很多东西你以前其实学过，只是现在忘了。

而且我们真正需要的数学深度，远没有大学数学系那么夸张。

---

# 二、第一课：什么是“函数”？

这是后面所有东西的基础。

先别管 AI。

假设有一个程序：

```text
输入 CPU 温度
      ↓
   某个计算公式
      ↓
输出风扇转速
```

例如：

```text
风扇转速 = 10 × 温度
```

数学上写成：

```text
y = 10x
```

这就是一个**函数**。

可以理解成：

> **函数 = 一个输入 → 按某种规则 → 得到一个输出**

例如：

```text
x = 20
↓
y = 10 × 20
↓
y = 200
```

所以：

```text
f(x) = 10x
```

和：

```text
y = 10x
```

本质上是一回事。

---

# 三、为什么 AI 里面到处都是函数？

因为神经网络本质上就是：

```text
输入
 ↓
函数
 ↓
函数
 ↓
函数
 ↓
输出
```

例如：

```text
输入 x
 ↓
f₁(x)
 ↓
f₂(x)
 ↓
f₃(x)
 ↓
预测结果
```

所以可以把神经网络粗略理解成：

> **一个非常复杂的函数。**

例如：

```text
图片
 ↓
神经网络
 ↓
猫的概率 = 0.97
```

数学上其实就是：

```text
y = f(x)
```

---

# 四、第二个概念：变量

这个更简单。

```text
x = 10
```

这里：

```text
x
```

就是变量。

它可以换：

```text
x = 20
x = 30
x = 100
```

在 AI 中：

```text
x
```

可能代表：

* 一个温度
* 一个 CPU 利用率
* 一个图片
* 一个 Token
* 一个向量
* 一批训练数据

所以看到：

```text
x
```

不要害怕。

它通常就是：

> **某个我们暂时不知道具体数值的东西。**

---

# 五、第三个概念：向量

这个是你接下来必须重点理解的。

假设我们测试一台服务器，记录：

```text
CPU = 80%
Memory = 60%
GPU = 90%
Temperature = 70℃
```

可以写成：

```text
x =
[
    80
    60
    90
    70
]
```

这就是一个**向量（Vector）**。

你也可以把它理解成：

> **一组有顺序的数字。**

例如：

```text
[1, 2, 3]
```

就是一个 3 维向量。

```text
[1, 2, 3, 4, 5]
```

就是 5 维向量。

---

# 六、为什么 AI 特别喜欢向量？

因为计算机最擅长处理数字。

例如：

```text
一个人
```

计算机不知道这个人是什么。

但是我们可以把一些特征数字化：

```text
年龄 = 30
身高 = 175
体重 = 70
收入 = 10000
```

变成：

```text
[30, 175, 70, 10000]
```

于是：

> **现实世界的信息 → 数字 → 向量**

这就是 AI 数学非常重要的一步。

---

# 七、Embedding 就是这个思路

以后你会经常看到：

```text
Embedding
```

例如：

```text
"苹果"
```

经过模型：

```text
Embedding
 ↓
[0.12, -0.43, 0.82, 0.11, ...]
```

可能是 768 维：

```text
[
  0.12,
 -0.43,
  0.82,
 ...
]
```

于是计算机就可以通过数学方法比较：

```text
苹果
香蕉
汽车
电脑
```

之间的“相似程度”。

所以你以后看到：

> **Embedding = 把东西变成向量**

先记住这个直觉。

---

# 八、第四个概念：矩阵

如果一个向量是一行数据：

```text
[1, 2, 3]
```

那么很多向量放在一起：

```text
[
  1  2  3
  4  5  6
  7  8  9
]
```

就是：

> **矩阵 Matrix**

可以简单理解：

```text
向量 = 一排数字

矩阵 = 很多排数字
```

比如：

```text
CPU Memory GPU
80  60     90
70  50     80
90  70     95
```

就是一个矩阵。

---

# 九、为什么 AI 需要矩阵？

这是非常重要的问题。

假设：

```text
输入：
[1, 2, 3]
```

神经网络需要把它变换成：

```text
[4, 5]
```

于是可以使用一个矩阵：

```text
W =
[
  1  2
  3  4
  5  6
]
```

然后做：

```text
X × W
```

得到：

```text
Y
```

这就是神经网络最核心的计算之一：

```text
Y = XW + b
```

你以后会发现：

> **深度学习里面大量计算，本质上就是矩阵运算。**

而这也正是为什么 GPU 对 AI 如此重要。

---

# 十、矩阵乘法一定要搞懂

这个是后面 Transformer、CUDA、GPU 性能测试的基础。

假设：

```text
A =
[
  1  2
  3  4
]
```

```text
B =
[
  5  6
  7  8
]
```

那么：

```text
A × B
```

结果：

```text
[
  1×5 + 2×7    1×6 + 2×8
  3×5 + 4×7    3×6 + 4×8
]
```

得到：

```text
[
  19  22
  43  50
]
```

你不需要现在死记。

但是一定要形成一个意识：

> **矩阵乘法不是“对应位置直接相乘”，而是“行 × 列”。**

---

# 十一、为什么矩阵乘法和 GPU 有关系？

看一下刚才的计算：

```text
1×5 + 2×7
```

实际上就是：

```text
乘
+
乘
+
乘
+
乘
...
```

如果矩阵非常大：

```text
4096 × 4096
```

就会产生海量乘加操作。

AI 模型里面这种计算可能达到：

```text
数十亿
数万亿
```

次。

而 GPU 特别擅长：

> **同时进行大量简单的乘加计算。**

所以：

```text
Transformer
 ↓
大量矩阵乘法
 ↓
GPU
 ↓
Tensor Core
```

这条链你以后会经常看到。

---

# 十二、第五个概念：Tensor

你以后看 PyTorch 会疯狂看到：

```python
Tensor
```

Tensor 不需要把它想得很复杂。

可以先这么理解：

```text
标量 Scalar
    ↓
向量 Vector
    ↓
矩阵 Matrix
    ↓
多维数组 Tensor
```

例如：

```text
10
```

是标量。

```text
[1, 2, 3]
```

是向量。

```text
[
 [1,2,3],
 [4,5,6]
]
```

是矩阵。

再往上：

```text
[
 [
   [1,2,3],
   [4,5,6]
 ],
 [
   [7,8,9],
   [10,11,12]
 ]
]
```

就是更高维的 Tensor。

所以你可以简单记：

> **Tensor = 多维数字容器。**

---

# 十三、为什么 PyTorch 不直接叫 Matrix？

因为 AI 数据经常不是二维。

例如一批图片：

```text
Batch
 ×
Channel
 ×
Height
 ×
Width
```

可能是：

```text
32 × 3 × 224 × 224
```

这已经是 4 维数据。

所以：

```python
x.shape
```

可能返回：

```text
[32, 3, 224, 224]
```

这就是 Tensor。

---

# 十四、接下来是一个非常重要的概念：距离

假设：

```text
A = [1, 2]

B = [4, 6]
```

A 和 B 离得多远？

你应该还记得初中数学：

```text
√((4-1)² + (6-2)²)
```

也就是：

```text
√(3² + 4²)
= √25
= 5
```

这就是向量之间的**欧氏距离**。

为什么 AI 需要这个？

例如：

```text
Embedding A
Embedding B
```

如果两个向量距离比较近：

```text
语义可能比较相似
```

于是：

```text
Embedding
 ↓
Vector
 ↓
Distance / Similarity
 ↓
判断相似程度
```

这就是 RAG、向量数据库的基础之一。

---

# 十五、点积：AI 中超级重要

再看：

```text
A = [1, 2, 3]

B = [4, 5, 6]
```

点积：

```text
A · B
=
1×4 + 2×5 + 3×6
=
32
```

你会发现：

> **点积本质上也是乘法 + 加法。**

它可以用来衡量两个向量之间的某种“方向一致程度”。

这就非常重要了。

因为 Transformer 的 Attention：

```text
QKᵀ
```

本质上就在大量做：

> **向量之间的点积。**

所以你现在理解：

```text
向量
 ↓
点积
 ↓
矩阵乘法
 ↓
Attention
```

以后学 Transformer 会轻松很多。

---

# 十六、然后我们进入微积分：导数

这个名字很吓人。

实际上先理解一个非常简单的问题：

> **一个东西变化的时候，另一个东西变化得有多快？**

例如：

```text
时间 → CPU温度
```

假设：

```text
10秒：50℃
20秒：60℃
30秒：70℃
```

温度变化速度：

```text
10℃ / 10秒
=
1℃/秒
```

这个“变化速度”的概念，就是导数最核心的直觉。

---

# 十七、为什么 AI 需要导数？

这是 AI 最关键的问题之一。

假设：

```text
模型参数 W
    ↓
模型
    ↓
预测结果
    ↓
Loss
```

我们希望：

> **Loss 越来越小。**

那么我们需要知道：

> W 改一点，Loss 会怎么变化？

也就是：

```text
Loss 对 W 的变化率
```

这就是导数。

---

# 十八、梯度

如果只有一个参数：

```text
W
```

我们可以：

```text
dLoss / dW
```

但是神经网络可能有：

```text
10亿个参数
```

于是：

```text
W1
W2
W3
...
W1000000000
```

每个参数都有一个变化方向。

于是把这些导数放在一起：

> **梯度 Gradient**

可以理解成：

```text
Gradient =
[
 ∂Loss/∂W1
 ∂Loss/∂W2
 ∂Loss/∂W3
 ...
]
```

---

# 十九、梯度到底有什么用？

想象你站在一座山上。

目标：

> **走到山谷最低点。**

你需要知道：

> 哪个方向是下坡？

梯度就是在告诉你：

> **当前这个位置，哪个方向 Loss 增长最快。**

所以我们反过来走：

```text
参数
 ↓
计算梯度
 ↓
朝梯度反方向走
 ↓
Loss下降
```

这就是：

# Gradient Descent

梯度下降。

---

# 二十、这就是 AI 训练的核心循环

你现在应该开始把前面的知识串起来：

```text
输入数据
   ↓
Tensor
   ↓
神经网络
   ↓
矩阵运算
   ↓
预测结果
   ↓
Loss
   ↓
计算 Gradient
   ↓
修改参数
   ↓
再次计算
   ↓
Loss越来越小
```

所以你以后看到：

```python
loss.backward()
```

不要觉得这是什么神秘魔法。

它本质上是在：

> **计算损失函数对模型参数的梯度。**

---

# 二十一、概率：AI 为什么需要概率？

这个也非常重要。

假设模型看到一张图片：

```text
猫？
狗？
兔子？
```

模型可能输出：

```text
猫：0.80
狗：0.15
兔子：0.05
```

这里：

```text
0.80
0.15
0.05
```

就是概率。

所以 AI 很多时候不是：

```text
一定是猫
```

而是：

```text
P(猫) = 80%
P(狗) = 15%
P(兔) = 5%
```

---

# 二十二、条件概率

这个以后也非常重要。

例如：

> 已知一个词前面出现了“北京”，后面出现“天气”的概率是多少？

写成：

```text
P(天气 | 北京)
```

读作：

> 在已知北京的条件下，天气出现的概率。

LLM 本质上就在不断做类似的事情：

```text
P(next token | previous tokens)
```

也就是：

> **根据前面的 Token，预测下一个 Token 的概率。**

这句话非常重要。

因为：

# LLM 的核心任务之一，就是预测下一个 Token。

---

# 二十三、均值

这个最简单。

例如 GPU 温度：

```text
60
65
70
75
```

平均值：

```text
(60+65+70+75)/4
=67.5
```

AI 里面到处都是均值。

例如：

```text
Batch Mean
Dataset Mean
Loss Mean
```

---

# 二十四、方差

这个非常值得理解。

假设两组测试数据：

```text
A：
50
50
50
50
```

```text
B：
20
50
80
50
```

两组平均值都是：

```text
50
```

但是：

> B 的波动明显更大。

这个“数据有多分散”，就是：

# 方差 Variance

标准差：

```text
Standard Deviation
```

就是方差开平方。

你以后做 AI 性能测试，会大量用到：

```text
Mean
Median
P95
P99
Standard Deviation
```

所以统计学对测试工程师其实非常重要。

---

# 二十五、你现在暂时不用学什么？

为了避免你重新掉进“大学数学大坑”，这些暂时不用深入：

```text
❌ 复杂积分
❌ 微分方程
❌ 实分析
❌ 抽象代数
❌ 群论
❌ 拓扑
```

甚至：

```text
特征值
SVD
概率分布
贝叶斯
```

现在也只需要先建立概念。

后面学 Transformer、机器学习的时候再回来补。

---

# 二十六、我们现在先建立一张“AI 数学地图”

你可以把下面这张图当作接下来学习的主线：

```text
                    AI
                     │
          ┌──────────┴──────────┐
          │                     │
       数据表示                模型训练
          │                     │
       Vector                  Loss
          │                     │
       Matrix                  Gradient
          │                     │
       Tensor                  Derivative
          │                     │
       Dot Product             Optimization
          │                     │
          └──────────┬──────────┘
                     │
                Neural Network
                     │
                 Transformer
                     │
                    LLM
```

---

# 二十七、你现在最应该先搞懂的 10 个东西

不要一次学几十个。

按照这个顺序：

```text
① 函数
② 变量
③ 向量
④ 矩阵
⑤ 矩阵乘法
⑥ Tensor
⑦ 点积
⑧ 导数
⑨ 梯度
⑩ 概率
```

其中我尤其建议：

> **向量 → 矩阵 → 矩阵乘法 → 点积**

这四个一定要真正理解。

因为后面：

```text
Neural Network
       ↓
Transformer
       ↓
Attention
       ↓
LLM
       ↓
GPU
       ↓
CUDA
```

会不断出现它们。