高斯过程¶

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

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]¶

为参数设置先验。

参数

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

autoguide(name, dist_constructor)[source]¶

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

注意

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

参数

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

set_mode(mode)[source]¶

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

注意

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

参数: mode (str) – “model” 或 “guide” 之一。

property mode¶

training: bool¶

模型¶

GPModel¶

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] Gaussian Processes for Machine Learning, Carl E. Rasmussen, Christopher K. I. Williams

参数

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）学习得到。

参数

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

返回值

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

返回类型

tuple(torch.Tensor, torch.Tensor)

set_data(X, y=None)[source]¶

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

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

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

>>> 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] Scalable Variational Gaussian Process Classification, James Hensman, Alexander G. de G. Matthews, Zoubin Ghahramani

[2] Deep Gaussian Processes, Andreas C. Damianou, Neil D. Lawrence

参数

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

training: bool¶

GPRegression¶

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

继承自: 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] Gaussian Processes for Machine Learning, Carl E. Rasmussen, Christopher K. I. Williams

参数

X (torch.Tensor) – 用于训练的输入数据。其第一维是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。其最后一维是数据点的数量。
kernel (Kernel) – 一个 Pyro 核函数对象，它是协方差函数 \(k\)。
noise (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）学习得到。

参数

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

返回值

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

返回类型

tuple(torch.Tensor, torch.Tensor)

iter_sample(noiseless=True)[source]¶

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

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

此方法从该多元高斯分布中惰性地抽取样本。这种方法的优点是后续查询点可以依赖于先前的点。这在通过优化程序进行查询时特别有用。

注意

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

参数: noiseless (bool) – 一个标志，决定是否在样本中添加采样噪声，超出 GP 后验固有的噪声。
返回值: 采样器
返回类型: 函数

training: bool¶

SparseGPRegression¶

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\)（参见参考 [1]）来近似 \(k(X, X)\)，从而降低计算成本，其中：

\[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] A Unifying View of Sparse Approximate Gaussian Process Regression, Joaquin Quiñonero-Candela, Carl E. Rasmussen

[2] Variational learning of inducing variables in sparse Gaussian processes, Michalis Titsias

参数

X (torch.Tensor) – 用于训练的输入数据。其第一维是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。其最后一维是数据点的数量。
kernel (Kernel) – 一个 Pyro 核函数对象，它是协方差函数 \(k\)。
Xu (torch.Tensor) – 诱导点的初始值，它们是模型参数。
noise (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）学习得到。

参数

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

返回值

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

返回类型

tuple(torch.Tensor, torch.Tensor)

training: bool¶

VariationalGP¶

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

继承自: 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)\)。

参数

X (torch.Tensor) – 用于训练的输入数据。其第一维是数据点的数量。
y (torch.Tensor) – 用于训练的输出数据。其最后一维是数据点的数量。
kernel (Kernel) – 一个 Pyro 核函数对象，它是协方差函数 \(k\)。
likelihood (likelihood Likelihood) – 一个似然函数对象。
mean_function (callable) – 此高斯过程的可选均值函数 \(m\)。默认情况下，我们使用零均值。
latent_shape (torch.Size) – 潜在过程的形状（\(q(f)\) 的 batch_shape）。默认情况下，它等于输出批量形状 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）学习得到。

参数

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

返回值

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

返回类型

tuple(torch.Tensor, torch.Tensor)

training: bool¶

VariationalSparseGP¶

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

继承自: 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] Scalable variational Gaussian process classification, James Hensman, Alexander G. de G. Matthews, Zoubin Ghahramani

[2] MCMC for Variationally Sparse Gaussian Processes, James Hensman, Alexander G. de G. Matthews, Maurizio Filippone, Zoubin Ghahramani

参数

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

model()[source]¶

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）学习得到。

参数

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

返回值

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

返回类型

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 的多元正态分布来近似其后验。

例如，我们可以对 Iris 数据集进行降维如下

>>> # 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] Bayesian Gaussian Process Latent Variable Model Michalis K. Titsias, Neil D. Lawrence

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

model()[source]¶

guide()[source]¶

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

training: bool¶

核函数¶

Kernel¶

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

继承自: pyro.contrib.gp.parameterized.Parameterized

此高斯过程模块中使用的核函数的基类。

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

为了从旧核函数构造新核函数，我们可以使用方法 add(), mul(), exp(), warp(), vertical_scale()。

参考

[1] Gaussian Processes for Machine Learning, Carl E. Rasmussen, Christopher K. I. Williams

参数

input_dim (整型) – 输入的特征维度数量。
variance (torch.Tensor) – 此核函数的方差参数。
active_dims (列表) – 核函数作用于输入的特征维度列表。

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

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

参数

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

返回值

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

返回类型

torch.Tensor

training: bool¶

Brownian¶

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

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

此核函数对应于双边布朗运动 (Wiener 过程)

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

注意，此核函数的输入维度必须为 1。

参考

[1] Theory and Statistical Applications of Stochastic Processes, Yuliya Mishura, Georgiy Shevchenko

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

training: bool¶

组合¶

class Combination(kern0, kern1)[source]¶

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

从核函数组合中派生的核函数的基类。

参数

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

training: bool¶

常数¶

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

基类：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 × rank 矩阵，且通常 rank < input_dim，而 D 是对角矩阵。

这将 Linear 核函数泛化为具有低秩加对角权重矩阵的多特征核函数。典型用例是建模多输出 GP 中输出之间的相关性，其中输出被编码为具有独热编码特征的离散数据点，这些特征指示每个数据点代表哪个输出。

如果只指定了 rank，核函数 (W W^T + D) 将随机初始化为期望值为单位矩阵的矩阵。如果既未指定 rank 也未指定 components，则 rank 默认为 input_dim。

参考

[1] Mauricio A. Alvarez, Lorenzo Rosasco, Neil D. Lawrence (2012): Kernels for Vector-Valued Functions: a Review

参数

input_dim (整型) – 输入的特征维度数量。
rank (整型) – 可选的秩。这仅在未指定 components 时使用。如果既未指定 rank 也未指定 components，则 rank 默认为 input_dim。
components (torch.Tensor) – 一个可选的 (input_dim, rank) 形状的矩阵，将特征映射到 rank 个分量。如果未指定，这将随机初始化。
diagonal (torch.Tensor) – 一个可选的长度为 input_dim 的向量。如果未指定，这将设为常数 0.5。
active_dims (列表) – 核函数作用于输入的特征维度列表。
name (字符串) – 核函数的名称。

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

training: bool¶

余弦¶

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

基类：pyro.contrib.gp.kernels.isotropic.Isotropy

余弦核函数的实现

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

参数: 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)[source]¶

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

根据以下公式创建一个新的核函数

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

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

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。

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

training: bool¶

线性¶

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

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

线性核函数的实现

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

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

注意

这里我们实现的是齐次版本。要使用非齐次版本，请考虑使用 Polynomial 核函数，参数为 degree=1，或通过 Sum 与 Constant 核函数构成。

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)[source]¶

基类：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] Introduction to Gaussian processes, David J.C. MacKay

参数

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

参数

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

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

training: bool¶

乘积¶

class Product(kern0, kern1)[source]¶

基类：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)[source]¶

基类：pyro.contrib.gp.kernels.isotropic.Isotropy

径向基函数核函数的实现

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

注意

此核函数在文献中也称为 Squared Exponential (平方指数)。

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

有理二次核函数的实现

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

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

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

training: bool¶

求和¶

class Sum(kern0, kern1)[source]¶

基类：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

通过对核函数进行诸如形变、指数、垂直缩放等变换而派生的核函数的基类。

参数: kern (核函数) – 原始核函数。

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\) 是一个函数。

参数: vscaling_fn (可调用对象) – 一个垂直缩放函数 \(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] Deep Kernel Learning, Andrew G. Wilson, Zhiting Hu, Ruslan Salakhutdinov, Eric P. Xing

参数

iwarping_fn (可调用对象) – 一个输入形变函数 \(f\)。
owarping_coef (列表) – 输出形变多项式的系数列表。这些系数必须是非负的。

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\) 是一个 Dirac delta 函数。

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

training: bool¶

似然函数¶

Likelihood¶

class Likelihood[source]¶

继承自: pyro.contrib.gp.parameterized.Parameterized

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

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

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

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

参数

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

返回值

从似然函数中采样的张量

返回类型

torch.Tensor

training: bool¶

二元¶

class Binary(response_function=None)[source]¶

基类：pyro.contrib.gp.likelihoods.likelihood.Likelihood

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

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

参数: response_function (可调用对象) – 用于将二元似然函数映射到正确域的映射。

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

根据以下公式采样 \(y\)，给定 \(f_{loc}\), \(f_{var}\)

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

注意

对数似然使用蒙特卡罗方法估计，采样 \(f\) 的 1 个样本。

参数

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

返回值

从似然函数中采样的张量

返回类型

torch.Tensor

training: bool¶

高斯¶

class Gaussian(variance=None)[source]¶

基类：pyro.contrib.gp.likelihoods.likelihood.Likelihood

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

高斯似然使用 Normal 分布。

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

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

根据以下公式采样 \(y\)，给定 \(f_{loc}\), \(f_{var}\)

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

其中 \(\epsilon\) 是此似然函数的 variance 参数。

参数

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

返回值

从似然函数中采样的张量

返回类型

torch.Tensor

training: bool¶

多类别¶

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

基类：pyro.contrib.gp.likelihoods.likelihood.Likelihood

多类别似然的实现，用于解决多类别分类问题。

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

参数

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

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

根据以下公式采样 \(y\)，给定 \(f_{loc}\), \(f_{var}\)

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

注意

对数似然使用蒙特卡罗方法估计，采样 \(f\) 的 1 个样本。

参数

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

返回值

从似然函数中采样的张量

返回类型

torch.Tensor

training: bool¶

泊松¶

class Poisson(response_function=None)[source]¶

基类：pyro.contrib.gp.likelihoods.likelihood.Likelihood

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

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

参数: response_function (callable) – 映射到正实数的函数。

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

根据以下公式采样 \(y\)，给定 \(f_{loc}\), \(f_{var}\)

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

注意

对数似然使用蒙特卡罗方法估计，采样 \(f\) 的 1 个样本。

参数

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

返回值

从似然函数中采样的张量

返回类型

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]¶

为参数设置先验。

参数

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

autoguide(name, dist_constructor)[source]¶

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

注意

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

参数

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

set_mode(mode)[source]¶

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

注意

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

参数: 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}\)，预测条件多元正态分布的 loc 和协方差矩阵

\[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\) 由 \(f\) 通过某个似然函数 \(p(y|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] 机器学习中的高斯过程，Carl E. Rasmussen, Christopher K. I. Williams

参数

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 分解。

返回值

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

返回类型

tuple(torch.Tensor, torch.Tensor)

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

一个用于优化 GP 模块参数的辅助函数。

参数

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

返回值

训练过程中的损失列表

返回类型

列表