为什么 AI 论文全是天书？因为每一个数学符号，其实都是一句人话

AI 论文里的 ∑、∂、∇、𝔼、argmax 为什么越看越像天书？其实它们不是新的知识，而是一整句话被压缩后的缩写。从数学符号的诞生历史，到 GPT、Transformer、PyTorch 代码，一篇文章教你读懂任何公式。

"一个好的记号，能把大脑从不必要的劳动中解放出来，让它去思考更高级的问题。" —— 怀特海

"在 1591 年之前，人类甚至写不出'一般的方程'这句话。"

上一篇（Chapter 0 / 0.5）讲的是为什么是这个公式 —— 为什么反复出现平方、\(1/r^2\)、\(\log\)。 这一篇讲更前置、也更卡人的一步：你拿到一个陌生公式，怎么把它读下去。

很多人说"我数学不好"，其实说的是："我看到 \(\sum\)、\(\partial\)、\(\nabla\)、\(\mathbb{E}\)、\(\arg\max\)、\(\otimes\) 就自动关机了。" 这不是智力问题，是没人告诉你这些符号是缩写，而缩写的全称从来没被展开过。

🕰️ 0.6.1 先看一件震撼的事实：数学在 1600 年前，是用大白话写的

数学史学家 Nesselmann（1842）把代数分成三个阶段：

花拉子米（al-Khwārizmī, 820，al-Jabr —— "algebra" 一词的来源）解一元二次方程时，原文大意是：

"一个平方，与十个它的根，等于三十九迪拉姆。取根数目之半，得五；自乘之，得二十五；加于三十九，得六十四；取其方根，得八；减去根数目之半，得三 —— 此即所求之根。"

翻译成今天的符号，全文就是一行：

一整段话 → 一行符号。 你现在感受到的"公式好难"，本质是信息密度难：一行公式压缩了一整段人话，而没人教你解压。

而且这些符号是被一个一个发明出来的，每一个背后都有一个具体的人、一个具体的偷懒动机：

看这张表要看出的东西：没有一个符号是"从天上掉下来的规定"。每一个都是某个人嫌麻烦，于是把一段话压成一个记号。 所以读符号的正确姿势永远是：把它解压回那句人话。

🧭 0.6.2 读公式六步法：像读代码一样读公式

数学公式和一段代码是同构的。程序员读陌生代码有一套本能流程 —— 读公式用同一套。

Step 1 · 先做 shape check：每个符号是什么"类型"？

在读含义之前，先读类型：标量？向量？矩阵？函数？算子？集合？分布？

import torch
# 读公式的第一件事不是"理解"，是"标注类型"
x = torch.randn(4)        # 输入：向量,  shape (4,)      —— 小写粗体 → 向量
W = torch.randn(3, 4)     # 权重：矩阵,  shape (3, 4)    —— 大写 → 矩阵
b = torch.randn(3)        # 偏置：向量,  shape (3,)
sigma = torch.sigmoid     # σ：函数 R→R，逐元素作用     —— 希腊字母这里是"函数"不是"标准差"

y = sigma(W @ x + b)      # (3,4)@(4,) -> (3,) ; +(3,) -> (3,) ; σ 不改 shape
print(y.shape)            # torch.Size([3])

类型对不上，公式一定读错了。 这一步能过滤掉 80% 的误读 —— 就像编译器帮你抓住的那 80% 的 bug。

Step 2 · 找"主动词"：从外向内读，不要从左向右读

汉语句子先找谓语，公式先找最外层的运算。这才是这个公式"在干什么"。

从外往里剥：

最外层：  负号 + 平均            → "我要最小化某个平均量"
第二层：  ∑_i  遍历 N 个样本      → "这个量是逐样本算完再平均的"
第三层：  ∑_c  遍历 C 个类别      → "每个样本内部再对类别求和"
最内层：  y·log p̂                → "只有真实类别 (y=1) 那一项活下来"

到这里公式已经读完了：交叉熵 = 对每个样本，取真实类别的 \(-\log\) 预测概率，再平均。 一行代码：

loss = -(y_onehot * p_hat.log()).sum(dim=1).mean()   # 逐符号对应，一一映射

由外向内是关键。从左向右读 \(-\frac{1}{N}\sum\sum y\log\hat p\)，你会淹死在下标里； 先看清"这是一个平均"，剩下的都是细节。

Step 3 · 分清哑变量与自由变量 —— 这是最大的困惑源

\(i\) / \(k\) 是哑变量（bound variable）：它只在 \(\sum\) 内部存在，出了求和号就没有意义。 \(n\) 和 \(a\) 是自由变量：它们从外面传进来。

这就是 lambda 的参数，改名不改语义 —— λ 演算里叫 α-变换（呼应 Chapter 0.9）：

# 哑变量 = 函数的局部参数，改名毫无影响
f = lambda a, n: sum(a[i] for i in range(n))   # i 是哑的
g = lambda a, n: sum(a[k] for k in range(n))   # k 是哑的，f 和 g 完全相同

凡是带"绑定器"的符号，其紧跟的变量都是哑的：

一旦你会分辨"哪个字母是临时工、哪个是从外面传进来的"，公式的作用域就清晰了 —— 和读代码找变量作用域是同一个动作。

Step 4 · 量纲/维度检查：加号两边必须是同类东西

• 加号两边必须同量纲、同 shape。 \(E = mc^2 + v\) 一眼就是错的（能量 + 速度）。
• \(\exp\)、\(\log\)、\(\sin\) 的宗量必须无量纲。 所以 \(e^{-t/\tau}\) 里必然有个时间常数 \(\tau\) 来把 \(t\) 除成纯数 —— 看到 \(e^{-x/\lambda}\)，你立刻知道 \(\lambda\) 和 \(x\) 同量纲。
• 比值和平方要跟着量纲走。 \(\mathrm{Var}[X]\) 的量纲是 \(X\) 的平方，所以才需要开根号变成标准差，才能跟 \(X\) 画在同一张图上。

# 用量纲反推陌生公式里某个符号的身份：高斯密度里的 σ 一定和 x 同量纲
# 因为 exp 的宗量 (x-μ)²/(2σ²) 必须无量纲
# 又因为整个密度要积分成 1（无量纲），前面的 1/(σ√(2π)) 必须是 1/量纲(x)

这一步不需要理解公式就能做，却能倒推出符号的身份。 物理学家用它猜公式（呼应 Chapter 0.7），你可以用它读公式。

Step 5 · 代极端值：\(n=0,1\)；\(\sigma\to0,\infty\)；\(T\to 0\)

公式是抽象的，抽象的东西要审问（呼应 Chapter 0.95 的代入法）：

import torch

def softmax_T(z, T):
    return torch.softmax(z / T, dim=-1)

z = torch.tensor([2.0, 1.0, 0.1])
print(softmax_T(z, 1.0))    # tensor([0.6590, 0.2424, 0.0986])            正常
print(softmax_T(z, 0.01))   # tensor([1.0000e+00, 3.78e-44, 0.0000e+00])  T→0 退化成 argmax（一位独大）
print(softmax_T(z, 100.0))  # tensor([0.3366, 0.3332, 0.3302])            T→∞ 退化成均匀分布

三个极端一试，\(T\) 这个符号的身份立刻水落石出：它是"决策锐度"的旋钮。 这比读十行文字描述都快。任何含参数的公式，都先把参数推到两个极端看它退化成什么。

Step 6 · 写成代码跑一遍 —— 唯一的验收标准

能把公式写成一个不用任何数学库的 for 循环，才算真读懂了。

xs = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]

mu = sum(xs) / len(xs)                         # 𝔼[X]      → 平均
var = sum((x - mu) ** 2 for x in xs) / len(xs) # 𝔼[(X-μ)²] → 平方后再平均
print(mu, var)                                 # 5.0 4.0

# 对拍：库函数必须给出一样的答案，否则是你读错了公式
import torch
t = torch.tensor(xs)
print(t.mean().item(), t.var(unbiased=False).item())   # 5.0 4.0  ✓

"手写 for 循环 vs 库函数对拍" 是检验"我是不是真看懂这个符号"的黄金标准 —— 它无法自欺欺人。

📖 0.6.3 符号 → 代码 总字典

把这张表贴在显示器旁边。读公式时逐符号查，读三个月，就不用查了。

求和 / 求积 / 积分 —— "循环"家族

微分 —— "变化率"家族

import torch
x = torch.tensor([1.0, 2.0], requires_grad=True)
f = (x ** 2).sum()                      # f = x₁² + x₂²
g, = torch.autograd.grad(f, x)          # ∇f = (2x₁, 2x₂)
print(g)                                # tensor([2., 4.])
# ∇ 这个符号在代码里的全部内容，就是这一行：把标量变成和输入同 shape 的向量

线性代数 —— "shape 流"家族

\(\otimes\) 和 \(\odot\) 这类符号最容易糊 —— 别背名字，背 shape： 外积让维度变多，Hadamard 让维度不变，内积让维度消失。

逻辑 / 集合 —— "断言"家族

\(\max\) 与 \(\arg\max\) 的区别，是初学者最常见的翻车点： \(\max_x f(x)\) 返回最高的分数，\(\arg\max_x f(x)\) 返回取得最高分的那个选手。 一个是 f(x).max()，一个是 f(x).argmax()。

⚠️ 0.6.4 一词多义地图：同一个符号，五种意思

这是"符号看不懂"最真实的原因 —— 不是符号太多，是符号太少，被反复重用。 希腊字母只有 24 个，而数学分支有上百个。

唯一的消歧规则：符号本身没有意义，"符号 + 领域 + 位置"才有意义。

具体三招： 1. 看它出现在什么运算里：\(\Sigma\) 后面跟下标 \(i=1\) 就是求和，出现在 \(\mathcal{N}(\mu,\Sigma)\) 里就是协方差矩阵。 2. 看它的 shape：\(\delta\) 带两个下标（\(\delta_{ij}\)）是 Kronecker，带括号（\(\delta(x)\)）是 Dirac。 3. 看这一页的第一次出现：论文的规范是首次出现处必须定义。看不懂就往回找定义 —— 找不到的话，那是作者的错，不是你的。

🔬 0.6.5 实战解剖：三个公式，逐符号拆开

按本项目的规矩：现象 → 模拟 → 拆解 → 公式（Chapter 0.7），不是反过来。

案例一：高斯分布 —— 从"高尔顿板"到符号

先看现象：一堆小球从上往下掉，每层随机左右偏一次，落到底部形成一堆。

import torch, matplotlib.pyplot as plt

n_balls, n_rows = 20000, 32
steps = (torch.randint(0, 2, (n_balls, n_rows)) * 2 - 1)   # 每层 ±1，公平的硬币
pos = steps.sum(dim=1).float()                             # 累积左右偏移

plt.hist(pos.numpy(), bins=40, density=True, alpha=.6, label="高尔顿板（模拟）")
mu, sigma = pos.mean(), pos.std()
xs = torch.linspace(pos.min(), pos.max(), 300)
pdf = 1/(sigma*torch.sqrt(torch.tensor(2*torch.pi))) * torch.exp(-(xs-mu)**2/(2*sigma**2))
plt.plot(xs, pdf, lw=2, label="高斯公式")
plt.legend(); plt.show()

先跑出那个钟形，再回头解剖公式：

\(\sqrt{2\pi}\) 不是审美，是积分 \(\int e^{-x^2/2}dx=\sqrt{2\pi}\) 逼出来的账单（那个极坐标换元技巧，正是 Chapter 0.3 的 gaussian_integral_polar.py）。

案例二：注意力公式 —— 现代 AI 里最"吓人"的一行

用六步法，只跟 shape 走，两分钟读完：

import torch
n, d_k, d_v = 5, 8, 8                     # 5 个 token
Q = torch.randn(n, d_k)                   # Query：我在找什么
K = torch.randn(n, d_k)                   # Key  ：我是什么
V = torch.randn(n, d_v)                   # Value：我能提供什么

scores = Q @ K.T                          # (n,d_k)@(d_k,n) -> (n,n)   ← 每对 token 的内积=相似度
scores = scores / d_k ** 0.5              # 除 √d_k：内积随维度增长 ~√d_k，不缩放 softmax 会饱和
w = torch.softmax(scores, dim=-1)         # (n,n)，每行求和为 1        ← 变成"注意力权重分配"
out = w @ V                               # (n,n)@(n,d_v) -> (n,d_v)   ← 按权重把别人的信息加权平均

print(scores.shape, w.shape, out.shape)   # (5,5) (5,5) (5,8)
print(w.sum(dim=-1))                      # tensor([1., 1., 1., 1., 1.]) ✓ 归一化确认

逐符号翻译成人话：

结论：这一行公式的全部内容是 —— "算相似度 → 归一化成权重 → 加权平均"。 三个动作，每个都有两百年历史。吓人的只是符号密度，不是思想密度。

案例三：链式法则 —— 一个 \(\partial\) 引发的百年国耻

莱布尼茨记法的天才之处：它长得就像可以约分（\(\frac{\partial L}{\partial \hat y}\cdot\frac{\partial \hat y}{\partial z}\) 中间的 \(\partial\hat y\) "消掉"）。 这个视觉暗示不是严格证明，但它让人敢往下推 —— 这就是好符号的全部价值。

import torch
w = torch.tensor(2.0, requires_grad=True)
x = torch.tensor(3.0)

z     = w * x                     # ∂z/∂w = x = 3
y_hat = torch.sigmoid(z)          # ∂ŷ/∂z = ŷ(1-ŷ)
L     = (y_hat - 1.0) ** 2        # ∂L/∂ŷ = 2(ŷ-1)

L.backward()                      # ← 这一行就是那个连乘

manual = 2*(y_hat-1) * y_hat*(1-y_hat) * x     # 逐符号手抄公式
print(w.grad.item(), manual.item())            # 两者相等 ✓ —— 公式读对了

而牛顿的 \(\dot{x}\) 写不出这种链式约分。 英国数学界出于民族情绪坚持点记法一百年，直到 1812 年剑桥的巴贝奇、赫歇尔、皮考克成立"分析学会"，打出那句著名口号：

"推行纯粹的 d 主义，反对这所大学的 点时代。" （the principles of pure D-ism in opposition to the Dot-age of the University —— 一句双关：D-ism / deism（自然神论），Dot-age / dotage（老糊涂））

一个符号的选择，让一个国家的数学落后了一个世纪。 这是"符号即思维外骨骼"最贵的一次学费。

🧠 0.6.6 三条习惯：把"看不懂"变成"查得到"

1. 看到陌生符号，先问"它是什么类型"，而不是"它是什么意思"。 标量/向量/矩阵/函数/算子/集合 —— 类型定了，能做什么运算就定了一半。这是 shape check，不是理解力问题。
2. 看到复杂公式，先找最外层运算，由外向内剥。 一个公式只有一个"主动词"。找到它，你就知道这个公式产出什么；剩下的括号都是它的参数。
3. 看到任何公式，最后一定要写成能跑的代码，并跟库函数对拍。 手写 for 循环 = 唯一无法自欺欺人的验收。跑通那一刻，符号就从"要背"变成了"我造过"。

再补一条对付一词多义的：符号无意义，符号 + 领域才有意义。 别问"\(\sigma\) 是什么"，要问"在这一页里，\(\sigma\) 是什么"。

🎨 0.6.7 可视化与代码：ch00_97_reading_formulas/

本文小结：数学符号不是门槛，是压缩包。每一个都由某个具体的人，为了少写几个字，在某一年发明出来 —— 莱布尼茨 1675 年 10 月 29 日写下的那个拉长的 s，至今仍在每一篇论文里喊着"我是求和"。

看不懂公式，从来不是因为你笨，而是因为没人给你解压密码。密码就三条：先读类型，由外向内，写成代码。

下期预告：Chapter 0.7 —— 学物理就是学数学，为什么大脑只记得住"有现实意义的事"。