Blitz - Torch Zoo 中的贝叶斯层

BLiTZ 是一个简单且可扩展的库，用于在 PyTorch 上构建贝叶斯神经网络层（基于《神经网络中的权重不确定性》论文中提出的方案）。通过使用 BLiTZ 的层和工具，您可以以一种不会影响各层之间交互的方式，轻松地为模型添加不确定性并计算复杂度代价，就像使用标准 PyTorch 一样。

借助我们核心的权重采样器类，您可以扩展和完善此库，以更广泛地为各种层引入不确定性，并且这些操作将与 PyTorch 完美集成。我们也欢迎贡献代码！

目录

• 安装
• 文档
• 回归任务的简单示例
  • 导入必要的模块
  • 加载并标准化数据
  • 创建我们的变分回归器类
  • 定义置信区间评估函数
  • 创建回归器并加载数据
  • 主训练与评估循环
• 贝叶斯深度学习简述
  • 首先，确定性神经网络层的线性变换
  • 贝叶斯层的目的
  • 贝叶斯层中的权重采样
  • 我们可以优化可训练的权重
  • 同时，存在一个关于其变量可导的复杂度代价函数
  • 获取第 n 次采样的完整代价函数
  • 一些说明与总结
• 引用
• 参考文献

安装

要安装 BLiTZ，您可以使用 pip 命令：

pip install blitz-bayesian-pytorch

或者通过 conda：

conda install -c conda-forge blitz-bayesian-pytorch

您也可以通过 git 克隆并在本地使用 pip 安装：

conda create -n blitz python=3.9
conda activate blitz
git clone https://github.com/piEsposito/blitz-bayesian-deep-learning.git
cd blitz-bayesian-deep-learning
pip install .

文档

关于我们层、权重（及先验分布）采样器和工具的文档：

• 贝叶斯层
• 权重与先验分布采样器
• 工具（便于与 PyTorch 集成）
• 损失函数

回归任务的简单示例

（您可以在自己的机器上运行 这个示例 来亲自体验）。

接下来我们将展示如何利用贝叶斯深度学习进行回归任务，从而为每个数据点预测一个置信区间，而不是单一的连续值预测。为预测结果提供置信区间，有时甚至比低误差的精确估计更有用。

我的理由是，在某些情况下，拥有一个高置信度的区间范围，往往能帮助我们做出比非常接近真实值的估计更为可靠的决策：例如，在进行交易操作时，如果能够知道价格至少会在某个特定范围内波动，就能判断这笔交易是否会带来收益或损失。了解某个数值是否一定会落在某个区间内，对于需要谨慎决策的场景来说，可能比一个非常接近但可能超出界限的精确估计更有价值。关键在于，有时候知道“是否有收益”本身可能比精确衡量收益大小更重要。

为了证明这一点，我们将使用 Boston-house-data 这个玩具数据集，构建一个贝叶斯神经网络回归器，尝试为待预测房价生成置信区间。我们将对数据进行标准化处理，置信区间的置信度设为 75%。有趣的是，我们会发现大约 90% 的预测置信区间要么低于上限，要么高于下限。

导入必要的模块

除了常用的模块外，我们还将从 BLiTZ 库中引入 variational_estimator 装饰器，它可以帮助我们在保持与 PyTorch 完全兼容的同时处理 BayesianLinear 层；当然，还有我们的核心层——具有权重不确定性的 BayesianLinear。

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np

from blitz.modules import BayesianLinear
from blitz.utils import variational_estimator

from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

加载并标准化数据

这里没有什么新内容，我们只是加载数据并对其进行标准化处理，以便更好地进行训练。

X, y = load_boston(return_X_y=True)
X = StandardScaler().fit_transform(X)
y = StandardScaler().fit_transform(np.expand_dims(y, -1))

X_train, X_test, y_train, y_test = train_test_split(X,
                                                    y,
                                                    test_size=.25,
                                                    random_state=42)


X_train, y_train = torch.tensor(X_train).float(), torch.tensor(y_train).float()
X_test, y_test = torch.tensor(X_test).float(), torch.tensor(y_test).float()

创建我们的变分回归器类

我们可以像构建任何 PyTorch 网络一样，通过继承 nn.Module 来创建我们的类。装饰器为我们提供了处理贝叶斯特性的方法，例如计算贝叶斯层的复杂度代价，以及执行多次前向传播（每次采样不同的权重）来估计损失。

@variational_estimator
class BayesianRegressor(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        #self.linear = nn.Linear(input_dim, output_dim)
        self.blinear1 = BayesianLinear(input_dim, 512)
        self.blinear2 = BayesianLinear(512, output_dim)
        
    def forward(self, x):
        x_ = self.blinear1(x)
        x_ = F.relu(x_)
        return self.blinear2(x_)

定义置信区间评估函数

该函数为我们尝试对标签值进行采样的批次上的每个预测创建一个置信区间。然后，我们可以通过计算预测分布中有多少确实包含了数据点的正确标签来衡量预测的准确性。

def evaluate_regression(regressor,
                        X,
                        y,
                        samples = 100,
                        std_multiplier = 2):
    preds = [regressor(X) for i in range(samples)]
    preds = torch.stack(preds)
    means = preds.mean(axis=0)
    stds = preds.std(axis=0)
    ci_upper = means + (std_multiplier * stds)
    ci_lower = means - (std_multiplier * stds)
    ic_acc = (ci_lower <= y) * (ci_upper >= y)
    ic_acc = ic_acc.float().mean()
    return ic_acc, (ci_upper >= y).float().mean(), (ci_lower <= y).float().mean()

创建回归器并加载数据

请注意，我们在这里创建 BayesianRegressor 的方式与其他神经网络相同。

regressor = BayesianRegressor(13, 1)
optimizer = optim.Adam(regressor.parameters(), lr=0.01)
criterion = torch.nn.MSELoss()

ds_train = torch.utils.data.TensorDataset(X_train, y_train)
dataloader_train = torch.utils.data.DataLoader(ds_train, batch_size=16, shuffle=True)

ds_test = torch.utils.data.TensorDataset(X_test, y_test)
dataloader_test = torch.utils.data.DataLoader(ds_test, batch_size=16, shuffle=True)

主训练和评估循环

我们的训练循环与普通的 PyTorch 训练循环唯一的不同之处在于，其损失是通过 sample_elbo 方法进行采样的。其他部分都可以正常进行，因为 BLiTZ 的目的就是让你在使用不同的贝叶斯神经网络时，能够更轻松地迭代数据，而无需担心复杂性。

以下是我们的简单训练循环：

iteration = 0
for epoch in range(100):
    for i, (datapoints, labels) in enumerate(dataloader_train):
        optimizer.zero_grad()
        
        loss = regressor.sample_elbo(inputs=datapoints,
                           labels=labels,
                           criterion=criterion,
                           sample_nbr=3)
        loss.backward()
        optimizer.step()
        
        iteration += 1
        if iteration%100==0:
            ic_acc, under_ci_upper, over_ci_lower = evaluate_regression(regressor,
                                                                        X_test,
                                                                        y_test,
                                                                        samples=25,
                                                                        std_multiplier=3)
            
            print("CI acc: {:.2f}, CI upper acc: {:.2f}, CI lower acc: {:.2f}".format(ic_acc, under_ci_upper, over_ci_lower))
            print("Loss: {:.4f}".format(loss))

贝叶斯深度学习简述

快速解释一下如何在贝叶斯神经网络中引入不确定性，以及我们如何对其损失进行建模，以便客观地提高预测的置信度并减少方差，而无需使用 Dropout 技术。

首先，确定性神经网络层的线性变换

如我们所知，在确定性的（非贝叶斯）神经网络层中，可训练参数直接对应于其前一层（或输入层，如果是第一层的话）线性变换中使用的权重。这可以用以下公式表示：

}&space;=&space;W^{(i+1)}\cdot&space;z^{(i)}&space;+&space;b^{(i+1)})

(Z 表示第 i 层的激活输出)

贝叶斯层的目的

贝叶斯层旨在通过在每次前向传播时从由可训练变量参数化的分布中采样权重，从而在其权重中引入不确定性。

这样做的好处不仅在于优化模型的性能指标，还在于可以收集网络对特定数据点预测的不确定性（通过多次采样并测量分散程度），并尽可能地减少网络预测的方差，从而让我们了解在基于特定数据点进行建模时，我们对标签仍然有多少不确定性。

贝叶斯层中的权重采样

为此，在每次前向传播时，我们会使用以下公式对线性变换的参数进行采样（其中 ρ 参数化标准差，μ 参数化样本线性变换参数的均值）：

对于权重：

}_{(n)}&space;=&space;\mathcal{N}(0,1)&space;*&space;log(1&space;+&space;\rho^{(i)}&space;)&space;+&space;\mu^{(i)})

其中采样的 W 对应于第 i 层在第 n 次采样时用于线性变换的权重。

对于偏置：

}_{(n)}&space;=&space;\mathcal{N}(0,1)&space;*&space;log(1&space;+&space;\rho^{(i)}&space;)&space;+&space;\mu^{(i)})

其中采样的 b 对应于第 i 层在第 n 次采样时用于线性变换的偏置。

可以优化我们的可训练权重

尽管我们的权重和偏置带有随机乘数，但我们仍然可以通过给定一个关于采样权重和可训练参数的可微分函数（在本例中为损失），然后对该函数分别对这两个参数求导来优化它们：

1. 设 )
2. 设 )
3. 设 &space;*&space;\epsilon)
4. 设 ) 关于其变量可微分

因此：

5. 

以及

6. 

同样地，也存在一种复杂度代价函数，其对各变量可导。

众所周知，交叉熵损失（以及均方误差）都是可导的。因此，如果我们证明存在一种可导的复杂度代价函数，就可以让我们的框架自动求导并计算优化步骤中的梯度。

复杂度代价是在前向传播过程中，由每个贝叶斯层分别计算得出的（基于预先定义的较简单先验分布及其经验分布）。各层的复杂度代价之和会被累加到总损失中。

正如《神经网络中的权重不确定性》论文所提出的，我们可以通过计算该分布与一个更简单的分布之间的KL散度来获取分布的复杂度代价，并通过一些近似处理，使这一函数能够对其变量（即各个分布）求导：

1. 设 ) 为人工设定的低熵分布的概率密度函数，将其视为权重的“先验”分布。
2. 设 ) 为我们采样的权重在给定参数下的后验经验分布的概率密度函数。

因此，对于采样矩阵 W 中的每一个标量：

3. &space;\lVert&space;{P}(w)&space;)&space;=&space;\lim_{n\to\infty}1/n\sum_{i=0}^{n}&space;{Q}(w^{(i)}&space;|&space;\theta)*&space;(\log{{Q}(w^{(i)}&space;|&space;\theta)}&space;-&space;\log{{P}(w^{(i)})}&space;))

假设 n 非常大时，我们可以近似得到：

4. &space;\lVert&space;{P}(w)&space;)&space;=&space;1/n\sum_{i=0}^{n}&space;{Q}(w^{(i)}&space;|&space;\theta)*&space;(\log{{Q}(w^{(i)}&space;|&space;\theta)}&space;-&space;\log{{P}(w^{(i)})}&space;))

从而有：

5. &space;\lVert&space;{P}(w)&space;)&space;=&space;\mu_Q&space;*\sum_{i=0}^{n}&space;(\log{{Q}(w^{(i)}&space;|&space;\theta)}&space;-&space;\log{{P}(w^{(i)})}&space;))

由于 Q 分布的期望值（均值）只是对数值进行缩放，因此可以将其从表达式中提取出来（因为不会影响框架的梯度追踪）。于是，第 n 个样本的复杂度代价为：

6. }&space;(w^{(n)},&space;\theta)&space;}&space;=&space;(\log{{Q}(w^{(n)}&space;|&space;\theta)}&space;-&space;\log{{P}(w^{(n)})}&space;))

该表达式对其所有参数均可导。

要得到第 n 个样本的完整代价函数：

1. 设性能（拟合数据）函数为：}&space;(w^{(n)},&space;\theta)})

因此，第 n 个权重样本的完整代价函数为：

2. }&space;(w^{(n)},&space;\theta)&space;}&space;=&space;{C^{(n)}&space;(w^{(n)},&space;\theta)&space;}&space;+&space;{P^{(n)}&space;(w^{(n)},&space;\theta)&space;})

我们可以通过蒙特卡洛采样来估计真实的完整代价函数（即多次前向传播网络并取总损失的平均值），然后使用该估计值进行反向传播。这种方法即使每次反向传播只进行少量实验，甚至只进行一次实验，也同样有效。

一些说明与总结

至此，《贝叶斯深度学习概览》教程就告一段落了。了解了这里的内容后，您可以根据自己的需求实现贝叶斯神经网络模型。

例如，您可以在每次采样时执行一次优化步骤，或者采用这种类似蒙特卡洛的方法多次收集损失、取其平均值后再进行优化。一切由您决定。

温馨提示：我们的贝叶斯层及工具类会在每次前向传播时自动计算各层的复杂度代价，因此您无需过多关注这一点。

参考文献：

• 查尔斯·布伦德尔、朱利安·科恩比斯、科雷·卡武克乔卢和达安·维尔斯特拉。神经网络中的权重不确定性。arXiv 预印本 arXiv:1505.05424，2015 年。

引用方式

如果您在研究中使用了 BLiTZ，可以按如下方式引用：

@misc{esposito2020blitzbdl,
    author = {皮耶罗·埃斯波西托},
    title = {BLiTZ - Torch Zoo 中的贝叶斯层（一个面向 Torch 的贝叶斯深度学习库）},
    year = {2020},
    publisher = {GitHub},
    journal = {GitHub 仓库},
    howpublished = {\url{https://github.com/piEsposito/blitz-bayesian-deep-learning/}},
}

制作：皮耶罗·埃斯波西托

BLiTZ 快速上手指南

BLiTZ (Bayesian Layers in Torch Zoo) 是一个基于 PyTorch 的轻量级扩展库，旨在帮助开发者轻松构建贝叶斯神经网络（BNN）。它允许你在不改变原有 PyTorch 层交互逻辑的前提下，为模型引入权重不确定性（Weight Uncertainty），从而获取预测结果的置信区间并计算模型复杂度成本。

环境准备

在开始之前，请确保你的开发环境满足以下要求：

• 操作系统: Linux, macOS 或 Windows
• Python 版本: 推荐 Python 3.8 - 3.9 (原文示例使用 3.9)
• 核心依赖:
  • PyTorch (建议安装最新稳定版)
  • NumPy
  • Scikit-learn (用于数据预处理和加载示例数据集)

安装步骤

你可以选择通过 pip、conda 或源码方式进行安装。国内用户若遇到下载速度慢的问题，建议使用国内镜像源加速。

方式一：使用 pip 安装（推荐）

# 使用官方源
pip install blitz-bayesian-pytorch

# 【推荐】国内用户使用清华镜像源加速
pip install blitz-bayesian-pytorch -i https://pypi.tuna.tsinghua.edu.cn/simple

方式二：使用 conda 安装

# 使用官方 channel
conda install -c conda-forge blitz-bayesian-pytorch

# 【推荐】国内用户使用中科大镜像源加速
conda install -c https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge blitz-bayesian-pytorch

方式三：源码安装（适合需要修改源码的开发者）

conda create -n blitz python=3.9
conda activate blitz
git clone https://github.com/piEsposito/blitz-bayesian-deep-learning.git
cd blitz-bayesian-deep-learning
pip install .

基本使用

以下是一个完整的回归任务示例，展示如何使用 BLiTZ 构建贝叶斯回归模型并评估预测置信区间。

1. 导入必要模块

除了常规的 PyTorch 模块外，我们需要从 blitz 导入 BayesianLinear 层和 variational_estimator 装饰器。

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np

# 从 BLiTZ 导入核心组件
from blitz.modules import BayesianLinear
from blitz.utils import variational_estimator

from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

2. 数据加载与预处理

加载波士顿房价数据集并进行标准化处理，随后转换为 PyTorch Tensor。

X, y = load_boston(return_X_y=True)
X = StandardScaler().fit_transform(X)
y = StandardScaler().fit_transform(np.expand_dims(y, -1))

X_train, X_test, y_train, y_test = train_test_split(X,
                                                    y,
                                                    test_size=.25,
                                                    random_state=42)

X_train, y_train = torch.tensor(X_train).float(), torch.tensor(y_train).float()
X_test, y_test = torch.tensor(X_test).float(), torch.tensor(y_test).float()

3. 定义贝叶斯回归模型

使用 @variational_estimator 装饰器修饰你的 nn.Module 类。这将自动注入处理贝叶斯特性所需的方法（如计算复杂度成本和多次采样前向传播）。

@variational_estimator
class BayesianRegressor(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        # 使用 BayesianLinear 替代普通的 nn.Linear
        self.blinear1 = BayesianLinear(input_dim, 512)
        self.blinear2 = BayesianLinear(512, output_dim)
        
    def forward(self, x):
        x_ = self.blinear1(x)
        x_ = F.relu(x_)
        return self.blinear2(x_)

4. 定义置信区间评估函数

该函数通过多次采样预测结果来计算均值和标准差，进而生成置信区间，并统计真实标签落在区间内的比例。

def evaluate_regression(regressor,
                        X,
                        y,
                        samples = 100,
                        std_multiplier = 2):
    preds = [regressor(X) for i in range(samples)]
    preds = torch.stack(preds)
    means = preds.mean(axis=0)
    stds = preds.std(axis=0)
    ci_upper = means + (std_multiplier * stds)
    ci_lower = means - (std_multiplier * stds)
    ic_acc = (ci_lower <= y) * (ci_upper >= y)
    ic_acc = ic_acc.float().mean()
    return ic_acc, (ci_upper >= y).float().mean(), (ci_lower <= y).float().mean()

5. 训练与评估循环

初始化模型和优化器。注意训练循环中的损失计算需使用 sample_elbo 方法，该方法会自动处理贝叶斯层的采样和复杂度成本计算。

# 初始化模型
regressor = BayesianRegressor(13, 1)
optimizer = optim.Adam(regressor.parameters(), lr=0.01)
criterion = torch.nn.MSELoss()

# 创建 DataLoader
ds_train = torch.utils.data.TensorDataset(X_train, y_train)
dataloader_train = torch.utils.data.DataLoader(ds_train, batch_size=16, shuffle=True)

ds_test = torch.utils.data.TensorDataset(X_test, y_test)
dataloader_test = torch.utils.data.DataLoader(ds_test, batch_size=16, shuffle=True)

# 训练循环
iteration = 0
for epoch in range(100):
    for i, (datapoints, labels) in enumerate(dataloader_train):
        optimizer.zero_grad()
        
        # 关键步骤：使用 sample_elbo 计算包含不确定性成本的损失
        loss = regressor.sample_elbo(inputs=datapoints,
                           labels=labels,
                           criterion=criterion,
                           sample_nbr=3)
        loss.backward()
        optimizer.step()
        
        iteration += 1
        if iteration % 100 == 0:
            ic_acc, under_ci_upper, over_ci_lower = evaluate_regression(regressor,
                                                                        X_test,
                                                                        y_test,
                                                                        samples=25,
                                                                        std_multiplier=3)
            
            print("CI acc: {:.2f}, CI upper acc: {:.2f}, CI lower acc: {:.2f}".format(ic_acc, under_ci_upper, over_ci_lower))
            print("Loss: {:.4f}".format(loss))