pyro 概率编程语言能直接调用pytorch的save函数保存模型，贝叶斯神经网络-CFANZ编程社区

Neural Networks — Pyro documentation

https://docs.pyro.ai/en/stable/nn.html

docs.pyro.ai/en/stable/nn.html

神经网络¶

该模块pyro.nn提供在深度概率编程上下文中有用的神经网络模块的实现。

烟火模块¶

Pyro包括一个类PyroModule，的子类torch.nn.Module，其属性可以被火焰效果修改。若要创建可识别poutine的属性，请使用PyroParam结构或PyroSample结构:

my_module = PyroModule()
my_module.x = PyroParam(torch.tensor(1.), constraint=constraints.positive)
my_module.y = PyroSample(dist.Normal(0, 1))

班级PyroParam(初始值: 可选择的[联盟[火炬。张量, 请求即付的[[], 火炬。张量]]] = 没有人, 限制: 火炬.分布.约束.约束 = 真实(), 事件_尺寸: 可选择的[（同Internationalorganizations）国际组织] = 没有人)[来源]¶

碱基:tuple

声明的Pyro管理的可学习属性PyroModule，类似于pyro.param.

这可以用来设置PyroModule实例:

assert isinstance(my_module, PyroModule)
my_module.x = PyroParam(torch.zeros(4))                   # eager
my_module.y = PyroParam(lambda: torch.randn(4))           # lazy
my_module.z = PyroParam(torch.ones(4),                    # eager
                        constraint=constraints.positive,
                        event_dim=1)

或者作为惰性初始化属性的装饰者:

class MyModule(PyroModule):
    @PyroParam
    def x(self):
        return torch.zeros(4)

    @PyroParam
    def y(self):
        return torch.randn(4)

    @PyroParam(constraint=constraints.real, event_dim=1)
    def z(self):
        return torch.ones(4)

    def forward(self):
        return self.x + self.y + self.z  # accessed like a @property

因素

初始值 (火炬。张量或者可调用的返回火炬。张量或者没有人)–要么是用于急切初始化的张量，要么是用于惰性初始化的可调用函数，要么是用作装饰的无。
限制 (限制)–火炬约束，默认为constraints.real.
事件_尺寸 (（同Internationalorganizations）国际组织)–(可选)与baching无关的最右侧维度的数量。左边的维度将被视为批维度；如果param语句在二次抽样的样品板内，则参数的相应批次尺寸将相应地进行二次抽样。如果未指定，所有维度都将被视为事件变暗，并且不会执行二次采样。

初始值: 可选择的[联盟[火炬。张量, 请求即付的[[], 火炬。张量]]]¶

字段编号0的别名

限制: 火炬.分布.约束.约束¶

字段编号1的别名

事件_尺寸: 可选择的[（同Internationalorganizations）国际组织]¶

字段编号2的别名

班级高温样品(在先的；在前的: 联盟[火炬分配混合, 请求即付的[[烟火模块], 火炬分配混合]])[来源]¶

碱基:object

声明的一个烟火管理的随机属性PyroModule，类似于pyro.sample.

这可以用来设置PyroModule实例:

assert isinstance(my_module, PyroModule)
my_module.x = PyroSample(Normal(0, 1))                    # independent
my_module.y = PyroSample(lambda self: Normal(self.x, 1))  # dependent

或者作为惰性初始化方法的装饰者:

class MyModule(PyroModule):
    @PyroSample
    def x(self):
        return Normal(0, 1)       # independent

    @PyroSample
    def y(self):
        return Normal(self.x, 1)  # dependent

    def forward(self):
        return self.y             # accessed like a @property

因素

在先的；在前的–输入的分配对象或功能PyroModule情况self并返回分发对象。

在先的；在前的: 联盟[火炬分配混合, 请求即付的[[烟火模块], 火炬分配混合]]¶

班级烟火模块(名字: 潜艇用热中子反应堆（submarine thermal reactor的缩写） = '')[来源]¶

碱基:torch.nn.modules.module.Module

的子类torch.nn.Module它的属性可以被火焰效果修改。可以使用辅助对象设置属性PyroParam和PyroSample、和方法可以由pyro_method() .

因素

要创建Pyro管理的参数属性，请使用以下任一方法设置该属性torch.nn.Parameter(对于无约束参数)或PyroParam(对于受约束的参数)。读取该属性将触发一个pyro.param声明。例如:

# Create Pyro-managed parameter attributes.
my_module = PyroModule()
my_module.loc = nn.Parameter(torch.tensor(0.))
my_module.scale = PyroParam(torch.tensor(1.),
                            constraint=constraints.positive)
# Read the attributes.
loc = my_module.loc  # Triggers a pyro.param statement.
scale = my_module.scale  # Triggers another pyro.param statement.

请注意，与正常情况不同torch.nn.Modules，PyroModule不应向注册pyro.module声明。PyroModules可以包含其他PyroModules和正常torch.nn.Module南访问正常的torch.nn.Module的属性PyroModule触发一个pyro.module声明。如果是倍数PyroModule出现在单个Pyro模型或指南中，它们应该包含在单个根中PyroModule对于那个模型。

PyroModules将数据与每个的参数存储同步setattr, getattr，以及delattr事件，基于属性的嵌套名称:

环境mod.x = x_init尝试阅读x从参数商店。如果在参数存储中找到一个值，该值将被复制到mod和x_init被忽略；否则x_init被复制到两者中mod和参数存储。
阅读mod.x尝试阅读x从参数商店。如果在参数存储中找到一个值，该值将被复制到mod；否则mod的值被复制到param存储中。最后mod和param store同意返回一个值。
删除del mod.x从两者中移除一个值mod和参数存储。

注意二PyroModule将与全局参数存储同步，因此包含相同的数据。当创建PyroModule，然后删除它，再用相同的名称创建另一个，后者将用前者在param存储中的数据填充。为了避免这种持久性pyro.clear_param_store()或者打电话clear()删除前PyroModule .

PyroModule可以直接使用torch.save() / torch.load()或者间接地使用参数存储的save() / load()。注意到torch.load()将被param存储区中的任何值覆盖，因此最安全的做法是pyro.clear_param_store()装货前。

样品

若要创建烟火管理的随机属性，请使用PyroSample帮助器，指定先前的分布。读取该属性将触发一个pyro.sample声明。例如:

# Create Pyro-managed random attributes.
my_module.x = PyroSample(dist.Normal(0, 1))
my_module.y = PyroSample(lambda self: dist.Normal(self.loc, self.scale))

# Sample the attributes.
x = my_module.x  # Triggers a pyro.sample statement.
y = my_module.y  # Triggers one pyro.sample + two pyro.param statements.

采样在每次调用.__call__()或由修饰的方法pyro_method()。因为示例语句在Pyro跟踪中只能出现一次，所以您应该确保对示例属性的跟踪访问被包装在对.__call__()或由修饰的方法pyro_method() .

要使现有的模块具有概率性，您可以创建一个子类并用PyroSample学生:

class RandomLinear(nn.Linear, PyroModule):  # used as a mixin
    def __init__(self, in_features, out_features):
        super().__init__(in_features, out_features)
        self.weight = PyroSample(
            lambda self: dist.Normal(0, 1)
                             .expand([self.out_features,
                                      self.in_features])
                             .to_event(2))

混合类

PyroModule可用作mixin类，并支持动态创建mixin的简单语法，例如，以下内容是等效的:

# Version 1. create a named mixin class
class PyroLinear(nn.Linear, PyroModule):
    pass

m.linear = PyroLinear(m, n)

# Version 2. create a dynamic mixin class
m.linear = PyroModule[nn.Linear](m, n)

这种符号可以递归地用于创建贝叶斯模块，例如:

model = PyroModule[nn.Sequential](
    PyroModule[nn.Linear](28 * 28, 100),
    PyroModule[nn.Sigmoid](),
    PyroModule[nn.Linear](100, 100),
    PyroModule[nn.Sigmoid](),
    PyroModule[nn.Linear](100, 10),
)
assert isinstance(model, nn.Sequential)
assert isinstance(model, PyroModule)

# Now we can be Bayesian about weights in the first layer.
model[0].weight = PyroSample(
    prior=dist.Normal(0, 1).expand([28 * 28, 100]).to_event(2))
guide = AutoDiagonalNormal(model)

注意到PyroModule[...]不递归混合PyroModule输入的子模块Module；因此，我们需要包装nn.Sequential以上。

因素

名字 (潜艇用热中子反应堆（submarine thermal reactor的缩写）)–根PyroModule的可选名称。这在另一个高温模块的子高温模块中被忽略。

添加模块(名字: 潜艇用热中子反应堆（submarine thermal reactor的缩写）, 组件: 可选择的[火炬. nn .模块.模块.模块])→ 没有人[来源]¶

向当前模块添加子模块。

命名火焰参数(前缀: 潜艇用热中子反应堆（submarine thermal reactor的缩写） = '', 递归: 弯曲件 = 真实的)→ 迭代程序[元组[潜艇用热中子反应堆（submarine thermal reactor的缩写）, 火炬. nn .参数.参数]][来源]¶

返回PyroModule参数的迭代器，产生参数名和参数本身。

因素

前缀 (潜艇用热中子反应堆（submarine thermal reactor的缩写）)–添加到所有参数名称前面的前缀。
递归 (弯曲件)–如果为真，则产生该模块和所有子模块的参数。否则，只生成作为该模块直接成员的参数。

生成包含名称和参数的元组的生成器

培养: 弯曲件¶

高温法(【数学】函数: 请求即付的[[pyro.nn .模块. _PyroModule, pyro.nn .模块_P], pyro.nn .模块_T])→ 请求即付的[[pyro.nn .模块. _PyroModule, pyro.nn .模块_P], pyro.nn .模块_T][来源]¶

控件的顶级方法的装饰器PyroModule启用烟火效果和缓存pyro.sample声明。

这应该应用于所有读取Pyro管理的属性的公共方法，但对于.forward().

清楚的(现代的: 火模块)→ 没有人[来源]¶

从两个PyroModule和参数存储。

因素

现代的 (烟火模块)–要清除的模块。

to_pyro_module_(m: 火炬. nn .模块.模块.模块, 递归: 弯曲件 = 真实的)→ 没有人[来源]¶

将普通的torch.nn.Module实例添加到PyroModule 原状.

这对于向第三方模块添加烟火效果很有用:不需要修改第三方代码。例如:

model = nn.Sequential(
    nn.Linear(28 * 28, 100),
    nn.Sigmoid(),
    nn.Linear(100, 100),
    nn.Sigmoid(),
    nn.Linear(100, 10),
)
to_pyro_module_(model)
assert isinstance(model, PyroModule[nn.Sequential])
assert isinstance(model[0], PyroModule[nn.Linear])

# Now we can attempt to be fully Bayesian:
for m in model.modules():
    for name, value in list(m.named_parameters(recurse=False)):
        setattr(m, name, PyroSample(prior=dist.Normal(0, 1)
                                              .expand(value.shape)
                                              .to_event(value.dim())))
guide = AutoDiagonalNormal(model)

因素

m (torch.nn .模块)–一个模块实例。
递归 (弯曲件)–是否将子模块转换为PyroModules .

班级高温模块列表(模块)[来源]¶

碱基:torch.nn.modules.container.ModuleList, pyro.nn.module.PyroModule

自回归NN¶

班级自回归NN(输入_尺寸: （同Internationalorganizations）国际组织, 隐藏_变暗: 目录[（同Internationalorganizations）国际组织], 参数_尺寸: 目录[（同Internationalorganizations）国际组织] = [1, 1], 排列: 可选择的[火炬。龙腾传感器] = 没有人, 跳过_连接: 弯曲件 = 错误的, 非线性: 火炬. nn .模块.模块.模块 = ReLU())[来源]¶

碱基:pyro.nn.auto_reg_nn.ConditionalAutoRegressiveNN

仿自回归神经网络的实现。

示例用法:

>>> x = torch.randn(100, 10)
>>> arn = AutoRegressiveNN(10, [50], param_dims=[1])
>>> p = arn(x)  # 1 parameters of size (100, 10)
>>> arn = AutoRegressiveNN(10, [50], param_dims=[1, 1])
>>> m, s = arn(x) # 2 parameters of size (100, 10)
>>> arn = AutoRegressiveNN(10, [50], param_dims=[1, 5, 3])
>>> a, b, c = arn(x) # 3 parameters of sizes, (100, 1, 10), (100, 5, 10), (100, 3, 10)

因素

输入_尺寸 (（同Internationalorganizations）国际组织)–输入变量的维度
隐藏_变暗 (目录[（同Internationalorganizations）国际组织])–每层隐藏单元的维度
参数_尺寸 (目录[（同Internationalorganizations）国际组织])–当p_n > 1时，将输出整形为param_dims中p_n的dimension (p_n，input_dim)参数，当p_n == 1时，整形为dimension (input_dim)参数。默认为[1，1]，即输出维数(input_dim)的两个参数，这对逆自回归流很有用。
排列 (火炬。龙腾传感器)–应用于输入并控制自回归因子分解顺序的可选排列。特别地，对于单位置换，自回归结构使得雅可比矩阵是上三角的。默认情况下，这是随机选择的。
跳过_连接 (弯曲件)–是否添加从输入到输出的跳过连接。
非线性 (torch.nn .模块)–前馈网络中使用的非线性，如torch.nn.ReLU()。请注意，最终网络输出没有应用非线性，因此输出是一个无界实数。

参考:

制造商:用于分布估计的屏蔽自动编码器[arXiv:1502.03509]马修·杰曼、凯罗尔·格雷戈、伊恩·默里、雨果·拉罗彻尔

向前(x: 火炬。张量)→ 联盟[顺序[火炬。张量], 火炬。张量][来源]¶

培养: 弯曲件¶

丹森¶

班级丹森(输入_尺寸: （同Internationalorganizations）国际组织, 隐藏_变暗: 目录[（同Internationalorganizations）国际组织], 参数_尺寸: 目录[（同Internationalorganizations）国际组织] = [1, 1], 非线性: 火炬. nn .模块.模块.模块 = ReLU())[来源]¶

碱基:pyro.nn.dense_nn.ConditionalDenseNN

简单的密集前馈网络的实现，用于例如一些条件流，例如pyro.distributions.transforms.ConditionalPlanarFlow和其他无条件流，例如pyro.distributions.transforms.AffineCoupling不需要自回归网络。

示例用法:

>>> input_dim = 10
>>> context_dim = 5
>>> z = torch.rand(100, context_dim)
>>> nn = DenseNN(context_dim, [50], param_dims=[1, input_dim, input_dim])
>>> a, b, c = nn(z)  # parameters of size (100, 1), (100, 10), (100, 10)

因素

输入_尺寸 (（同Internationalorganizations）国际组织)–输入的维度
隐藏_变暗 (目录[（同Internationalorganizations）国际组织])–每层隐藏单元的维度
参数_尺寸 (目录[（同Internationalorganizations）国际组织])–当p_n > 1时，将输出整形为param_dims中p_n的dimension (p_n，)参数，当p_n == 1时，整形为dimension()参数。默认为[1，1]，即输出dimension()的两个参数。
非线性 (torch.nn .模块)–前馈网络中使用的非线性，如torch.nn.ReLU()。请注意，最终网络输出没有应用非线性，因此输出是一个无界实数。

向前(x: 火炬。张量)→ 联盟[顺序[火炬。张量], 火炬。张量][来源]¶

培养: 弯曲件¶

条件句¶

班级条件句(输入_尺寸: （同Internationalorganizations）国际组织, context_dim: （同Internationalorganizations）国际组织, 隐藏_变暗: 目录[（同Internationalorganizations）国际组织], 参数_尺寸: 目录[（同Internationalorganizations）国际组织] = [1, 1], 排列: 可选择的[火炬。龙腾传感器] = 没有人, 跳过_连接: 弯曲件 = 错误的, 非线性: 火炬. nn .模块.模块.模块 = ReLU())[来源]¶

碱基:torch.nn.modules.module.Module

一种仿自回归神经网络的实现，可以输入额外的上下文变量。(参见参考文献[2]第3.3节，了解条件生成架构如何工作。)

示例用法:

>>> x = torch.randn(100, 10)
>>> y = torch.randn(100, 5)
>>> arn = ConditionalAutoRegressiveNN(10, 5, [50], param_dims=[1])
>>> p = arn(x, context=y)  # 1 parameters of size (100, 10)
>>> arn = ConditionalAutoRegressiveNN(10, 5, [50], param_dims=[1, 1])
>>> m, s = arn(x, context=y) # 2 parameters of size (100, 10)
>>> arn = ConditionalAutoRegressiveNN(10, 5, [50], param_dims=[1, 5, 3])
>>> a, b, c = arn(x, context=y) # 3 parameters of sizes, (100, 1, 10), (100, 5, 10), (100, 3, 10)

因素

输入_尺寸 (（同Internationalorganizations）国际组织)–输入变量的维度
context_dim (（同Internationalorganizations）国际组织)–上下文变量的维度
隐藏_变暗 (目录[（同Internationalorganizations）国际组织])–每层隐藏单元的维度
参数_尺寸 (目录[（同Internationalorganizations）国际组织])–当p_n > 1时，将输出整形为param_dims中p_n的dimension (p_n，input_dim)参数，当p_n == 1时，整形为dimension (input_dim)参数。默认为[1，1]，即输出维数(input_dim)的两个参数，这对逆自回归流很有用。
排列 (火炬。龙腾传感器)–应用于输入并控制自回归因子分解顺序的可选排列。特别地，对于单位置换，自回归结构使得雅可比矩阵是上三角的。默认情况下，这是随机选择的。
跳过_连接 (弯曲件)–是否添加从输入到输出的跳过连接。
非线性 (torch.nn .模块)–前馈网络中使用的非线性，如torch.nn.ReLU()。请注意，最终网络输出没有应用非线性，因此输出是一个无界实数。

参考:

1.制造商:用于分布估计的屏蔽自动编码器[arXiv:1502.03509]马修·杰曼、凯罗尔·格雷戈、伊恩·默里、雨果·拉罗彻尔

2.图形模型中序列蒙特卡罗的推理网络[arXiv:1602.06701]

向前(x: 火炬。张量, 语境: 可选择的[火炬。张量] = 没有人)→ 联盟[顺序[火炬。张量], 火炬。张量][来源]¶

获取排列()→ 火炬。龙腾传感器[来源]¶

将排列应用于输入(默认情况下，这是随机选择的)

培养: 弯曲件¶

ConditionalDenseNN¶

班级ConditionalDenseNN(输入_尺寸: （同Internationalorganizations）国际组织, context_dim: （同Internationalorganizations）国际组织, 隐藏_变暗: 目录[（同Internationalorganizations）国际组织], 参数_尺寸: 目录[（同Internationalorganizations）国际组织] = [1, 1], 非线性: 火炬. nn .模块.模块.模块 = ReLU())[来源]¶

碱基:torch.nn.modules.module.Module

采用上下文变量的简单密集前馈网络的实现，用于例如一些条件流，例如pyro.distributions.transforms.ConditionalAffineCoupling.

示例用法:

>>> input_dim = 10
>>> context_dim = 5
>>> x = torch.rand(100, input_dim)
>>> z = torch.rand(100, context_dim)
>>> nn = ConditionalDenseNN(input_dim, context_dim, [50], param_dims=[1, input_dim, input_dim])
>>> a, b, c = nn(x, context=z)  # parameters of size (100, 1), (100, 10), (100, 10)

因素

输入_尺寸 (（同Internationalorganizations）国际组织)–输入的维度
context_dim (（同Internationalorganizations）国际组织)–上下文变量的维度
隐藏_变暗 (目录[（同Internationalorganizations）国际组织])–每层隐藏单元的维度
参数_尺寸 (目录[（同Internationalorganizations）国际组织])–当p_n > 1时，将输出整形为param_dims中p_n的dimension (p_n，)参数，当p_n == 1时，整形为dimension()参数。默认为[1，1]，即输出dimension()的两个参数。
非线性 (torch.nn .模块)–前馈网络中使用的非线性，如torch.nn.ReLU()。请注意，最终网络输出没有应用非线性，因此输出是一个无界实数。

向前(x: 火炬。张量, 语境: 火炬。张量)→ 联盟[顺序[火炬。张量], 火炬。张量][来源]¶

培养: 弯曲件¶

以前的然后