def setUp(self): self.mean = MultitaskMean( [ConstantMean(), ZeroMean(), ZeroMean(), ConstantMean()], n_tasks=4) self.mean.base_means[0].constant.data.fill_(5) self.mean.base_means[3].constant.data.fill_(7)
def __init__(self): super(GPClassificationModel, self).__init__(grid_size=10, grid_bounds=[(0, n), (0, n)]) # Near-zero mean self.mean_module = ConstantMean(constant_bounds=[-1e-5, 1e-5]) # RBF as universal approximator self.covar_module = RBFKernel(log_lengthscale_bounds=(-5, 6)) self.register_parameter('log_outputscale', nn.Parameter(torch.Tensor([0])), bounds=(-5,6))
def __init__(self, train_x, train_y, likelihood): super(SpectralMixtureGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1, 1)) self.covar_module = SpectralMixtureKernel(num_mixtures=4, ard_num_dims=1) self.covar_module.initialize_from_data(train_x, train_y)
def __init__(self, train_inputs, train_targets, likelihood, batch_size=1): super(ExactGPModel, self).__init__(train_inputs, train_targets, likelihood) self.mean_module = MultitaskMean( ConstantMean(batch_size=batch_size, prior=gpytorch.priors.SmoothedBoxPrior(-1, 1)), num_tasks=2 ) if batch_size > 1: self.covar_module = MultitaskKernel( RBFKernel( batch_size=batch_size, lengthscale_prior=gpytorch.priors.NormalPrior( loc=torch.zeros(batch_size, 1, 1), scale=torch.ones(batch_size, 1, 1) ), ), num_tasks=2, rank=1, ) else: self.covar_module = MultitaskKernel( RBFKernel( lengthscale_prior=gpytorch.priors.NormalPrior( loc=torch.zeros(batch_size, 1, 1), scale=torch.ones(batch_size, 1, 1) ), ), num_tasks=2, rank=1, )
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.covar_module = ScaleKernel( RBFKernel(lengthscale_prior=SmoothedBoxPrior( exp(-3), exp(3), sigma=0.1)))
def __init__(self): likelihood = GaussianLikelihood(log_noise_bounds=(-3, 3)) super(Model, self).__init__(likelihood) self.mean_module = ConstantMean(constant_bounds=(-1, 1)) covar_module = RBFKernel() self.grid_covar_module = GridInterpolationKernel(covar_module) self.initialize_interpolation_grid(10, [(0, 1), (0, 1)])
def __init__(self, train_X, train_Y, outcome_transform=None, input_transform=None): with torch.no_grad(): transformed_X = self.transform_inputs( X=train_X, input_transform=input_transform) if outcome_transform is not None: train_Y, _ = outcome_transform(train_Y) self._validate_tensor_args(transformed_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, ) if outcome_transform is not None: self.outcome_transform = outcome_transform if input_transform is not None: self.input_transform = input_transform self.to(train_X)
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 = InducingPointKernel( self.base_covar_module, inducing_points=torch.linspace(0, 1, 32), likelihood=likelihood )
def __init__(self, train_x, train_y, likelihood): super(GPRegressionModel, self).__init__(train_x, train_y, likelihood) self.mean_module = ConstantMean(constant_bounds=[-1e-5, 1e-5]) self.base_covar_module = RBFKernel(log_lengthscale_bounds=(-5, 6)) self.covar_module = InducingPointKernel(self.base_covar_module, inducing_points=torch.linspace( 0, 1, 32))
def __init__(self, train_x, train_y, likelihood, ex_var_dim, kernel, **ker_conf): super(ExactGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = ConstantMean() _ker_conf = {'ard_num_dims': ex_var_dim} _ker_conf.update(ker_conf) self.covar_module = set_kernel(kernel, **_ker_conf)
def __init__(self, train_x): super(LatentFunction, self).__init__(inducing_points=train_x) self.mean_module = ConstantMean(constant_bounds=[-1e-5, 1e-5]) self.covar_module = RBFKernel(log_lengthscale_bounds=(-5, 6)) self.register_parameter('log_outputscale', nn.Parameter(torch.Tensor([0])), bounds=(-5, 6))
def create_mean(self): return MultitaskMean([ ConstantMean(batch_shape=torch.Size([2, 3])), ZeroMean(), ZeroMean() ], num_tasks=3)
def test_mi_acqf(self): mean = ConstantMean().initialize(constant=1.2) covar = LinearKernel().initialize(variance=1.0) model = GPClassificationModel( inducing_min=torch.Tensor([0]), inducing_max=torch.Tensor([1]), inducing_size=10, mean_module=mean, covar_module=covar, ) x = torch.rand(size=(10, 1)) acqf = BernoulliMCMutualInformation(model=model, objective=ProbitObjective()) acq_pytorch = acqf(x) samps_numpy = norm.cdf( multivariate_normal.rvs(mean=np.ones(10) * 1.2, cov=x @ x.T, size=10000) ) samp_entropies = bernoulli(samps_numpy).entropy() mean_entropy = bernoulli(samps_numpy.mean(axis=0)).entropy() acq_numpy = mean_entropy - samp_entropies.mean(axis=0) # this assertion fails, not sure why, these should be equal to numerical # precision # self.assertTrue(np.allclose(acq_numpy, acq_pytorch.detach().numpy().flatten())) # this one succeeds self.assertTrue( pearsonr(acq_numpy, acq_pytorch.detach().numpy().flatten())[0] > (1 - 1e-5) )
def __init__(self, train_x, train_y, likelihood, num_tasks=2): self.shape = torch.Size([num_tasks]) super().__init__(train_x, train_y, likelihood) self.mean_module = ConstantMean(batch_shape=self.shape) self.covar_module = ScaleKernel(MaternKernel(batch_shape=self.shape), batch_shape=self.shape)
def __init__(self): super(KissGPModel, self).__init__(grid_size=300, grid_bounds=[(0, 1)]) self.mean_module = ConstantMean(constant_bounds=(-1, 1)) covar_module = RBFKernel(log_lengthscale_bounds=(-100, 100)) covar_module.log_lengthscale.data = torch.FloatTensor([-2]) self.covar_module = covar_module
def __init__(self, input_dims, output_dims, num_inducing=128, mean_type='constant'): if output_dims is None: inducing_points = torch.randn(num_inducing, input_dims) batch_shape = torch.Size([]) else: inducing_points = torch.randn(output_dims, num_inducing, input_dims) batch_shape = torch.Size([output_dims]) variational_distribution = CholeskyVariationalDistribution( num_inducing_points=num_inducing, batch_shape=batch_shape) variational_strategy = VariationalStrategy( self, inducing_points, variational_distribution, learn_inducing_locations=True) super(ApproximateDeepGPHiddenLayer, self).__init__(variational_strategy, input_dims, output_dims) if mean_type == 'constant': self.mean_module = ConstantMean(batch_shape=batch_shape) else: self.mean_module = LinearMean(input_dims) self.covar_module = ScaleKernel(RBFKernel(batch_shape=batch_shape, ard_num_dims=input_dims), batch_shape=batch_shape, ard_num_dims=None) self.linear_layer = Linear(input_dims, 1)
def __init__(self, train_x, train_y, likelihood): super(GPRegressionModel, self).__init__(train_x, train_y, likelihood) self.mean_module = ConstantMean(constant_bounds=[-5,5]) self.base_covar_module = RBFKernel(log_lengthscale_bounds=(-5, 6)) self.covar_module = GridInterpolationKernel(self.base_covar_module, grid_size=500, grid_bounds=[(-10, 10), (-10, 10)]) self.register_parameter('log_outputscale', nn.Parameter(torch.Tensor([0])), bounds=(-5,6))
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()) self.covar_module = ProductStructureKernel(GridInterpolationKernel( self.base_covar_module, grid_size=100, num_dims=1), num_dims=2)
def __init__(self, n_inducing): # number of inducing points and optimisation samples assert isinstance(n_inducing, int) self.m = n_inducing # variational distribution and strategy # NOTE: we put random normal dumby inducing points # here, which we'll change in self.fit vardist = CholeskyVariationalDistribution(self.m) varstra = VariationalStrategy(self, torch.randn((self.m, 2)), vardist, learn_inducing_locations=True) VariationalGP.__init__(self, varstra) # kernel — implemented in self.forward self.mean = ConstantMean() self.cov = MaternKernel(ard_num_dims=2) # self.cov = GaussianSymmetrizedKLKernel() self.cov = ScaleKernel(self.cov, ard_num_dims=2) # likelihood self.likelihood = GaussianLikelihood() # hardware allocation self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.likelihood.to(self.device).float() self.to(self.device).float()
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 = GridInterpolationKernel(self.base_covar_module, grid_size=64, grid_bounds=[(0, 1), (0, 1)])
def __init__(self, input_dims, output_dims, num_inducing=128): if output_dims is None: inducing_points = torch.randn(num_inducing, input_dims) if torch.cuda.is_available(): inducing_points = inducing_points.cuda() batch_shape = torch.Size([]) else: inducing_points = torch.randn(output_dims, num_inducing, input_dims) if torch.cuda.is_available(): inducing_points = inducing_points.cuda() batch_shape = torch.Size([output_dims]) variational_distribution = CholeskyVariationalDistribution( num_inducing_points=num_inducing, batch_shape=batch_shape) variational_strategy = VariationalStrategy( self, inducing_points, variational_distribution, learn_inducing_locations=True) super().__init__(variational_strategy, input_dims, output_dims) self.mean_module = ConstantMean(batch_shape=batch_shape) self.covar_module = ScaleKernel(RBFKernel(ard_num_dims=None), ard_num_dims=None)
def __init__(self, train_X, train_Y): # squeeze output dim before passing train_Y to ExactGP super().__init__(train_X, train_Y.squeeze(-1), GaussianLikelihood()) self.mean_module = ConstantMean() self.covar_module = ScaleKernel( base_kernel=RBFKernel(ard_num_dims=train_X.shape[-1]), ) self.to(train_X) # make sure we're on the right device/dtype
def __init__(self, train_x, train_y, likelihood): super(GPRegressionModel, self).__init__(train_x, train_y, likelihood) self.mean_module = ConstantMean(constant_bounds=(-1, 1)) self.base_covar_module = RBFKernel(log_lengthscale_bounds=(-3, 3)) self.covar_module = AdditiveGridInterpolationKernel( self.base_covar_module, grid_size=100, grid_bounds=[(0, 1)], n_components=2 )
def _parse_mean(input_size: int, dim_outputs: int = 1, kind: str = 'zero') -> Mean: """Parse Mean string. Parameters ---------- input_size: int. Size of input to GP (needed for linear mean functions). kind: str. String that identifies mean function. Returns ------- mean: Mean. Mean function. """ if kind.lower() == 'constant': mean = ConstantMean() elif kind.lower() == 'zero': mean = ZeroMean() elif kind.lower() == 'linear': mean = LinearMean(input_size=input_size, batch_shape=torch.Size([dim_outputs])) else: raise NotImplementedError( 'Mean function {} not implemented.'.format(kind)) return mean
def __init__(self, train_x, train_y, likelihood): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), n_tasks=2) self.data_covar_module = RBFKernel() self.covar_module = MultitaskKernel(self.data_covar_module, n_tasks=2, rank=1)
def __init__(self): super(GPClassificationModel, self).__init__(BernoulliLikelihood()) self.mean_module = ConstantMean(constant_bounds=[-1e-5, 1e-5]) self.covar_module = RBFKernel(log_lengthscale_bounds=(-5, 6)) self.register_parameter('log_outputscale', nn.Parameter(torch.Tensor([0])), bounds=(-5, 6))
def __init__(self, train_x, train_y, likelihood): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), num_tasks=2) self.base_kernel_list = [RBFKernel()] self.covar_module = LCMKernel(self.base_kernel_list, num_tasks=2, rank=1)
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 = RBFKernel(ard_num_dims=2) self.covar_module = GridInterpolationKernel(self.base_covar_module, grid_size=16, num_dims=2)
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): super(GPRegressionModel, self).__init__(grid_size=20, grid_bounds=[(-0.05, 1.05)]) self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-10, 10)) self.covar_module = ScaleKernel( RBFKernel(log_lengthscale_prior=SmoothedBoxPrior( exp(-3), exp(6), sigma=0.1, log_transform=True)))