高斯过程¶

请参阅高斯过程教程以获取介绍。

class Parameterized[source]¶

基础类：pyro.nn.module.PyroModule

PyroModule 的一个包装器，其参数可以设置约束和先验。

默认情况下，当我们为参数设置先验时，将自动创建一个Delta指南。我们可以使用autoguide()方法来设置其他自动指南。

示例：

>>> class Linear(Parameterized):
...     def __init__(self, a, b):
...         super().__init__()
...         self.a = Parameter(a)
...         self.b = Parameter(b)
...
...     def forward(self, x):
...         return self.a * x + self.b
...
>>> linear = Linear(torch.tensor(1.), torch.tensor(0.))
>>> linear.a = PyroParam(torch.tensor(1.), constraints.positive)
>>> linear.b = PyroSample(dist.Normal(0, 1))
>>> linear.autoguide("b", dist.Normal)
>>> assert "a_unconstrained" in dict(linear.named_parameters())
>>> assert "b_loc" in dict(linear.named_parameters())
>>> assert "b_scale_unconstrained" in dict(linear.named_parameters())

请注意，默认情况下，参数的数据类型是浮点数 torch.Tensor （除非我们使用 torch.set_default_dtype() 来更改默认的张量类型）。要将这些参数转换为正确的数据类型或GPU设备，我们可以调用诸如 double() 或 cuda() 的方法。更多信息请参见 torch.nn.Module。

set_prior(name, prior)[source]¶

为参数设置先验。

Parameters

name (str) – 参数的名称。
prior (Distribution) – 一个Pyro先验分布。

autoguide(name, dist_constructor)[source]¶

为现有参数设置自动指南，参数名为 name（模仿模块 pyro.infer.autoguide 的行为）。

注意

dist_constructor 应该是以下之一 Delta, Normal, 和 MultivariateNormal。如果需要，未来将支持更多的分布构造函数。

Parameters

name (str) – 参数的名称。
dist_constructor – 一个 Distribution 构造函数。

set_mode(mode)[source]¶

设置此对象的mode以便能够在随机函数中使用其参数。如果mode="model"，参数将从其先验中获取值。如果mode="guide"，值将从其指南中抽取。

注意

此方法自动为属于Parameterized类的子模块设置mode。

Parameters: mode (str) – 可以是“model”或“guide”。

property mode¶

training: bool¶

模型¶

GP模型¶

class GPModel(X, y, kernel, mean_function=None, jitter=1e-06)[source]¶

基础类：pyro.contrib.gp.parameterized.Parameterized

高斯过程模型的基础类。

高斯过程的核心是一个协方差函数 \(k\)，它控制着输入点之间的相似性。给定 \(k\)，我们可以通过多元正态分布建立一个关于函数 \(f\) 的分布。

\[p(f(X)) = \mathcal{N}(0, k(X, X)),\]

其中 \(X\) 是任意一组输入点，\(k(X, X)\) 是一个协方差矩阵，其条目是 \(k\) 在输入对 \((x, z)\) 上的输出 \(k(x, z)\)。这个分布通常表示为

\[f \sim \mathcal{GP}(0, k).\]

注意

通常，除了协方差矩阵 \(k\) 之外，高斯过程还可以通过均值函数 \(m\) 来指定（默认情况下是一个零值函数）。在这种情况下，其分布将为

\[p(f(X)) = \mathcal{N}(m(X), k(X, X)).\]

高斯过程模型是Parameterized的子类。因此，可以通过使用Parameterized中的相应方法来学习、设置先验或固定其参数。定义高斯过程模型的典型方式是

>>> X = torch.tensor([[1., 5, 3], [4, 3, 7]])
>>> y = torch.tensor([2., 1])
>>> kernel = gp.kernels.RBF(input_dim=3)
>>> kernel.variance = pyro.nn.PyroSample(dist.Uniform(torch.tensor(0.5), torch.tensor(1.5)))
>>> kernel.lengthscale = pyro.nn.PyroSample(dist.Uniform(torch.tensor(1.0), torch.tensor(3.0)))
>>> gpr = gp.models.GPRegression(X, y, kernel)

有两种方法可以训练高斯过程模型：

在model()上使用MCMC算法（在模块pyro.infer.mcmc中）来获取高斯过程参数的后验样本。例如：

>>> hmc_kernel = HMC(gpr.model)
>>> mcmc = MCMC(hmc_kernel, num_samples=10)
>>> mcmc.run()
>>> ls_name = "kernel.lengthscale"
>>> posterior_ls = mcmc.get_samples()[ls_name]

在model()和guide()对上使用变分推断：

>>> optimizer = torch.optim.Adam(gpr.parameters(), lr=0.01)
>>> loss_fn = pyro.infer.TraceMeanField_ELBO().differentiable_loss
>>>
>>> for i in range(1000):
...     optimizer.zero_grad()
...     loss = loss_fn(gpr.model, gpr.guide)  
...     loss.backward()  
...     optimizer.step()

要对新数据集进行预测，只需像使用任何PyTorch的torch.nn.Module一样使用forward()：

>>> Xnew = torch.tensor([[2., 3, 1]])
>>> f_loc, f_cov = gpr(Xnew, full_cov=True)

参考：

[1] 机器学习中的高斯过程, 卡尔·E·拉斯穆森, 克里斯托弗·K·I·威廉姆斯

Parameters

X (torch.Tensor) – 用于训练的输入数据。其第一个维度是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。它的最后一个维度是数据点的数量。
kernel (Kernel) – 一个Pyro内核对象，它是协方差函数 \(k\)。
mean_function (callable) – 一个可选的均值函数 \(m\)，用于这个高斯过程。默认情况下，我们使用零均值。
jitter (float) – 一个小的正数项，它被添加到协方差矩阵的对角线部分，以帮助稳定其Cholesky分解。

model()[source]¶: 一个“模型”随机函数。如果self.y是None，此方法返回高斯过程先验的均值和方差。

guide()[source]¶: 一个用于变分推断方法的“引导”随机函数。它还为预测方法forward()提供后验信息。

forward(Xnew, full_cov=False)[source]¶

计算高斯过程后验在测试输入数据 \(X_{new}\) 上的均值和协方差矩阵（或方差）：

\[p(f^* \mid X_{new}, X, y, k, \theta),\]

其中 \(\theta\) 是这个模型的参数。

注意

模型的参数 \(\theta\) 与核函数的参数已通过训练过程（MCMC 或 SVI）学习得到。

Parameters

Xnew (torch.Tensor) – 用于测试的输入数据。请注意 Xnew.shape[1:] 必须与 X.shape[1:] 相同。
full_cov (bool) – 一个标志，用于决定我们是否要预测完整的协方差矩阵或仅仅是方差。

Returns

位置和协方差矩阵（或方差）的 \(p(f^*(X_{new}))\)

Return type

tuple(torch.Tensor, torch.Tensor)

set_data(X, y=None)[来源]¶

为高斯过程模型设置数据。

使用此方法的一些示例如下：

在稀疏变分模型上进行批量训练：

>>> Xu = torch.tensor([[1., 0, 2]])  # inducing input
>>> likelihood = gp.likelihoods.Gaussian()
>>> vsgp = gp.models.VariationalSparseGP(X, y, kernel, Xu, likelihood)
>>> optimizer = torch.optim.Adam(vsgp.parameters(), lr=0.01)
>>> loss_fn = pyro.infer.TraceMeanField_ELBO().differentiable_loss
>>> batched_X, batched_y = X.split(split_size=10), y.split(split_size=10)
>>> for Xi, yi in zip(batched_X, batched_y):
...     optimizer.zero_grad()
...     vsgp.set_data(Xi, yi)
...     loss = loss_fn(vsgp.model, vsgp.guide)  
...     loss.backward()  
...     optimizer.step()

制作一个两层高斯过程随机函数：

>>> gpr1 = gp.models.GPRegression(X, None, kernel)
>>> Z, _ = gpr1.model()
>>> gpr2 = gp.models.GPRegression(Z, y, kernel)
>>> def two_layer_model():
...     Z, _ = gpr1.model()
...     gpr2.set_data(Z, y)
...     return gpr2.model()

参考文献：

[1] 可扩展的变分高斯过程分类, James Hensman, Alexander G. de G. Matthews, Zoubin Ghahramani

[2] 深度高斯过程, 安德烈亚斯·C·达米安努, 尼尔·D·劳伦斯

Parameters

X (torch.Tensor) – 用于训练的输入数据。其第一个维度是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。它的最后一个维度是数据点的数量。

training: bool¶

GP回归¶

class GPRegression(X, y, kernel, noise=None, mean_function=None, jitter=1e-06)[源代码]¶

基础类：pyro.contrib.gp.models.model.GPModel

高斯过程回归模型。

高斯过程的核心是一个协方差函数 \(k\)，它控制着输入点之间的相似性。给定 \(k\)，我们可以通过多元正态分布建立一个关于函数 \(f\) 的分布。

\[p(f(X)) = \mathcal{N}(0, k(X, X)),\]

其中 \(X\) 是任意一组输入点，\(k(X, X)\) 是一个协方差矩阵，其条目是 \(k\) 在输入对 \((x, z)\) 上的输出 \(k(x, z)\)。这个分布通常表示为

\[f \sim \mathcal{GP}(0, k).\]

注意

通常，除了协方差矩阵 \(k\) 之外，高斯过程还可以通过均值函数 \(m\) 来指定（默认情况下是一个零值函数）。在这种情况下，其分布将为

\[p(f(X)) = \mathcal{N}(m(X), k(X, X)).\]

给定输入 \(X\) 和它们的噪声观测值 \(y\)，高斯过程回归模型的形式为

\[\begin{split}f &\sim \mathcal{GP}(0, k(X, X)),\\ y & \sim f + \epsilon,\end{split}\]

其中 \(\epsilon\) 是高斯噪声。

注意

该模型的训练复杂度为\(\mathcal{O}(N^3)\)，测试复杂度为\(\mathcal{O}(N^3)\)。这里，\(N\)是训练输入的数量。

参考：

[1] 机器学习中的高斯过程, 卡尔·E·拉斯穆森, 克里斯托弗·K·I·威廉姆斯

Parameters

X (torch.Tensor) – 用于训练的输入数据。其第一个维度是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。它的最后一个维度是数据点的数量。
kernel (Kernel) – 一个Pyro内核对象，它是协方差函数 \(k\)。
噪声 (torch.Tensor) – 该模型的高斯噪声的方差。
mean_function (callable) – 一个可选的均值函数 \(m\)，用于这个高斯过程。默认情况下，我们使用零均值。
jitter (float) – 一个小的正数项，它被添加到协方差矩阵的对角线部分，以帮助稳定其Cholesky分解。

model()[source]¶

guide()[source]¶

forward(Xnew, full_cov=False, noiseless=True)[source]¶

计算高斯过程后验在测试输入数据 \(X_{new}\) 上的均值和协方差矩阵（或方差）：

\[p(f^* \mid X_{new}, X, y, k, \epsilon) = \mathcal{N}(loc, cov).\]

注意

噪声参数 noise (\(\epsilon\)) 与核函数的参数一起通过训练过程（MCMC 或 SVI）学习得到。

Parameters

Xnew (torch.Tensor) – 用于测试的输入数据。注意 Xnew.shape[1:] 必须与 self.X.shape[1:] 相同。
full_cov (bool) – 一个标志，用于决定我们是否要预测完整的协方差矩阵或仅仅是方差。
无噪声 (bool) – 一个标志，用于决定我们是否希望在预测输出中包含噪声。

Returns

位置和协方差矩阵（或方差）的 \(p(f^*(X_{new}))\)

Return type

tuple(torch.Tensor, torch.Tensor)

iter_sample(noiseless=True)[来源]¶

从高斯过程后验中迭代构建样本。

回想一下，在测试输入点 \(X_{new}\) 处，后验分布是多元高斯分布，其均值和协方差矩阵由 forward() 给出。

此方法从该多元高斯分布中进行惰性采样。这种方法的优点是后续的查询点可以依赖于先前的点。当查询由优化例程完成时，这种方法特别有用。

注意

噪声参数 noise (\(\epsilon\)) 与核函数的参数一起通过训练过程（MCMC 或 SVI）学习得到。

Parameters: 无噪声 (bool) – 一个标志，用于决定我们是否要在GP后验固有的噪声之外向样本添加采样噪声。
Returns: 采样器
Return type: 函数

training: bool¶

稀疏高斯过程回归¶

class SparseGPRegression(X, y, kernel, Xu, noise=None, mean_function=None, approx=None, jitter=1e-06)[source]¶

基础类：pyro.contrib.gp.models.model.GPModel

稀疏高斯过程回归模型。

在GPRegression模型中，当输入数据\(X\)的数量很大时，协方差矩阵\(k(X, X)\)将需要大量的计算步骤来计算其逆矩阵（用于对数似然和预测）。通过引入一个额外的诱导输入参数\(X_u\)，我们可以通过低秩Nyström近似\(Q\)来近似\(k(X, X)\)（参见参考文献[1]），从而减少计算成本，其中

\[Q = k(X, X_u) k(X_u,X_u)^{-1} k(X_u, X).\]

给定输入 \(X\)，它们的噪声观测值 \(y\)，以及诱导输入参数 \(X_u\)，模型的形式如下：

\[\begin{split}u & \sim \mathcal{GP}(0, k(X_u, X_u)),\\ f & \sim q(f \mid X, X_u) = \mathbb{E}_{p(u)}q(f\mid X, X_u, u),\\ y & \sim f + \epsilon,\end{split}\]

其中 \(\epsilon\) 是高斯噪声，条件分布 \(q(f\mid X, X_u, u)\) 是以下分布的近似：

\[p(f\mid X, X_u, u) = \mathcal{N}(m, k(X, X) - Q),\]

其项 \(m\) 和 \(k(X, X) - Q\) 是从联合多元正态分布中导出的：

\[[f, u] \sim \mathcal{GP}(0, k([X, X_u], [X, X_u])).\]

该类实现了三种近似方法：

确定性训练条件 (DTC):

\[q(f\mid X, X_u, u) = \mathcal{N}(m, 0),\]

这反过来将意味着

\[f \sim \mathcal{N}(0, Q).\]
完全独立训练条件（FITC）：

\[q(f\mid X, X_u, u) = \mathcal{N}(m, diag(k(X, X) - Q)),\]

这反过来将纠正DTC中近似的对角部分：

\[f \sim \mathcal{N}(0, Q + diag(k(X, X) - Q)).\]
变分自由能（VFE），类似于DTC，但在模型的对数似然中有一个额外的trace_term。这个额外的项使得“VFE”等同于VariationalSparseGP中的变分方法（参见参考文献[2]）。

注意

该模型的训练复杂度为\(\mathcal{O}(NM^2)\)，测试复杂度为\(\mathcal{O}(NM^2)\)。这里，\(N\)是训练输入的数量， \(M\)是诱导输入的数量。

参考文献：

[1] 稀疏近似高斯过程回归的统一视角, Joaquin Quiñonero-Candela, Carl E. Rasmussen

[2] 稀疏高斯过程中诱导变量的变分学习, Michalis Titsias

Parameters

X (torch.Tensor) – 用于训练的输入数据。其第一个维度是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。它的最后一个维度是数据点的数量。
kernel (Kernel) – 一个Pyro内核对象，它是协方差函数 \(k\)。
Xu (torch.Tensor) – 诱导点的初始值，这些是我们模型的参数。
噪声 (torch.Tensor) – 该模型的高斯噪声的方差。
mean_function (callable) – 一个可选的均值函数 \(m\)，用于这个高斯过程。默认情况下，我们使用零均值。
approx (str) – 近似方法之一：“DTC”、“FITC”和“VFE”（默认）。
jitter (float) – 一个小的正数项，它被添加到协方差矩阵的对角线部分，以帮助稳定其Cholesky分解。
name (str) – 此模型的名称。

model()[source]¶

guide()[source]¶

forward(Xnew, full_cov=False, noiseless=True)[source]¶

计算高斯过程后验在测试输入数据 \(X_{new}\) 上的均值和协方差矩阵（或方差）：

\[p(f^* \mid X_{new}, X, y, k, X_u, \epsilon) = \mathcal{N}(loc, cov).\]

注意

噪声参数 noise (\(\epsilon\))，诱导点参数 Xu，以及核函数的参数已经通过训练过程（MCMC 或 SVI）学习得到。

Parameters

Xnew (torch.Tensor) – 用于测试的输入数据。注意 Xnew.shape[1:] 必须与 self.X.shape[1:] 相同。
full_cov (bool) – 一个标志，用于决定我们是否要预测完整的协方差矩阵或仅仅是方差。
无噪声 (bool) – 一个标志，用于决定我们是否希望在预测输出中包含噪声。

Returns

位置和协方差矩阵（或方差）的 \(p(f^*(X_{new}))\)

Return type

tuple(torch.Tensor, torch.Tensor)

training: bool¶

变分高斯过程¶

class VariationalGP(X, y, kernel, likelihood, mean_function=None, latent_shape=None, whiten=False, jitter=1e-06)[源代码]¶

基础类：pyro.contrib.gp.models.model.GPModel

变分高斯过程模型。

该模型处理高斯和非高斯似然。给定输入\(X\)及其噪声观测值\(y\)，模型的形式为

\[\begin{split}f &\sim \mathcal{GP}(0, k(X, X)),\\ y & \sim p(y) = p(y \mid f) p(f),\end{split}\]

其中 \(p(y \mid f)\) 是似然函数。

我们将在这个模型中使用变分方法，通过近似\(q(f)\)到后验\(p(f\mid y)\)。具体来说，\(q(f)\)将是一个具有两个参数f_loc和f_scale_tril的多元正态分布，这些参数将在变分推断过程中学习。

注意

该模型可以看作是VariationalSparseGP模型的一个特殊版本，其中\(X_u = X\)。

注意

该模型的训练复杂度为\(\mathcal{O}(N^3)\)，测试复杂度为\(\mathcal{O}(N^3)\)。这里，\(N\)是训练输入的数量。变分参数的大小为\(\mathcal{O}(N^2)\)。

Parameters

X (torch.Tensor) – 用于训练的输入数据。其第一个维度是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。它的最后一个维度是数据点的数量。
kernel (Kernel) – 一个Pyro内核对象，它是协方差函数 \(k\)。
likelihood (likelihood Likelihood) – 一个似然对象。
mean_function (callable) – 一个可选的均值函数 \(m\)，用于这个高斯过程。默认情况下，我们使用零均值。
latent_shape (torch.Size) – 潜在过程的形状（batch_shape 的 \(q(f)\)）。默认情况下，它等于输出批次形状 y.shape[:-1]。对于多类分类问题，latent_shape[-1] 应该对应于类别数量。
whiten (bool) – 一个标志，用于指示变分参数 f_loc 和 f_scale_tril 是否通过 Lff 的逆进行转换，其中 Lff 是 \(kernel(X, X)\) 的下三角分解。启用此标志将有助于优化。
jitter (float) – 一个小的正数项，它被添加到协方差矩阵的对角线部分，以帮助稳定其Cholesky分解。

model()[source]¶

guide()[source]¶

forward(Xnew, full_cov=False)[source]¶

计算高斯过程后验在测试输入数据 \(X_{new}\) 上的均值和协方差矩阵（或方差）：

\[p(f^* \mid X_{new}, X, y, k, f_{loc}, f_{scale\_tril}) = \mathcal{N}(loc, cov).\]

注意

变分参数 f_loc, f_scale_tril 以及核函数的参数已经通过训练过程（MCMC 或 SVI）学习得到。

Parameters

Xnew (torch.Tensor) – 用于测试的输入数据。注意 Xnew.shape[1:] 必须与 self.X.shape[1:] 相同。
full_cov (bool) – 一个标志，用于决定我们是否要预测完整的协方差矩阵或仅仅是方差。

Returns

位置和协方差矩阵（或方差）的 \(p(f^*(X_{new}))\)

Return type

tuple(torch.Tensor, torch.Tensor)

training: bool¶

变分稀疏高斯过程¶

class VariationalSparseGP(X, y, kernel, Xu, likelihood, mean_function=None, latent_shape=None, num_data=None, whiten=False, jitter=1e-06)[源代码]¶

基础类：pyro.contrib.gp.models.model.GPModel

变分稀疏高斯过程模型。

在VariationalGP模型中，当输入数据\(X\)的数量很大时，协方差矩阵\(k(X, X)\)将需要大量的计算步骤来计算其逆矩阵（用于对数似然和预测）。该模型引入了一个额外的诱导输入参数\(X_u\)来解决这个问题。给定输入\(X\)，它们的噪声观测值\(y\)，以及诱导输入参数\(X_u\)，模型的形式如下：

\[\begin{split}[f, u] &\sim \mathcal{GP}(0, k([X, X_u], [X, X_u])),\\ y & \sim p(y) = p(y \mid f) p(f),\end{split}\]

其中 \(p(y \mid f)\) 是似然函数。

我们将在这个模型中使用变分方法，通过近似\(q(f,u)\)到后验\(p(f,u \mid y)\)。具体来说，\(q(f) = p(f\mid u)q(u)\)，其中\(q(u)\)是一个具有两个参数u_loc和u_scale_tril的多元正态分布，这些参数将在变分推断过程中学习。

注意

该模型可以使用参考文献[2]中的MCMC方法进行学习。另请参见 GPModel。

注意

该模型的训练复杂度为\(\mathcal{O}(NM^2)\)，测试复杂度为\(\mathcal{O}(M^3)\)。这里，\(N\)是训练输入的数量， \(M\)是诱导输入的数量。变分参数的大小为\(\mathcal{O}(M^2)\)。

参考文献：

[1] 可扩展的变分高斯过程分类, 詹姆斯·亨斯曼, 亚历山大·G·德·G·马修斯, 祖宾·加拉马尼

[2] 变分稀疏高斯过程的MCMC, 詹姆斯·亨斯曼, 亚历山大·G·德·G·马修斯, 毛里齐奥·菲利波内, 祖宾·加拉马尼

Parameters

X (torch.Tensor) – 用于训练的输入数据。其第一个维度是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。它的最后一个维度是数据点的数量。
kernel (Kernel) – 一个Pyro内核对象，它是协方差函数 \(k\)。
Xu (torch.Tensor) – 诱导点的初始值，这些是我们模型的参数。
likelihood (likelihood Likelihood) – 一个似然对象。
mean_function (callable) – 一个可选的均值函数 \(m\)，用于这个高斯过程。默认情况下，我们使用零均值。
latent_shape (torch.Size) – 潜在过程的形状（batch_shape 的 \(q(u)\)）。默认情况下，它等于输出批次形状 y.shape[:-1]。对于多类分类问题，latent_shape[-1] 应该对应于类别数量。
num_data (int) – 完整训练数据集的大小。这对于使用小批量训练此模型非常有用。
whiten (bool) – 一个标志，用于指示变分参数 u_loc 和 u_scale_tril 是否通过 Luu 的逆进行转换，其中 Luu 是 \(kernel(X_u, X_u)\) 的下三角分解。启用此标志将有助于优化。
jitter (float) – 一个小的正数项，它被添加到协方差矩阵的对角线部分，以帮助稳定其Cholesky分解。

model()[源代码]¶

guide()[source]¶

forward(Xnew, full_cov=False)[source]¶

计算高斯过程后验在测试输入数据 \(X_{new}\) 上的均值和协方差矩阵（或方差）：

\[p(f^* \mid X_{new}, X, y, k, X_u, u_{loc}, u_{scale\_tril}) = \mathcal{N}(loc, cov).\]

注意

变分参数 u_loc, u_scale_tril, 诱导点参数 Xu, 以及核函数的参数已经通过训练过程（MCMC 或 SVI）学习得到。

Parameters

Xnew (torch.Tensor) – 用于测试的输入数据。注意 Xnew.shape[1:] 必须与 self.X.shape[1:] 相同。
full_cov (bool) – 一个标志，用于决定我们是否要预测完整的协方差矩阵或仅仅是方差。

Returns

位置和协方差矩阵（或方差）的 \(p(f^*(X_{new}))\)

Return type

tuple(torch.Tensor, torch.Tensor)

training: bool¶

GPLVM¶

class GPLVM(base_model)[source]¶

基础类：pyro.contrib.gp.parameterized.Parameterized

高斯过程潜在变量模型（GPLVM）模型。

GPLVM 是一种高斯过程模型，其训练输入数据是一个潜在变量。该模型对于高维数据的降维非常有用。假设从低维潜在变量到高维数据的映射是一个高斯过程实例。那么高维数据将扮演训练输出 y 的角色，我们的目标是学习最能解释 y 的潜在输入。为了降维的目的，潜在输入的维度应低于 y。

我们遵循参考文献[1]，对输入施加单位高斯先验，并通过具有两个变分参数的多变量正态分布来近似其后验：X_loc 和 X_scale_tril。

例如，我们可以对鸢尾花数据集进行降维，如下所示：

>>> # With y as the 2D Iris data of shape 150x4 and we want to reduce its dimension
>>> # to a tensor X of shape 150x2, we will use GPLVM.

>>> # First, define the initial values for X parameter:
>>> X_init = torch.zeros(150, 2)
>>> # Then, define a Gaussian Process model with input X_init and output y:
>>> kernel = gp.kernels.RBF(input_dim=2, lengthscale=torch.ones(2))
>>> Xu = torch.zeros(20, 2)  # initial inducing inputs of sparse model
>>> gpmodule = gp.models.SparseGPRegression(X_init, y, kernel, Xu)
>>> # Finally, wrap gpmodule by GPLVM, optimize, and get the "learned" mean of X:
>>> gplvm = gp.models.GPLVM(gpmodule)
>>> gp.util.train(gplvm)  
>>> X = gplvm.X

参考：

[1] 贝叶斯高斯过程潜在变量模型 Michalis K. Titsias, Neil D. Lawrence

Parameters: base_model (GPModel) – 一个Pyro高斯过程模型对象。请注意，base_model.X 将是变分参数 X_loc 的初始值。

model()[source]¶

guide()[source]¶

forward(**kwargs)[source]¶: Forward 方法与其 base_model 具有相同的信号。请注意，base_model 的训练输入数据是从 GPLVM 中采样的。

training: bool¶

核函数¶

内核¶

class Kernel(input_dim, active_dims=None)[source]¶

基础类：pyro.contrib.gp.parameterized.Parameterized

用于此高斯过程模块的内核基类。

每个继承的类都应该实现一个forward()传递，该传递接受输入 \(X\), \(Z\)并返回它们的协方差矩阵。

要从旧的内核构建新的内核，我们可以使用add()、 mul()、exp()、warp()、vertical_scale()方法。

参考文献：

[1] 机器学习中的高斯过程, 卡尔·E·拉斯穆森, 克里斯托弗·K·I·威廉姆斯

Parameters

input_dim (int) – 输入的特征维度数量。
variance (torch.Tensor) – 该核的方差参数。
active_dims (list) – 输入的特征维度列表，内核作用于这些维度。

forward(X, Z=None, diag=False)[source]¶

计算输入在活动维度上的协方差矩阵。

Parameters

X (torch.Tensor) – 一个形状为 \(N \times input\_dim\) 的二维张量。
Z (torch.Tensor) – 一个（可选的）2D张量，形状为 \(M \times input\_dim\)。
diag (bool) – 一个标志，用于决定我们是否要返回完整的协方差矩阵或仅返回其对角线部分。

Returns

\(X\) 和 \(Z\) 的协方差矩阵，形状为 \(N \times M\)

Return type

torch.Tensor

training: bool¶

布朗运动¶

class Brownian(input_dim, variance=None, active_dims=None)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

该核对应于一个双边的布朗运动（维纳过程）：

\(k(x,z)=\begin{cases}\sigma^2\min(|x|,|z|),& \text{如果 } x\cdot z\ge 0\\ 0, & \text{否则}. \end{cases}\)

请注意，此内核的输入维度必须为1。

参考：

[1] 随机过程的理论与统计应用, 尤利娅·米舒拉, 乔治·谢甫琴科

forward(X, Z=None, diag=False)[source]¶

training: bool¶

组合¶

class Combination(kern0, kern1)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

从多个内核组合派生的内核的基类。

Parameters

kern0 (Kernel) – 要组合的第一个内核。
kern1 (Kernel 或 numbers.Number) – 要组合的第二个核。

training: bool¶

常量¶

class Constant(input_dim, variance=None, active_dims=None)[源代码]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

常数核的实现：

\(k(x, z) = \sigma^2.\)

forward(X, Z=None, diag=False)[source]¶

training: bool¶

协同区域化¶

class Coregionalize(input_dim, rank=None, components=None, diagonal=None, active_dims=None)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

核心区域化线性模型的内核 \(k(x,z) = x^T (W W^T + D) z\) 其中 \(W\) 是一个 input_dim-by-rank 矩阵，通常 rank < input_dim，而 D 是一个对角矩阵。

这将 Linear 核推广到具有低秩加对角权重矩阵的多个特征。典型的用例是用于建模多输出GP的输出之间的相关性，其中输出被编码为具有独热编码特征的不同数据点，表示每个数据点代表的输出。

如果仅指定了rank，则内核(W W^T + D)将被随机初始化为一个期望值为单位矩阵的矩阵。

参考文献：

[1] Mauricio A. Alvarez, Lorenzo Rosasco, Neil D. Lawrence (2012): 向量值函数的内核：综述

Parameters

input_dim (int) – 输入的特征维度数量。
rank (int) – 可选的排名。仅在未指定components时使用。如果既未指定rank也未指定components，则rank默认为input_dim。
组件 (torch.Tensor) – 一个可选的 (input_dim, rank) 形状的矩阵，用于将特征映射到 rank 个组件。如果未指定，这将随机初始化。
对角线 (torch.Tensor) – 一个可选的长度为 input_dim 的向量。如果未指定，这将设置为常数 0.5。
active_dims (list) – 输入的特征维度列表，内核作用于这些维度。
name (str) – 内核的名称。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

余弦¶

class Cosine(input_dim, variance=None, lengthscale=None, active_dims=None)[源代码]¶

基础类: pyro.contrib.gp.kernels.isotropic.Isotropy

余弦核的实现：

\(k(x,z) = \sigma^2 \cos\left(\frac{|x-z|}{l}\right).\)

Parameters: lengthscale (torch.Tensor) – 该核的长度尺度参数。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

点积¶

class DotProduct(input_dim, variance=None, active_dims=None)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

核函数的基类，这些核函数是\(x \cdot z\)的函数。

training: bool¶

指数¶

class Exponent(kern)[源代码]¶

基础：pyro.contrib.gp.kernels.kernel.Transforming

根据以下内容创建一个新的内核

\(k_{new}(x, z) = \exp(k(x, z)).\)

forward(X, Z=None, diag=False)[来源]¶

training: bool¶

指数¶

class Exponential(input_dim, variance=None, lengthscale=None, active_dims=None)[source]¶

基础类: pyro.contrib.gp.kernels.isotropic.Isotropy

指数核的实现：

\(k(x, z) = \sigma^2\exp\left(-\frac{|x-z|}{l}\right).\)

forward(X, Z=None, diag=False)[source]¶

training: bool¶

各向同性¶

class Isotropy(input_dim, variance=None, lengthscale=None, active_dims=None)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

一类各向同性协方差核的基类，这些核是距离 \(|x-z|/l\) 的函数，其中 \(l\) 是长度尺度参数。

默认情况下，参数 lengthscale 的大小为 1。要使用各向同性版本（每个维度有不同的长度尺度），请确保 lengthscale 的大小等于 input_dim。

Parameters: lengthscale (torch.Tensor) – 该核的长度尺度参数。

training: bool¶

线性¶

class Linear(input_dim, variance=None, active_dims=None)[源代码]¶

基础：pyro.contrib.gp.kernels.dot_product.DotProduct

线性核的实现：

\(k(x, z) = \sigma^2 x \cdot z.\)

使用线性核进行高斯过程回归等同于进行线性回归。

注意

这里我们实现了同质版本。要使用非同质版本，考虑使用Polynomial核与degree=1或与Constant核进行Sum。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

Matern32¶

class Matern32(input_dim, variance=None, lengthscale=None, active_dims=None)[source]¶

基础类: pyro.contrib.gp.kernels.isotropic.Isotropy

Matern32核的实现：

\(k(x, z) = \sigma^2\left(1 + \sqrt{3} \times \frac{|x-z|}{l}\right) \exp\left(-\sqrt{3} \times \frac{|x-z|}{l}\right).\)

forward(X, Z=None, diag=False)[source]¶

training: bool¶

Matern52¶

class Matern52(input_dim, variance=None, lengthscale=None, active_dims=None)[source]¶

基础类: pyro.contrib.gp.kernels.isotropic.Isotropy

Matern52核的实现：

\(k(x,z)=\sigma^2\left(1+\sqrt{5}\times\frac{|x-z|}{l}+\frac{5}{3}\times \frac{|x-z|^2}{l^2}\right)\exp\left(-\sqrt{5} \times \frac{|x-z|}{l}\right).\)

forward(X, Z=None, diag=False)[source]¶

training: bool¶

周期性¶

class Periodic(input_dim, variance=None, lengthscale=None, period=None, active_dims=None)[源代码]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

周期核的实现：

\(k(x,z)=\sigma^2\exp\left(-2\times\frac{\sin^2(\pi(x-z)/p)}{l^2}\right),\)

其中 \(p\) 是 period 参数。

参考文献：

[1] 高斯过程简介, David J.C. MacKay

Parameters

lengthscale (torch.Tensor) – 该核的长度尺度参数。
period (torch.Tensor) – 该核的周期参数。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

多项式¶

class Polynomial(input_dim, variance=None, bias=None, degree=1, active_dims=None)[source]¶

基础：pyro.contrib.gp.kernels.dot_product.DotProduct

多项式核的实现：

\(k(x, z) = \sigma^2(\text{bias} + x \cdot z)^d.\)

Parameters

bias (torch.Tensor) – 该核的偏置参数。应为正数。
degree (int) – 多项式的次数 \(d\)。

forward(X, Z=None, diag=False)[源代码]¶

training: bool¶

产品¶

class Product(kern0, kern1)[源代码]¶

基础类: pyro.contrib.gp.kernels.kernel.Combination

返回一个新的内核，其行为类似于两个内核的乘积/张量积。第二个内核可以是一个常数。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

RBF¶

class RBF(input_dim, variance=None, lengthscale=None, active_dims=None)[源代码]¶

基础类: pyro.contrib.gp.kernels.isotropic.Isotropy

径向基函数核的实现：

\(k(x,z) = \sigma^2\exp\left(-0.5 \times \frac{|x-z|^2}{l^2}\right).\)

注意

这个核在文献中也被称为平方指数。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

有理二次¶

class RationalQuadratic(input_dim, variance=None, lengthscale=None, scale_mixture=None, active_dims=None)[source]¶

基础类: pyro.contrib.gp.kernels.isotropic.Isotropy

实现RationalQuadratic核函数：

\(k(x, z) = \sigma^2 \left(1 + 0.5 \times \frac{|x-z|^2}{\alpha l^2} \right)^{-\alpha}.\)

Parameters: scale_mixture (torch.Tensor) – 该核的尺度混合参数 (\(\alpha\))。大小应为1。

forward(X, Z=None, diag=False)[来源]¶

training: bool¶

求和¶

class Sum(kern0, kern1)[源代码]¶

基础类: pyro.contrib.gp.kernels.kernel.Combination

返回一个新内核，其行为类似于两个内核的和/直和。第二个内核可以是一个常数。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

转换¶

class Transforming(kern)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

从某个核通过一些变换（如扭曲、指数、垂直缩放）派生的核的基类。

Parameters: kern (Kernel) – 原始的内核。

training: bool¶

垂直扩展¶

class VerticalScaling(kern, vscaling_fn)[source]¶

基础：pyro.contrib.gp.kernels.kernel.Transforming

根据以下内容创建一个新的内核

\(k_{new}(x, z) = f(x)k(x, z)f(z),\)

其中 \(f\) 是一个函数。

Parameters: vscaling_fn (callable) – 一个垂直缩放函数 \(f\)。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

扭曲¶

class Warping(kern, iwarping_fn=None, owarping_coef=None)[source]¶

基础：pyro.contrib.gp.kernels.kernel.Transforming

根据以下内容创建一个新的内核

\(k_{new}(x, z) = q(k(f(x), f(z))),\)

其中 \(f\) 是一个函数，\(q\) 是一个具有非负系数的多项式 owarping_coef。

我们可以利用\(f\)将高斯过程核与深度学习架构结合起来。例如：

>>> linear = torch.nn.Linear(10, 3)
>>> # register its parameters to Pyro's ParamStore and wrap it by lambda
>>> # to call the primitive pyro.module each time we use the linear function
>>> pyro_linear_fn = lambda x: pyro.module("linear", linear)(x)
>>> kernel = gp.kernels.Matern52(input_dim=3, lengthscale=torch.ones(3))
>>> warped_kernel = gp.kernels.Warping(kernel, pyro_linear_fn)

参考：

[1] 深度核学习, 安德鲁·G·威尔逊, 志廷·胡, 鲁斯兰·萨拉赫丁诺夫, 埃里克·P·邢

Parameters

iwarping_fn (callable) – 一个输入变形函数 \(f\)。
owarping_coef (list) – 输出扭曲多项式的系数列表。这些系数必须是非负的。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

白噪声¶

class WhiteNoise(input_dim, variance=None, active_dims=None)[source]¶

基础类：pyro.contrib.gp.kernels.kernel.Kernel

白噪声核的实现：

\(k(x, z) = \sigma^2 \delta(x, z),\)

其中 \(\delta\) 是一个狄拉克δ函数。

forward(X, Z=None, diag=False)[source]¶

training: bool¶

可能性¶

似然¶

class Likelihood[source]¶

基础类：pyro.contrib.gp.parameterized.Parameterized

高斯过程中使用的似然基类。

每个继承的类都应该实现一个前向传递，该传递接受输入 \(f\) 并返回一个样本 \(y\)。

forward(f_loc, f_var, y=None)[来源]¶

给定 \(f_{loc}\), \(f_{var}\) 的样本 \(y\)。

Parameters

f_loc (torch.Tensor) – 潜在函数输出的均值。
f_var (torch.Tensor) – 潜在函数输出的方差。
y (torch.Tensor) – 训练输出张量。

Returns

从似然中采样的张量

Return type

torch.Tensor

training: bool¶

二进制¶

class Binary(response_function=None)[source]¶

基础类: pyro.contrib.gp.likelihoods.likelihood.Likelihood

二元似然的实现，用于二元分类问题。

二元似然使用Bernoulli分布，因此response_function的输出应在\((0,1)\)范围内。默认情况下，我们使用sigmoid函数。

Parameters: response_function (callable) – 用于二元似然的域校正映射。

forward(f_loc, f_var, y=None)[来源]¶

根据 \(f_{loc}\) 和 \(f_{var}\) 生成样本 \(y\)

\[\begin{split}f & \sim \mathbb{Normal}(f_{loc}, f_{var}),\\ y & \sim \mathbb{Bernoulli}(f).\end{split}\]

注意

对数似然是通过蒙特卡洛方法使用1个\(f\)样本进行估计的。

Parameters

f_loc (torch.Tensor) – 潜在函数输出的均值。
f_var (torch.Tensor) – 潜在函数输出的方差。
y (torch.Tensor) – 训练输出张量。

Returns

从似然中采样的张量

Return type

torch.Tensor

training: bool¶

高斯¶

class Gaussian(variance=None)[source]¶

基础类: pyro.contrib.gp.likelihoods.likelihood.Likelihood

高斯似然的实现，用于回归问题。

高斯似然使用Normal分布。

Parameters: variance (torch.Tensor) – 一个方差参数，在回归问题中扮演noise的角色。

forward(f_loc, f_var, y=None)[source]¶

根据 \(f_{loc}\) 和 \(f_{var}\) 生成样本 \(y\)

\[y \sim \mathbb{Normal}(f_{loc}, f_{var} + \epsilon),\]

其中 \(\epsilon\) 是这个似然的 variance 参数。

Parameters

f_loc (torch.Tensor) – 潜在函数输出的均值。
f_var (torch.Tensor) – 潜在函数输出的方差。
y (torch.Tensor) – 训练输出张量。

Returns

从似然中采样的张量

Return type

torch.Tensor

training: bool¶

多类别¶

class MultiClass(num_classes, response_function=None)[source]¶

基础类: pyro.contrib.gp.likelihoods.likelihood.Likelihood

多类似然函数的实现，用于多类分类问题。

多类似然使用Categorical 分布，因此response_function应归一化其输入的最右侧轴。默认情况下，我们使用softmax函数。

Parameters

num_classes (int) – 用于预测的类别数量。
response_function (callable) – 用于多类似然性的域校正映射。

forward(f_loc, f_var, y=None)[source]¶

根据 \(f_{loc}\) 和 \(f_{var}\) 生成样本 \(y\)

\[\begin{split}f & \sim \mathbb{Normal}(f_{loc}, f_{var}),\\ y & \sim \mathbb{Categorical}(f).\end{split}\]

注意

对数似然是通过蒙特卡洛方法使用1个\(f\)样本进行估计的。

Parameters

f_loc (torch.Tensor) – 潜在函数输出的均值。
f_var (torch.Tensor) – 潜在函数输出的方差。
y (torch.Tensor) – 训练输出张量。

Returns

从似然中采样的张量

Return type

torch.Tensor

training: bool¶

泊松¶

class Poisson(response_function=None)[source]¶

基础类: pyro.contrib.gp.likelihoods.likelihood.Likelihood

泊松似然的实现，用于计数数据。

泊松似然使用Poisson 分布，因此response_function的输出应该是正数。默认情况下，我们使用torch.exp()作为响应函数，对应于对数高斯Cox过程。

Parameters: response_function (callable) – 一个映射到正实数的函数。

forward(f_loc, f_var, y=None)[来源]¶

根据 \(f_{loc}\) 和 \(f_{var}\) 生成样本 \(y\)

\[\begin{split}f & \sim \mathbb{Normal}(f_{loc}, f_{var}),\\ y & \sim \mathbb{Poisson}(\exp(f)).\end{split}\]

注意

对数似然是通过蒙特卡洛方法使用1个\(f\)样本进行估计的。

Parameters

f_loc (torch.Tensor) – 潜在函数输出的均值。
f_var (torch.Tensor) – 潜在函数输出的方差。
y (torch.Tensor) – 训练输出张量。

Returns

从似然中采样的张量

Return type

torch.Tensor

training: bool¶

参数化¶

class Parameterized[source]¶

基础类：pyro.nn.module.PyroModule

PyroModule 的一个包装器，其参数可以设置约束和先验。

默认情况下，当我们为参数设置先验时，将自动创建一个Delta指南。我们可以使用autoguide()方法来设置其他自动指南。

示例：

>>> class Linear(Parameterized):
...     def __init__(self, a, b):
...         super().__init__()
...         self.a = Parameter(a)
...         self.b = Parameter(b)
...
...     def forward(self, x):
...         return self.a * x + self.b
...
>>> linear = Linear(torch.tensor(1.), torch.tensor(0.))
>>> linear.a = PyroParam(torch.tensor(1.), constraints.positive)
>>> linear.b = PyroSample(dist.Normal(0, 1))
>>> linear.autoguide("b", dist.Normal)
>>> assert "a_unconstrained" in dict(linear.named_parameters())
>>> assert "b_loc" in dict(linear.named_parameters())
>>> assert "b_scale_unconstrained" in dict(linear.named_parameters())

请注意，默认情况下，参数的数据类型是浮点数 torch.Tensor （除非我们使用 torch.set_default_dtype() 来更改默认的张量类型）。要将这些参数转换为正确的数据类型或GPU设备，我们可以调用诸如 double() 或 cuda() 的方法。更多信息请参见 torch.nn.Module。

set_prior(name, prior)[source]¶

为参数设置先验。

Parameters

name (str) – 参数的名称。
prior (Distribution) – 一个Pyro先验分布。

autoguide(name, dist_constructor)[source]¶

为现有参数设置自动指南，参数名为 name（模仿模块 pyro.infer.autoguide 的行为）。

注意

dist_constructor 应该是以下之一 Delta, Normal, 和 MultivariateNormal。如果需要，未来将支持更多的分布构造函数。

Parameters

name (str) – 参数的名称。
dist_constructor – 一个 Distribution 构造函数。

set_mode(mode)[source]¶

设置此对象的mode以便能够在随机函数中使用其参数。如果mode="model"，参数将从其先验中获取值。如果mode="guide"，值将从其指南中抽取。

注意

此方法自动为属于Parameterized类的子模块设置mode。

Parameters: mode (str) – 可以是“model”或“guide”。

property mode¶

training: bool¶

工具¶

conditional(Xnew, X, kernel, f_loc, f_scale_tril=None, Lff=None, full_cov=False, whiten=False, jitter=1e-06)[source]¶

给定 \(X_{new}\)，预测条件多元正态分布的位置和协方差矩阵

\[p(f^*(X_{new}) \mid X, k, f_{loc}, f_{scale\_tril}).\]

这里 f_loc 和 f_scale_tril 是变分分布的变分参数

\[q(f \mid f_{loc}, f_{scale\_tril}) \sim p(f | X, y),\]

其中 \(f\) 是给定输入 \(X\) 的高斯过程的函数值

\[p(f(X)) \sim \mathcal{N}(0, k(X, X))\]

并且 \(y\) 是通过某种似然函数 \(p(y|f)\) 从 \(f\) 计算得出的。

如果 f_scale_tril=None，我们考虑 \(f = f_{loc}\) 并计算

\[p(f^*(X_{new}) \mid X, k, f).\]

如果 f_scale_tril 不是 None，我们遵循参考文献 [1] 的推导。对于 f_scale_tril=None 的情况，我们遵循流行的参考文献 [2]。

参考文献：

[1] 稀疏高斯过程：近似后验，而非模型

[2] 机器学习中的高斯过程, 卡尔·E·拉斯穆森, 克里斯托弗·K·I·威廉姆斯

Parameters

Xnew (torch.Tensor) – 一个新的输入数据。
X (torch.Tensor) – 一个需要被条件化的输入数据。
kernel (Kernel) – 一个Pyro内核对象。
f_loc (torch.Tensor) – \(q(f)\) 的均值。在 f_scale_tril=None 的情况下， \(f_{loc} = f\)。
f_scale_tril (torch.Tensor) – \(q(f)\) 的协方差矩阵的下三角分解。
Lff (torch.Tensor) – \(kernel(X, X)\) 的下三角分解 (可选).
full_cov (bool) – 一个标志，用于决定我们是否要返回完整的协方差矩阵或仅返回方差。
whiten (bool) – 一个标志，用于指示 f_loc 和 f_scale_tril 是否已经被 Lff 的逆变换处理过。
jitter (float) – 一个小的正数项，它被添加到协方差矩阵的对角线部分，以帮助稳定其Cholesky分解。

Returns

位置和协方差矩阵（或方差）的 \(p(f^*(X_{new}))\)

Return type

tuple(torch.Tensor, torch.Tensor)

train(gpmodule, optimizer=None, loss_fn=None, retain_graph=None, num_steps=1000)[source]¶

一个帮助优化GP模块参数的助手。

Parameters

gpmodule (GPModel) – 一个GP模块。
optimizer (Optimizer) – 一个 PyTorch 优化器实例。默认情况下，我们使用 Adam 优化器，学习率为 lr=0.01。
loss_fn (可调用) – 一个损失函数，其输入为 gpmodule.model, gpmodule.guide, 并返回ELBO损失。默认情况下，loss_fn=TraceMeanField_ELBO().differentiable_loss。
retain_graph (bool) – torch.autograd.backward 的一个可选标志。
num_steps (int) – 运行SVI的步骤数。

Returns

训练过程中的损失列表

Return type

list