概率的基本概念

概率的基本概念

概率论为不确定性建立形式化的描述，并提供了在不确定性下进行推理的规则。本文件介绍样本空间、事件、概率公理、条件概率、独立性、贝叶斯定理，以及频率派与贝叶斯派两种诠释——这是机器学习中每一个生成模型与判别模型背后的数学框架。

• 概率用一个 0 到 1 之间的数来度量一个事件发生的可能性。

• 概率为 0 表示不可能，1 表示必然，0.5 表示像掷硬币那样五五开。

• 主要有两种诠释。**频率派（frequentist）**观点认为概率是长期相对频率：把一枚均匀的硬币掷 10000 次，正面大约会出现 50% 的次数。

• **贝叶斯派（Bayesian）**观点则认为概率是一种信念程度：你可以说"明天下雨的概率是 70%"，即使明天只会发生一次。

• 两种诠释用的是同一套数学规则。差异是哲学层面的，但在机器学习中很重要。频率派方法给出点估计，贝叶斯方法则给出参数的完整分布。

• 样本空间（sample space） S 是一次试验所有可能结果的集合。掷硬币：S = \{H, T\}。掷骰子：S = \{1, 2, 3, 4, 5, 6\}。

• **事件（event）**是样本空间的任意一个子集。"掷出偶数"就是事件 A = \{2, 4, 6\}，它是 S 的子集。

• 当所有结果等可能时，一个事件的概率就是计数（来自第 1 节）：

• 对于偶数的例子：P(\text{even}) = \frac{3}{6} = 0.5。

• 事件 A 的补事件（complement），记作 A' 或 A^c，是 S 中不属于 A 的所有结果。由于每个结果要么在 A 中、要么不在：

• 取补往往是更简便的路径。与其列举掷 5 次硬币至少出现 1 次正面的所有情况，不如数一下一次正面都没有的那一种，再用 1 减去：P(\text{at least one head}) = 1 - P(\text{all tails}) = 1 - (0.5)^5 = 0.969。

• 如果两个事件不能同时发生，即 A \cap B = \emptyset，就称它们互斥（mutually exclusive，也称 disjoint）。一次掷骰子掷出 2 和掷出 5 是互斥的。

• 互斥事件的加法法则很直接：

• 当事件可能重叠时，就需要一般加法法则，以避免把交集部分重复计算：

• 这与计数中的容斥原理完全对应。上面的韦恩图说明了原因：紫色区域（交集）在 P(A) 中被算了一次，在 P(B) 中又被算了一次，所以要把它减去一次。

• 联合概率（joint probability） P(A \cap B) 是 A 和 B 同时发生的概率。在一副扑克牌中，P(\text{red} \cap \text{king}) = \frac{2}{52}，因为共有 2 张红色的 K。

• **边缘概率（marginal probability）**是单个事件（不管其他事件）的概率。P(\text{red}) = \frac{26}{52} = 0.5 就是一个边缘概率。如果你有关于两个变量的联合分布，边缘概率可以通过对另一个变量求和（或积分）得到。

• **条件概率（conditional probability）**回答的是：已知 B 已经发生，那么 A 发生的概率是多少？我们把样本空间从 S 缩小到 B，问 B 中有多大比例也属于 A：

• 例子：你抽了一张牌，有人告诉你它是红色的。那么它是 K 的概率是多少？红色牌有 26 张，其中 2 张是 K，所以 P(\text{king} | \text{red}) = \frac{2}{26} = \frac{1}{13}。套用公式：P(\text{king} \cap \text{red}) / P(\text{red}) = \frac{2/52}{26/52} = \frac{1}{13}。

• 如果知道一个事件发生并不告诉你另一个事件的任何信息，就称这两个事件独立（independent）。形式化地：

• 等价地，P(A | B) = P(A)。掷两枚独立的硬币是独立事件。不放回地抽两张牌则不独立（第一次抽取改变了剩余的牌）。

• 独立性是极大的简化。对于独立事件，联合概率可以分解为乘积，这让计算变得可行。许多 ML 模型之所以假设特征之间相互独立（例如朴素贝叶斯），正是因为这种简化。

• 任意两个事件的**乘法法则（multiplication rule）**是把条件概率公式重排得到的：

• 对于独立事件，由于条件概率就等于边缘概率，它简化为 P(A \cap B) = P(A) \cdot P(B)。

• **贝叶斯定理（Bayes' theorem）**是概率论中最重要的结论之一，也是贝叶斯机器学习的基础。它允许你反过来求一个条件概率：

• 这个定理直接来自于把 P(A \cap B) 写成两种形式：P(B|A) \cdot P(A) = P(A|B) \cdot P(B)，然后解出 P(A|B)。

• 每个部分都有自己的名字：

  • 先验（prior） P(A)：在看到证据之前你最初的信念
  • 似然（likelihood） P(B|A)：假设 A 为真时，证据出现的概率有多大
  • 证据（evidence） P(B)：看到证据的总概率，起归一化的作用
  • 后验（posterior） P(A|B)：看到证据之后更新过的信念

• 我们来走一遍经典的医学诊断例子。假设某种疾病影响 1% 的人口。一种检测有 95% 的准确率：它能正确识别 95% 的病人（灵敏度），也能正确识别 90% 的健康人（特异度）。

• 你检测呈阳性。你真正患病的概率是多少？

• 令 D = 患病，+ = 检测阳性。

  • 先验：P(D) = 0.01
  • 似然：P(+ | D) = 0.95
  • 假阳性率：P(+ | D') = 0.10

• 我们需要求 P(+)。根据全概率公式：

• 现在套用贝叶斯定理：

• 尽管检测"95% 准确"，阳性结果只意味着你大约有 8.8% 的概率真的患病。先验的影响极大。因为这种病很罕见，大多数阳性结果其实是假阳性。这对 ML 中任何分类问题都是个关键洞见：当类别不平衡时，单看准确率会误导人。

• **全概率法则（law of total probability）**把样本空间划分成若干互斥且穷尽的事件 B_1, B_2, \ldots, B_n，把任意事件 A 表达为：

• 这正是我们在医学例子里用来计算 P(+) 的方法：把人群分成"患病"和"未患病"两部分。

• **概率的链式法则（chain rule of probability）**把乘法法则推广到任意多个事件：

• 每一项都以上之前发生的所有事件为条件。这就是自回归语言模型的骨干：一句话的概率等于每个词在给定前面所有词条件下的概率的乘积。

• **条件独立（conditional independence）**指的是在给定第三个事件的条件下两个事件独立。如果下式成立，就说 A 和 B 在给定 C 时条件独立：

• 事件可以边缘相关但条件独立，反之亦然。例如，两个学生的考试成绩可能相关（都取决于考试难度），但在给定考试难度后，他们的成绩就独立了。

• 条件独立是贝叶斯网络（Bayesian networks）等图模型背后的关键假设。它让你能把复杂的联合分布分解成易于处理的若干部分，使推断在计算上变得可行。

编程练习（使用 CoLab 或 notebook）

1. 模拟医学诊断问题。生成 10 万人的群体，套用疾病流行率和检测准确率，验证贝叶斯定理给出正确的后验。

import jax
import jax.numpy as jnp

key = jax.random.PRNGKey(42)
n = 100_000

# 生成人群
k1, k2 = jax.random.split(key)
has_disease = jax.random.bernoulli(k1, p=0.01, shape=(n,))

# 生成检测结果
k3, k4 = jax.random.split(k2)
# 灵敏度: P(+|D) = 0.95, 特异度: P(-|D') = 0.90
test_positive = jnp.where(
    has_disease,
    jax.random.bernoulli(k3, p=0.95, shape=(n,)),
    jax.random.bernoulli(k4, p=0.10, shape=(n,))
)

# 在检测为阳性的人中，真正患病的比例是多少？
positives = test_positive.astype(bool)
true_positives = (has_disease & positives).sum()
total_positives = positives.sum()

print(f"Total positive tests: {total_positives}")
print(f"True positives: {true_positives}")
print(f"P(Disease | Positive) = {true_positives / total_positives:.4f}")
print(f"Bayes' formula:         {0.95 * 0.01 / 0.1085:.4f}")
​

2. 通过模拟验证加法法则。生成具有已知概率和重叠的随机事件 A 和 B，然后验证 P(A \cup B) = P(A) + P(B) - P(A \cap B)。

import jax
import jax.numpy as jnp

key = jax.random.PRNGKey(0)
n = 200_000
k1, k2 = jax.random.split(key)

# 事件：A = value < 0.4，B = value < 0.6（在 < 0.4 处重叠）
vals_a = jax.random.uniform(k1, shape=(n,))
vals_b = jax.random.uniform(k2, shape=(n,))

A = vals_a < 0.4
B = vals_b < 0.6

p_a = A.mean()
p_b = B.mean()
p_a_and_b = (A & B).mean()
p_a_or_b = (A | B).mean()

print(f"P(A) = {p_a:.4f}")
print(f"P(B) = {p_b:.4f}")
print(f"P(A ∩ B) = {p_a_and_b:.4f}")
print(f"P(A ∪ B) simulated = {p_a_or_b:.4f}")
print(f"P(A) + P(B) - P(A∩B) = {p_a + p_b - p_a_and_b:.4f}")
​

3. 演示条件概率如何随证据变化。模拟掷两枚骰子，计算 P(\text{sum} = 7)，再计算 P(\text{sum} = 7 | \text{first die} = 3)。

import jax
import jax.numpy as jnp

key = jax.random.PRNGKey(1)
n = 500_000
k1, k2 = jax.random.split(key)

d1 = jax.random.randint(k1, shape=(n,), minval=1, maxval=7)
d2 = jax.random.randint(k2, shape=(n,), minval=1, maxval=7)
total = d1 + d2

# 无条件
p_sum7 = (total == 7).mean()
print(f"P(sum=7) = {p_sum7:.4f} (exact: {6/36:.4f})")

# 在第一枚骰子 = 3 的条件下
mask = d1 == 3
p_sum7_given_d1_3 = (total[mask] == 7).mean()
print(f"P(sum=7 | d1=3) = {p_sum7_given_d1_3:.4f} (exact: {1/6:.4f})")
​

4. 把贝叶斯定理实现为一个函数，并用来迭代地更新信念。以硬币偏度的均匀先验开始，每观察到一次投掷就更新一次。

import jax.numpy as jnp
import matplotlib.pyplot as plt

def bayes_update(prior, likelihood):
    """先验乘以似然后归一化。"""
    posterior = prior * likelihood
    return posterior / posterior.sum()

# 离散化可能的偏度取值
theta = jnp.linspace(0, 1, 200)
prior = jnp.ones_like(theta)  # 均匀先验
prior = prior / prior.sum()

# 观察到的投掷：1=正面，0=反面
flips = [1, 1, 0, 1, 1, 1, 0, 1, 0, 1]

plt.figure(figsize=(10, 5))
plt.plot(theta, prior, "--", color="#999", label="prior")

for i, flip in enumerate(flips):
    likelihood = theta if flip == 1 else (1 - theta)
    prior = bayes_update(prior, likelihood)
    if i in [0, 2, 4, 9]:
        plt.plot(theta, prior, label=f"after {i+1} flips", linewidth=2)

plt.xlabel("Coin bias θ")
plt.ylabel("Belief (normalised)")
plt.title("Bayesian updating: belief about coin bias")
plt.legend()
plt.grid(alpha=0.3)
plt.show()
​