Lecture 14 · 贝叶斯网络 III：参数学习

CS221: Artificial Intelligence — Principles and Techniques · Stanford · Autumn 2025
📅 Nov 5 · 💻 bayes_learning.py

---

承上启下

前两讲（Lecture 12 · 贝叶斯网络 I：建模与推断 / Lecture 13 · 贝叶斯网络 II：Gibbs 采样与条件独立）：

• 我们已经有了完整的贝叶斯网络——有向无环图（DAG）+ 每个节点的局部条件分布 $p(x_i \mid x_{\mathrm{Parents}(i)})$；
• 一直假设这些概率已知，任务是做推断（inference）：精确推断、拒绝采样、Gibbs 采样；
• 还搞清了图结构如何编码条件独立（d-分离、马尔可夫毯）。

本讲（贝叶斯网络 III）：

• 追问一个一直被跳过的问题——这些概率从哪来？
• 任务反过来：给定训练数据，学习（learn）每个局部条件分布的参数 $\theta$；
• 核心答案朴素得惊人：计数 + 归一化（count + normalize）。

本讲的逻辑线（对齐源码 main()）：

1. 完全可观测设定（所有变量都被观测到）→ 计数与归一化 → 用最大似然证明它；
2. 拉普拉斯平滑（Laplace smoothing）→ 防止零概率、对抗过拟合；
3. EM 算法（Expectation Maximization）→ 处理部分可观测（有隐变量）的数据。

---

1. 回顾：贝叶斯网络三步走

源码开头 review_bayesian_networks() 用经典的 盗窃 $B$（Burglary）/ 地震 $E$（Earthquake）/ 警报 $A$（Alarm） 例子快速回顾定义。

联合分布就像一个「描述世界如何运作的数据库」，构造步骤：定义变量 → 连边（DAG）→ 写局部条件分布 → 相乘：

$$P(B = b, E = e, A = a) = p(b)\, p(e)\, p(a \mid b, e)$$

from bayes import ProbTable
from einops import einsum

# 1. 随机变量 X = (B, E, A)   2. DAG（B → A ← E）   3. 局部条件分布
p_b = ProbTable("B", [0.95, 0.05])                    # p(b)
p_e = ProbTable("E", [0.95, 0.05])                    # p(e)
p_a_given_be = ProbTable("A | B E",
    lambda b, e, a: a == (b or e), shape=(2, 2, 2))    # p(a | b, e)：有任一发生则报警

# 4. 联合分布 = 所有局部条件分布相乘：P(B,E,A) = p(b)·p(e)·p(a|b,e)
P_BEA = ProbTable("B E A",
    einsum(p_b.p, p_e.p, p_a_given_be.p, "b, e, b e a -> b e a"))

推断（像对联合分布做 SQL 查询）三种方法回顾：

方法	思路	精确/近似
精确推断	选中 $A{=}1$ 的切片，边缘化掉 $E$，除以 $P(A{=}1)$	精确
拒绝采样	前向采样 $(B, E, A)$，不满足 $A{=}1$ 就丢弃	近似
Gibbs 采样	固定 $A{=}1$，交替按 $P(B \mid E, A)$、$P(E \mid B, A)$ 重采样	近似（MCMC）

条件独立一句话判据：给定 $C$，$A$ 与 $B$ 条件独立 ⟺ 从 $A$ 到 $B$ 的每条路径都被 $C$ 阻塞。三种模式——链 $X \to C \to Y$、分叉 $X \leftarrow C \to Y$、碰撞 $X \to Z \leftarrow Y$（要求 $C$ 不含 $Z$ 及其后代）——在 Lecture 13 · 贝叶斯网络 II：Gibbs 采样与条件独立 已展开。

本讲要回答的问题：上面这些数字 p_b = [0.95, 0.05] 到底是怎么来的？

---

2. 完全可观测设定：计数 + 归一化

源码 introduce_fully_observable_setting() 定义了本讲的监督学习任务：

• 输入：一组样本，每个样本是对所有变量的完整赋值（fully observable）；
• 输出：所有局部条件分布的参数。

策略是先用一串越来越复杂的例子建立直觉，最后统一成一个通用算法，再从最大似然原理证明它。

2.1 单变量：最简单的计数

变量 $R \in \{1, 2, 3, 4, 5\}$：一部电影的评分。参数就是整张概率表 $\theta = (p_R(1), \dots, p_R(5))$。

from collections import defaultdict
from util import normalize_dict

# 训练数据：10 个评分
training_data = [{"R": r} for r in [1, 3, 4, 4, 4, 4, 4, 5, 5, 5]]

# 1. 计数：每个评分出现了几次
counts_r = defaultdict(float)
for x in training_data:
    counts_r[x["R"]] += 1
# counts_r = {1: 1, 3: 1, 4: 5, 5: 3}

# 2. 归一化：除以总数，得到概率
p_r = normalize_dict(counts_r)
# p_r = {1: 0.1, 3: 0.1, 4: 0.5, 5: 0.3}

写成公式，估计值就是经验频率：

$$\hat{p}_R(r) = \frac{\mathrm{count}(r)}{n}$$

其中 $\mathrm{count}(r)$ 是取值 $r$ 在数据中出现的次数，$n$ 是样本总数。就这么简单——count + normalize。

flowchart LR
    D["训练数据<br/>{R=1,3,4,4,4,4,4,5,5,5}"] --> C["① 计数 Count<br/>counts_r"]
    C --> N["② 归一化 Normalize<br/>÷ 总数"]
    N --> P["p_R<br/>{1:.1, 3:.1, 4:.5, 5:.3}"]

    style D fill:#e1f5fe,stroke:#0277bd
    style C fill:#ffe0b2,stroke:#e65100
    style P fill:#c8e6c9,stroke:#2e7d32

2.2 两变量：局部计数，忽略无关变量

变量加一个 $G \in \{\text{drama}, \text{comedy}\}$（类型）。结构 $G \to R$，联合分布：

$$P(G = g, R = r) = p_G(g) \cdot p_R(r \mid g)$$

training_data = [
    {"G": "drama",  "R": 4},
    {"G": "drama",  "R": 4},
    {"G": "drama",  "R": 5},
    {"G": "comedy", "R": 1},
    {"G": "comedy", "R": 5},
]

# 1. 计数：p_G 直接数 G；p_R(·|g) 按 g 分桶数 R
counts_g  = defaultdict(float)
counts_gr = defaultdict(lambda: defaultdict(float))
for x in training_data:
    counts_g[x["G"]] += 1
    counts_gr[x["G"]][x["R"]] += 1

# 2. 归一化
p_g = normalize_dict(counts_g)                 # {drama: 0.6, comedy: 0.4}
p_r_given_g = {}
for g in counts_g:
    p_r_given_g[g] = normalize_dict(counts_gr[g])
# p_r_given_g[drama]  = {4: 2/3, 5: 1/3}
# p_r_given_g[comedy] = {1: 0.5, 5: 0.5}

条件分布的估计公式——按父取值分桶后再数频率：

$$\hat{p}_R(r \mid g) = \frac{\mathrm{count}(g, r)}{\sum_{r'} \mathrm{count}(g, r')}$$

2.3 v-结构与倒 v-结构：无非是多几个桶

源码用 v_structure() 和 inverted_v_structure() 强调：结构再花哨，算法不变。

v-结构 $G \to R \leftarrow A$（类型与获奖 $A$ 两个父节点汇聚到评分 $R$）：

$$P(g, a, r) = p_G(g)\, p_A(a)\, p_R(r \mid g, a)$$

唯一要点是——同时以所有父节点为条件，桶的键是父取值元组 $(g, a)$：

counts_gar = defaultdict(lambda: defaultdict(float))
for x in training_data:
    counts_gar[(x["G"], x["A"])][x["R"]] += 1   # 键 = 全部父节点的联合取值

倒 v-结构 $R_1 \leftarrow G \to R_2$（一个类型驱动两个用户的评分）：

$$P(g, r_1, r_2) = p_G(g)\, p_{R_1}(r_1 \mid g)\, p_{R_2}(r_2 \mid g)$$

$R_1$、$R_2$ 各有自己独立的一套参数（counts_gr1、counts_gr2 两套），分别在 $G$ 的桶里数。

2.4 参数共享：多个节点共用同一套参数

parameter_sharing() 是本节最重要的概念。还是 $R_1 \leftarrow G \to R_2$，但现在写成：

$$P(G = g, R_1 = r_1, R_2 = r_2) = p_G(g) \cdot p_R(r_1 \mid g) \cdot p_R(r_2 \mid g) \qquad \leftarrow \text{注意：两处都是同一个 } p_R!$$

参数只有两套：$\theta = (p_G, p_R)$——不是 $p_{R_1}$ 和 $p_{R_2}$。这就是参数共享（parameter sharing / tying）：不同节点被同一个局部条件分布「驱动」。

graph TD
    G["G 类型"] --> R1["R1 用户1评分"]
    G --> R2["R2 用户2评分"]
    P["共享参数 p_R(· | g)"] -."驱动".-> R1
    P -."驱动".-> R2

    style G fill:#e1f5fe,stroke:#0277bd
    style P fill:#f3e5f5,stroke:#7b1fa2
    style R1 fill:#c8e6c9,stroke:#2e7d32
    style R2 fill:#c8e6c9,stroke:#2e7d32

代码上的唯一改动：$R_1$ 和 $R_2$ 累加到同一个 counts_gr：

counts_gr = defaultdict(lambda: defaultdict(float))
for x in training_data:
    counts_g[x["G"]] += 1
    # 关键：R1 和 R2 都增量到同一个 counts_gr！
    counts_gr[x["G"]][x["R1"]] += 1
    counts_gr[x["G"]][x["R2"]] += 1

何时用参数共享？ 这是一个建模决策（modeling decision）：

维度	参数更少（共享）	参数更多（不共享）
需要的样本量	少（更省数据）	多
灵活性	低	高（各节点可不同）
适用假设	两个用户「相似」	两个用户「不同」

2.5 隐马尔可夫模型（HMM）：转移与发射的共享

HMM 是参数共享的教科书级应用（Lecture 12 · 贝叶斯网络 I：建模与推断 里用它做过物体追踪）：

• $H_t \in \{0, 1\}$：$t$ 时刻物体的位置（隐状态）；
• $E_t \in \{0, 1\}$：$t$ 时刻的传感器读数（观测）。

$$P(H, E) = p_{\text{start}}(h_1) \prod_{t=2}^{T} p_{\text{trans}}(h_t \mid h_{t-1}) \prod_{t=1}^{T} p_{\text{emit}}(e_t \mid h_t)$$

参数只有三套：$\theta = (p_{\text{start}}, p_{\text{trans}}, p_{\text{emit}})$——起始分布、转移分布、发射分布，被所有时刻共享。链条无论多长，参数量不变，这正是 HMM 能处理任意长度序列的原因。

graph LR
    H1["H1"] -->|p_trans| H2["H2"] -->|p_trans| H3["H3"]
    H1 -->|p_emit| E1["E1"]
    H2 -->|p_emit| E2["E2"]
    H3 -->|p_emit| E3["E3"]
    S(["p_start"]) -.-> H1

    style H1 fill:#e1f5fe,stroke:#0277bd
    style H2 fill:#e1f5fe,stroke:#0277bd
    style H3 fill:#e1f5fe,stroke:#0277bd
    style E1 fill:#fff9c4,stroke:#f9a825
    style E2 fill:#fff9c4,stroke:#f9a825
    style E3 fill:#fff9c4,stroke:#f9a825

在完全可观测（$H$ 也被观测到）的设定下，学习依旧是 count + normalize，只是把每条轨迹上所有转移对 $(h_t, h_{t+1})$ 累加进同一套 counts_trans、所有发射对 $(h_t, e_t)$ 累加进同一套 counts_emit：

training_data = [
    {"H1": 0, "E1": 0, "H2": 1, "E2": 1, "H3": 0, "E3": 0},
    {"H1": 0, "E1": 1, "H2": 0, "E2": 1, "H3": 0, "E3": 1},
]
counts_start = defaultdict(float)
counts_trans = defaultdict(lambda: defaultdict(float))   # 所有时刻共享
counts_emit  = defaultdict(lambda: defaultdict(float))   # 所有时刻共享
for x in training_data:
    counts_start[x["H1"]] += 1
    counts_emit[x["H1"]][x["E1"]] += 1;  counts_trans[x["H1"]][x["H2"]] += 1
    counts_emit[x["H2"]][x["E2"]] += 1;  counts_trans[x["H2"]][x["H3"]] += 1
    counts_emit[x["H3"]][x["E3"]] += 1
# 归一化：p_start 直接归一；p_trans / p_emit 按前一隐状态 h 分桶归一
p_start = normalize_dict(counts_start)
p_trans = {h: normalize_dict(counts_trans[h]) for h in counts_trans}
p_emit  = {h: normalize_dict(counts_emit[h])  for h in counts_emit}

2.6 通用算法：一个函数搞定所有结构

general_bayesian_networks() 把前面所有特例抽象成一个统一框架：

• 设 $D$ 为局部条件分布类型的集合。HMM 里 $D = \{\text{start}, \text{trans}, \text{emit}\}$；
• 参数 $\theta = \{p_d : d \in D\}$；
• 联合分布：
  $$P(x_1, \dots, x_n) = \prod_{i=1}^{n} p_{d_i}\big(x_i \mid x_{\mathrm{Parents}(i)}\big)$$
  其中 $d_i$ 是节点 $X_i$ 使用的参数类型——多个 $X_i$ 可以指向同一个 $d_i$（即参数共享）。

用一个网络结构字典描述整张图（变量名 → (参数名, 父变量名列表)）：

network_structure = {
    # 变量名 -> (参数名, 父变量名列表)
    "H1": ("start", []),
    "H2": ("trans", ["H1"]),
    "H3": ("trans", ["H2"]),   # H2、H3 共享 "trans"
    "E1": ("emit",  ["H1"]),
    "E2": ("emit",  ["H2"]),
    "E3": ("emit",  ["H3"]),   # 三个 E 共享 "emit"
}
theta = fully_observable_learning(network_structure, training_data)

通用学习器就是把「计数 + 归一化」写成一个循环——这是本讲代码的核心：

def fully_observable_learning(network_structure, training_data, pseudocounts=None):
    """对贝叶斯网络做监督学习（完全可观测）。
    network_structure: 变量名 -> (参数名, 父变量名列表)
    training_data:     字典列表，每个字典是对所有变量的完整赋值
    pseudocounts:      预置的伪计数（用于拉普拉斯平滑，见 §4）
    返回 theta：参数名 -> 父取值 -> 取值 -> 概率
    """
    # 初始化计数（若给了伪计数，就从伪计数出发）
    # counts[参数名][父取值元组][取值] = 出现次数
    if pseudocounts is None:
        counts = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))
    else:
        counts = deepcopy(pseudocounts)

    # ① 计数：遍历每个样本的每个变量
    for x in training_data:
        for var, value in x.items():
            parameter_name, parent_vars = network_structure[var]
            parents_value = tuple(x[pv] for pv in parent_vars)  # 父节点的联合取值
            counts[parameter_name][parents_value][value] += 1   # 参数共享在此自动发生

    # ② 归一化：对每个 (参数, 父取值) 桶归一化
    theta = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))
    for parameter_name in counts:
        for parents_value in counts[parameter_name]:
            theta[parameter_name][parents_value] = \
                normalize_dict(counts[parameter_name][parents_value])
    return theta

---

3. 最大似然估计：为什么「计数 + 归一化」是对的

maximum_likelihood() 回答了一个自然的疑问：count + normalize 只是「看起来合理」，还是有理论依据？答案是——它恰好就是最大似然估计（Maximum Likelihood Estimation, MLE）的闭式解。

3.1 最大似然原理

最大似然原理：找到使观测数据出现概率最大的参数：

$$\hat{\theta} = \arg\max_{\theta} \prod_{x \in \mathcal{D}} P(X = x; \theta) = \arg\max_{\theta} \sum_{x \in \mathcal{D}} \log P(X = x; \theta)$$

其中 $\mathcal{D}$ 是训练集；取对数把连乘变连加（不改变最优点，因为 $\log$ 单调），既避免数值下溢又便于求导。

3.2 单变量的证明（拉格朗日乘子）

以数据 $\{R{=}1, R{=}5, R{=}5\}$ 为例，记 $c_r = \mathrm{count}(r)$，目标是：

$$\max_{\theta} \; \sum_{r} c_r \log p_R(r) \qquad \text{s.t.} \quad \sum_{r} p_R(r) = 1$$

为等式约束引入拉格朗日乘子（Lagrange multiplier） $\mu$：

$$\mathcal{L}(\theta, \mu) = \sum_{r} c_r \log p_R(r) + \mu \Big(1 - \sum_{r} p_R(r)\Big)$$

令对每个 $p_R(r)$ 的偏导为零：

$$\frac{\partial \mathcal{L}}{\partial p_R(r)} = \frac{c_r}{p_R(r)} - \mu = 0 \quad \Longrightarrow \quad p_R(r) = \frac{c_r}{\mu}$$

代回约束 $\sum_r p_R(r) = 1$ 得 $\mu = \sum_r c_r = n$，于是：

$$\hat{p}_R(r) = \frac{c_r}{n}$$

——正是频率！本例中 $\hat{p}_R(1) = 1/3$、$\hat{p}_R(5) = 2/3$。

3.3 两变量：似然自动分解

数据 $\{(\text{drama}, 4), (\text{drama}, 5), (\text{comedy}, 5)\}$，似然是：

$$\max_{\theta}\; p_G(\text{dr})\, p_R(4 \mid \text{dr}) \cdot p_G(\text{dr})\, p_R(5 \mid \text{dr}) \cdot p_G(\text{co})\, p_R(5 \mid \text{co})$$

关键一步——把因子按「涉及哪套参数」重新分组：

$$\max_{\theta}\; \underbrace{\big[p_G(\text{dr})\, p_G(\text{dr})\, p_G(\text{co})\big]}_{\text{只关于 } p_G} \cdot \underbrace{\big[p_R(4 \mid \text{dr})\, p_R(5 \mid \text{dr})\big]}_{\text{只关于 } p_R(\cdot \mid \text{dr})} \cdot \underbrace{\big[p_R(5 \mid \text{co})\big]}_{\text{只关于 } p_R(\cdot \mid \text{co})}$$

三组因子没有共享参数，整体最大化 = 各组分别最大化。每个子问题都长得和 §3.2 的单变量情形一模一样，各自 count + normalize 即可解。

flowchart TD
    L["整体对数似然<br/>Σ_x log P(x; θ)"] --> S1["子问题: p_G"]
    L --> S2["子问题: p_R(·|drama)"]
    L --> S3["子问题: p_R(·|comedy)"]
    S1 --> A["计数 + 归一化"]
    S2 --> A
    S3 --> A

    style L fill:#ffe0b2,stroke:#e65100
    style A fill:#c8e6c9,stroke:#2e7d32

---

4. 拉普拉斯平滑：别让概率变成 0

introduce_laplace_smoothing() 指出纯 MLE 的一个尴尬。看这个例子：

network_structure = {"R": ("R", [])}
training_data = [{"R": 1}, {"R": 4}]
theta = fully_observable_learning(network_structure, training_data)
# p_R = {1: 0.5, 4: 0.5}，而 p_R(2) = p_R(3) = p_R(5) = 0

解法：拉普拉斯平滑（Laplace / add-λ smoothing）——给每个取值的计数都预加一个伪计数（pseudocount） $\lambda$：

$$\hat{p}_{\lambda}(v) = \frac{\mathrm{count}(v) + \lambda}{n + \lambda \lvert \mathcal{V} \rvert}$$

其中 $n$ 是（该桶内的）样本总数，$\lvert\mathcal{V}\rvert$ 是取值域大小；分母加 $\lambda \lvert\mathcal{V}\rvert$ 保证归一。$\lambda = 1$ 即经典的 add-one smoothing。

def get_pseudocounts(smoothing: float):
    # 给 R 的每个可能取值都预置 smoothing 个伪计数
    return {"R": {(): {1: smoothing, 2: smoothing, 3: smoothing,
                       4: smoothing, 5: smoothing}}}

# λ = 1：每个取值先「白送」1 次
pseudocounts = get_pseudocounts(smoothing=1)
theta = fully_observable_learning(network_structure, training_data, pseudocounts)
# 计数变为 {1: 2, 2: 1, 3: 1, 4: 2, 5: 1}，总数 7
# p_R = {1: 2/7, 2: 1/7, 3: 1/7, 4: 2/7, 5: 1/7}  ← 不再有 0！

注意实现之巧：伪计数直接作为 fully_observable_learning 的初始 counts（deepcopy(pseudocounts)），真实数据在它之上继续累加——平滑与学习共用同一段代码。

$\lambda$ 构成一条从「完全信数据」到「完全不信数据」的连续谱：$\lambda \to 0$ 退回原始 MLE（可能有 0），$\lambda$ 适中是数据与先验的折中，$\lambda \to \infty$ 趋于均匀分布：

graph LR
    Z["λ → 0<br/>最大似然 MLE<br/>（可能出现 0）"] --- M["λ 适中<br/>平滑估计<br/>（数据+先验）"] --- I["λ → ∞<br/>均匀分布<br/>（无视数据）"]

    style Z fill:#ffcdd2,stroke:#c62828
    style M fill:#c8e6c9,stroke:#2e7d32
    style I fill:#e1f5fe,stroke:#0277bd

---

5. EM 算法：数据不完整时怎么办

前面所有例子都假设每个样本对所有变量都有观测。introduce_expectation_maximization() 打破这个假设：如果某些变量从没被观测到呢？

5.1 部分可观测设定

还是 $R_1 \leftarrow G \to R_2$，但训练数据里没有 $G$（类型是隐藏的）：

# 完全可观测（对照）：G 也在
training_data = [{"G": "drama", "R1": 1, "R2": 1},
                 {"G": "comedy", "R1": 2, "R2": 2}]

# 部分可观测（本节）：没有 G！
training_data = [{"R1": 1, "R2": 1},
                 {"R1": 2, "R2": 2}]

此时最大似然要最大化观测数据的似然，隐变量 $G$ 被求和边缘化掉：

$$\max_{\theta} \sum_{(r_1, r_2) \in \mathcal{D}} \log \underbrace{\sum_{g} P(G = g, R_1 = r_1, R_2 = r_2; \theta)}_{\text{对隐变量求和}}$$

三个玩家：观测变量 $(R_1, R_2)$、未观测变量 $G$、参数 $\theta$。难点在于 $G$ 和 $\theta$ 都不知道。

5.2 先有鸡还是先有蛋

这是一个典型的鸡生蛋（chicken-and-egg）问题：

• 若知道参数 $\theta$ → 可以算隐变量的后验 $P(G = g \mid R_1, R_2; \theta)$（一次贝叶斯网络推断！）；
• 若知道隐变量 $G$ → 数据变成完全可观测，像 §2 那样 count + normalize 即得 $\theta$。

EM 算法（Expectation Maximization，[Dempster et al. 1977]）的破局办法：随机初始化 $\theta$，然后反复迭代两步——

flowchart LR
    Init["随机初始化 θ<br/>（打破对称！）"] --> E
    subgraph Loop["迭代直到收敛"]
        E["E 步<br/>用当前 θ 算 P(G|R1,R2)<br/>→ 生成加权的完整数据"] --> M["M 步<br/>在加权数据上 count+normalize<br/>→ 更新 θ"]
        M -->|新的 θ| E
    end
    M --> Out["局部最优 θ"]

    style Init fill:#e1f5fe,stroke:#0277bd
    style E fill:#f3e5f5,stroke:#7b1fa2
    style M fill:#ffe0b2,stroke:#e65100
    style Out fill:#c8e6c9,stroke:#2e7d32

• E 步（Expectation）：用当前 $\theta$ 对每个样本计算隐变量的后验，作为软标签权重：
  $$q_x(g) = P(G = g \mid R_1, R_2; \theta) = \frac{p_G(g)\, p_R(r_1 \mid g)\, p_R(r_2 \mid g)}{\sum_{g'} p_G(g')\, p_R(r_1 \mid g')\, p_R(r_2 \mid g')}$$
  据此把每个样本「幻想」成若干条加权的完整赋值；
• M 步（Maximization）：在这些加权赋值上做 count + normalize（把 §2 里的「+1」换成「+ 权重 $q_x(g)$」），得到最大化期望对数似然的新 $\theta$。

5.3 源码：EM 的完整实现

def expectation_maximization(training_data, num_iterations: int):
    # 随机初始化 θ = (p_g, p_r_given_g)——注意故意设成非均匀以打破对称
    p_g = {"drama": 0.5, "comedy": 0.5}
    p_r_given_g = {
        "comedy": {1: 0.4, 2: 0.6},   # 例：p(r=1 | g=comedy) = 0.4
        "drama":  {1: 0.6, 2: 0.4},
    }

    for iteration in range(num_iterations):
        # ===== E 步：猜隐变量，据此给训练数据加权 =====
        weighted_training_data = []   # 「幻想」出来的加权完整数据
        for x in training_data:
            # 先算未归一化的 P(G=g, R1, R2; θ)
            q = {}
            for g in p_g:
                q[g] = p_g[g] * p_r_given_g[g][x["R1"]] * p_r_given_g[g][x["R2"]]
            # 归一化得到后验 q(g) = P(G=g | R1, R2; θ)
            q = normalize_dict(q)
            # 每个样本按后验权重「分裂」成多条带权完整赋值
            for g in q:
                weighted_training_data.append((x | {"G": g}, q[g]))

        # ===== M 步：在加权数据上 count + normalize =====
        counts_g  = defaultdict(float)
        counts_gr = defaultdict(lambda: defaultdict(float))
        for x, weight in weighted_training_data:
            counts_g[x["G"]] += weight              # 关键：+= 权重，而非 +1
            counts_gr[x["G"]][x["R1"]] += weight
            counts_gr[x["G"]][x["R2"]] += weight

        p_g = normalize_dict(counts_g)
        p_r_given_g = {g: normalize_dict(counts_gr[g]) for g in counts_gr}

    return {"p_g": p_g, "p_r_given_g": p_r_given_g}

调用与效果：

training_data = [{"R1": 1, "R2": 1}, {"R1": 2, "R2": 2}]
theta = expectation_maximization(training_data, num_iterations=5)
# 迭代后：模型自发把 (1,1) 归为一类、(2,2) 归为另一类

5.4 EM 的性质与坑

性质	说明
✅ 单调不减	每次迭代保证不降低观测数据似然，收敛到驻点/局部最大
⚠️ 非全局最优	不保证收敛到全局最大——结果依赖初始化，常用多次随机重启取最优
⚠️ 需打破对称	若各类初始参数完全相同，E 步给出的后验也完全相同，M 步更新后依旧对称——永远分不开各类
⚠️ 标签可置换	隐变量只能恢复到标签置换意义下（drama / comedy 可整体互换，似然不变）

---

6. 总结

mindmap
  root((贝叶斯网络<br/>参数学习))
    完全可观测
      count + normalize
      忽略无关变量, 按父节点分桶
      通用学习器 fully_observable_learning
    参数共享
      多节点共用一套分布
      HMM: start/trans/emit
      建模决策: 数据量 vs 灵活性
    最大似然 MLE
      count+normalize 是闭式解
      似然按局部分布因子分解
      拉格朗日乘子证明
    拉普拉斯平滑
      counts 全部 +λ, 防零概率
      λ→0 退回MLE, λ→∞ 均匀
      伪计数 = 先验, 被数据冲淡
    EM 算法
      处理隐变量/部分观测
      E步后验加权, M步加权计数
      聚类/软标签, 局部最优

关键要点：

• 学习任务：给定训练数据，估计贝叶斯网络每个局部条件分布的参数 $\theta$。
• 完全可观测下，算法就是 count + normalize：$\hat p_d(v \mid \pi) = \mathrm{count}_d(\pi, v) / \sum_{v'} \mathrm{count}_d(\pi, v')$——估计每个局部分布时忽略其他变量、按父节点联合取值分桶；一个 fully_observable_learning 函数覆盖所有结构。
• 参数共享：多个节点共用同一套局部条件分布（如 HMM 的转移/发射）——推断时无所谓（只读），学习时决定计数桶（写入）；用不用是建模决策，本质是样本效率与灵活性的权衡。
• 最大似然：count + normalize 不是拍脑袋，而是 MLE 的闭式解——拉格朗日乘子法给出 $\hat p(r) = c_r / n$，且似然按局部条件分布因子分解，全局最优 = 局部子问题拼接。
• 拉普拉斯平滑：所有计数加伪计数 $\lambda$，$\hat p_\lambda(v) = (\mathrm{count}(v) + \lambda)/(n + \lambda\lvert\mathcal V\rvert)$，防止零概率；$\lambda \to 0$ 退回 MLE、$\lambda \to \infty$ 趋均匀，数据一多平滑被冲淡（伪计数 = 先验）。
• EM 算法：数据不完整（有隐变量）时，似然含 $\log \sum$、无闭式解——E 步用当前参数算隐变量后验 $q_x(g)$、生成加权完整数据；M 步在加权数据上 count + normalize；反复迭代、似然单调不减、收敛到局部最优（本质是软聚类，HMM 版即 Baum-Welch）。

下一讲预告：到此为止，变量型模型单元（建模 → 推断 → 学习）完整收官。下一讲 Lecture 15 · 逻辑 I：命题逻辑 画风突变，转向逻辑（Logic）——用语法、语义、推理规则做更高阶的确定性推理（如「每个学生都有一个 TA」这类断言），从命题逻辑、模型、蕴含（entailment）讲到归结（resolution）。

---

复习自测

---

参考资料

• 💻 bayes_learning.py — 本讲源码
• 📖 CS221 Bayesian Networks: Supervised Learning — 监督学习模块
• 📖 CS221 Bayesian Networks: Smoothing — 拉普拉斯平滑模块
• 📖 CS221 Bayesian Networks: EM Algorithm — EM 算法模块
• 📄 Maximum Likelihood from Incomplete Data via the EM Algorithm (Dempster, Laird & Rubin, 1977) — EM 算法奠基论文
• 📖 Koller & Friedman, Probabilistic Graphical Models (2009) — 第 17–19 章：参数估计与 EM
• 🌐 CS221 课程主页 — 全部讲义与模块