def __init__(self):
super(GPClassificationModel, self).__init__(grid_size=32, grid_bounds=[(0, 1)])
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-5, 5))
self.covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(exp(-5), exp(6), sigma=0.1, log_transform=True)),
log_outputscale_prior=SmoothedBoxPrior(exp(-5), exp(6), sigma=0.1, log_transform=True),
)
def __init__(self, train_x, train_y, likelihood, num_classes):
super(DirichletGPModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(
batch_shape=torch.Size((num_classes, )))
self.covar_module = ScaleKernel(
RBFKernel(batch_shape=torch.Size((num_classes, ))),
batch_shape=torch.Size((num_classes, )),
)
def __init__(self, train_X, train_Y):
self._validate_tensor_args(train_X, train_Y)
train_Y = train_Y.squeeze(-1)
likelihood = GaussianLikelihood()
super().__init__(train_X, train_Y, likelihood)
self.mean_module = ConstantMean()
self.covar_module = ScaleKernel(RBFKernel())
self.to(train_X)
def __init__(self, train_inputs, train_targets, likelihood):
super(ExactGPModel, self).__init__(train_inputs, train_targets, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1, 1))
self.rbf_covar_module = RBFKernel(
log_lengthscale_prior=SmoothedBoxPrior(exp(-3), exp(3), sigma=0.1, log_transform=True)
)
self.noise_covar_module = WhiteNoiseKernel(variances=torch.ones(11) * 0.001)
self.covar_module = ScaleKernel(self.rbf_covar_module + self.noise_covar_module)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean()
self.base_covar_module = ScaleKernel(RBFKernel())
self.covar_module = InducingPointKernel(
self.base_covar_module,
inducing_points=train_x[:500, :],
likelihood=likelihood)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.base_covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(exp(-5), exp(6), sigma=0.1, log_transform=True))
)
self.covar_module = GridInterpolationKernel(self.base_covar_module, grid_size=50, grid_bounds=[(0, 1)])
self.feature_extractor = feature_extractor
def __init__(self, train_x, train_y, likelihood, amountinducing):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean()
self.base_covar_module = ScaleKernel(RBFKernel())
dimension = train_x.size(-1)
self.covar_module = ProductStructureKernel(GridInterpolationKernel(
self.base_covar_module, grid_size=amountinducing, num_dims=1),
num_dims=dimension)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1, 1))
self.base_covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(
exp(-3), exp(3), sigma=0.1, log_transform=True)))
self.covar_module = ProductStructureKernel(GridInterpolationKernel(
self.base_covar_module, grid_size=100, num_dims=2),
num_dims=2)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.base_covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(
exp(-5), exp(6), sigma=0.1, log_transform=True)))
self.covar_module = InducingPointKernel(self.base_covar_module,
inducing_points=torch.linspace(
0, 1, 32))
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ZeroMean()
self.base_covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(exp(-3), exp(3), sigma=0.1, log_transform=True))
)
self.covar_module = AdditiveGridInterpolationKernel(
self.base_covar_module, grid_size=100, grid_bounds=[(-0.5, 1.5)], n_components=2
)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.base_covar_module = ScaleKernel(
RBFKernel(lengthscale_prior=SmoothedBoxPrior(
exp(-5), exp(6), sigma=0.1)))
self.covar_module = GridInterpolationKernel(self.base_covar_module,
grid_size=50,
num_dims=1)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean()
self.covar_module = ScaleKernel(
MaternKernel(
nu=5 / 2,
lengthscale=1.,
))
def __init__(self):
super(GPClassificationModel, self).__init__(grid_size=8,
grid_bounds=[(0, 3),
(0, 3)])
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.covar_module = ScaleKernel(
RBFKernel(ard_num_dims=2,
log_lengthscale_prior=SmoothedBoxPrior(
exp(-2.5), exp(3), sigma=0.1, log_transform=True)))
def __init__(self, train_x, train_y):
likelihood = gpytorch.likelihoods.GaussianLikelihood()
super().__init__(train_x, train_y, likelihood)
self.mean_module = gpytorch.means.ZeroMean()
self.covar_module = InducingPointKernel(
ScaleKernel(RBFKernel(ard_num_dims=3)),
inducing_points=torch.randn(512, 3),
likelihood=likelihood,
)
def test_ard(self):
base_k = RBFKernel(ard_num_dims=3)
base_k.initialize(lengthscale=[1., 2., 3.])
AddK = NewtonGirardAdditiveKernel(base_k, 3, max_degree=1)
testvals = torch.tensor([[1, 2, 3], [7, 5, 2]], dtype=torch.float)
add_k_val = AddK(testvals, testvals).evaluate()
ks = []
for i in range(3):
k = RBFKernel(active_dims=i)
k.initialize(lengthscale=i + 1)
ks.append(k)
manual_k = ScaleKernel(AdditiveKernel(*ks))
manual_k.initialize(outputscale=1.)
manual_add_k_val = manual_k(testvals, testvals).evaluate()
# np.testing.assert_allclose(add_k_val.detach().numpy(), manual_add_k_val.detach().numpy(), atol=1e-5)
self.assertTrue(torch.allclose(add_k_val, manual_add_k_val, atol=1e-5))
def __init__(self, train_inputs, train_targets, likelihood):
super().__init__(train_inputs, train_targets, likelihood)
if train_inputs.ndim == 2:
dims = train_inputs.shape[1]
else:
dims = 1
self.mean_module = gpytorch.means.ZeroMean()
# self.covar_module = ScaleKernel(RBFKernel(ard_num_dims=dims))
self.covar_module = ScaleKernel(MaternKernel(ard_num_dims=dims,
nu=1.5))
def __init__(self,
train_inputs,
train_targets,
likelihood,
batch_shape=torch.Size([2])):
super(ExactGPModel, self).__init__(train_inputs, train_targets,
likelihood)
self.mean_module = ConstantMean(batch_shape=batch_shape)
self.covar_module = ScaleKernel(RBFKernel(batch_shape=batch_shape),
batch_shape=batch_shape)
def create_bayesian_quadrature_iso_gauss():
x1 = torch.from_numpy(np.array([[-1, 1], [0, 0], [-2, 0.1]]))
x2 = torch.from_numpy(np.array([[-1, 1], [0, 0], [-2, 0.1], [-3, 3]]))
M1 = x1.size()[0]
M2 = x2.size()[0]
D = x1.size()[1]
prior_mean = torch.from_numpy(np.arange(D))[None, :]
prior_variance = 2.
rbf = RBFKernel()
rbf.lengthscale = 1.
kernel = ScaleKernel(rbf)
kernel.outputscale = 1.
bqkernel = QuadratureRBFGaussPrior(kernel, prior_mean, prior_variance)
return bqkernel, x1, x2, M1, M2, D
def __init__(self, train_x, train_y, likelihood, lengthscale_constraint,
outputscale_constraint, ard_dims):
super(GP, self).__init__(train_x, train_y, likelihood)
self.ard_dims = ard_dims
self.mean_module = ConstantMeanGrad()
base_kernel = RBFKernelGrad(
lengthscale_constraint=lengthscale_constraint,
ard_num_dims=ard_dims)
self.covar_module = ScaleKernel(
base_kernel, outputscale_constraint=outputscale_constraint)
def __init__(self, dim):
# squeeze output dim before passing train_Y to ExactGP
# super().__init__(train_X, train_Y.squeeze(-1), GaussianLikelihood())
# super().__init__(train_X, train_Y, MultitaskGaussianLikelihood(num_tasks=1+train_X.shape[-1]))
self.likelihood = MultitaskGaussianLikelihood(num_tasks=1 + dim)
self.mean_module = ConstantMeanGrad()
base_kernel = RBFKernelGrad(ard_num_dims=dim)
self.covar_module = ScaleKernel(base_kernel=base_kernel)
# self.to(train_X) # make sure we're on the right device/dtype
self.dim = dim
def __init__(self, n_features, grid_size=100, grid_bounds=(-10.1, 10.1)):
#super(GPLayer, self).__init__(grid_size=grid_size, grid_bounds=n_features*[grid_bounds])
super(GPLayer, self).__init__(grid_size=grid_size,
grid_bounds=[grid_bounds],
n_components=n_features,
mixing_params=False,
sum_output=True)
self.grid_bounds = grid_bounds
self.mean_module = ConstantMean()
self.covar_module = ScaleKernel(RBFKernel())
def __init__(self, train_x, train_y, likelihood, outputscale=1.0):
super().__init__(train_x, train_y, likelihood)
self.mean_module = ZeroMean()
self.kernel = ScaleKernel(
MaternKernel(nu=2.5,
# ard_num_dims=train_x.shape[-1]
))
self.kernel.outputscale = outputscale
def __init__(self, x_train, y_train, likelihood):
super().__init__(x_train, y_train, likelihood)
self.mean = ConstantMean()
base_kernel = ScaleKernel(RBFKernel())
# self.covariance = base_kernel
# here we chose inducing points very randomly just based on the first five
# samples of training data but it can be much better or smarter
self.covariance = InducingPointKernel(base_kernel,
inducing_points=x_train[:5],
likelihood=likelihood)
def __init__(self, input_dim, feature_dim, label_dim, hidden_width,
hidden_depth, n_inducing, batch_size, max_epochs_since_update,
**kwargs):
"""
Args:
input_dim (int)
feature_dim (int): dimension of deep kernel features
label_dim (int)
hidden_depth (int)
hidden_width (int or list)
n_inducing (int): number of inducing points for variational approximation
batch_size (int)
max_epochs_since_update (int)
"""
params = locals()
del params['self']
self.__dict__ = params
super().__init__()
noise_constraint = GreaterThan(1e-4)
self.likelihood = GaussianLikelihood(batch_shape=torch.Size(
[label_dim]),
noise_constraint=noise_constraint)
self.nn = FCNet(input_dim,
output_dim=label_dim,
hidden_width=hidden_width,
hidden_depth=hidden_depth,
batch_norm=True)
self.batch_norm = torch.nn.BatchNorm1d(feature_dim)
self.mean_module = ConstantMean(batch_shape=torch.Size([label_dim]))
base_kernel = RBFKernel(batch_shape=torch.Size([label_dim]),
ard_num_dims=feature_dim)
self.covar_module = ScaleKernel(base_kernel,
batch_shape=torch.Size([label_dim]))
variational_dist = MeanFieldVariationalDistribution(
num_inducing_points=n_inducing,
batch_shape=torch.Size([label_dim]))
inducing_points = torch.randn(n_inducing, feature_dim)
self.variational_strategy = VariationalStrategy(
self,
inducing_points,
variational_dist,
learn_inducing_locations=True)
# initialize preprocessers
self.register_buffer("input_mean", torch.zeros(input_dim))
self.register_buffer("input_std", torch.ones(input_dim))
self.register_buffer("label_mean", torch.zeros(label_dim))
self.register_buffer("label_std", torch.ones(label_dim))
self._train_ckpt = deepcopy(self.state_dict())
self._eval_ckpt = deepcopy(self.state_dict())
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ZeroMean()
self.base_covar_module = ScaleKernel(
RBFKernel(ard_num_dims=2,
lengthscale_prior=SmoothedBoxPrior(exp(-3),
exp(3),
sigma=0.1)))
self.covar_module = AdditiveStructureKernel(GridInterpolationKernel(
self.base_covar_module, grid_size=100, num_dims=2),
num_dims=2)
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.base_covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(
exp(-5), exp(6), sigma=0.1, log_transform=True)))
self.grid_covar_module = GridInterpolationKernel(
self.base_covar_module, grid_size=50, num_dims=1)
self.noise_covar_module = WhiteNoiseKernel(variances=torch.ones(100) *
0.001)
self.covar_module = self.grid_covar_module + self.noise_covar_module
def __init__(self,
train_x,
train_y,
likelihood,
shape,
output_device,
use_ard=False,
use_priors=False,
kernel='rq',
mean_type='zero',
matern_nu=2.5,
heuristic_lengthscales=None,
lengthscale_prior_std=0.1):
# Run constructor of superclass
super(BatchedGP, self).__init__(train_x, train_y, likelihood)
# Determine if using ARD
ard_num_dims = None
if use_ard:
ard_num_dims = train_x.shape[-1]
# Get input size
input_size = train_x.shape[-1]
self.shape = torch.Size([shape])
# Get mean function and kernel
M, K, kwargs = get_mean_and_kernel(kernel,
mean_type,
shape,
input_size,
is_composite=False,
matern_nu=matern_nu)
# Default priors work if targets standardized and features min-max normalized
lengthscale_prior = None
outputscale_prior = None
# Now construct mean function and kernel
self.mean_module = M
self.base_kernel = K(batch_shape=self.shape,
ard_num_dims=ard_num_dims,
lengthscale_prior=lengthscale_prior,
**kwargs)
self.covar_module = ScaleKernel(self.base_kernel,
batch_shape=self.shape,
output_device=output_device,
outputscale_prior=outputscale_prior)
# Set priors, if applicable
if lengthscale_prior is not None:
self.covar_module.base_kernel.lengthscale = lengthscale_prior.mean
elif use_priors:
self.covar_module.base_kernel.lengthscale = lengthscale_prior.mean
def __init__(self, train_x):
super(GPClassificationModel, self).__init__(train_x)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.covar_module = ScaleKernel(
RBFKernel(log_lengthscale_prior=SmoothedBoxPrior(
exp(-5), exp(6), sigma=0.1, log_transform=True)),
log_outputscale_prior=SmoothedBoxPrior(exp(-5),
exp(6),
sigma=0.1,
log_transform=True),
)
def __init__(self, train_inputs, train_targets, inducing_points,
likelihood):
super().__init__(train_inputs, train_targets, likelihood)
if train_inputs.ndim == 2:
dims = train_inputs.shape[1]
else:
dims = 1
self.mean_module = gpytorch.means.ZeroMean()
self.base_cov_module = ScaleKernel(RBFKernel(arg_num_dims=dims))
self.covar_module = NystromKernel(self.base_cov_module,
inducing_points, likelihood)
def __init__(self, train_X, train_Y):
self._validate_tensor_args(train_X, train_Y)
self._set_dimensions(train_X=train_X, train_Y=train_Y)
train_X, train_Y, _ = self._transform_tensor_args(X=train_X, Y=train_Y)
likelihood = GaussianLikelihood(batch_shape=self._aug_batch_shape)
super().__init__(train_X, train_Y, likelihood)
self.mean_module = ConstantMean(batch_shape=self._aug_batch_shape)
self.covar_module = ScaleKernel(
RBFKernel(batch_shape=self._aug_batch_shape),
batch_shape=self._aug_batch_shape,
)
self.to(train_X)
