概率与最大似然：为什么 ML 是个概率问题

读到这里，你已经知道了：

• AI 模型本质上是矩阵变换（L1-02）
• 训练 = 调矩阵里的数让损失最小（L1-03）

但还有一个没回答的问题：

“损失”到底是怎么定义的？为什么有这么多种损失函数？

答案藏在概率论里。这一篇我们换个视角——把整个 ML 看成一个概率问题，你会发现所有的”损失函数”都是同一个数学结构。

重新看 ML 的目标

我们用一个具体例子。任务：垃圾邮件分类。

你给模型看一封邮件，让它输出”是垃圾邮件”或”不是”。

传统想法是：“让模型输出对的标签。”

但更准确的描述是：

让模型输出”是垃圾邮件”的概率。

模型不输出 0/1，输出一个 0-1 之间的数：0.92 代表”92% 是垃圾”。

这件事的好处巨大：

• 你能知道模型的置信度
• 可以设阈值（>0.5 才标记）
• 可以比较不同模型的输出（哪个更确信）

似然 vs 概率

这两个词长得像，但讲的是完全不同的事。

概率

已知参数，问数据出现的可能性是多少。

例子：已知硬币是公平的（p=0.5），抛 3 次得到”正反正”的概率是？

$$P(\text{正反正} | p=0.5) = 0.5 \times 0.5 \times 0.5 = 0.125$$

似然

已知数据，问什么参数最能解释这个数据。

例子：我抛了 3 次硬币得到”正反正”，这枚硬币的 $p$ 应该是多少？

我们试不同的 $p$，看哪个让数据最”合理”：

| $p$ | $P(\text{正反正} | p)$ = $p \times (1-p) \times p$ | |---|---| | 0.1 | $0.1 \times 0.9 \times 0.1 = 0.009$ | | 0.3 | $0.3 \times 0.7 \times 0.3 = 0.063$ | | 0.5 | $0.5 \times 0.5 \times 0.5 = 0.125$ | | 0.667 | $0.667 \times 0.333 \times 0.667 = \mathbf{0.148}$ | | 0.8 | $0.8 \times 0.2 \times 0.8 = 0.128$ | | 0.9 | $0.9 \times 0.1 \times 0.9 = 0.081$ |

$p = 0.667$ 让数据出现的概率最大 —— 这就是最大似然估计。

直觉一致——抛 3 次得到 2 正 1 反，最合理的估计就是 $p \approx 2/3$。

把这事推广到 ML

回到垃圾邮件的例子。

• 数据：一堆邮件 + 它们的真实标签 ($x_i, y_i$)
• 参数：模型的所有矩阵 $\theta$（神经网络的权重）
• 目标：找一个 $\theta$，使得”模型输出的概率”和”真实标签”最一致

数学化：

$$\theta^* = \arg\max_\theta \prod_i P(y_i | x_i, \theta)$$

意思：找一个 $\theta$，让所有数据的”被解释概率”乘积最大。

但乘积有个问题——一堆 0-1 的数相乘，结果会非常小，电脑算不准。

所以我们取个 log：

$$\theta^* = \arg\max_\theta \sum_i \log P(y_i | x_i, \theta)$$

乘积变成了相加。然后我们一般爱”最小化”而不是”最大化”，所以加个负号：

$$\theta^* = \arg\min_\theta -\sum_i \log P(y_i | x_i, \theta)$$

这个 $-\sum \log P$ 就是 ML 圈子里最著名的损失函数——交叉熵（Cross Entropy）。

“交叉熵” = “负对数似然”

是的，它们是同一个东西，只是名字不同。

• 概率角度：最大化对数似然
• ML 工程角度：最小化交叉熵

负号一加，最大化变最小化——但目标完全一样。

下面是 PyTorch 用的标准二分类交叉熵公式：

$$L = -\sum_i [y_i \log \hat{y}_i + (1-y_i) \log(1-\hat{y}_i)]$$

其中 $\hat{y}_i$ 是模型预测的概率，$y_i$ 是真实标签（0 或 1）。

翻译：

• 当真实是垃圾邮件（$y=1$），$\hat{y}$ 越接近 1，$\log \hat{y}$ 越接近 0（损失小）
• 当真实是垃圾邮件，$\hat{y}$ 接近 0，$\log \hat{y} \to -\infty$（损失爆炸大）

这惩罚了”自信地说错话”。

为什么 LLM 也是同一个数学

回到 ChatGPT。它是怎么训练的？

ChatGPT 在做的事是预测下一个 token。给定前面的话，模型输出词表中每个词的概率分布：

输入: "今天天气真"
模型输出: { "好":0.45, "不错":0.22, "糟":0.10, "冷":0.08, ... }

训练时：

• 数据：海量文本，每个位置都有”真实下一个词”
• 损失：交叉熵——模型对”真实词”的概率越高越好

就是这一个公式，训练出了所有的大模型。

损失 = -log P(真实下一个词 | 前文, 模型参数)

加总几万亿个 token，就是 GPT-3 的训练损失。

贝叶斯一瞥

最大似然的”反派”是贝叶斯——它不止考虑数据，还考虑”先验”。

$$P(\theta | \text{数据}) \propto P(\text{数据} | \theta) \cdot P(\theta)$$

意思：

• $P(\text{数据} | \theta)$：似然（数据的合理性）
• $P(\theta)$：先验（你对参数本身的信念）
• $P(\theta | \text{数据})$：后验（看完数据后的更新信念）

这是统计学的另一大流派。当下深度学习主要用最大似然，但贝叶斯思想在以下方面仍然重要：

• 模型不确定性（“它有多确信”）
• 小数据场景
• 一些专门的研究（贝叶斯神经网络、变分推断）

L2 路径会专门讲贝叶斯方法。

用 Python 看看

import numpy as np

# 模拟垃圾邮件预测
# y 是真实标签 (0/1)，y_hat 是模型预测的概率 (0-1)

y      = np.array([1, 0, 1, 1, 0])
y_hat  = np.array([0.9, 0.2, 0.8, 0.65, 0.4])

# 二分类交叉熵
ce = -np.mean(y * np.log(y_hat) + (1-y) * np.log(1 - y_hat))
print(f"交叉熵损失: {ce:.4f}")

# 假设模型变好了
y_hat_better = np.array([0.95, 0.05, 0.95, 0.85, 0.1])
ce_better = -np.mean(y * np.log(y_hat_better) + (1-y) * np.log(1 - y_hat_better))
print(f"更好模型: {ce_better:.4f}")  # 这个数会更小

你会发现：预测越准、越自信，交叉熵越小。这就是为什么 ML 训练目标是它。

KL 散度（一瞥）

最后再讲一个相关概念——KL 散度。它测量”两个概率分布有多不同”：

$$KL(P \| Q) = \sum_i P(i) \log \frac{P(i)}{Q(i)}$$

关键性质：

• $KL(P \| P) = 0$（自己和自己没差异）
• $KL > 0$ 总是
• 不对称：$KL(P \| Q) \ne KL(Q \| P)$

KL 散度在 ML 里到处出现：

• VAE（变分自编码器）的损失里有它
• 强化学习 PPO 算法用它做”策略约束”
• 知识蒸馏用它让小模型学大模型的分布

小知识：交叉熵 = 熵 + KL 散度。 训练时”熵”是常数，所以最小化交叉熵 = 最小化 KL 散度——本质上是让模型预测的分布越接近真实分布越好。

一句话总结

机器学习 = 假设一个概率模型 + 找最让数据合理的参数。

交叉熵 / 最大似然 / KL 散度 —— 都是同一件事的不同视角。

你以后看到任何损失函数，它本质上都在做”对齐两个概率分布”——只是对齐的方式不同。

想看更多

👀 LLM 采样可视化 —— 看模型输出的概率分布，玩 temperature / top-k / top-p。

下一步推荐：L2-09 配套：优化器深度解析 —— 你已经懂梯度下降，下一步是 Adam 为什么强。