Markdown 数学公式写作指南（四）：27 个 AI 算法公式实战

文章目录

- 用真实公式检验学习成果
- 一、线性模型：最基础的公式组合
- - [1. 线性回归](#1. 线性回归)
  - [2. Sigmoid 函数](#2. Sigmoid 函数)
  - [3. Softmax 函数](#3. Softmax 函数)
  - [4. 逻辑回归](#4. 逻辑回归)
- 二、损失函数：公式写作的高频场景
- - [5. 交叉熵损失](#5. 交叉熵损失)
  - [6. 均方误差损失](#6. 均方误差损失)
  - [7. L2 正则化](#7. L2 正则化)
  - [8. SVM 目标函数](#8. SVM 目标函数)
- 三、优化与训练：公式最密集的领域
- - [9. 梯度下降](#9. 梯度下降)
  - [10. 反向传播（链式法则）](#10. 反向传播（链式法则）)
  - [11. Batch Normalization](#11. Batch Normalization)
  - [12. Adam 优化器](#12. Adam 优化器)
- [四、Transformer 与 Attention：公式写作的终极考验](#四、Transformer 与 Attention：公式写作的终极考验)
- - [13. 缩放点积注意力](#13. 缩放点积注意力)
  - [14. 多头注意力](#14. 多头注意力)
  - [15. 位置编码](#15. 位置编码)
- 五、概率与信息论：公式语法的高阶应用
- - [16. 高斯分布](#16. 高斯分布)
  - [17. 贝叶斯定理](#17. 贝叶斯定理)
  - [18. 信息熵](#18. 信息熵)
  - [19. KL 散度](#19. KL 散度)
  - [20. VAE 损失（ELBO）](#20. VAE 损失（ELBO）)
- 六、经典机器学习公式
- - [21. 余弦相似度](#21. 余弦相似度)
  - [22. 距离度量对比](#22. 距离度量对比)
  - [23. 决策树信息增益](#23. 决策树信息增益)
  - [24. Gini 不纯度](#24. Gini 不纯度)
- 七、完整语法速查表
- 八、综合实战：从零搭建一个完整训练流程
- - [步骤 1：定义模型（线性回归 → Sigmoid → 二分类）](#步骤 1：定义模型（线性回归 → Sigmoid → 二分类）)
  - [步骤 2：定义损失函数（交叉熵）](#步骤 2：定义损失函数（交叉熵）)
  - [步骤 3：添加正则化（L2）](#步骤 3：添加正则化（L2）)
  - [步骤 4：计算梯度（反向传播）](#步骤 4：计算梯度（反向传播）)
  - [步骤 5：更新参数（梯度下降 → Adam）](#步骤 5：更新参数（梯度下降 → Adam）)
  - [步骤 6：归一化（Batch Normalization）](#步骤 6：归一化（Batch Normalization）)
  - [步骤 7：注意力机制（Transformer）](#步骤 7：注意力机制（Transformer）)
  - 语法使用统计
- 系列总结

用真实公式检验学习成果

前三篇我们学完了 Markdown 数学公式的全部核心语法：希腊字母和上下标、分数求和积分根号、矩阵和特殊符号、排版进阶技巧。

这篇是系列的综合实战------用 AI 领域最经典的算法公式，把前面学过的所有语法都用起来。但不是简单的语法罗列，而是按照模型类型分组，每个公式给出完整的 Markdown 源码、语法拆解、Python 代码对照和实际使用中的注意事项。

如果你是 AI 算法工程师或研究者，这些公式你每天都在看；如果你是学习者，这篇可以当公式手册用，同时也是 Markdown 公式写作的综合练习。

前置要求：本文不单独解释基础语法。如果遇到看不懂的命令，回翻前三篇对应章节。每个公式都配有 Python/PyTorch 代码，帮你建立公式和代码的对应关系。

一、线性模型：最基础的公式组合

1. 线性回归

markdown 复制代码

$$
\hat{y} = \mathbf{w}^T \mathbf{x} + b = \sum_{i=1}^{d} w_i x_i + b
$$

y ^ = w T x + b = ∑ i = 1 d w i x i + b \hat{y} = \mathbf{w}^T \mathbf{x} + b = \sum_{i=1}^{d} w_i x_i + b y^=wTx+b=i=1∑dwixi+b

python 复制代码

# PyTorch 实现
y_hat = torch.matmul(W, x) + b           # 矩阵形式
y_hat = sum(w[i] * x[i] for i in range(d)) + b  # 分量展开形式

语法拆解 ：\mathbf 写粗体向量、^T 写转置、\sum 写求和、_i 和 ^d 写上下标。

实际使用注意 ：等号左右两种写法等价------矩阵形式 w T x \mathbf{w}^T \mathbf{x} wTx 更紧凑，展开形式 ∑ w i x i \sum w_i x_i ∑wixi 更直观。写博客时建议两种都给出，帮读者建立矩阵运算和分量运算之间的联系。

2. Sigmoid 函数

markdown 复制代码

$$
\sigma(x) = \frac{1}{1 + e^{-x}} = \frac{e^x}{1 + e^x}
$$

σ ( x ) = 1 1 + e − x = e x 1 + e x \sigma(x) = \frac{1}{1 + e^{-x}} = \frac{e^x}{1 + e^x} σ(x)=1+e−x1=1+exex

python 复制代码

# PyTorch 实现
output = torch.sigmoid(x)  # σ(x)
# 手动实现
output = 1 / (1 + torch.exp(-x))

语法拆解 ：\frac 写分数、e^{-x} 写指数（注意负号在花括号内）、= 连接等价形式。

踩坑提醒 ：不要写成 $1/1+e^{-x}$ ------没有 \frac 包裹的话，渲染器会把 1/1 当成分数，后面的 +e^{-x} 就乱了。分数一律用 \frac{}{}。

数值稳定性提醒 ：当 x x x 是很大的负数时， e − x e^{-x} e−x 会溢出。实际代码中用 torch.sigmoid 而不是手动实现，因为 PyTorch 内部做了数值稳定化处理。

3. Softmax 函数

markdown 复制代码

$$
\text{Softmax}(z_i) = \frac{\exp(z_i)}{\sum_{j=1}^{K} \exp(z_j)}
$$

Softmax ( z i ) = exp ⁡ ( z i ) ∑ j = 1 K exp ⁡ ( z j ) \text{Softmax}(z_i) = \frac{\exp(z_i)}{\sum_{j=1}^{K} \exp(z_j)} Softmax(zi)=∑j=1Kexp(zj)exp(zi)

python 复制代码

# PyTorch 实现
probs = F.softmax(logits, dim=-1)  # Softmax(z)

# 数值稳定版本（实际实现方式）
z_max = z.max(dim=-1, keepdim=True).values
exp_z = torch.exp(z - z_max)  # 减去最大值防止溢出
probs = exp_z / exp_z.sum(dim=-1, keepdim=True)

语法拆解 ：\text{} 在公式中插入正常文字、\exp 写指数函数、分子分母都是复杂表达式。

实际使用注意 ：Softmax 要用 \text{Softmax} 写，否则会被当成变量 S o f t m a x S o f t m a x Softmax 逐字母斜体。

为什么手动实现会溢出 ：当 z i z_i zi 是很大的正数时， exp ⁡ ( z i ) \exp(z_i) exp(zi) 可能超过浮点数上限。解决方案是减去最大值，结果数学上等价但数值稳定。

4. 逻辑回归

markdown 复制代码

$$
P(y=1|\mathbf{x}) = \sigma(\mathbf{w}^T \mathbf{x} + b) = \frac{1}{1 + \exp(-\mathbf{w}^T \mathbf{x} - b)}
$$

P ( y = 1 ∣ x ) = σ ( w T x + b ) = 1 1 + exp ⁡ ( − w T x − b ) P(y=1|\mathbf{x}) = \sigma(\mathbf{w}^T \mathbf{x} + b) = \frac{1}{1 + \exp(-\mathbf{w}^T \mathbf{x} - b)} P(y=1∣x)=σ(wTx+b)=1+exp(−wTx−b)1

python 复制代码

# PyTorch 实现
logits = torch.matmul(X, W) + b
probabilities = torch.sigmoid(logits)  # P(y=1|x)

二、损失函数：公式写作的高频场景

5. 交叉熵损失

markdown 复制代码

$$
\mathcal{L}_{\text{CE}} = -\frac{1}{N} \sum_{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic})
$$

L CE = − 1 N ∑ i = 1 N ∑ c = 1 C y i c log ⁡ ( y ^ i c ) \mathcal{L}{\text{CE}} = -\frac{1}{N} \sum{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic}) LCE=−N1i=1∑Nc=1∑Cyiclog(y^ic)

python 复制代码

# PyTorch 实现
loss = F.cross_entropy(logits, labels)  # 内部就是 CE 公式

# 手动实现
log_probs = F.log_softmax(logits, dim=-1)  # log(ŷ)
loss = -(labels_onehot * log_probs).sum(dim=-1).mean()

语法拆解 ：\mathcal{L} 写花体损失函数、_{\text{CE}} 用文本下标区分不同损失、双重求和、\log 写对数函数。

为什么 PyTorch 用 log_softmax 而不是 log(softmax()) ：先做 Softmax 再取对数会有数值不稳定问题。F.log_softmax 内部用了 LogSumExp 技巧，直接计算 log ⁡ Softmax ( z i ) \log \text{Softmax}(z_i) logSoftmax(zi) 而不经过中间步骤。写博客时如果涉及实现细节，一定要提到这个。

6. 均方误差损失

markdown 复制代码

$$
\mathcal{L}_{\text{MSE}} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2
$$

L MSE = 1 N ∑ i = 1 N ( y i − y ^ i ) 2 \mathcal{L}{\text{MSE}} = \frac{1}{N} \sum{i=1}^{N} (y_i - \hat{y}_i)^2 LMSE=N1i=1∑N(yi−y^i)2

python 复制代码

# PyTorch 实现
loss = F.mse_loss(predictions, targets)  # L_MSE

7. L2 正则化

markdown 复制代码

$$
\mathcal{L}_{\text{total}} = \mathcal{L}_{\text{data}} + \lambda \|\mathbf{w}\|_2^2 = \mathcal{L}_{\text{data}} + \lambda \sum_{i=1}^{d} w_i^2
$$

L total = L data + λ ∥ w ∥ 2 2 = L data + λ ∑ i = 1 d w i 2 \mathcal{L}{\text{total}} = \mathcal{L}{\text{data}} + \lambda \|\mathbf{w}\|2^2 = \mathcal{L}{\text{data}} + \lambda \sum_{i=1}^{d} w_i^2 Ltotal=Ldata+λ∥w∥22=Ldata+λi=1∑dwi2

python 复制代码

# PyTorch 实现
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)  # λ = 1e-4

语法拆解 ：\| 写范数竖线、_2 和 ^2 分别写范数阶数和平方、\lambda 写正则化系数。

PyTorch 的 weight_decay 和公式的关系 ：PyTorch 的 weight_decay 参数实现的不是在 loss 上加 λ ∥ w ∥ 2 \lambda \|\mathbf{w}\|^2 λ∥w∥2，而是在梯度更新时直接 w ← w − η ( ∇ L + λ w ) w \leftarrow w - \eta (\nabla L + \lambda w) w←w−η(∇L+λw)。两者数学上等价，但实现方式不同。写博客时要注意区分"loss 级别的正则化"和"优化器级别的正则化"。

8. SVM 目标函数

markdown 复制代码

$$
\min_{\mathbf{w}, b} \frac{1}{2} \|\mathbf{w}\|^2 \quad \text{s.t.} \quad y_i(\mathbf{w}^T \mathbf{x}_i + b) \geq 1, \ \forall i
$$

min ⁡ w , b 1 2 ∥ w ∥ 2 s.t. y i ( w T x i + b ) ≥ 1 , ∀ i \min_{\mathbf{w}, b} \frac{1}{2} \|\mathbf{w}\|^2 \quad \text{s.t.} \quad y_i(\mathbf{w}^T \mathbf{x}_i + b) \geq 1, \ \forall i w,bmin21∥w∥2s.t.yi(wTxi+b)≥1, ∀i

语法拆解 ：\min 写最值函数、\quad 插入空格、\text{s.t.} 写"subject to"、\geq 写大于等于、\forall 写任意。

为什么是 1 2 \frac{1}{2} 21 而不是 1 1 1 ：系数 1 2 \frac{1}{2} 21 是为了求导后形式简洁------ ∂ ∂ w 1 2 ∥ w ∥ 2 = w \frac{\partial}{\partial \mathbf{w}} \frac{1}{2}\|\mathbf{w}\|^2 = \mathbf{w} ∂w∂21∥w∥2=w，没有多余的 2。这种小细节在推导 SVM 时经常出现，写文章时值得指出。

三、优化与训练：公式最密集的领域

9. 梯度下降

markdown 复制代码

$$
\theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L}(\theta_t)
$$

θ t + 1 = θ t − η ∇ θ L ( θ t ) \theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L}(\theta_t) θt+1=θt−η∇θL(θt)

python 复制代码

# PyTorch 实现
optimizer.zero_grad()
loss.backward()        # 计算 ∇θ L(θ)
optimizer.step()       # θ_{t+1} = θ_t - η * ∇θ L

语法拆解 ：_{t+1} 写时间步下标、\nabla 写梯度算子、\nabla_\theta 的下标表示对 θ \theta θ 求梯度。

10. 反向传播（链式法则）

markdown 复制代码

$$
\frac{\partial \mathcal{L}}{\partial W^{(l)}} = \frac{\partial \mathcal{L}}{\partial a^{(l)}} \cdot \frac{\partial a^{(l)}}{\partial z^{(l)}} \cdot \frac{\partial z^{(l)}}{\partial W^{(l)}}
$$

∂ L ∂ W ( l ) = ∂ L ∂ a ( l ) ⋅ ∂ a ( l ) ∂ z ( l ) ⋅ ∂ z ( l ) ∂ W ( l ) \frac{\partial \mathcal{L}}{\partial W^{(l)}} = \frac{\partial \mathcal{L}}{\partial a^{(l)}} \cdot \frac{\partial a^{(l)}}{\partial z^{(l)}} \cdot \frac{\partial z^{(l)}}{\partial W^{(l)}} ∂W(l)∂L=∂a(l)∂L⋅∂z(l)∂a(l)⋅∂W(l)∂z(l)

python 复制代码

# PyTorch 中反向传播自动完成这个链式法则
loss.backward()  # 自动计算 ∂L/∂W^(l)

语法拆解 ：\partial 写偏导符号、嵌套分数 \frac{\partial ...}{\partial ...}、\cdot 写点乘、^{(l)} 写层标号。

写作建议 ：在博客中解释反向传播时，先给公式，再逐步解释每一项偏导的含义------ ∂ L ∂ a ( l ) \frac{\partial \mathcal{L}}{\partial a^{(l)}} ∂a(l)∂L 是损失对激活值的梯度， ∂ a ( l ) ∂ z ( l ) \frac{\partial a^{(l)}}{\partial z^{(l)}} ∂z(l)∂a(l) 是激活函数的导数， ∂ z ( l ) ∂ W ( l ) \frac{\partial z^{(l)}}{\partial W^{(l)}} ∂W(l)∂z(l) 是线性变换的导数。

11. Batch Normalization

markdown 复制代码

$$
\hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}, \quad y_i = \gamma \hat{x}_i + \beta
$$

x ^ i = x i − μ B σ B 2 + ϵ , y i = γ x ^ i + β \hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}, \quad y_i = \gamma \hat{x}_i + \beta x^i=σB2+ϵ xi−μB,yi=γx^i+β

python 复制代码

# PyTorch 实现
bn = nn.BatchNorm1d(num_features)
output = bn(x)  # 内部就是这两个公式

# 手动实现
mu = x.mean(dim=0)                        # μ_B
var = x.var(dim=0)                         # σ²_B
x_hat = (x - mu) / torch.sqrt(var + eps)  # 归一化
output = gamma * x_hat + beta              # 缩放和平移

语法拆解 ：根号嵌套分数、\hat{} 写帽子符号、\mu_B 写批次均值、\sigma_B^2 写批次方差。

踩坑提醒 ： ϵ \epsilon ϵ 是一个很小的常数（如 10 − 5 10^{-5} 10−5），防止除以零。 γ \gamma γ 和 β \beta β 是可学习参数------BN 不是简单地把数据归一化到均值 0 方差 1，而是通过 γ \gamma γ 和 β \beta β 恢复模型的表达能力。

12. Adam 优化器

markdown 复制代码

$$
m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t
$$

$$
v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2
$$

$$
\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}
$$

$$
\theta_t = \theta_{t-1} - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}
$$

m t = β 1 m t − 1 + ( 1 − β 1 ) g t m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t mt=β1mt−1+(1−β1)gt

v t = β 2 v t − 1 + ( 1 − β 2 ) g t 2 v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2 vt=β2vt−1+(1−β2)gt2

m ^ t = m t 1 − β 1 t , v ^ t = v t 1 − β 2 t \hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t} m^t=1−β1tmt,v^t=1−β2tvt

θ t = θ t − 1 − η m ^ t v ^ t + ϵ \theta_t = \theta_{t-1} - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} θt=θt−1−ηv^t +ϵm^t

python 复制代码

# PyTorch 实现
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, betas=(0.9, 0.999), eps=1e-8)
# η = 1e-3, β1 = 0.9, β2 = 0.999, ε = 1e-8

语法拆解：四个公式组合在一起，用到了上下标、分数、根号、希腊字母------几乎覆盖了前两篇的所有语法。

为什么需要偏差校正 ： m t m_t mt 和 v t v_t vt 在初始几步中偏向 0（因为 m 0 = 0 m_0 = 0 m0=0）， m ^ t = m t 1 − β 1 t \hat{m}_t = \frac{m_t}{1 - \beta_1^t} m^t=1−β1tmt 的分母 1 − β 1 t 1 - \beta_1^t 1−β1t 会从小于 1 逐渐趋近 1，起到校正作用。当 t → ∞ t \to \infty t→∞ 时 β 1 t → 0 \beta_1^t \to 0 β1t→0，校正项趋近 1，不再有影响。写博客时如果不解释这个，读者会很困惑 m ^ t \hat{m}_t m^t 和 m t m_t mt 的关系。

四、Transformer 与 Attention：公式写作的终极考验

13. 缩放点积注意力

markdown 复制代码

$$
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V
$$

Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V Attention(Q,K,V)=softmax(dk QKT)V

python 复制代码

# PyTorch 实现（简化版）
scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5)  # QK^T / √d_k
attn_weights = F.softmax(scores, dim=-1)                       # softmax(QK^T/√d_k)
output = torch.matmul(attn_weights, V)                          # Attention = softmax(...)V

语法拆解 ：\left( \right) 自适应括号包裹分数、矩阵乘法 Q K T QK^T QKT、\sqrt{d_k} 写特征维度根号。

为什么要除以 d k \sqrt{d_k} dk ：当 d k d_k dk 较大时， Q K T QK^T QKT 的值会很大，导致 softmax 进入梯度饱和区。除以 d k \sqrt{d_k} dk 把方差缩放到合理范围。这个解释如果不写，读者只看到公式却不知道为什么要这样设计。

14. 多头注意力

markdown 复制代码

$$
\text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h) W^O
$$

$$
\text{head}_i = \text{Attention}(Q W_i^Q, K W_i^K, V W_i^V)
$$

MultiHead ( Q , K , V ) = Concat ( head 1 , ... , head h ) W O \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h) W^O MultiHead(Q,K,V)=Concat(head1,...,headh)WO

head i = Attention ( Q W i Q , K W i K , V W i V ) \text{head}_i = \text{Attention}(Q W_i^Q, K W_i^K, V W_i^V) headi=Attention(QWiQ,KWiK,VWiV)

语法拆解 ：\ldots 写省略号、W_i^Q 写参数矩阵（下标 i i i 上标 Q Q Q）、W^O 写输出投影矩阵。

15. 位置编码

markdown 复制代码

$$
PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right)
$$

$$
PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right)
$$

P E ( p o s , 2 i ) = sin ⁡ ( p o s 10000 2 i / d model ) PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) PE(pos,2i)=sin(100002i/dmodelpos)

P E ( p o s , 2 i + 1 ) = cos ⁡ ( p o s 10000 2 i / d model ) PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) PE(pos,2i+1)=cos(100002i/dmodelpos)

语法拆解 ：_{(pos, 2i)} 多字符下标、10000^{2i/d_{\text{model}}} 嵌套上标、\sin \cos 写三角函数。

五、概率与信息论：公式语法的高阶应用

16. 高斯分布

markdown 复制代码

$$
\mathcal{N}(x | \mu, \sigma^2) = \frac{1}{\sqrt{2\pi}\sigma} \exp\left(-\frac{(x - \mu)^2}{2\sigma^2}\right)
$$

N ( x ∣ μ , σ 2 ) = 1 2 π σ exp ⁡ ( − ( x − μ ) 2 2 σ 2 ) \mathcal{N}(x | \mu, \sigma^2) = \frac{1}{\sqrt{2\pi}\sigma} \exp\left(-\frac{(x - \mu)^2}{2\sigma^2}\right) N(x∣μ,σ2)=2π σ1exp(−2σ2(x−μ)2)

python 复制代码

# PyTorch 实现
dist = torch.distributions.Normal(loc=mu, scale=sigma)
log_prob = dist.log_prob(x)  # log N(x | μ, σ²)

语法拆解 ：花体 N \mathcal{N} N、条件概率竖线 |、归一化系数、自适应括号 \left( \right)。

17. 贝叶斯定理

markdown 复制代码

$$
P(\theta | \mathcal{D}) = \frac{P(\mathcal{D} | \theta) P(\theta)}{P(\mathcal{D})} = \frac{P(\mathcal{D} | \theta) P(\theta)}{\int P(\mathcal{D} | \theta) P(\theta) \, d\theta}
$$

P ( θ ∣ D ) = P ( D ∣ θ ) P ( θ ) P ( D ) = P ( D ∣ θ ) P ( θ ) ∫ P ( D ∣ θ ) P ( θ ) d θ P(\theta | \mathcal{D}) = \frac{P(\mathcal{D} | \theta) P(\theta)}{P(\mathcal{D})} = \frac{P(\mathcal{D} | \theta) P(\theta)}{\int P(\mathcal{D} | \theta) P(\theta) \, d\theta} P(θ∣D)=P(D)P(D∣θ)P(θ)=∫P(D∣θ)P(θ)dθP(D∣θ)P(θ)

语法拆解 ：花体数据集 D \mathcal{D} D、条件概率、分数、积分、\, 细空格。这个公式综合了概率论的核心元素。

18. 信息熵

markdown 复制代码

$$
H(X) = -\sum_{i=1}^{n} P(x_i) \log P(x_i)
$$

H ( X ) = − ∑ i = 1 n P ( x i ) log ⁡ P ( x i ) H(X) = -\sum_{i=1}^{n} P(x_i) \log P(x_i) H(X)=−i=1∑nP(xi)logP(xi)

19. KL 散度

markdown 复制代码

$$
D_{\text{KL}}(P \| Q) = \sum_{i=1}^{n} P(i) \log\frac{P(i)}{Q(i)}
$$

D KL ( P ∥ Q ) = ∑ i = 1 n P ( i ) log ⁡ P ( i ) Q ( i ) D_{\text{KL}}(P \| Q) = \sum_{i=1}^{n} P(i) \log\frac{P(i)}{Q(i)} DKL(P∥Q)=i=1∑nP(i)logQ(i)P(i)

语法拆解 ：\| 写双竖线（不是单竖线 |）、\log\frac{}{} 对数内嵌分数。

踩坑提醒 ：KL 散度中的 \| 和范数中的 \| 是同一个命令。不要写成 \parallel，虽然效果相同但不是标准写法。

20. VAE 损失（ELBO）

markdown 复制代码

$$
\mathcal{L}_{\text{VAE}} = \mathbb{E}_{q_\phi(z|x)}[\log p_\theta(x|z)] - D_{\text{KL}}(q_\phi(z|x) \| p(z))
$$

L VAE = E q ϕ ( z ∣ x ) $log p θ ( x ∣ z )$ − D KL ( q ϕ ( z ∣ x ) ∥ p ( z ) ) \mathcal{L}{\text{VAE}} = \mathbb{E}{q_\phi(z|x)} $\\log p_\\theta(x\|z)$ - D_{\text{KL}}(q_\phi(z|x) \| p(z)) LVAE=Eqϕ(z∣x) $logpθ(x∣z)$ −DKL(qϕ(z∣x)∥p(z))

python 复制代码

# PyTorch 实现（简化版）
recon_loss = F.binary_cross_entropy(recon_x, x, reduction='sum')  # 重建项
kl_loss = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())  # KL 项
total_loss = recon_loss + kl_loss  # ELBO

语法拆解 ：\mathbb{E} 写期望算子、_{q_\phi(z|x)} 期望的下标是函数表达式、\phi 写参数。

VAE 损失的两项含义 ：重建项 E $log p θ ( x ∣ z )$ \mathbb{E} $\\log p_\\theta(x\|z)$ E $logpθ(x∣z)$ 衡量重建质量，KL 项 D KL ( q ϕ ∥ p ) D_{\text{KL}}(q_\phi \| p) DKL(qϕ∥p) 衡量编码分布和先验的偏离。两者权衡就是 VAE 的核心思想。

六、经典机器学习公式

21. 余弦相似度

markdown 复制代码

$$
\cos(\mathbf{a}, \mathbf{b}) = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \|\mathbf{b}\|} = \frac{\sum_{i=1}^{d} a_i b_i}{\sqrt{\sum_{i=1}^{d} a_i^2} \sqrt{\sum_{i=1}^{d} b_i^2}}
$$

cos ⁡ ( a , b ) = a ⋅ b ∥ a ∥ ∥ b ∥ = ∑ i = 1 d a i b i ∑ i = 1 d a i 2 ∑ i = 1 d b i 2 \cos(\mathbf{a}, \mathbf{b}) = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \|\mathbf{b}\|} = \frac{\sum_{i=1}^{d} a_i b_i}{\sqrt{\sum_{i=1}^{d} a_i^2} \sqrt{\sum_{i=1}^{d} b_i^2}} cos(a,b)=∥a∥∥b∥a⋅b=∑i=1dai2 ∑i=1dbi2 ∑i=1daibi

python 复制代码

# PyTorch 实现
similarity = F.cosine_similarity(a, b, dim=0)  # cos(a, b)

语法拆解 ：粗体向量、点乘 \cdot、范数 \|\|、求和、根号、分数嵌套------一个公式用到了全部四篇的语法。

22. 距离度量对比

markdown 复制代码

$$
d_{\text{Manhattan}}(\mathbf{x}, \mathbf{y}) = \sum_{i=1}^{d} |x_i - y_i|
$$

$$
d_{\text{Euclidean}}(\mathbf{x}, \mathbf{y}) = \sqrt{\sum_{i=1}^{d} (x_i - y_i)^2}
$$

$$
d_{\text{Chebyshev}}(\mathbf{x}, \mathbf{y}) = \max_{i=1}^{d} |x_i - y_i|
$$

d Manhattan ( x , y ) = ∑ i = 1 d ∣ x i − y i ∣ d_{\text{Manhattan}}(\mathbf{x}, \mathbf{y}) = \sum_{i=1}^{d} |x_i - y_i| dManhattan(x,y)=i=1∑d∣xi−yi∣

d Euclidean ( x , y ) = ∑ i = 1 d ( x i − y i ) 2 d_{\text{Euclidean}}(\mathbf{x}, \mathbf{y}) = \sqrt{\sum_{i=1}^{d} (x_i - y_i)^2} dEuclidean(x,y)=i=1∑d(xi−yi)2

d Chebyshev ( x , y ) = max ⁡ i = 1 d ∣ x i − y i ∣ d_{\text{Chebyshev}}(\mathbf{x}, \mathbf{y}) = \max_{i=1}^{d} |x_i - y_i| dChebyshev(x,y)=i=1maxd∣xi−yi∣

python 复制代码

# PyTorch 实现
manhattan = torch.sum(torch.abs(x - y))      # L1 距离
euclidean = torch.norm(x - y, p=2)           # L2 距离
chebyshev = torch.max(torch.abs(x - y))      # L∞ 距离

写作建议：三种距离放在一组对比，读者可以直观看到"求和 → 求和开方 → 取最大"的递进关系，对应 L1 → L2 → L∞ 范数。

23. 决策树信息增益

markdown 复制代码

$$
\text{IG}(S, A) = H(S) - \sum_{v \in \text{Values}(A)} \frac{|S_v|}{|S|} H(S_v)
$$

IG ( S , A ) = H ( S ) − ∑ v ∈ Values ( A ) ∣ S v ∣ ∣ S ∣ H ( S v ) \text{IG}(S, A) = H(S) - \sum_{v \in \text{Values}(A)} \frac{|S_v|}{|S|} H(S_v) IG(S,A)=H(S)−v∈Values(A)∑∣S∣∣Sv∣H(Sv)

语法拆解 ：\in 写属于、\text{Values}(A) 在公式中写函数名、|S_v| 写集合大小、求和条件写在下标。

24. Gini 不纯度

markdown 复制代码

$$
\text{Gini}(S) = 1 - \sum_{i=1}^{C} p_i^2
$$

Gini ( S ) = 1 − ∑ i = 1 C p i 2 \text{Gini}(S) = 1 - \sum_{i=1}^{C} p_i^2 Gini(S)=1−i=1∑Cpi2

python 复制代码

# Gini 不纯度实现
def gini(probs):
    return 1 - sum(p ** 2 for p in probs)

七、完整语法速查表

基础语法

语法	效果	用途
$x$	行内公式	公式嵌在文字中
`$$x$$`	块级公式	公式独占一行
`\frac{a}{b}`	a b \frac{a}{b} ba	分数
`\dfrac{a}{b}`	a b \dfrac{a}{b} ba	行内分数（不缩小）
`x^{a}` / `x_{a}`	x a x^a xa / x a x_a xa	上标 / 下标
`\sqrt{x}` / `\sqrt[n]{x}`	x \sqrt{x} x / x n \sqrt $n$ {x} nx	平方根 / n 次根

运算符号

语法	效果	用途
`\sum_{i=1}^{N}`	∑ i = 1 N \sum_{i=1}^{N} ∑i=1N	求和
`\prod_{i=1}^{N}`	∏ i = 1 N \prod_{i=1}^{N} ∏i=1N	连乘
`\int_{a}^{b}`	∫ a b \int_{a}^{b} ∫ab	积分
`\lim_{x \to \infty}`	lim ⁡ x → ∞ \lim_{x \to \infty} limx→∞	极限
`\max` / `\min`	max ⁡ \max max / min ⁡ \min min	最值
`\log` / `\exp`	log ⁡ \log log / exp ⁡ \exp exp	对数 / 指数

字体与修饰

语法	效果	用途
`\mathbf{x}`	x \mathbf{x} x	粗体向量
`\mathcal{L}`	L \mathcal{L} L	花体（损失函数）
`\mathbb{E}` / `\mathbb{R}`	E \mathbb{E} E / R \mathbb{R} R	期望 / 实数集
`\hat{y}` / `\tilde{x}`	y ^ \hat{y} y^ / x ~ \tilde{x} x~	帽子 / 波浪
`\text{文字}`	文字 \text{文字} 文字	公式内插入文字

关系与逻辑

语法	效果	用途
`\leq` / `\geq` / `\neq`	≤ \leq ≤ / ≥ \geq ≥ / ≠ \neq =	比较
`\approx` / `\equiv`	≈ \approx ≈ / ≡ \equiv ≡	约等 / 恒等
`\propto` / `\sim`	∝ \propto ∝ / ∼ \sim ∼	正比 / 服从
`\in` / `\forall` / `\exists`	∈ \in ∈ / ∀ \forall ∀ / ∃ \exists ∃	属于 / 任意 / 存在
`\nabla` / `\partial`	∇ \nabla ∇ / ∂ \partial ∂	梯度 / 偏导

排版进阶

语法	效果	用途
`\left( ... \right)`	自适应括号	括号跟随内容大小
`	`	∣ \| ∣
`\cdot` / `\odot`	⋅ \cdot ⋅ / ⊙ \odot ⊙	点乘 / 逐元素乘
`\quad` / `\,`	空格	大空格 / 细空格
`\begin{bmatrix}...\end{bmatrix}`	矩阵	方括号矩阵
`\begin{cases}...\end{cases}`	条件分支	分段函数

八、综合实战：从零搭建一个完整训练流程

前面七章按类型分组列举了 24 个公式，但实际写博客时，公式不是孤立出现的------它们按训练流程串成一条线。这个章节把所有公式串起来，模拟一个完整的"从模型定义到训练优化"的推导过程。

这不是公式罗列，而是你在写 AI 技术博客时真正需要的叙述结构------每一步都用前面的公式，每一步都给出代码对照。

步骤 1：定义模型（线性回归 → Sigmoid → 二分类）

markdown 复制代码

$$
\hat{y} = \sigma(\mathbf{w}^T \mathbf{x} + b) = \frac{1}{1 + \exp(-\mathbf{w}^T \mathbf{x} - b)}
$$

y ^ = σ ( w T x + b ) = 1 1 + exp ⁡ ( − w T x − b ) \hat{y} = \sigma(\mathbf{w}^T \mathbf{x} + b) = \frac{1}{1 + \exp(-\mathbf{w}^T \mathbf{x} - b)} y^=σ(wTx+b)=1+exp(−wTx−b)1

python 复制代码

# PyTorch 实现
import torch.nn as nn

class SimpleClassifier(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)  # w^T x + b
    
    def forward(self, x):
        return torch.sigmoid(self.linear(x))  # σ(w^T x + b)

用到的语法 ：粗体 \mathbf、转置 ^T、分数 \frac、指数 \exp、Sigmoid σ \sigma σ。串联了第一篇和第二篇的核心语法。

步骤 2：定义损失函数（交叉熵）

markdown 复制代码

$$
\mathcal{L}_{\text{CE}} = -\frac{1}{N} \sum_{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic})
$$

L CE = − 1 N ∑ i = 1 N ∑ c = 1 C y i c log ⁡ ( y ^ i c ) \mathcal{L}{\text{CE}} = -\frac{1}{N} \sum{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic}) LCE=−N1i=1∑Nc=1∑Cyiclog(y^ic)

python 复制代码

# PyTorch 实现
import torch.nn.functional as F

loss = F.binary_cross_entropy(predictions, labels)  # 二分类交叉熵
loss = F.cross_entropy(logits, labels)            # 多分类交叉熵

用到的语法 ：花体 \mathcal{L}、文本下标 _{\text{CE}}、分数 \frac、双重求和 \sum\sum、对数 \log、上下标 _{ic} \hat{y}。

步骤 3：添加正则化（L2）

markdown 复制代码

$$
\mathcal{L}_{\text{total}} = \mathcal{L}_{\text{CE}} + \lambda \|\mathbf{w}\|_2^2
$$

L total = L CE + λ ∥ w ∥ 2 2 \mathcal{L}{\text{total}} = \mathcal{L}{\text{CE}} + \lambda \|\mathbf{w}\|_2^2 Ltotal=LCE+λ∥w∥22

python 复制代码

# PyTorch 实现
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)
# weight_decay 就是 λ

用到的语法 ：范数 \|\|、上下标 _2 ^2、希腊字母 λ \lambda λ。

步骤 4：计算梯度（反向传播）

markdown 复制代码

$$
\frac{\partial \mathcal{L}}{\partial \theta} = \nabla_\theta \mathcal{L}(\theta)
$$

∂ L ∂ θ = ∇ θ L ( θ ) \frac{\partial \mathcal{L}}{\partial \theta} = \nabla_\theta \mathcal{L}(\theta) ∂θ∂L=∇θL(θ)

python 复制代码

# PyTorch 实现
loss.backward()  # 自动计算所有梯度
for param in model.parameters():
    print(param.grad)  # 这就是 ∂L/∂θ

用到的语法 ：偏导 \partial、嵌套分数 \frac{\partial...}{\partial...}、梯度算子 \nabla、花体 L \mathcal{L} L。

步骤 5：更新参数（梯度下降 → Adam）

先用基础梯度下降：

markdown 复制代码

$$
\theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L}
$$

θ t + 1 = θ t − η ∇ θ L \theta_{t+1} = \theta_t - \eta \nabla_\theta \mathcal{L} θt+1=θt−η∇θL

升级为 Adam：

markdown 复制代码

$$
\theta_t = \theta_{t-1} - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}
$$

θ t = θ t − 1 − η m ^ t v ^ t + ϵ \theta_t = \theta_{t-1} - \eta \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} θt=θt−1−ηv^t +ϵm^t

python 复制代码

# 从 SGD 升级到 Adam
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, betas=(0.9, 0.999), eps=1e-8)

用到的语法 ：时间步下标 _{t+1}、_{t-1}、分数 \frac、根号 \sqrt、帽子 \hat{}、希腊字母 η \eta η ϵ \epsilon ϵ β \beta β。

步骤 6：归一化（Batch Normalization）

markdown 复制代码

$$
\hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}, \quad y_i = \gamma \hat{x}_i + \beta
$$

x ^ i = x i − μ B σ B 2 + ϵ , y i = γ x ^ i + β \hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}, \quad y_i = \gamma \hat{x}_i + \beta x^i=σB2+ϵ xi−μB,yi=γx^i+β

python 复制代码

# PyTorch 实现
self.bn = nn.BatchNorm1d(hidden_dim)
# 在前向传播中
x = self.bn(x)  # 归一化 + 缩放平移

用到的语法 ：根号嵌套分数、帽子 \hat{}、均值线 $\mu_B$ 、方差 $\sigma_B^2$ 、希腊字母 γ \gamma γ β \beta β ϵ \epsilon ϵ。

步骤 7：注意力机制（Transformer）

markdown 复制代码

$$
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V
$$

Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V Attention(Q,K,V)=softmax(dk QKT)V

python 复制代码

# PyTorch 实现
scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5)
attn = F.softmax(scores, dim=-1)
output = torch.matmul(attn, V)

用到的语法 ：文本标注 \text{}、自适应括号 \left( \right)、分数 \frac、矩阵转置 ^T、根号 \sqrt、下标 d_k。这是公式语法的终极综合------一个公式串联了全部四篇的语法。

语法使用统计

这个完整训练流程中用到的所有语法：

| 语法 | 出现次数 | 出现步骤 |

|---|---|---|---|

| \frac | 8 | 损失函数、梯度、Adam、BN、Attention |

| \sum | 3 | 交叉熵双重求和 |

| \mathcal{L} | 5 | 每个涉及损失的步骤 |

| \nabla | 2 | 梯度下降 |

| \partial | 2 | 反向传播 |

| \sqrt | 3 | Adam、BN、Attention |

| \hat{} | 4 | 预测值、BN、Adam 偏差校正 |

| \mathbf{} | 3 | 权重向量、输入向量 |

| \text{} | 4 | Softmax、Attention、CE 下标 |

| \| | 1 | L2 正则化范数 |

| \left( \right) | 2 | 高斯分布、Attention |

| 希腊字母 | 12+ | η \eta η θ \theta θ λ \lambda λ σ \sigma σ μ \mu μ γ \gamma γ β \beta β ϵ \epsilon ϵ |

写作建议：在博客中展示这种"从零到一"的完整推导过程，比逐个列公式有价值得多。读者能看到公式之间的逻辑递进------从模型定义到损失函数到优化器到归一化到注意力机制，每一步都用前面的公式作为基础。这就是"教学型博客"和"公式手册"的区别。如果你能把这条线写清楚，读者一遍就能理解整个 AI 训练流程的数学骨架。

系列总结

这个系列四篇文章，从最基础的 $ 符号到 24 个 AI 经典公式的完整写法，覆盖了 Markdown 数学公式的一切核心语法：

第一篇：行内/块级公式、希腊字母、上下标、特殊修饰符号、错误排查
第二篇：分数、求和、连乘、极限、积分、根号、自适应括号、数值稳定性
第三篇：矩阵、特殊运算符、箭头关系符号、多行对齐、条件公式、颜色标注
第四篇（本文）：AI 算法公式综合实战 + Python 代码对照 + 完整速查表

写好数学公式的关键就三步：记语法、多练习、善用速查表。但更重要的是理解公式背后的含义------不要只复制粘贴公式，要在博客中解释为什么这样写、代码怎么实现、容易踩什么坑。

如果你在写文章时遇到本文没覆盖的语法，可以在 KaTeX 文档查到完整的命令列表------CSDN 和大多数 Markdown 编辑器使用的都是 KaTeX 渲染引擎。