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

 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))

• 1.
• 2.
• 3.

班级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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

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

登录后复制

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

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.

因素

• 初始值 ( 火炬。张量或者可调用的返回火炬。张量或者 没有人)–要么是用于急切初始化的张量，要么是用于惰性初始化的可调用函数，要么是用作装饰的无。
• 限制 ( 限制)–火炬约束，默认为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

• 1.
• 2.
• 3.

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

登录后复制

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

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

因素

在先的；在前的–输入的分配对象或功能 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.

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.

请注意，与正常情况不同 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.

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.

采样在每次调用.__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))

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.

混合类

 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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.

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

登录后复制

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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.

注意到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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.

因素

• 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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.

因素

• 输入_尺寸 ( （同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)

• 1.
• 2.
• 3.
• 4.
• 5.

因素

• 输入_尺寸 ( （同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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.

因素

• 输入_尺寸 ( （同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)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

因素

• 输入_尺寸 ( （同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:  火炬。张量, 语境:  火炬。张量)→ 联盟[顺序[ 火炬。张量],  火炬。张量] [来源] ¶

培养:  弯曲件 ¶

 以前的 然后

原创作者: u_16120231 转载于: https://blog.51cto.com/u_16120231/11907320