Pyro：基于PyTorch的概率编程框架

Pyro：基于PyTorch的概率编程框架

Pyro是一个灵活的概率编程框架，构建在PyTorch之上，专为贝叶斯建模、概率推理和深度学习集成设计。其文档结构清晰，覆盖核心功能、推理算法、扩展应用等模块，以下从核心组件、推理方法、扩展应用等维度展开介绍。

基础讲解

一、Pyro核心模块

1. 入门与基础原语

• Getting Started
  快速上手指南，涵盖安装、基本模型定义（如贝叶斯线性回归）、推理流程示例，适合新手了解Pyro的建模范式。
• Primitives
  核心编程原语，包括sample（随机变量采样）、plate（批量处理）、param（参数声明）等，是构建概率模型的基础。

2. 推理算法

Pyro支持多种经典与前沿推理方法，分为变分推理、MCMC、无似然推理等类别：

• 变分推理（Variational Inference）
  • SVI（随机变分推理）：基于ELBO（证据下界）的优化框架，适合大规模数据。
  • 自动引导生成（Automatic Guide Generation）：自动生成变分分布（如均值场、自回归引导），降低手动设计引导分布的成本。
• MCMC（马尔可夫链蒙特卡洛）
  包括HMC（哈密顿蒙特卡洛）、NUTS（无回转采样器）等，适用于复杂后验分布的精确采样。
• 无似然推理（Likelihood-Free Methods）
  如近似贝叶斯计算（ABC），用于似然函数难以显式计算的场景（如物理模拟模型）。
• 其他推理方法
  重要性重加权、序列蒙特卡洛（SMC）、斯坦方法（Stein Methods）等，覆盖多场景需求。

3. 概率分布与变换

• Distributions
  集成PyTorch原生分布（如正态、伯努利），并扩展Pyro特有分布（如可组合的复合分布）。
• Transforms
  支持变量变换（如对数变换、分位数变换），通过TransformModules实现神经网络参数化的动态变换，增强分布灵活性。

4. 神经网络与优化

• Pyro Modules
  基于PyTorch的nn.Module，支持概率神经网络（如贝叶斯神经网络），可无缝集成变分推理。
• 优化器
  包括PyTorch优化器（SGD、Adam）、高阶优化器（如牛顿法），以及Pyro特有的推理优化工具（如用于HMC的辅助函数）。

5. 效应处理与工具库

• Poutine（效应处理器）
  通过Handlers（如trace、runtime）实现模型追踪、条件干预等功能，支持动态模型修改（如推断时固定某些变量）。
• 实用工具
  张量操作（索引、收缩）、高斯收缩、流式统计、状态空间模型工具等，提升建模效率。

二、扩展应用与社区贡献

1. 特定领域建模

• 流行病学模型
  提供 compartmental 模型基类（如SIR、SEIR），支持传染病传播动力学建模，包含示例模型代码。
• 时间序列与预测
  涵盖线性高斯状态空间模型、卡尔曼滤波、动态系统建模，适用于金融数据、传感器追踪等场景。
• 高斯过程（GPs）
  内置核函数（如RBF、Matern）、似然函数、参数化模型，支持贝叶斯优化与不确定性建模。

2. 高级主题

• 因果推断与VAE
  CEVAE（因果效应变分自动编码器）模块，用于从观测数据中估计因果效应，结合VAE实现隐变量建模。
• 生物序列模型
  基于MuE（多尺度嵌入）的生物序列分析工具，支持可变长度数据的隐马尔可夫模型（HMM），适用于基因组学、蛋白质序列分析。
• 最优实验设计
  通过预期信息增益（EIG）优化实验方案，减少数据采集成本，适用于科学实验与机器学习调参。

3. 轻量级与集成工具

• Minipyro
  轻量级版本，用于教学或资源受限环境，保留核心建模功能，简化依赖。
• Funsor集成
  结合Funsor库实现符号化概率计算，支持自动微分与优化，适用于复杂模型的高效推理。

三、学习路径与实践建议

1. 新手入门

• 从《Getting Started》开始，通过简单示例（如抛硬币模型）掌握sample、param等原语。
• 学习变分推理基础（SVI、ELBO），尝试使用自动引导生成功能快速搭建模型。
• 参考Pyro Examples中的案例（如贝叶斯神经网络、高斯过程回归），结合实际数据动手实践。

2. 进阶应用

• 深入研究MCMC与无似然推理，对比不同算法在计算效率与精度上的权衡。
• 利用Poutine实现自定义推理逻辑（如干预查询、模型调试），探索动态模型修改技巧。
• 在Contributed Code中寻找领域相关模块（如流行病学、时间序列），直接复用或二次开发。

3. 生态整合

• 结合PyTorch生态（如TorchScript、Lightning）实现模型部署与规模化训练。
• 使用TensorBoard等工具可视化推理过程（如后验分布演变、ELBO收敛曲线）。

四、总结：Pyro的核心优势

• 灵活性：通过Poutine和自定义推理算法支持复杂模型设计，适合前沿研究。
• 高效性：底层基于PyTorch，支持GPU加速与自动微分，处理大规模数据游刃有余。
• 扩展性：社区贡献模块覆盖多领域（生物、医疗、工程），降低跨学科建模门槛。

如需进一步学习，可访问官方文档（https://docs.pyro.ai）或GitHub仓库，参与社区讨论与案例实践。

代码案例

以下是针对Pyro核心功能模块的案例代码汇总，按照推理算法、概率分布与变换、神经网络集成等维度分类呈现，每个子模块包含场景描述、代码示例及关键点解析：

一、推理算法

1. 变分推理（SVI + 自动引导生成）

场景：贝叶斯线性回归，使用自动引导生成简化变分分布设计

import pyro  
import pyro.distributions as dist  
from pyro.infer import SVI, Trace_ELBO  
from pyro.optim import Adam  
from pyro.nn import AutoRegressiveNN  # 自动引导生成组件  # 定义线性回归模型  
def linear_regression(x, y=None):  w = pyro.sample("w", dist.Normal(torch.zeros(1), 10))  b = pyro.sample("b", dist.Normal(0, 10))  mu = x * w + b  with pyro.plate("obs", len(x)):  pyro.sample("y", dist.Normal(mu, 1), obs=y)  return mu  # 生成模拟数据：y = 3x + 噪声  
x = torch.linspace(-5, 5, 100)  
y = 3 * x + torch.normal(0, 1, x.shape)  # 使用自动引导生成（均值场正态分布）  
guide = AutoDiagonalNormal(  linear_regression,  input_names=["x"],  param_names=["w", "b"]  
)  # 变分推理训练  
svi = SVI(linear_regression, guide, Adam({"lr": 0.05}), loss=Trace_ELBO())  
for i in range(200):  loss = svi.step(x, y)  if i % 50 == 0:  print(f"Iter {i}, Loss: {loss:.4f}")  # 输出后验均值  
w_post = guide.median()["w"].item()  
b_post = guide.median()["b"].item()  
print(f"估计参数：w={w_post:.3f}, b={b_post:.3f}")  # 接近3和0  

关键点：

• AutoDiagonalNormal自动为模型参数生成独立正态分布引导
• 适用于大规模数据，通过ELBO优化实现快速推断

2. MCMC（HMC/NUTS）

场景：贝叶斯逻辑回归，使用NUTS采样估计分类器参数

from pyro.infer import MCMC, NUTS  
import torch.nn.functional as F  def logistic_regression(x, y=None):  w = pyro.sample("w", dist.Normal(torch.zeros(x.shape[1]), 10))  b = pyro.sample("b", dist.Normal(0, 10))  logits = x @ w + b  with pyro.plate("obs", len(x)):  pyro.sample("y", dist.Bernoulli(logits=logits), obs=y)  return logits  # 生成二分类数据（2维特征）  
x = torch.randn(100, 2)  
y = (x[:, 0] + x[:, 1] > 0).float()  # 运行NUTS采样  
kernel = NUTS(logistic_regression)  
mcmc = MCMC(kernel, num_samples=500, warmup_steps=100)  
mcmc.run(x, y)  
samples = mcmc.get_samples()  # 后验统计  
print("w后验均值:", samples["w"].mean(dim=0))  # 接近1和1（假设数据线性可分）  

关键点：

• NUTS自动调整步长和采样轨迹，优于传统HMC
• 适用于小数据集或需要精确后验的场景

3. 无似然推理（ABC）

场景：物理模拟模型推断（假设似然函数不可解）

from pyro.infer import ABC  # 模拟模型：y = a * x^2 + b + 噪声（已知a∈[1,3], b∈[-2,2]）  
def simulator(theta):  a, b = theta  x = torch.linspace(-2, 2, 20)  y = a * x**2 + b + torch.normal(0, 0.5, x.shape)  return y  # 观测数据：假设真实a=2, b=0  
obs = simulator(torch.tensor([2.0, 0.0]))  # ABC推断（均匀先验）  
kernel = ABC(  model=simulator,  prior=dist.Uniform(torch.tensor([1.0, -2.0]), torch.tensor([3.0, 2.0])),  distance=lambda x, y: F.mse_loss(x, y),  # 距离度量  num_samples=1000  
)  
posterior = kernel.run(obs=obs)  # 后验均值  
print("a后验均值:", posterior["_theta"][:, 0].mean())  # 接近2.0  

关键点：

• 通过模拟数据与观测数据的距离（如MSE）替代似然函数
• 适用于物理、生物等复杂生成模型

4. 序列蒙特卡洛（SMC）

处理高维动态系统的在线推理：

from pyro.infer import SMCFilter  # 状态空间模型（如股票价格波动）  
def model(observations=None, time_steps=10):  x = pyro.sample("x_0", dist.Normal(0, 1))  # 初始状态  for t in range(1, time_steps):  x = pyro.sample(f"x_{t}", dist.Normal(x, 0.1))  # 状态转移  pyro.sample(f"y_{t}", dist.Normal(x, 0.5), obs=observations[t] if observations else None)  # 初始化SMC滤波器  
smc = SMCFilter(model, num_particles=100, max_plate_nesting=1)  # 在线推断（模拟）  
for t in range(10):  new_obs = torch.randn(1)  smc.step(new_obs)  print(f"Time {t}: State mean = {smc.get_empirical()['x'].mean().item()}")  

二、概率分布与变换

1. 复合分布（混合分布）

场景：生成式模型中的多模态分布建模

from pyro.distributions import MixtureOfGaussians  # 定义3个高斯组件（均值、标准差、权重）  
means = torch.tensor([-2, 0, 2])  
stds = torch.tensor([0.5, 1.0, 0.5])  
weights = torch.tensor([0.3, 0.4, 0.3])  # 混合高斯分布  
mog = MixtureOfGaussians(weights, means, stds)  
samples = mog.sample((1000,))  # 可视化直方图（需matplotlib）  
plt.hist(samples.numpy(), bins=30, density=True)  
plt.show()  

关键点：

• MixtureOfGaussians直接支持多组件混合分布
• 比手动构造MixtureSameFamily更简洁

2. 自定义分布

构建混合分布模拟复杂数据：

# 构建零膨胀泊松分布  
class ZeroInflatedPoisson(dist.Distribution):  def __init__(self, rate, pi):  self.rate = rate  self.pi = pi  # 零值比例  super().__init__(event_shape=())  def sample(self, sample_shape=torch.Size()):  zeros = torch.bernoulli(self.pi.expand(sample_shape))  poisson = dist.Poisson(self.rate).sample(sample_shape)  return torch.where(zeros == 1, torch.zeros_like(poisson), poisson)  def log_prob(self, value):  case_zero = torch.log(self.pi + (1 - self.pi) * torch.exp(-self.rate))  case_non_zero = torch.log(1 - self.pi) + dist.Poisson(self.rate).log_prob(value)  return torch.where(value == 0, case_zero, case_non_zero)  # 使用自定义分布  
zip_dist = ZeroInflatedPoisson(rate=3.0, pi=0.2)  
samples = zip_dist.sample((1000,))  
print("零值比例:", (samples == 0).float().mean().item())  # 接近0.2  

3. 分布变换

通过变换增强分布表达能力：

from pyro.distributions import TransformedDistribution, AffineTransform, SigmoidTransform  # 构建逻辑分布（正态分布的sigmoid变换）  
base_dist = dist.Normal(0, 1)  
transforms = [SigmoidTransform(), AffineTransform(loc=0, scale=10)]  # y = 10*sigmoid(x)  
logistic_dist = TransformedDistribution(base_dist, transforms)  # 采样与概率密度计算  
x = logistic_dist.sample()  
print(f"采样值: {x.item():.3f}, 概率密度: {logistic_dist.log_prob(x).exp().item():.3f}")  

4. 神经网络参数化变换（TransformModule）

场景：动态调整分布形状（如条件生成模型）

from pyro.distributions import TransformedDistribution  
from pyro.distributions.transforms import TransformModule  # 定义可学习变换：y = a*x + b，a和b由神经网络生成  
class LinearTransform(TransformModule):  def __init__(self, input_dim):  super().__init__()  self.net = nn.Sequential(  nn.Linear(input_dim, 2),  nn.Softplus()  # 确保a>0, b为任意实数  )  def _call(self, x, context=None):  params = self.net(context)  # context为条件输入（如标签）  a, b = params.chunk(2, dim=-1)  return a * x + b  # 基础分布 + 变换  
base_dist = dist.Normal(0, 1)  
transform = LinearTransform(input_dim=1)  
cond_dist = TransformedDistribution(base_dist, [transform])  # 条件采样（如context=torch.tensor([1.0])）  
context = torch.tensor([1.0]).unsqueeze(0)  
x = cond_dist.sample(context=context)  # 采样结果受context控制  

关键点：

• TransformModule的参数可通过神经网络动态生成
• 适用于条件分布建模（如CVAE、强化学习价值函数）

三、神经网络与优化

1. 贝叶斯神经网络（BNN）+ 高阶优化器

场景：不确定性量化的回归任务，使用牛顿法加速收敛

from pyro.optim import Newton  
from pyro.infer.autoguide import AutoMultivariateNormal  class BNN(pnn.PyroModule):  def __init__(self, input_dim, hidden_dim):  super().__init__()  self.fc1 = pnn.PyroLinear(input_dim, hidden_dim)  self.fc2 = pnn.PyroLinear(hidden_dim, 1)  def forward(self, x):  x = F.relu(self.fc1(x))  return self.fc2(x)  model = BNN(input_dim=1, hidden_dim=32)  
guide = AutoMultivariateNormal(model)  # 全协方差引导  
optim = Newton({"step_size": 0.1})  # 牛顿法优化器  
svi = SVI(model, guide, optim, loss=Trace_ELBO())  # 训练（假设数据为x~N(0,1), y=sin(x)+噪声）  
x = torch.randn(100, 1)  
y = torch.sin(x) + 0.1 * torch.randn(x.shape)  
for i in range(50):  loss = svi.step(x, y)  

关键点：

• Newton优化器利用Hessian矩阵加速收敛，适合低维问题
• AutoMultivariateNormal生成多元正态引导，捕捉参数相关性

2. 多种优化策略

from pyro.optim import ClippedAdam, ExponentialLR  # 带梯度裁剪的Adam优化器  
optimizer = ClippedAdam({  "lr": 0.001,  "betas": (0.9, 0.999),  "clip_norm": 10.0  # 梯度裁剪阈值  
})  # 学习率指数衰减调度器  
lr_scheduler = ExponentialLR(optimizer, gamma=0.99)  # 在训练循环中更新学习率  
for epoch in range(100):  svi.step(data)  if epoch % 10 == 0:  lr_scheduler.step()  print(f"Epoch {epoch}, LR: {lr_scheduler.get_lr()[0]}")  

3. 自定义优化器组合

场景：分阶段优化（先训练权重，再优化超参数）

from pyro.optim import MultiOptimizer  # 定义不同参数组的优化器  
optim_params = {  "w": Adam({"lr": 0.01}),  "b": SGD({"lr": 0.1})  
}  
multi_optim = MultiOptimizer(optim_params)  # 在引导函数中指定参数组  
def guide(data=None):  w = pyro.param("w", torch.tensor(0.5), group="w")  b = pyro.param("b", torch.tensor(0.0), group="b")  return pyro.sample("theta", dist.Normal(w, b))  

关键点：

• MultiOptimizer支持对不同参数使用独立优化器
• 适用于多尺度参数优化（如超参数与模型权重分离）

四、效应处理与工具库（Poutine）

1. 模型追踪与条件干预

场景：观测部分变量后，计算条件后验概率

from pyro.poutine import condition, trace  def model():  a = pyro.sample("a", dist.Normal(0, 1))  b = pyro.sample("b", dist.Normal(a, 1))  c = pyro.sample("c", dist.Normal(b, 1))  return c  # 条件化：已知c=3，追踪a和b的采样路径  
conditioned_model = condition(model, data={"c": torch.tensor(3.0)})  
traced = trace(conditioned_model).get_trace()  
traced.compute_log_prob()  # 计算条件概率分布  # 打印条件后验样本  
print("条件后验a:", traced.nodes["a"]["value"].item())  
print("条件后验b:", traced.nodes["b"]["value"].item())  

关键点：

• condition实现贝叶斯条件化（类似do-calculus干预）
• trace用于调试模型执行流程，查看中间变量采样值

2. 张量收缩与高斯操作

场景：高维张量求和（如板积运算）与高斯分布乘积

from pyro.util import torch_sum, gaussian_product  # 张量收缩：对3维张量沿第2维求和  
x = torch.randn(2, 5, 3)  # 形状(batch, plate, features)  
sum_x = torch_sum(x, dim=1)  # 形状(batch, features)，等价于x.sum(dim=1)  # 高斯分布乘积：合并两个独立高斯分布  
mu1, var1 = 1.0, 0.5  
mu2, var2 = 2.0, 0.3  
post_mu, post_var = gaussian_product(mu1, var1, mu2, var2)  
print(f"合并后均值：{post_mu}, 方差：{post_var}")  # 接近(1*0.3+2*0.5)/(0.5+0.3)和(0.5*0.3)/(0.5+0.3)  

关键点：

• torch_sum自动处理板积（plate）维度，避免手动指定dim
• gaussian_product高效计算高斯分布的乘积，用于消息传递算法

3. 高斯过程回归

处理不确定性感知的函数拟合：

from pyro.contrib.gp.models import GPRegression  
from pyro.contrib.gp.kernels import RBF  # 生成数据  
x = torch.linspace(0, 10, 100)  
y = torch.sin(x) + torch.randn(100) * 0.1  # 定义高斯过程模型  
kernel = RBF(input_dim=1)  
gpr = GPRegression(x, y, kernel, noise=torch.tensor(0.1))  # 优化核参数  
optimizer = torch.optim.Adam(gpr.parameters(), lr=0.01)  
for i in range(100):  optimizer.zero_grad()  loss = gpr.step()  if i % 10 == 0:  print(f"Step {i}, Loss: {loss:.3f}")  # 预测  
x_new = torch.linspace(0, 15, 200)  
mean, cov = gpr(x_new, full_cov=True)  

五、扩展应用：特定领域建模

1. 流行病学模型（SEIR）

场景：新冠疫情传播模拟，包含暴露仓室（E）

from pyro.contrib.epidemiology import CompartmentalModel  model = CompartmentalModel(  compartments=["S", "E", "I", "R"],  parameters={  "pop_size": 1e5,  "initial_exposed": 10,  "initial_infected": 1,  "beta": 0.3,       # 感染率  "sigma": 1/5.2,    # 暴露到感染率（潜伏期倒数）  "gamma": 1/14      # 恢复率  },  contact_matrix=[  [0, 1, 0, 0],     # S -> E  [0, 0, 1, 0],     # E -> I  [0, 0, 0, 1],     # I -> R  [0, 0, 0, 0]      # R 无输出  ]  
)  # 模拟180天传播  
times = torch.arange(0, 180)  
trajectory = model(times)  
plt.plot(times, trajectory["I"], label="Infected")  
plt.show()  

关键点：

• contact_matrix定义仓室间转移关系
• 可扩展为多群体模型（如分年龄层）

2. 高斯过程（GP）回归

场景：函数拟合，使用RBF核与自动微分推断

from pyro.contrib.gp import GPRegression  
from pyro.contrib.gp.kernels import RBF  # 生成数据：y = sin(x) + 噪声  
x = torch.linspace(-3, 3, 20).unsqueeze(-1)  
y = torch.sin(x) + 0.1 * torch.randn_like(x)  # 定义GP模型  
kernel = RBF(input_dim=1, lengthscale=torch.tensor(1.0))  
gpr = GPRegression(x, y, kernel, noise=torch.tensor(0.01))  # 变分推断训练  
gpr.set_prior("lengthscale", dist.Uniform(0.1, 5.0))  # 设置超参数先验  
gpr.autoguide("AutoNormal")  
gpr.fit(n_iter=200, lr=0.05)  # 预测新点  
x_new = torch.linspace(-4, 4, 100).unsqueeze(-1)  
mu, cov = gpr(x_new, full_cov=True)  

关键点：

• GPRegression封装了变分高斯过程推断
• 可通过set_prior对核超参数进行贝叶斯推断

3. 隐马尔可夫模型（HMM）

使用隐马尔可夫模型（HMM）预测股票价格：

from pyro.contrib.timeseries import GaussianHMM  # 假设我们有每日股票收益率数据  
returns = torch.randn(100) * 0.02  # 定义HMM模型（2个隐藏状态：高波动和低波动）  
hmm = GaussianHMM(  num_states=2,  feature_dim=1,  transition_concentration=torch.tensor(10.0),  emission_loc=torch.tensor([-0.01, 0.01]),  emission_scale=torch.tensor([0.02, 0.05])  
)  # 训练模型  
optimizer = Adam({"lr": 0.01})  
for i in range(100):  loss = hmm.step(returns.unsqueeze(-1))  if i % 10 == 0:  print(f"Step {i}, Loss: {loss:.3f}")  # 预测未来5天的收益率  
pred_mean, pred_std = hmm.forecast(returns.unsqueeze(-1), 5)  
print("未来5天预测均值:", pred_mean.squeeze())  

六、高级主题：因果推断（CEVAE）

场景：从观测数据中估计药物治疗（T=1/0）对疗效（Y）的因果效应

from pyro.contrib.cevae import CEVAE  
from torch.utils.data import DataLoader  # 假设数据：X为特征，T为治疗变量，Y为结果  
X = torch.randn(1000, 50)  # 50维特征  
T = (torch.rand(1000) > 0.5).float()  # 二值治疗  
Y = 2 * T + X[:, 0] + torch.randn(1000)  # 因果效应为2  # 构建CEVAE模型  
cevae = CEVAE(  input_dim=50,  treatment_dim=1,  outcome_dim=1,  latent_dim=10,  encoder=nn.Sequential(nn.Linear(51, 128), nn.ReLU(), nn.Linear(128, 10)),  outcome_model=nn.Linear(11, 1)  
)  # 训练模型  
data_loader = DataLoader(list(zip(X, T, Y)), batch_size=32, shuffle=True)  
cevae.fit(data_loader, num_epochs=100)  # 估计平均处理效应（ATE）  
ate = cevae.predict_ate(X).mean()  
print(f"估计因果效应：{ate.item():.3f}")  # 接近2.0  

关键点：

• CEVAE通过隐变量分离混淆因素与因果效应
• predict_ate返回个体处理效应（ITE）或平均效应（ATE）

七、高级主题：生物序列分析（MuE）

使用MuE模型分析DNA序列：

from pyro.contrib.bnn import MuE  # 假设我们有DNA序列数据（简化为整数编码）  
sequences = torch.randint(0, 4, (100, 1000))  # 100条序列，每条长度1000  # 初始化MuE模型  
mue = MuE(  input_size=4,  # DNA碱基类型数  hidden_size=64,  output_size=10,  # 预测类别数  sequence_length=1000,  num_layers=2  
)  # 训练模型（简化）  
optimizer = Adam({"lr": 0.001})  
for epoch in range(50):  loss = mue.step(sequences)  if epoch % 10 == 0:  print(f"Epoch {epoch}, Loss: {loss:.3f}")  # 预测序列类别  
predictions = mue(sequences)  

七、代码实践建议

1. 调试工具链

   • 使用pyro.enable_validation(True)捕获无效采样（如负概率）
   • 通过pyro.get_param_store().keys()查看所有可训练参数
   • 在MCMC中使用mcmc.summary()生成后验统计报告

2. 分布式推断

   • 对大规模MCMC任务，使用pyro.distributions的并行采样接口
   • 结合Dask或PyTorch Lightning实现分布式变分推理

3. 社区资源

   • 案例库：[Pyro Examples](https://docs.pyro.ai/en/stable/examples以下是补充完整的技术博客，在每个功能模块下新增详细案例与代码，并保持原有结构的连贯性：

三、学习与优化建议

1. 调试技巧

   • 使用pyro.render_model(model)可视化模型结构
   • 通过poutine.trace检查采样轨迹，验证模型正确性

2. 性能优化

   • 对大数据集使用pyro.plate的subsample参数进行小批量训练
   • 启用PyTorch的混合精度训练（torch.cuda.amp）加速MCMC采样

3. 资源推荐

   • Pyro官方教程：包含20+完整案例
   • Probabilistic Programming and Bayesian Methods for Hackers：贝叶斯方法入门经典

通过上述案例可见，Pyro通过模块化设计和PyTorch深度集成，为概率编程提供了从基础建模到复杂推理的全流程工具链。无论是学术研究还是工业应用，Pyro都能成为构建不确定性感知系统的有力工具。