概率图模型与深度学习融合：从理论到现代架构

引言

概率图模型（Probabilistic Graphical Models, PGM）是概率论与图论的结合，用图结构编码变量之间的条件独立关系。深度学习的崛起使得 PGM 的核心思想（消息传递、变分推断、采样）以新的方式复活：

图神经网络 (GNN) = 图上的消息传递（Sum-Product 算法的可微版本）
VAE = 变分自编码器（变分推断的现代实现）
扩散模型 = 连续时间 MCMC（Langevin 动力学的离散化）
注意力机制 = 软消息传递（节点到所有其他节点）

本文系统梳理 PGM 的数学基础，并展示如何将其核心思想与现代深度学习架构融合，建立统一的概率-几何视角。[^1]

一、图模型基础

1.1 三种表示

贝叶斯网络（Bayesian Network, BN）：有向无环图（DAG），编码条件分布 $p (x_{i} ∣ pa (x_{i}))$ 。

马尔可夫随机场（Markov Random Field, MRF）：无向图，编码联合分布通过势函数（potential functions）：

p (x) = \frac{1}{Z} c \in C \prod ψ_{c} (x_{c})

因子图（Factor Graph）：二部图，显式表示变量与因子（局部函数）的关系。

三种表示的等价性：

BN ⊂ 道德化后 → MRF
MRF 通过弦化可转换为因子图
因子图是消息传递算法最自然的表示

1.2 条件独立与马尔可夫性

图模型的核心是条件独立性的图表示：

图结构	马尔可夫性
链式图	$X_i \perp!!!\perp X_j
贝叶斯网络	局部马尔可夫：$X \perp!!!\perp \text{非后代}
MRF	全局马尔可夫：$A \perp!!!\perp B

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
 
# 创建示例贝叶斯网络：学生成绩
def create_student_bn():
    G = nx.DiGraph()
    # 节点：D=难度, I=智力, G=成绩, S=推荐信, L=考试
    G.add_edges_from([
        ('D', 'G'), ('I', 'G'), ('I', 'S'), ('D', 'L'), ('G', 'L')
    ])
    return G
 
# 创建示例马尔可夫随机场：图像去噪
def create_image_mrf(n_rows=10, n_cols=10):
    G = nx.Graph()
    # 4-邻接格子
    for i in range(n_rows):
        for j in range(n_cols):
            if i + 1 < n_rows:
                G.add_edge((i, j), (i+1, j))
            if j + 1 < n_cols:
                G.add_edge((i, j), (i, j+1))
    return G
 
# 创建因子图
def create_factor_graph():
    G = nx.Graph()
    # 变量节点
    variables = ['A', 'B', 'C', 'D']
    # 因子节点
    factors = ['f1', 'f2', 'f3']
    
    for v in variables:
        G.add_node(v, bipartite=0)
    for f in factors:
        G.add_node(f, bipartite=1)
    
    # 因子连接
    G.add_edge('A', 'f1'); G.add_edge('B', 'f1')
    G.add_edge('B', 'f2'); G.add_edge('C', 'f2')
    G.add_edge('C', 'f3'); G.add_edge('D', 'f3')
    
    return G

1.3 联合分布的分解

贝叶斯网络的链式分解：

p (x) = i = 1 \prod n p (x_{i} ∣ pa (x_{i}))

MRF 的吉布斯分解（Hammersley-Clifford 定理）：

p (x) = \frac{1}{Z} c \in C \prod ψ_{c} (x_{c})

其中 $Z = \sum_{x} \prod_{c} ψ_{c} (x_{c})$ 是配分函数（partition function），通常难计算。

二、消息传递与信念传播

2.1 变量消除（Variable Elimination）

变量消除是 PGM 推断的经典算法，复杂度依赖于消元顺序。

算法步骤：

选择消元变量
将包含该变量的因子相乘
对该变量求和（边际化）
重复

def variable_elimination(factors, query_var, evidence, elimination_order):
    """
    变量消除算法
    factors: dict {factor_name: function}
    query_var: 要查询的变量
    evidence: dict {var: value} 观测到的变量
    elimination_order: 消元顺序
    """
    # 1. 固定证据
    for var, val in evidence.items():
        factors = {name: (lambda f, v, val: 
                          lambda *args: f(*args) if args[v] == val else 0)(f, var, val)
                   for name, f in factors.items()}
    
    # 2. 按顺序消元
    for var in elimination_order:
        if var == query_var:
            continue
        # 找到所有包含 var 的因子
        involved = [name for name, f in factors.items() if var in get_vars(f)]
        # 乘积
        product = lambda *args: np.prod([f(*args) for f in [factors[name] for name in involved]])
        # 边际化
        marginalized = lambda *args: sum([product(*args_with_var) 
                                           for args_with_var in set_var(args, var, val)]
                                          for val in range(n_values(var)))
        factors[f"τ_{var}"] = marginalized
        # 移除被合并的因子
        for name in involved:
            del factors[name]
    
    # 3. 归一化
    remaining = list(factors.values())
    if not remaining:
        return None
    unnormalized = lambda *args: np.prod([f(*args) for f in remaining])
    Z = sum([unnormalized(*set_var({}, var, val)) 
             for val in range(n_values(query_var))])
    return lambda val: unnormalized(*set_var({}, query_var, val)) / Z

2.2 Sum-Product 算法（信念传播）

信念传播（Belief Propagation, BP）是变量消除的高效实现，通过消息传递避免重复计算。

消息定义：变量 $x$ 到因子 $f$ 的消息：

μ_{x \to f} (x) = y \in nb (x) ∖ {f} \sum ψ_{x} (y) g \in nb (x) ∖ {f} \prod μ_{g \to x} (y)

因子 $f$ 到变量 $x$ 的消息：

μ_{f \to x} (x) = y \sim x \sum f (y) y \in nb (f) ∖ {x} \prod μ_{y \to f} (y)

信念（belief）：变量 $x$ 的边际：

b (x) \propto f \in nb (x) \prod μ_{f \to x} (x)

class FactorGraph:
    """因子图与消息传递"""
    def __init__(self):
        self.variables = {}  # {name: domain}
        self.factors = {}    # {name: function}
        self.edges = []      # (var, factor) pairs
    
    def add_variable(self, name, domain):
        self.variables[name] = domain
    
    def add_factor(self, name, scope, fn):
        self.factors[name] = (scope, fn)
        for var in scope:
            self.edges.append((var, name))
    
    def belief_propagation(self, max_iters=100, tol=1e-6):
        """Sum-Product 信念传播"""
        # 初始化消息
        messages = {}  # {(from, to): dict {value: msg}}
        for v, f in self.edges:
            for d in self.variables[v]:
                messages[(v, f)] = {d: 1.0}
        for f, v in self.edges:
            for d in self.variables[v]:
                messages[(f, v)] = {d: 1.0}
        
        for iteration in range(max_iters):
            old_messages = {k: v.copy() for k, v in messages.items()}
            
            # 更新变量到因子的消息
            for v, f in self.edges:
                msg = {}
                for x in self.variables[v]:
                    product = 1.0
                    for g, _ in self.edges:
                        if g != f and (g, v) in messages:
                            product *= messages[(g, v)][x]
                    msg[x] = product
                # 归一化
                total = sum(msg.values())
                messages[(v, f)] = {x: m / total for x, m in msg.items()}
            
            # 更新因子到变量的消息
            for f, v in self.edges:
                scope, fn = self.factors[f]
                other_vars = [u for u in scope if u != v]
                msg = {}
                for x in self.variables[v]:
                    # 求和：sum over other_vars
                    total = 0.0
                    for assignment in self._all_assignments(other_vars):
                        full = dict(zip(scope, [x] + assignment))
                        for u, val in zip(other_vars, assignment):
                            full[u] = val
                        # 注意：factor 中 x 的位置
                        args = [full[u] for u in scope]
                        f_val = fn(*args)
                        product = 1.0
                        for u, val in zip(other_vars, assignment):
                            if (u, f) in messages:
                                product *= messages[(u, f)][val]
                        total += f_val * product
                    msg[x] = total
                # 归一化
                Z = sum(msg.values()) + 1e-10
                messages[(f, v)] = {x: m / Z for x, m in msg.items()}
            
            # 检查收敛
            diff = max([max([abs(messages[k][d] - old_messages[k][d]) 
                            for d in messages[k]]) 
                       for k in messages])
            if diff < tol:
                break
        
        # 计算信念
        beliefs = {}
        for v in self.variables:
            b = {}
            for x in self.variables[v]:
                product = 1.0
                for g, _ in self.edges:
                    if (g, v) in messages:
                        product *= messages[(g, v)][x]
                b[x] = product
            Z = sum(b.values()) + 1e-10
            beliefs[v] = {x: p / Z for x, p in b.items()}
        return beliefs

2.3 GNN = 可微消息传递

图神经网络的消息传递与 Sum-Product 算法结构同构：[^2]

GNN 消息传递规则：

m_{i \to j}^{(l)} = MSG^{(l)} (h_{i}^{(l)}, h_{j}^{(l)}, e_{ij})

h_{i}^{(l + 1)} = AGG^{(l)} ({m_{j \to i}^{(l)} : j \in N (i)})

与 BP 的对应：

GNN 的 message = BP 的 $μ_{x \to f} (x)$
GNN 的 aggregation = BP 的乘积 + 求和
GNN 的 update = BP 的归一化

关键差异：

BP 是精确推断（在树上），GNN 是学习到的近似
BP 消息是概率分布，GNN 消息是嵌入向量
GNN 用神经网络参数化 MSG 和 AGG

class GNN_BP_Layer(nn.Module):
    """可微信念传播层"""
    def __init__(self, d_msg, d_hidden):
        super().__init__()
        # 消息函数（对应 BP 消息）
        self.msg_net = nn.Sequential(
            nn.Linear(2 * d_hidden, d_msg),
            nn.ReLU(),
            nn.Linear(d_msg, d_msg)
        )
        # 聚合函数（对应 BP 的乘积+求和）
        self.agg_net = nn.Sequential(
            nn.Linear(d_msg, d_hidden),
            nn.ReLU(),
            nn.Linear(d_hidden, d_hidden)
        )
    
    def forward(self, h, adj):
        """
        h: (N, d_hidden) 节点特征
        adj: (N, N) 邻接矩阵
        """
        N = h.size(0)
        # 构建所有边（i, j）
        messages = []
        for i in range(N):
            for j in range(N):
                if adj[i, j] > 0:
                    # 消息 m_{i -> j}
                    msg = self.msg_net(torch.cat([h[i], h[j]]))
                    messages.append((j, msg))
        
        # 聚合（对应 BP 的乘积+求和）
        h_new = torch.zeros_like(h)
        for node in range(N):
            in_msgs = [m for n, m in messages if n == node]
            if in_msgs:
                agg = torch.stack(in_msgs).sum(dim=0)  # 求和（对应 BP 求和）
                h_new[node] = self.agg_net(agg)
            else:
                h_new[node] = h[node]
        
        return h_new

2.4 Loopy Belief Propagation 与 GNN 深度

当图有环时，BP 可以迭代运行（Loopy BP），但不一定收敛。这与GNN 深度问题同构：

浅层 GNN（1-2 层）= 1-2 轮 BP
深层 GNN = 多轮 BP
深度 GNN 的过平滑 = Loopy BP 的振荡

三、变分推断

3.1 ELBO 与 KL 散度

变分推断的核心是找到一个简单的分布 $q (z)$ 来近似复杂的后验 $p (z ∣ x)$ 。

ELBO（Evidence Lower Bound）：

lo g p (x) \geq E_{q (z)} [lo g p (x ∣ z)] - D_{KL} (q (z) ∥ p (z)) = ELBO (q)

推导：

lo g p (x) = lo g \int p (x, z) d z = lo g \int q (z) \frac{p ( x , z )}{q ( z )} d z

\geq \int q (z) lo g \frac{p ( x , z )}{q ( z )} d z = ELBO (q)

(Jensen 不等式)

3.2 平均场变分推断

平均场假设： $q (z) = \prod_{i} q_{i} (z_{i})$ （各变量独立）。

坐标上升更新：

q_{j}^{*} (z_{j}) \propto exp (E_{q_{- j}} [lo g p (z, x)])

3.3 VAE：变分推断的现代实现

**VAE（变分自编码器）**用神经网络参数化变分分布：[^3]

q_{ϕ} (z ∣ x) = N (μ_{ϕ} (x), σ_{ϕ}^{2} (x))

ELBO 损失：

L = - E_{q_{ϕ} (z ∣ x)} [lo g p_{θ} (x ∣ z)] + D_{KL} (q_{ϕ} (z ∣ x) ∥ p (z))

重参数化技巧：

z = μ_{ϕ} (x) + σ_{ϕ} (x) ⊙ ϵ, ϵ \sim N (0, I)

class VAE(nn.Module):
    """变分自编码器（变分推断实现）"""
    def __init__(self, d_input, d_hidden, d_latent):
        super().__init__()
        # 编码器：q_φ(z|x)
        self.encoder = nn.Sequential(
            nn.Linear(d_input, d_hidden),
            nn.ReLU(),
            nn.Linear(d_hidden, d_hidden),
            nn.ReLU()
        )
        self.fc_mu = nn.Linear(d_hidden, d_latent)
        self.fc_logvar = nn.Linear(d_hidden, d_latent)
        
        # 解码器：p_θ(x|z)
        self.decoder = nn.Sequential(
            nn.Linear(d_latent, d_hidden),
            nn.ReLU(),
            nn.Linear(d_hidden, d_hidden),
            nn.ReLU(),
            nn.Linear(d_hidden, d_input),
            nn.Sigmoid()
        )
    
    def encode(self, x):
        h = self.encoder(x)
        return self.fc_mu(h), self.fc_logvar(h)
    
    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        recon = self.decoder(z)
        return recon, mu, logvar
    
    def loss(self, x, recon, mu, logvar):
        # 重构损失（负对数似然）
        recon_loss = F.binary_cross_entropy(recon, x, reduction='sum')
        # KL 散度
        kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
        return recon_loss + kl_loss

3.4 扩散变分推断（DDVI）

Piriyakulkij et al. (AAAI 2025) 提出DDVI：用扩散模型作为变分后验族，支持任意似然、黑盒、任意拓扑后验。[^4]

DDVI 的 ELBO：

\mathcal{L} = \mathbb{E}_{q(\mathbf{z}_0|\mathbf{x})}[\log p(\mathbf{x}|\mathbf{z}_0)] - D_{\text{KL}}(q(\mathbf{z}_T) \| p(\mathbf{z}_T)) - \sum_{t} \mathbb{E}[\text{KL}(q(\mathbf{z}_{t-1}|\mathbf{z}_t,\mathbf{x}) \| p(\mathbf{z}_{t-1}|\mathbf{z}_t))] ``` 这是经典 ELBO 在扩散模型上的推广。 --- ## 四、MCMC 与采样 ### 4.1 Metropolis-Hastings 算法 **目标**：从 $p(\mathbf{x})$ 采样。 **算法**： 1. 从提议分布 $q(\mathbf{x}' | \mathbf{x}^{(t)})$ 采样候选 $\mathbf{x}'$ 2. 计算接受率：

\alpha = \min\left(1, \frac{p(\mathbf{x}’) q(\mathbf{x}^{(t)} | \mathbf{x}’)}{p(\mathbf{x}^{(t)}) q(\mathbf{x}’ | \mathbf{x}^{(t)})}\right)

3. 以概率 $\alpha$ 接受 $\mathbf{x}'$，否则保留 $\mathbf{x}^{(t)}$ ### 4.2 Gibbs 采样 当 $p(\mathbf{x})$ 难以直接采样但每个条件分布 $p(x_i | \mathbf{x}_{-i})$ 易采样时： 1. 初始化 $\mathbf{x}^{(0)}$ 2. 迭代：从 $p(x_i | \mathbf{x}_{-i}^{(t)})$ 采样 $x_i^{(t+1)}$ ### 4.3 HMC 与 NUTS **Hamiltonian Monte Carlo (HMC)** 引入动量变量 $\mathbf{p}$ 与哈密顿量：

H(\mathbf{x}, \mathbf{p}) = U(\mathbf{x}) + K(\mathbf{p}) = -\log p(\mathbf{x}) + \frac{1}{2} |\mathbf{p}|

* * L e a p f ro g 积分 * * （保持辛结构）：

\begin{aligned}
\mathbf{p}^{(t+\epsilon/2)} &= \mathbf{p}^{(t)} - \frac{\epsilon}{2} \nabla U(\mathbf{x}^{(t)}) \
\mathbf{x}^{(t+\epsilon)} &= \mathbf{x}^{(t)} + \epsilon \mathbf{p}^{(t+\epsilon/2)} \
\mathbf{p}^{(t+\epsilon)} &= \mathbf{p}^{(t+\epsilon/2)} - \frac{\epsilon}{2} \nabla U(\mathbf{x}^{(t+\epsilon)})
\end{aligned}

**NUTS (No-U-Turn Sampler)** 自适应选择 leapfrog 步数 $L$，避免过度或不足采样。 ### 4.4 扩散模型 = 连续 MCMC 扩散模型的前向过程（加噪）是固定的，但**反向过程（去噪）是 learned MCMC**：

p_\theta(\mathbf{x}_{t-1} | \mathbf{x}t) = \mathcal{N}(\mu\theta(\mathbf{x}t, t), \Sigma\theta(\mathbf{x}_t, t))

与 L an g e v in 动力学的联系：

d\mathbf{x}_t = \nabla \log p(\mathbf{x}_t) dt + \sqrt{2} d\mathbf{W}_t

这正是扩散 SDE 的**score-based** 形式。 ### 4.5 SVGD：Stein 变分梯度下降 SVGD 用**粒子群**近似后验，通过 Stein 差异梯度更新：[^5]

\boldsymbol{\phi}^*(\cdot) = \mathbb{E}{\mathbf{x} \sim q}[\nabla{\mathbf{x}} \log p(\mathbf{x}) k(\mathbf{x}, \cdot) + \nabla_{\mathbf{x}} k(\mathbf{x}, \cdot)]

**Banerjee et al. (2024-2025)** 给出 SVGD 有限粒子数的非渐近收敛率 $W_2(\hat{q}_n, q^*) = O(n^{-1/2})$。 ```python class SVGD: """Stein 变分梯度下降""" def __init__(self, kernel='rbf', n_particles=100): self.n_particles = n_particles self.kernel = kernel def rbf_kernel(self, x, h=-1): """RBF 核函数""" N = x.size(0) xx = torch.mm(x, x.t()) x2 = torch.diag(xx) dist2 = x2.unsqueeze(0) + x2.unsqueeze(1) - 2 * xx if h < 0: # 中位数启发式 h = torch.median(dist2[dist2 > 0]) K = torch.exp(-dist2 / (h + 1e-8)) grad_K = -2 * K.unsqueeze(-1) * (x.unsqueeze(0) - x.unsqueeze(1)) / (h + 1e-8) return K, grad_K def svgd_update(self, particles, log_prob_fn, lr=0.01, n_iters=100): """SVGD 更新规则""" for _ in range(n_iters): log_prob = log_prob_fn(particles) # (N,) grad_log_prob = torch.autograd.grad( log_prob.sum(), particles, create_graph=False )[0] # (N, d) K, grad_K = self.rbf_kernel(particles) # phi^*(x_i) = (1/N) sum_j [k(x_j, x_i) grad_log_prob(x_j) + grad_k(x_j, x_i)] phi = (K @ grad_log_prob + grad_K.sum(dim=0)) / self.n_particles # 更新 particles = particles + lr * phi return particles ``` --- ## 五、PGM 与深度学习融合 ### 5.1 深度信念网络（DBN） DBN 是 PGM 与深度学习的早期融合：堆叠 RBM（受限玻尔兹曼机）。 **RBM 能量函数**：

E(\mathbf{v}, \mathbf{h}) = -\mathbf{b}^T \mathbf{v} - \mathbf{c}^T \mathbf{h} - \mathbf{v}^T \mathbf{W} \mathbf{h}

* * 联合分布 * * ：

p(\mathbf{v}, \mathbf{h}) = \frac{1}{Z} e^{-E(\mathbf{v}, \mathbf{h})}

DBN 训练使用**对比散度（CD-k）**算法，逐层贪婪预训练。 ### 5.2 GNN = 图模型的可微消息传递 **现代视角**：GNN 是用神经网络参数化的**信念传播**。 | PGM 概念 | GNN 对应 | |---------|---------| | 变量 $x_i$ | 节点特征 $\mathbf{h}_i$ | | 因子 $\psi_c$ | 消息函数 $\text{MSG}_\theta$ | | 消息 $\mu$ | 嵌入 $\mathbf{m}$ | | 信念 $b(x)$ | 节点表示 $\mathbf{h}_i$ | | BP 迭代 | GNN 层 | ### 5.3 变分自编码器（VAE）= 隐变量 PGM VAE 是**有向 PGM + 神经似然**：

p_\theta(\mathbf{x}, \mathbf{z}) = p(\mathbf{z}) p_\theta(\mathbf{x} | \mathbf{z})

用变分后验 $q_\phi(\mathbf{z} | \mathbf{x})$ 近似真实后验 $p(\mathbf{z} | \mathbf{x})$。 ### 5.4 神经 ODE 与图模型 Neural ODE（Chen et al. NeurIPS 2018）将 ResNet 视为 ODE 的离散化：

\frac{d\mathbf{h}(t)}{dt} = f(\mathbf{h}(t), t, \theta)

在连续极限下，**ResNet = PGM 上的连续时间推断**： - 状态 $\mathbf{h}(t)$ = 隐变量 - $f$ = 消息传递的连续版本 ### 5.5 注意力机制 = 软消息传递 **Transformer 的注意力**可以视为**软消息传递**：

\mathbf{h}i^{(l+1)} = \sum{j=1}^{n} A_{ij} \mathbf{W}_V \mathbf{h}_j^{(l)}

其中 $A_{ij}$ 是学习的、**软**的注意力权重（而非硬图结构）。 **与传统 BP 的对比**： - BP：消息在**显式图**上传递 - 注意力：消息在**全连接软图**上传递 --- ## 六、结构学习 ### 6.1 PC 算法 **PC 算法**通过条件独立性测试发现因果结构： 1. **阶段1（骨架发现）**：对每对变量 $(X, Y)$，测试在哪些条件下 $X \perp\!\!\!\perp Y$；找到这些条件集后，去掉 $X-Y$ 边 2. **阶段2（定向）**：使用碰撞规则、Meek 规则定向边 ```python def pc_algorithm(data, alpha=0.05): """ PC 算法：发现因果结构 data: (n_samples, n_vars) 数据矩阵 alpha: 显著性水平 """ n_vars = data.shape[1] # 初始化完全图 adj = np.ones((n_vars, n_vars), dtype=int) - np.eye(n_vars, dtype=int) sepset = {} # {i, j: conditioning_set} # 阶段1：骨架发现 for k in range(n_vars - 1): for i in range(n_vars): for j in range(i+1, n_vars): if adj[i, j] == 0: continue # 寻找条件集 adj_i = [v for v in range(n_vars) if v != i and v != j and adj[i, v] == 1 and adj[j, v] == 1] for cond_size in range(k + 1): for cond_set in itertools.combinations(adj_i, cond_size): # 条件独立性检验（Fisher Z 检验） if fisher_z_test(data[:, i], data[:, j], data[:, list(cond_set)], alpha): adj[i, j] = adj[j, i] = 0 sepset[(i, j)] = cond_set break if adj[i, j] == 0: break # 阶段2：定向边（v-structure 规则） cpdag = orient_v_structures(adj, sepset) return cpdag ``` ### 6.2 NOTEARS：连续结构学习 NOTEARS（Zheng et al. NeurIPS 2018）将离散图搜索转化为**连续优化**：

\min_{W \in \mathbb{R}^{d \times d}} F(W) \quad \text{s.t.} \quad h(W) = 0

其中 $h(W) = \text{tr}(e^{W \odot W}) - d$（矩阵指数保证无环）。 ```python class NOTEARS: """连续结构学习""" def __init__(self, lambda_l1=0.1): self.lambda_l1 = lambda_l1 def h_func(self, W): """无环约束""" d = W.shape[0] # 矩阵指数的迹 M = W * W E = torch.matrix_exp(M) return torch.trace(E) - d def fit(self, X, n_iters=100, lr=0.01, rho=1.0, alpha=0.0): """ X: (n_samples, n_vars) 数据 """ n, d = X.shape W = torch.zeros(d, d, requires_grad=True) optimizer = torch.optim.Adam([W], lr=lr) for _ in range(n_iters): # 损失：L(W) + lambda * ||W||_1 + (rho/2) * h(W)^2 + alpha * rho * h(W) pred = X @ W mse = 0.5 / n * torch.sum((X - pred) ** 2) l1 = self.lambda_l1 * torch.sum(torch.abs(W)) h = self.h_func(W) loss = mse + l1 + (rho / 2) * h ** 2 + alpha * rho * h optimizer.zero_grad() loss.backward() optimizer.step() # 更新 alpha with torch.no_grad(): h_val = h.item() if h_val > 0.25 * alpha: alpha = alpha + rho * h_val else: alpha = alpha - rho * h_val return W.detach().numpy() ``` --- ## 七、PGM 的现代应用 ### 7.1 贝叶斯神经网络 将神经网络权重视为**随机变量** $\theta \sim p(\theta | \mathcal{D})$： - **MC Dropout**：训练时启用 dropout，测试时也 dropout，得到近似的后验采样 - **Deep Ensembles**：训练多个独立模型，集成预测作为不确定性 - **Laplace 近似**：用 $\mathcal{N}(\theta^*, H^{-1})$ 近似后验 - **HMC**：用 HMC 采样权重后验 ### 7.2 神经隐变量模型 将 PGM 概念与神经网络的灵活性结合： - **VAE**：变分推断 + 神经似然 - **Normalizing Flows**：可逆 NN 表达灵活后验 - **Diffusion Models**：连续时间 MCMC + 神经 score - **Neural Processes**：元学习 + 隐变量 ### 7.3 概率电路（PC） **概率电路**（Probabilistic Circuits）是 PGM 的一种特殊形式，具有**可处理性**（tractability）： - 高效边际推断 - 高效条件推断 - 各种查询（最大后验、采样）都是多项式时间 **2024-2025 进展**： - **NPC**（神经概率电路）：神经网络与 PC 融合 - **Causal NPC**：因果干预 - **几何感知 PC**：Voronoi 镶嵌引入局部几何 --- ## 八、关键洞察总结 ### 8.1 三大统一 1. **GNN = 可微 BP**：用神经网络参数化消息传递 2. **VAE = 现代变分推断**：用 NN 表达变分后验 3. **扩散模型 = 连续 MCMC**：SDE 离散化 = 采样 ### 8.2 三大现代方向 1. **DDVI**：扩散模型作为变分后验 2. **SVGD 理论成熟**：有限粒子收敛率、加速方法 3. **因果结构学习**：PC、NOTEARS、GES 等算法 ### 8.3 三大核心挑战 1. **计算复杂度**：精确推断（BP）在环图上是 NP-hard 2. **可处理性 vs 表达力**：概率电路的可处理性限制表达力 3. **可扩展性**：大规模 PGM 的推断与学习 --- ## 九、与其他专题的连接 - **贝叶斯深度学习**：BNN = 权重后验 + NN - **GNN 理论**：GNN = 图模型的可微 BP - **扩散模型理论**：扩散 = 连续 MCMC - **变分推断**：VAE = NN 参数化的变分推断 - **因果推断**：结构学习 + 因果发现 --- ## 参考资料 [^1]: Koller, D. & Friedman, N. (2009). Probabilistic Graphical Models: Principles and Techniques. MIT Press. [^2]: Gilmer, J. et al. (2017). Neural Message Passing for Quantum Chemistry. ICML 2017. [arXiv:1704.01212](https://arxiv.org/abs/1704.01212) [^3]: Kingma, D.P. & Welling, M. (2014). Auto-Encoding Variational Bayes. ICLR 2014. [arXiv:1312.6114](https://arxiv.org/abs/1312.6114) [^4]: Piriyakulkij, M. et al. (2024). Denoising Diffusion Variational Inference. AAAI 2025. [arXiv:2401.02739](https://arxiv.org/abs/2401.02739) [^5]: Liu, Q. & Wang, D. (2016). Stein Variational Gradient Descent: A General Purpose Bayesian Inference Algorithm. NeurIPS 2016. [arXiv:1608.04471](https://arxiv.org/abs/1608.04471) #### 2024-2026 进展 - Winter, S. et al. (2024). Emerging Directions in Bayesian Computation. *Statistical Science* 39(1):62-89. [DOI](https://doi.org/10.1214/23-STS919) - Banerjee, I. et al. (2024-2025). Improved Finite-Particle Convergence Rates for SVGD. [arXiv:2409.08469](https://arxiv.org/abs/2409.08469) - Pituk, C. et al. (2025). Do Bayesian Neural Networks Actually Behave Like Bayesian Models? ICML 2025. [PMLR 267](https://proceedings.mlr.press/v267/) - Cinquin, V. et al. (2024). FSP-Laplace: Function-Space Priors for Laplace Approximation. NeurIPS 2024. - Deistler, M. et al. (2025). Simulation-Based Inference: A Practical Guide. [arXiv:2508.12939](https://arxiv.org/abs/2508.12939) - Zheng, X. et al. (2018). DAGs with NO TEARS: Continuous Optimization for Structure Learning. NeurIPS 2018. [arXiv:1803.01422](https://arxiv.org/abs/1803.01422) *最后更新：2026-06-22*

Metaphor

探索

概率图模型与深度学习融合：从理论到现代架构

概率图模型与深度学习融合：从理论到现代架构

引言

一、图模型基础

1.1 三种表示

1.2 条件独立与马尔可夫性

1.3 联合分布的分解

二、消息传递与信念传播

2.1 变量消除（Variable Elimination）

2.2 Sum-Product 算法（信念传播）

2.3 GNN = 可微消息传递

2.4 Loopy Belief Propagation 与 GNN 深度

三、变分推断

3.1 ELBO 与 KL 散度

3.2 平均场变分推断

3.3 VAE：变分推断的现代实现

3.4 扩散变分推断（DDVI）

关系图谱

目录

反向链接