动手写一下向量#

打开你的 Jupyter Notebook 或者随便一个 Python 文件：

1
import numpy as np
2

3
# 定义一个向量：向右 3，向上 2
4
v = np.array([3, 2])
5
print(f"向量 v: {v}")        # [3 2]
6
print(f"v 的长度: {np.linalg.norm(v):.2f}")  # 勾股定理: sqrt(3²+2²) ≈ 3.61
7

8
# 另一个向量：向左 2，向上 4
9
w = np.array([-2, 4])
10

11
# 向量加法 —— 就是"先做 v 这个移动，再做 w 这个移动"
12
v_plus_w = v + w
13
print(f"v + w = {v_plus_w}")  # [1 6]
14
# 你先向右3上2，再向左2上4 ⇒ 最终向右1上6 ✅
15

16
# 数乘 —— 把移动放大或缩小
17
v_scaled = 3 * v
18
print(f"3 × v = {v_scaled}")  # [9 6]
19
# 向右3上2 放大3倍 ⇒ 向右9上6 ✅

你会发现，向量加法就是数组逐位相加，数乘就是每个分量都乘以那个数字。不是魔法，就是数组运算。

来看一个”向量就是移动”的直观证据：

1
# 假设起点是 (0,0)
2
start = np.array([0, 0])
3
v1 = np.array([3, 0])   # 向右3
4
v2 = np.array([0, 2])   # 向上2
5

6
# 第一步：向右走3
7
step1 = start + v1      # (3, 0)
8
# 第二步：向上走2
9
step2 = step1 + v2      # (3, 2)
10

11
print(f"起点{start} → 向右3 → {step1} → 向上2 → {step2}")
12
# 输出: 起点[0 0] → 向右3 → [3 0] → 向上2 → [3 2]

你每一步的”移动”就是一个向量，最终位置就是所有向量相加的结果。这也是为什么向量加法叫”平行四边形法则”——如果你把两个箭头的起点放在一起，终点就是它们构成的平行四边形的对角。

1
        (3,2)
2
         •
3
        /|
4
       / |
5
      /  |
6
     /   | (0,2)
7
    /    |
8
   •-----•
9
 (0,0)  (3,0)

到这里你应该有个感觉了：向量不是抽象的数字，而是你可以真正”走”出来的路径。

动手验证一下矩阵变换#

用 NumPy 来实现刚才说的那几个矩阵，你就能亲眼看到点是怎么被”拉扯”的：

1
import numpy as np
2

3
# 定义一个点 (1, 2)
4
point = np.array([1, 2])
5

6
# --- 矩阵1: 横向拉伸2倍 ---
7
A_stretch = np.array([[2, 0],
8
                       [0, 1]])
9
result_stretch = A_stretch @ point   # @ 就是矩阵乘向量
10
print(f"横向拉伸: {point} → {result_stretch}")
11
# 输出: [1 2] → [2 2]
12
# x从1变成2（拉长），y保持2不变 ✅
13

14
# --- 矩阵2: 纵向拉伸3倍 ---
15
A_vertical = np.array([[1, 0],
16
                        [0, 3]])
17
result_vertical = A_vertical @ point
18
print(f"纵向拉伸: {point} → {result_vertical}")
19
# 输出: [1 2] → [1 6] ✅
20

21
# --- 矩阵3: 旋转90° ---
22
A_rotate = np.array([[0, -1],
23
                      [1,  0]])
24
result_rotate = A_rotate @ point
25
print(f"旋转90°: {point} → {result_rotate}")
26
# 输出: [1 2] → [-2 1]
27
# 画出来: ↗ 旋转后指向 ↖
28

29
# --- 矩阵4: 剪切 (shear) ---
30
A_shear = np.array([[1, 1],
31
                     [0, 1]])
32
result_shear = A_shear @ point
33
print(f"剪切: {point} → {result_shear}")
34
# 输出: [1 2] → [3 2]
35
# x方向被"推"了一下

仔细看 A_stretch @ point 这一步。@ 就是矩阵乘向量，它做的就是”把这个点扔进空间变化器，吐出一个新位置”。代码跑一遍比看十遍公式都管用。

矩阵不是神秘数字表，它是你对空间下达的指令：“把 x 方向拉长”、“把整个世界旋转”、“把上面固定、下面往右推”。

动手算一下行列式#

用 NumPy 验证一下：

1
import numpy as np
2

3
# 拉伸矩阵: 面积扩大2倍
4
A = np.array([[2, 0],
5
              [0, 1]])
6
print(f"det(A) = {np.linalg.det(A):.1f}")  # 2.0 ✅
7

8
# 翻转矩阵: 面积不变但方向反了
9
B = np.array([[-1, 0],
10
              [ 0, 1]])
11
print(f"det(B) = {np.linalg.det(B):.1f}")  # -1.0 ✅
12

13
# 压扁矩阵: 面积变0
14
C = np.array([[1, 1],
15
              [1, 1]])
16
print(f"det(C) = {np.linalg.det(C):.1f}")  # 0.0 ✅

行列式值的几何含义——一张表看懂#

行列式的正负和大小，其实就是在告诉你”空间被揉成了什么样”：

你可以这样记：行列式的绝对值 = 面积/体积变化倍数。行列式的符号 = 空间有没有被翻面（正=保持朝向，负=翻转）。

练习题（动手做，别光看）#

题目 1： 矩阵 [[3, 0], [0, 2]] 的行列式是多少？它在几何上代表什么？

题目 2： 为什么 det = 0 的矩阵不能求逆？用一句话解释。

题目 3： 下面这个矩阵，不用公式算，只凭几何直觉告诉我 det 大概是多少：

1
A = [[0.5, 0],
2
     [0,   2]]

用代码理解逆矩阵#

1
import numpy as np
2

3
# 拉伸矩阵: x方向×2, y方向×3
4
A = np.array([[2, 0],
5
              [0, 3]])
6

7
# 逆矩阵: x方向/2, y方向/3 —— 恢复原状
8
A_inv = np.linalg.inv(A)
9
print(f"A 的逆矩阵:\n{A_inv}")
10
# [[0.5  0. ]
11
#  [0.   0.33]]
12

13
# 验证: A × A_inv 应该 = 单位矩阵（什么都没变）
14
I = A @ A_inv
15
print(f"A × A⁻¹:\n{I}")
16
# [[1. 0.]
17
#  [0. 1.]]
18

19
# 把(2,3)扔进去，再撤销回来
20
v = np.array([2, 3])
21
v_transformed = A @ v      # (4, 9)
22
v_recovered = A_inv @ v_transformed  # (2, 3)
23
print(f"原向量{v} → 变换后{v_transformed} → 逆回去{v_recovered}")

用代码找特征值和特征向量#

NumPy 一行搞定。我们来实战一下：

1
import numpy as np
2

3
# 拉伸矩阵: x方向×2, y方向×3
4
A = np.array([[2, 0],
5
              [0, 3]])
6

7
# 求特征值和特征向量
8
eigenvalues, eigenvectors = np.linalg.eig(A)
9

10
print("特征值:", eigenvalues)        # [2. 3.]
11
print("特征向量 (两列):\n", eigenvectors)
12
# [[1. 0.]    ← 水平方向，特征值=2
13
#  [0. 1.]]   ← 竖直方向，特征值=3
14

15
# 验证: A × v = λ × v
16
v1 = eigenvectors[:, 0]   # 第一个特征向量 (1,0)
17
lambda1 = eigenvalues[0]  # 第一个特征值 2
18

19
print(f"A @ v1 = {A @ v1}")           # [2. 0.]
20
print(f"λ × v1 = {lambda1 * v1}")     # [2. 0.]
21
# 相等 ✅ 这就是 Ax = λx 的含义

实际用途： 以后你学到 PCA（主成分分析），本质上就是在求数据的协方差矩阵的特征向量——找到数据”最散开的方向”。这些方向就是你降维时应该保留的。Transformer 里的 Embedding 空间也有类似的结构：某些方向代表”动物性”，某些代表”语法性别”——这些方向本质上就是高维空间中的特征方向。

练习题#

题目 1： 矩阵 [[0, -1], [1, 0]]（旋转 90°）的特征值在实数范围内是什么？为什么？

题目 2： 用代码验证：矩阵 [[4, 1], [2, 3]] 的特征向量经过矩阵变换后，方向是否保持不变。

1
import numpy as np
2
A = np.array([[4, 1], [2, 3]])
3
eigvals, eigvecs = np.linalg.eig(A)
4

5
for i in range(2):
6
    v = eigvecs[:, i]
7
    lam = eigvals[i]
8
    print(f"特征向量 v{i+1}: {v}")
9
    print(f"A @ v = {A @ v}")
10
    print(f"λ × v = {lam * v}")
11
    print(f"方向是否一致: {np.allclose(A @ v, lam * v)}")
12
    print("---")

第一课：世界其实没有坐标轴#

我想让你先忘掉所有公式。

假设你现在站在一个巨大的草原。

1
🌳
2

3
            你
4
             ●

这里只有你。

没有 x 轴、y 轴、原点、坐标。

请问：你在哪里？

答案其实是：没人知道。

因为位置一定要有参照物。

那怎么告诉别人你的位置？

假设地上插了一根旗子。

1
🚩
2

3
            ●你

别人问：你在哪里？

你说：

我距离旗子向东 3 米，向北 2 米。

于是 (3,2) 出现了。

所以第一件非常重要的事情：

坐标不是世界本身，而只是描述世界的一种方法。

很多教材一开始就画坐标轴，让人误以为坐标是真实存在的。

其实不是。真正存在的是 空间。坐标只是给空间贴标签。

第二课：向量其实不是数字#

很多书会写：

然后说：这是向量。

其实不是。

假设你玩 Minecraft。有人说：去宝箱。

他说：

向东走 3 格，向北走 2 格。

1
↑
2
↑
3

4
→→→

这就是 (3,2)。

注意：它不是位置，而是 一种移动的方法。

所以向量真正表示的是：动作。

例如：

• (5,0) — 一直往右：→→→→→
• (0,4) — 一直往上
• (-2,3) — 左两步，上三步

所以以后看到 (7,-1)，你的脑子不要想数字，而要想：“怎么走”。

第三课：为什么向量可以相加？#

假设：

• 第一步：往右走 3：→→→
• 第二步：往上 2：↑↑

那么最后 (3,2) 是不是 (3,0) + (0,2)？

所以向量相加，其实就是：

连续做两个动作。

不是数字加数字，而是动作加动作。

例如 (3,1) + (-2,4)：

先 →→→↑，再 ←←↑↑↑↑，最后 →↑↑↑↑↑，得到 (1,5)。

第四课：为什么可以乘数字？#

假设 (2,1) 表示右两步，上一步。

如果乘 2：2 × (2,1)。

其实意思：动作放大两倍。

1
→→      →→→→
2
↑   →   ↑↑

得到 (4,2)。

所以数字乘向量 =

把移动放大。

不是数字运算。

到这里，你已经知道了三个最重要的概念：

注意：这里还没有矩阵。

因为矩阵其实是一个更高级的东西。

那矩阵到底是什么？#

这里先给你留一个问题。

假设有一个神奇机器。任何箭头进去，都会出来新的箭头。

• → 进去 → →→ 出来
• ↑ 进去 → ↑↑↑ 出来
• ↗ 进去 → ↘ 出来

它可以拉长、缩短、旋转、压缩、翻转，甚至几个一起做。

这个神奇机器，就是 矩阵。

所以你可以先把矩阵理解成：

一个”空间变换器”。

来看看答案#

先回忆规则：

所有水平方向拉长 2 倍，竖直方向保持不变。

也就是说：x 坐标 ×2，y 坐标 ×1。

第一题： (1,0)

只有水平。所以 → 变成 →→，得到 (2,0)。✅

第二题： (0,1)

只有竖直。所以 ↑ 还是 ↑，得到 (0,1)。

第三题： (1,1)

这一步千万不要想着”矩阵怎么算”。

把它想成：先向右走 1，再向上走 1。组合起来就是 ↗。

现在空间发生变化：

• 水平方向变成 2 倍
• 竖直方向保持不变

所以：右边 1→2，上边 1→1。

因此：

为什么这件事情这么重要？#

因为你刚刚已经碰到了 矩阵最核心的思想。

很多教材会直接告诉你：

然后让你开始算。

但实际上，这个式子表达的是：

不是数字在变，而是整个空间在变。

想象一张画着方格的橡皮纸，把橡皮纸横向拉长两倍——原来在 (1,1) 的那个点，并不是自己主动移动了，而是整个世界被拉宽了，于是它自然来到 (2,1)。

再进一步想一想#

如果我告诉你：

现在这个机器不是拉长，而是旋转 90°。

那么你觉得 (1,0) 会变成什么？

不要查公式，也不要算矩阵。

就在脑子里想象：把整张纸逆时针旋转 90°，那个向右的箭头最后会指向哪里？

答案是：

原来的 →，旋转以后变成 ↑。

我们发现一个非常重要的事情#

刚才的两个例子：

例 1：拉伸 — 横向扩大 2 倍

• (1,0) → (2,0)
• (0,1) → (0,1)

例 2：旋转 — 逆时针旋转 90°

• (1,0) → (0,1)

你有没有发现？

我们其实根本不需要知道整个矩阵。

只需要知道：

基准方向发生了什么。

中场休息：用代码把”矩阵=空间变换器”焊死在脑子里#

前面讲了这么多理论，现在是时候看看它们在代码里长什么样了。以下代码用 PyTorch 实现——以后你写 FreesLLM 也全都用这套工具。

1
import torch
2
import torch.nn as nn
3

4
# nn.Linear(输入维度, 输出维度) 就是一个矩阵 W
5
# 内部做的事: y = x @ W^T + b
6
layer = nn.Linear(2, 2)
7

8
# 这就是那个矩阵 W —— 也就是"空间变换器"
9
print("矩阵 W 的值（空间变换规则）:")
10
print(layer.weight.data)
11
# 输出类似:
12
# tensor([[ 0.5341, -0.3214],
13
#         [ 0.2187,  0.6912]])
14
# 这个矩阵里的数字一开始是随机的，训练会不断调整它们
15

16
# 把一个向量扔进去
17
x = torch.tensor([1.0, 2.0])  # 点 (1, 2)，就像你纸上那个点
18
y = layer(x)                    # 这就是 x 经过空间变换后的新位置
19

20
print(f"\n原始点: {x.tolist()}")
21
print(f"经过线性层后: {y.tolist()}")

1
# 两层神经网络 = 两个空间变换器串联
2
layer1 = nn.Linear(2, 4)   # 2维 → 4维（扩大空间）
3
layer2 = nn.Linear(4, 2)   # 4维 → 2维（压缩回来）
4

5
x = torch.tensor([1.0, 2.0])
6

7
# Forward pass —— 就是连续扔进两个空间变换器
8
h = layer1(x)              # 第一次变换：进入4维空间
9
y = layer2(h)              # 第二次变换：回到2维空间
10

11
print(f"原始: {x.tolist()}")
12
print(f"经过两层后: {y.tolist()}")

1
# 两层纯线性 = 可以合并成一个矩阵
2
layer1 = nn.Linear(4, 4, bias=False)
3
layer2 = nn.Linear(4, 4, bias=False)
4

5
# 两层连续变换 = W2 @ (W1 @ x) = (W2 @ W1) @ x = 一个大矩阵
6
W_combined = layer2.weight @ layer1.weight
7
print(f"W_combined 形状: {W_combined.shape}")  # (4, 4)
8

9
# 所以多层纯线性 = 一层线性，叠再多也没用
10
# 这就是为什么必须有激活函数（ReLU等）

1
# 带 ReLU 的简单网络 —— 终于像一个真正的神经网络了
2
model = nn.Sequential(
3
    nn.Linear(2, 4),    # 空间变换1: 2维 → 4维
4
    nn.ReLU(),          # 非线性: 把负的砍成0（空间被"折叠"）
5
    nn.Linear(4, 2),    # 空间变换2: 4维 → 2维
6
)
7

8
x = torch.tensor([1.0, -2.0])
9
y = model(x)
10
print(f"带激活函数的输出: {y.tolist()}")
11

12
# ReLU(-2.0) = 0 → 负数被"砍掉"
13
# 这一步让空间不能简单地用一个矩阵描述
14
# 这就是"非线性"的威力

1
import torch
2

3
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0, 3.0])
4
relu_out = torch.relu(x)
5
print(f"输入:  {x.tolist()}")
6
print(f"ReLU后: {relu_out.tolist()}")
7
# 输入:  [-2.0, -1.0, 0.0, 1.0, 2.0, 3.0]
8
# ReLU后: [0.0, 0.0, 0.0, 1.0, 2.0, 3.0]
9
# 所有负数 → 0，正数和零 → 保持不变

练习题#

题目 1： 写一个两层的神经网络（2→8→1），不要激活函数。随机初始化后，把向量 [1, 2] 扔进去看输出。

题目 2： 在题 1 的网络里，在两层之间加一个 nn.ReLU()。同样输入 [1, 2]。对比两个网络的输出，有什么区别？

题目 3： 如果把题 1 的网络层数增加到 100 层（每层 2→2，无激活函数），这和 1 层的 2→2 矩阵在数学上等价吗？为什么？

1
model = nn.Sequential(
2
    nn.Linear(2, 8),
3
    nn.Linear(8, 1),
4
)
5
x = torch.tensor([1.0, 2.0])
6
print(model(x))

1. 先忘掉坐标，想象真实世界#

假设桌子上有一个苹果。

苹果在那里。它真实存在。

现在我问：苹果在哪里？

你说：桌子中间。

这是一种描述。但是”桌子中间”不是苹果本身。

如果换一种描述：

距离桌子左边 30cm，距离桌子前面 20cm。

也是苹果的位置。

所以：

1
苹果（真实东西）
2
     ↓
3
描述方法（坐标）

数学里的点也是一样。点本身不是 (3,2)，而是一个位置。(3,2) 只是 一种描述这个位置的方法。

2. 为什么需要基底？#

假设你站在上海。别人问：“你在哪里？”

你不能说”我在这里”，因为别人不知道”这里”。

你需要参考。

方案 A： 以东方和北方作为参考。

1
      北
2
      ↑
3
      |
4
      |
5
      +------→ 东

你说：向东 3 公里，向北 2 公里。就是 (3,2)。

方案 B： 换一个参考方向。

比如规定：东北方向是第一个方向，西北方向是第二个方向。

1
        西北
2
          ↖
3
          |
4
          ●
5
          |
6
          ↗
7
        东北

现在你的位置仍然没变，但是你的描述方式变了。

这就是：基底。

基底就是：描述空间时，你选择的”参考方向”。

3. 一个更生活化的例子：地图导航#

假设你朋友问：“去宿舍怎么走？”

你有两种说法。

方式 1： 普通地图

向东 100 米，向北 50 米。

这是 (100, 50)。

方式 2： 学校地图

规定：沿着教学楼方向 = A，沿着操场方向 = B。

你说：走 3 个 A 单位，2 个 B 单位。

注意：你们描述的是同一个地方，但是数字不同。

为什么？因为参考方向不同。

4. 回到数学#

我们通常使用两个基底：

所以 (3,2) 其实不是一个整体。它拆开：

三个右方向 →→→，两个上方向 ↑↑，组合得到那个位置。

5. 现在改变基底#

重点来了。

假设我不用”右”和”上”。

我规定新的两个方向：

画一下：

1
原来的：          新的：
2
↑                 ↗
3
|                /
4
|               /
5
+----→          +----→

现在我要描述一个点 (3,2)。

问题：需要几个 b_1 和几个 b_2 才能拼出来？

我们写：

代入：

展开：

我要它等于 (3,2)。

所以：y = 2，x + y = 3，得 x = 1。

答案：

什么意思？

同一个位置：

• 以前：3e_1 + 2e_2
• 现在：1b_1 + 2b_2

数字变了，但是位置没变。

6. 这就是矩阵为什么存在#

矩阵其实就是一个”翻译器”。

1
旧语言（水平/竖直）
2
     ↓
3
   矩阵
4
     ↓
5
新语言（斜方向）

它负责：把一种坐标描述，转换成另一种坐标描述。

7. 为什么 AI 里面大量出现？#

因为机器学习面对的是高维空间。

比如一个人的照片，可能变成：

1
[0.23, 0.52, 0.91, ...]

几千个数字。但是这些数字本身没有意义。

模型训练的过程，就是不断学习：

哪些方向代表什么信息。

比如：

• 某个方向可能代表”猫的耳朵特征”
• 某个方向代表”毛发纹理”
• 某个方向代表”动物性”

矩阵就是不断调整”坐标系”，让重要的信息变得明显。

8. 你现在应该建立一个新的脑图#

以前：

1
向量 = 一串数字
2
矩阵 = 数字表

现在换成：

1
空间
2
 |
3
选择参考方向
4
 |
5
基底
6
 |
7
用数字描述位置
8
 |
9
矩阵改变描述方式/空间

1. 一个机器怎么描述变化？#

假设有一个空间变化机器：

1
输入箭头 → [ 神秘机器 ] → 输出箭头

我们想知道这个机器到底干了什么。

最简单的方法：不要测试所有箭头，只测试两个特殊箭头。

为什么？因为所有箭头都是它们组合出来的。

这两个箭头：

2. 假设机器改变了两个方向#

比如机器说：

• 右方向 (1,0) 进去 → (2,1) 出来（→ 变成 ↗）
• 上方向 (0,1) 进去 → (-1,1) 出来（↑ 变成 ↖）

那么这个机器是什么？其实已经完全知道了。

因为任何向量 (3,2) 都是 3e_1 + 2e_2。

3. 看这个向量经过机器#

原来 (3,2) = 3(1,0) + 2(0,1)

机器处理：

• 第一部分：(1,0) → (2,1)，3 个 → 3(2,1) = (6,3)
• 第二部分：(0,1) → (-1,1)，2 个 → 2(-1,1) = (-2,2)

最后：(6,3) + (-2,2) = (4,5)

所以这个机器把 (3,2) 变成了 (4,5)。

4. 现在重点来了#

这个机器的信息其实只有两个：

• 右方向变成 (2,1)
• 上方向变成 (-1,1)

那我们把它写成一个表：

注意！第一列 [2, 1] 是什么？就是 e_1 变化后的样子。

第二列 [-1, 1] 是什么？就是 e_2 变化后的样子。

所以：

矩阵的列，就是基底经过变化后的结果。

不是规定。是因为：我们只需要记录机器如何处理最基本的两个方向。

5. 为什么矩阵乘法长这样？#

现在看：

很多人觉得”第一行乘第一列”很奇怪。

但是换成我们刚才的理解：

(3,2) 意思：3 个第一个方向，2 个第二个方向。

所以 A(3,2) 其实就是：

也就是：

这就是矩阵乘法。

所以矩阵乘向量不是算术，而是：

按照新的基底重新组合。

6. 这和神经网络有什么关系？#

现在看神经网络：

比如输入 x 是一句话的向量（“猫”），它可能在一个”原始语义空间”。

矩阵 W 做的事情：改变基底。

把”猫”转换到”更容易预测的空间”。

例如：

• 原空间：动物程度、可爱程度、大小、颜色
• 经过 W：是否像宠物、是否像食物、是否像移动物体

（只是举例，真实情况更复杂）

7. 现在你应该理解一个非常重要的事实#

神经网络里的参数，本质上就是”空间变换规则”。

训练是什么？就是调整这些矩阵，让空间变成更有意义的样子。

1. 先回忆矩阵是什么#

我们已经知道：矩阵不是数字表，它是一个改变空间的机器。

假设 A 是一个旋转机器：→ 进去，↑ 出来。

B 是一个放大机器：↑ 进去，↑↑↑ 出来。

现在问题来了：如果两个机器连起来：

1
箭头 → A → B → 结果

这整体是什么？

答案：还是一个矩阵。也就是 BA。

2. 为什么顺序重要？#

这是很多人第一次学矩阵乘法最痛苦的地方：为什么 AB ≠ BA？

我们用现实理解。

假设：A = 旋转 90°，B = 横向拉长 2 倍。

情况 1：先旋转，再拉长（BA）

原来 →，旋转变成 ↑，横向拉长——但现在是竖直方向，横向拉长对它没影响。结果：↑。

情况 2：先拉长，再旋转（AB）

原来 →，横向拉长变成 →→，旋转变成 ↑↑。结果：长度变了。

所以：

1
先旋转再拉伸 ≠ 先拉伸再旋转

这就是 AB ≠ BA。

先做什么，再做什么，非常重要。

3. 矩阵乘法到底是什么？#

矩阵 A 是一个机器，矩阵 B 也是一个机器。

那么 BA 意思：先 A，再 B。

所以矩阵乘法不是数字相乘，而是：

两个空间变化合成一个新的空间变化。

4. 用游戏引擎理解#

假设你玩 3D 游戏。一个角色：

• 初始：人站着
• 第一步：旋转身体 45°
• 第二步：前进 10 米

电脑内部不会每次重新计算所有东西。它会把旋转矩阵 × 移动矩阵组合，最终得到一个总变换。

这就是 Unity、Unreal 里面每天都在做的事情。

5. AI 里面为什么需要很多层？#

假设输入一句话：“狗追猫”，进入模型。

• 第一层 W_1：简单特征提取 — 可能发现”狗、猫、动物”
• 第二层 W_2：进一步转换 — 发现”谁在行动、谁被影响”
• 第三层 W_3：更高层 — 理解”追意味着运动关系”

整个过程其实就是：

连续三个空间变化。

6. 但是这里有一个问题#

如果所有东西只是矩阵乘法 Wx，那么多个矩阵最后可以合并成一个大矩阵：

那为什么神经网络还需要很多层？

这个问题非常关键。

答案：因为现实 AI 里面还有 非线性。

也就是激活函数，例如 ReLU：

1
负数 → 0
2
正数 → 保留

于是神经网络不是 W_3 W_2 W_1 x，而是：

每一步：改变空间 → 切割空间 → 再改变空间。

这就是为什么深度学习强大。

7. 现在你已经理解了线性代数的第一大核心：空间变化#

1. 从一张橡皮纸开始#

假设有一个单位正方形 □，面积 = 1。

经过矩阵 A：

横向拉长 2 倍：□ → ▭，面积变成 2。

所以 det(A) = 2。

再比如：

横向 2 倍，纵向 3 倍：面积变成 6。

所以 det(B) = 6。

2. 行列式可以为负？#

如果矩阵包含翻转：

左右镜像翻转。

面积还是 1，但是方向反了。

所以 det(C) = -1。

负号表示：空间被翻了个面。

3. 为什么 det = 0 代表”信息丢失”？#

假设：

这个矩阵把整个平面压成一条线：

1
□ → ────

面积从 1 变成 0。所以 det(D) = 0。

为什么不可逆？

因为信息已经丢失了。一条线上的一个点，你不知道它原来在平面的哪个位置。无数个点被压到了同一个点。

4. 这和 AI 有什么关系？#

PCA 降维、SVD 分解，本质上都在找：

哪些方向信息量大（特征值大），哪些方向信息量小（接近 0）。

信息量接近 0 的方向，就可以安全丢弃。

这就是数据压缩的数学基础。

1. 先回忆矩阵是什么#

矩阵 A 是一个空间变换机器。

大部分箭头经过变化以后，方向都会改变。例如 ↗ 经过拉伸，角度可能变化。

但是！有一些特殊箭头，经过变化以后，方向完全不变。

这就是：特征向量。

2. 一个简单例子#

假设矩阵：

x 方向放大 2 倍，y 方向放大 3 倍。

水平方向 (1,0)： 变化后 (1,0) → (2,0)。方向没变，长度变成 2 倍。所以 (1,0) 是特征向量，对应 λ = 2。

竖直方向 (0,1)： 变化后 (0,1) → (0,3)。方向没变，长度 3 倍。所以 λ = 3。

3. 那普通箭头呢？#

比如 (1,1)，也就是 ↗。

经过 x×2, y×3：变成 (2,3)。

原来 45°，现在约 56°。角度变了。所以它不是特征向量。

4. 特征向量到底是什么？#

一句话：

空间变化时，保持方向不变的特殊方向。

特征值：

这个方向被拉长/压缩多少倍。

公式 Ax = λx 翻译成人话：

1
矩阵作用在某个方向
2
     ↓
3
还是同一个方向
4
     ↓
5
只是长度乘了一个数字

5. 为什么 AI 需要这个？#

假设你有很多数据：10000 个人的照片，每张 10000 维。想压缩。

想象数据云：

1
        *
2
      *
3
    *
4
  *
5
*

它虽然是二维，但是主要沿着一条斜线展开。

那么最重要方向就是这条斜线。

PCA 做什么？找数据变化最大的方向。这个方向就是：最大特征值对应的特征向量。

6. 和 Transformer 的联系#

一个词例如”猫”，经过 Embedding 变成几千维向量。

这个向量不是随机数字。它处于一个巨大的语义空间。

模型训练过程中会形成一些重要方向。例如（只是方便理解）：

• 某些方向可能对应”动物性”
• 某些方向对应”抽象程度”
• 某些方向对应”情感倾向”

当然真实模型不是这么简单的一条轴，但是思想类似：

在高维空间里寻找重要结构。

7. 一个非常有意思的想象#

假设 AI 看到”国王”的向量，减去”男人”方向，加上”女人”方向，结果靠近”女王”。

因为语义空间里面存在某些方向。这就是向量空间的几何。

1. 回到向量#

向量 A = (1,0) = →，向量 B = (1,0) = →。它们方向完全一样，非常相似。

向量 C = (-1,0) = ←。它和 A 完全相反。

所以我们需要一个东西可以告诉我们：两个方向关系如何。

这个东西就是：点积（Dot Product）。

2. 点积是什么？#

公式：

• (1,0) · (1,0) = 1（同方向 → 正数）
• (1,0) · (-1,0) = -1（反方向 → 负数）
• (1,0) · (0,1) = 0（垂直 → 0）

3. 几何意义更重要#

点积还有一个公式：

θ 是两个向量的夹角。

• θ = 0°（完全同方向）：cos0 = 1，点积最大
• θ = 90°（垂直）：cos90 = 0，点积为 0
• θ = 180°（完全相反）：cos180 = -1，点积负

所以点积本质：

测量两个箭头朝向是否一致。

4. 为什么 AI 需要这个？#

模型把”猫”转换成一个向量：[0.2, 0.7, -0.1, ...]，“狗”：[0.3, 0.6, -0.2, ...]，“汽车”：[-0.8, 0.1, 0.9, ...]。

我们想问：猫和狗像不像？计算 cat · dog。如果大，说明方向接近；如果小，说明差异大。

所以 AI 所谓”理解词语关系”，很多时候就是：

在高维空间中比较方向。

5. 但是有一个问题#

普通点积有一个缺陷：向量越长，点积越大。(10,0) · (10,0) = 100，(1,0) · (1,0) = 1。方向一样，但是数字不同。

于是出现：余弦相似度（Cosine Similarity）

意思：只看方向，不看长度。结果范围 [-1, 1]。

6. 现在进入 Transformer —— Attention#

Transformer 里面有三个东西：Q（Query，查询）、K（Key，键）、V（Value，信息）。

先不要管名字。

假设一句话”小猫吃鱼”，每个词都有一个向量。

现在模型处理”吃”。它想知道：我应该关注谁？

它拿”吃”的 Query q，去和所有词的 Key k 计算 q · k。

• “吃”的 Query 和”小猫”的 Key：点积 = 8
• 和”鱼”的 Key：点积 = 7
• 和”今天”的 Key：点积 = 0.2

于是模型知道：关注”小猫”和”鱼”，少关注”今天”。

这就是 Attention。

它的核心不是魔法，就是：

在一个高维空间里，用点积寻找方向接近的信息。

7. 现在串起来#

你已经学过：

你现在其实已经进入 Transformer 的数学入口了。

1. 先想一个现实场景#

你去图书馆。桌上有一本书：《人工智能基础》。

你想知道：“这本书和我现在的问题有没有关系？”

三个角度：

• Query（查询） — 我想找什么？“我想学习 Transformer”。
• Key（关键词） — 这本书有什么标签？“AI、机器学习、神经网络、数学”。
• Value（内容） — 真正拿出来读的内容：书里的章节、文字、知识。

所以：Q = 我想找什么，K = 你有什么特征，V = 你实际提供什么。

2. 回到数学#

一个词例如”猫”，经过 Embedding 变成 x（实际维度可能几千）。

这个向量包含关于”猫”的全部信息。但是问题：这个空间适合所有任务吗？不一定。

比如一句话”小猫追老鼠”，现在模型想理解”追”的主语是谁。它需要关注动作关系。

但是原来的词向量可能包含：外貌、声音、动物属性、常见程度等等。

所以模型会创造三个新的空间。

3. Q 空间：我要寻找什么#

原来的词向量经过矩阵 W_Q 转换。还记得矩阵是什么吗？一个空间转换器。

所以 W_Q 就是一个”查询视角转换器”。

原来的”吃”向量包含很多东西（动物、动作、食物、声音…），经过 W_Q 变成查询空间：“我想找：谁是执行者？“

4. K 空间：我能被怎样找到#

另一个矩阵。为什么不用 W_Q？因为寻找角度不同。

“小猫”可能有很多信息（动物、可爱、毛茸茸、执行动作…），经过 W_K 变成关键词空间：“我是一个可能的动作执行者”。

5. 为什么 Q 和 K 要分开？#

这是关键。

假设一个搜索系统。你搜索”苹果手机”。数据库里面商品：“iPhone 16 Pro Max”。

你不会要求搜索词和商品描述完全一样。你需要搜索空间，和商品标签空间。

如果 Q 和 K 一样：模型只能问”谁和我长得像？“。但真正需要的是：“谁和我的需求有关？”

所以：Q 提出问题，K 回答”我是否相关？“

6. 那 V 是什么？#

V 是真正的信息。

“小猫”的 Key 告诉别人”我是猫、我是动物”。Value 包含”真正关于我的信息”。

Attention 不是把 Key 给你。而是：用 Key 找人，然后拿 Value。

7. Attention 完整过程#

假设三个词”小猫 吃 鱼”，每个变成 Q、K、V。

现在看”吃”。它的 Query = q_吃，去问所有 Key：k_小猫、k_吃、k_鱼。

计算点积 q · k，得到相关程度：

1
小猫  8.2
2
吃    2.1
3
鱼    7.5

然后 Softmax 转换成比例：

1
小猫 60%
2
鱼   35%
3
吃    5%

最后加权 Value：

得到新的”吃”的表示。

这就是 Attention。

8. 现在回头看整个线性代数#

你会发现：Transformer 没有创造新数学。它只是组合：

1
向量    → 表示词
2
矩阵    → 改变观察角度
3
点积    → 比较两个方向关系
4
Softmax → 变成权重
5
加权求和 → 融合信息

所以 Attention 本质：

一个词在高维空间里寻找和自己相关的信息，然后重新构造自己。

9. 最重要的一句话#

你之前问”为什么线性代数重要？”

现在答案出现了。因为 AI 的核心动作就是：

1
空间 → 变换 → 比较 → 重新组合

而线性代数就是研究：如何在空间里表示、移动、比较、转换信息。

1. Attention 天生不知道顺序#

假设一句话”猫 吃 鱼”，输入三个向量 x_1, x_2, x_3。

Attention 计算 QK^T，本质是在问”谁和谁相关？”

但是问题来了：Attention 天生不知道顺序。

为什么？因为矩阵乘法有一个特点：它不关心排列顺序。

比如”我爱你”和”你爱我”。如果只看三个词的向量，其实集合一样：{我, 爱, 你}。

Attention 可能认为它们的信息组成非常接近。但是人类知道：完全不同。

因为语言有时间结构。

2. 人类理解语言依靠什么？#

你听一句话”小明打小红”。你脑子里不是三个孤立的词 {小明, 打, 小红}，而是一个顺序：小明 → 打 → 小红。

如果”小红打小明”，意思完全变了。

所以模型必须知道：第几个词。

3. 但是 Attention 没有顺序概念#

Attention 其实更像处理一个集合 {猫, 吃, 鱼}。它不知道谁在第一、谁在第二。

这叫：permutation invariance（排列不变性）。

如果交换输入顺序 [猫, 吃, 鱼] 变成 [鱼, 吃, 猫]，Attention 仍然可以正常计算。这对于图片、集合很好，但是语言不行。

所以需要：位置编码。给每个词增加一个”我在哪里”的信息。

4. 最简单的位置编码#

词向量 x + 位置 p，输入变成 x + p。

例如”猫”原本 [0.2, 0.5]，位置 1 是 [0.1, 0.3]，相加 = [0.3, 0.8]。

现在同一个”猫”，如果在不同位置，向量不同。这样 GPT 就知道这个词在哪里。

5. 为什么不用直接加数字？#

第 1 个位置加 1，第 2 个加 2… 看起来简单。但是有问题。

因为语言长度可能是 10 个词、100 个词、10000 个词。位置需要一种连续、可推广的表示。

所以 Transformer 使用：正弦位置编码。

第一次看：很多人”这是什么鬼？“但是我们从几何角度理解。

6. 正弦是什么？#

正弦就是一个周期运动。例如钟摆：左 → 中 → 右 → 中 → 左。数学就是 sin。

位置编码实际上是在说：每个位置拥有一组不同频率的波。

• 低频（慢变化）：1 1 1 2 2 2 3 3
• 高频（快速变化）：1 2 1 2 1 2

多个波组合，就形成唯一的位置指纹。

类似音乐。一个音符不是只有一个频率。多个频率组合形成声音。位置编码也是：多个正弦波组合。

7. 这和线性代数有什么关系？#

位置编码本质：是在向量空间里增加一个新的方向。

原来的词只有语义空间（动物属性、颜色、行为…），加入位置变成语义空间 + 空间位置。也就是：扩展向量空间。

8. 回到 Q/K/V#

现在输入不是 X，而是 X + P。

然后：

所以 Attention 比较的时候，已经包含”这个词是什么”和”它在哪里”。

9. 一个重要总结#

到现在，Transformer 里面：

所以 GPT 看一句话，不是”读文字”，而是在做：

1
文字 → 高维向量空间 → 加入位置 → 空间投影 → 寻找相关方向 → 融合信息 → 生成新的空间表示

动手实现正弦位置编码#

公式看着吓人，代码其实很简单。我们用 PyTorch 实现一下，你就能直观看到每个位置怎么对应一组唯一的”指纹”：

1
import torch
2
import math
3
import matplotlib.pyplot as plt
4

5
def sinusoidal_position_encoding(max_len, d_model):
6
    """
7
    max_len: 最多支持多长的序列
8
    d_model: 每个token的向量维度（也叫隐藏维度）
9
    返回: (max_len, d_model) 的位置编码矩阵
10
    """
11
    pe = torch.zeros(max_len, d_model)
12
    position = torch.arange(0, max_len).unsqueeze(1).float()  # (max_len, 1)
13

14
    # 公式里的 10000^(2i/d) 这一项 —— 每个维度一个不同的"波长"
15
    div_term = torch.exp(
16
        torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
17
    )
18

19
    pe[:, 0::2] = torch.sin(position * div_term)  # 偶数维度: sin
20
    pe[:, 1::2] = torch.cos(position * div_term)  # 奇数维度: cos
21

22
    return pe
23

24
# 生成位置编码: 最多100个位置, 每个512维
25
pe = sinusoidal_position_encoding(max_len=100, d_model=512)
26

27
print(f"位置编码矩阵形状: {pe.shape}")  # (100, 512)
28
print(f"第1个位置的编码 (前8维): {pe[0, :8]}")
29
print(f"第2个位置的编码 (前8维): {pe[1, :8]}")
30
# 每个位置的编码都不一样 —— 这就是"位置指纹"
31

32
# --- 可视化: 看低维度部分怎么随位置变化 ---
33
plt.figure(figsize=(12, 4))
34
for i in range(4):  # 画前4个维度
35
    plt.plot(pe[:50, i].numpy(), label=f'维度 {i}')
36
plt.xlabel('位置 (pos)')
37
plt.ylabel('编码值')
38
plt.title('前4个维度的正弦位置编码 (前50个位置)')
39
plt.legend()
40
plt.grid(True)

从这个图可以看到：低维度的波变化慢（周期长），高维度的波变化快（周期短）。每个位置在不同维度上取值不同，组合起来就形成了”独一无二”的编码。就像每首曲子由不同频率的音符组成——同一个位置，低频维度给一个大致的定位，高频维度给精细的区分。

练习题#

题目 1： 修改上面代码里的 d_model 从 512 改成 64，再跑一遍可视化。低维度的编码变化模式和 512 维时有什么不同？

题目 2： 计算位置 0 和位置 1 的编码之间的欧氏距离。再计算位置 0 和位置 10 之间的欧氏距离。哪个更大？为什么这是合理的？

题目 3： 如果把位置编码加到一个全是 0 的向量上，两个不同位置的词（位置 1 和位置 2）在向量空间中能区分吗？为什么？

1. 为什么不能直接用点积？#

Attention 计算完 q · k 之后，得到一堆数字，比如：

1
小猫  8.2
2
吃    2.1
3
鱼    7.5

这些原始分数有三个问题。

问题一：尺度不稳定。 向量维度越大，点积可能越大。比如 2 维向量点积最大几十，但 512 维向量点积可能几百。尺度一变，模型行为就不稳定。

问题二：没有可比性。 8.2 到底是”很相关”还是”一般相关”？没有标准。

问题三：负数怎么办？ 点积可能是负数，怎么解释”负的相关性”？

2. Softmax 做了什么？#

Softmax 把任意一堆数字变成”概率分布”：

• 所有数字变成正数
• 总和 = 1
• 大的更大，小的更小（拉开差距）

1
原始分数：8.2, 2.1, 7.5
2
     ↓ Softmax
3
概率分布：0.60, 0.05, 0.35

于是模型可以读懂：“把 60% 的注意力给小猫，35% 给鱼，5% 给自己。“

3. 为什么除以 √d？#

这是 Attention 论文里一个精妙的设计。

向量维度 d 越大，点积的方差越大。如果不除以 √d，当 d 很大（比如 512），点积的值会变得很大，Softmax 之后会趋近于 one-hot —— 只关注一个词，忽略所有其他词。

除以 √d 相当于”温度调节”：不让注意力太集中，也不让它太分散。

4. Softmax 为什么像”注意力开关”？#

Softmax 的效果是”赢家通吃”：

1
原始：8.2, 2.1, 7.5  →  Softmax →  0.60, 0.05, 0.35
2
原始：8.2, 8.1, 8.0  →  Softmax →  0.37, 0.34, 0.29

第一组差距大，Softmax 放大差距。第二组接近，Softmax 保持均匀。

这就是”注意力开关”——模型自动决定是”专注一个”还是”均匀分布”。

5. 完整的 Attention 公式现在可以读了#

拆开看：

• QK^T：用点积比较每个词和每个词的关系
• √d_k：除以维度开根号，稳定尺度
• softmax：把分数变成概率分布（注意力权重）
• × V：用权重提取实际信息

每一步都不是魔法，都是你前面学过的线性代数。

用代码感受 Attention 的完整计算#

1
import torch
2
import torch.nn.functional as F
3

4
# 假设: 3个token("小猫","吃","鱼"), embedding维度=4
5
# 这是简化版，真实模型用矩阵 W_Q, W_K, W_V 投影
6
Q = torch.randn(3, 4)  # 每个token的Query
7
K = torch.randn(3, 4)  # 每个token的Key
8
V = torch.randn(3, 4)  # 每个token的Value
9

10
# 第1步: QK^T —— 计算"谁和谁相关"
11
scores = Q @ K.T            # (3,3) 的注意力分数矩阵
12
print("注意力分数:\n", scores)
13

14
# 第2步: 除以√d —— 稳定尺度
15
d_k = 4
16
scores_scaled = scores / (d_k ** 0.5)
17

18
# 第3步: Softmax —— 变成概率分布
19
attn_weights = F.softmax(scores_scaled, dim=-1)
20
print("\n注意力权重 (每行之和=1):\n", attn_weights)
21
print("每行之和:", attn_weights.sum(dim=-1))  # [1.0, 1.0, 1.0]
22

23
# 第4步: × V —— 用权重提取信息
24
output = attn_weights @ V   # (3,4)
25
print("\nAttention输出:\n", output)
26

27
# 每一行 = 对应token"融合了所有相关信息后"的新表示

自己动手改一改： 把 Q、K、V 换成你想要的数字，手动追踪每一步，彻底把 Attention 公式从”魔法”变成”流程”。

练习题#

题目 1： 为什么要除以 √d_k？如果 d_k = 256，不除以 √d_k 直接用原始分数做 Softmax，会发生什么？（提示：想想 e^100 和 e^256 的区别。）

题目 2： 用上面那段代码，把 scores_scaled 的某一行改成 [100.0, 0.01, 0.01]，跑 Softmax 看结果。再改成 [5.0, 4.9, 4.8]，再看结果。解释 Softmax 在两种情况下行为的差异。

题目 3： Attention 的输出和输入的 V 在形状上一致吗（都是 (3,4)）？为什么？

最后看一眼 Transformer 的完整流程#

1
输入文字："猫吃鱼"
2
     ↓
3
Embedding：每个词变成向量
4
     ↓
5
+ 位置编码：加入位置信息
6
     ↓
7
Q = XW_Q, K = XW_K, V = XW_V：投影到三个空间
8
     ↓
9
(QK^T)/√d：计算注意力分数
10
     ↓
11
Softmax：变成注意力权重
12
     ↓
13
× V：提取相关信息
14
     ↓
15
输出：新的、融合了上下文的向量表示

每一步都是线性代数。每一步你都已经从几何直觉上理解了。

1. 第一步：QK^T —— 得到”关系表”#

假设”吃”的 Query q = (1,2)，某个词的 Key k = (3,4)。

点积 = 1×3 + 2×4 = 11。

这个数字不是距离，不是概率。它表示：两个向量方向有多一致。

对所有词计算后，得到 Attention Score：

1
          小猫    吃     鱼
2
吃        8      2      7

2. 为什么不能直接乘 V？#

如果直接 8V_1 + 7V_2 + 2V_3：

问题一：数字太大，总和 17。换一次计算可能是 170。尺度乱了。

问题二：没有可比性。8 是”很相关”还是”一般相关”？

问题三：负数怎么办？点积可能是负数。

我们需要把这些分数变成”比例”：小猫 60%、鱼 30%、吃 10%。这就是 Softmax。

3. Softmax 的数学#

为什么用 e^x？因为指数放大差距。

10 和 9 只差 1，但 e^10 和 e^9 差距巨大。这很好——Attention 需要突出重要信息。

现实比喻：老师问谁最擅长数学？分数 A=99, B=98, C=60。普通平均差距不明显。但指数放大后，A 和 B 被突出，C 几乎忽略。Softmax 让模型更明确”重点是谁”。

4. 为什么除以 √d？#

向量维度越大，点积可能越大。GPT 的向量可能是 512 维、1024 维、4096 维。

4096 个数字相乘再相加，结果可能非常大。e^800 直接爆炸。

除以 √d 把数值压回来。维度 1024 → √1024 = 32，分数除以 32，稳定。

这叫：Scaled Dot-Product Attention（缩放点积注意力）。

5. 最后乘 V#

注意力权重 [0.7, 0.1, 0.2] 乘以三个 Value：

不是选择一个词，而是混合信息。“吃”的新表示：70% 来自”小猫”，20% 来自”鱼”，10% 来自自己。于是它获得”谁吃什么”的信息。

6. Attention 完整翻译#

Attention 本质：在高维空间里，根据方向相似度寻找相关信息，然后按照重要程度重新组合信息。

1. 一个观察角度够吗？#

看一句话：“小明因为生病，所以没有参加考试。”

人类理解这句话时，会同时注意：

• 因果关系：生病 → 没考试
• 人物关系：谁？小明
• 时间关系：先生病，后没考试
• 语法关系：“因为”连接原因

同一句话有很多种关系。如果只有一个 Attention，它需要在一个空间里面同时编码所有关系。这很困难。

所以 Transformer 想：既然一个空间不够，那就创造多个空间。

这就是 Multi-Head。

2. 什么叫 Head？#

一个 Head = 一套独立的 Q/K/V 投影。

1
              Head 1
2
             /
3
输入 ------ Head 2
4
             \
5
              Head 3

每个 Head 拥有自己的 W_Q, W_K, V，每个 Head 看世界的方法不同。用数学表示：

也就是说，同一个输入 X，乘以不同的 W_Q, W_K, W_V，进入不同的子空间。“猫”在 Head 1 里是”主语的候选”，在 Head 2 里是”宠物的候选”，在 Head 3 里是”被指代的候选”——同一个词，在不同 Head 眼里是不同的”身份”。

3. 具体例子#

“小猫喜欢吃鱼”，假设有三个 Head：

• Head 1（语法头）： 关注”小猫 → 喜欢 → 吃 → 鱼”的主谓宾结构
• Head 2（语义头）： 关注”小猫 ≈ 动物”、“鱼 ≈ 食物”的概念关系
• Head 3（指代头）： 找”她”是谁（在更复杂的句子中）

4. 从线性代数看#

原始向量 x，维度 512。

Head 1 学习空间中的某些方向（比如表示语法）。Head 2 学习另一组方向（比如表示情绪）。Head 3 学习又一组方向（比如表示实体关系）。

其实就是：不同的矩阵，创造不同基底。

还记得基底是什么吗？描述空间的语言。

所以 Multi-Head Attention = 同时建立多个”描述语言”。

5. 为什么最后要 Concat + W_O？#

每个 Head 输出 head_1, head_2, ...，拼起来：

因为每个 Head 学到了不同信息，需要合并。

然后乘以 W_O：

W_O 也是矩阵，作用：把多个空间重新融合。

流程：一个空间 → 多个观察空间 → 多个结果 → 重新组合成一个空间。

这就是线性代数里的：投影 + 拼接 + 再投影。

1. Transformer Block 的结构#

1
输入 → Multi-Head Attention → Add+Norm → FFN → Add+Norm → 输出

每一层做两件事：

• Attention： 我应该从别人那里获取什么信息？（信息交换）
• FFN： 我拿到这些信息后，应该怎么处理？（内部消化）

2. FFN 的结构#

拆开：

• W_1 x：把信息投影到更大的空间（比如 512 → 2048）
• σ：激活函数，引入非线性
• W_2：压缩回来（2048 → 512）

3. 为什么要扩大维度？#

低维空间表达能力有限。描述一个城市，只有”人口、面积”很粗糙。增加”收入、交通、天气、文化、历史…”描述更丰富。

神经网络也是：扩大维度 = 创造更多”思考空间”。

输入”苹果”的原始向量混合了”水果、公司、手机、颜色”。进入 FFN 后，可能产生：食物相关方向、科技相关方向、品牌相关方向。然后 W_2 把有用的信息组合回来。

4. 为什么需要激活函数？#

如果没有激活，只有 W_2 W_1 x。矩阵乘矩阵还是矩阵。无论多少层，最后还是一个线性变换 Wx。没有复杂能力。

所以需要非线性。ReLU：max(0, x)。负数不要，正数保留。

它像一个开关：重要方向留下，无用方向关闭。

5. 为什么 GPT 参数大部分在 FFN？#

隐藏维度 d=4096，FFN 扩大 4d=16384。

第一层：4096×16384 ≈ 6700 万参数。第二层差不多。

而 Attention 一个矩阵 4096×4096 ≈ 1600 万。

所以 FFN 参数更多。大模型的”知识”（比如”巴黎是法国首都”这种事实关联）很可能分布在大量 FFN 权重里。

用代码实现一个 FFN Block#

1
import torch
2
import torch.nn as nn
3

4
class FeedForward(nn.Module):
5
    """Transformer 的 FFN 模块 —— 就是两个 Linear 中间夹一个激活函数"""
6
    def __init__(self, d_model=512, d_ff=2048, dropout=0.1):
7
        super().__init__()
8
        self.w1 = nn.Linear(d_model, d_ff)    # 512 → 2048 (扩大)
9
        self.w2 = nn.Linear(d_ff, d_model)    # 2048 → 512 (压缩回来)
10
        self.dropout = nn.Dropout(dropout)
11

12
    def forward(self, x):
13
        # x shape: (batch, seq_len, d_model)
14
        x = self.w1(x)          # 投影到更大的"思考空间"
15
        x = torch.relu(x)       # 非线性：关掉没用的方向
16
        x = self.dropout(x)     # 随机丢弃一些神经元（防止过拟合）
17
        x = self.w2(x)          # 压缩回原始维度
18
        return x
19

20
# 测试
21
ffn = FeedForward(d_model=512, d_ff=2048)
22
x = torch.randn(2, 10, 512)    # 2句，每句10个词，每个词512维
23
out = ffn(x)
24
print(f"输入形状: {x.shape}")    # (2, 10, 512)
25
print(f"输出形状: {out.shape}")  # (2, 10, 512) ← 维度和输入一致！
26

27
# 数一下参数
28
total_params = sum(p.numel() for p in ffn.parameters())
29
print(f"FFN 总参数量: {total_params:,}")
30
# 512×2048 + 2048 + 2048×512 + 512 ≈ 2.1M
31

32
# 对比一下 Attention 的参数量
33
attn_params = 512 * 512 * 4     # Q, K, V, O 四个矩阵，每个 512×512
34
print(f"Attention(单头) 参数量: {attn_params:,}")  # ≈ 1.0M
35
# 可以看到 FFN 参数大约是 Attention 的 2 倍 —— 所以大模型的知识主要存在 FFN 里