def test_deepgplayer_checks_constructor_args(): with pytest.raises(ValueError): deepgp.Layer(kernels.RBFKernel(), input_dim=0) with pytest.raises(ValueError): deepgp.Layer(kernels.RBFKernel(), output_dim=0) with pytest.raises(ValueError): deepgp.Layer(kernels.RBFKernel(), grid_bound=0) with pytest.raises(ValueError): deepgp.Layer(kernels.RBFKernel(), grid_num=0)
def test_deepgp_can_compute_kl_regularization(): dgp = deepgp.DeepGP( layers=(deepgp.Layer(kernels.RBFKernel()), deepgp.Layer(kernels.RBFKernel())), likelihood=deepgp.ExpPoisson(), ) dgp(torch.randn(10, 1)) assert torch.is_tensor(dgp.kl_regularization) assert dgp.kl_regularization > 0.0
def test_deepgp_can_compute_outputs(): dgp = deepgp.DeepGP( layers=(deepgp.Layer(kernels.RBFKernel()), deepgp.Layer(kernels.RBFKernel())), likelihood=deepgp.ExpPoisson(), ) loss = dgp(torch.randn(10, 1)).log_prob(torch.ones(10, 1)).sum() loss.backward() loss = dgp(torch.randn(10, 1)).log_prob(torch.ones(10, 1)).sum() loss.backward() dgp.eval() dgp(torch.randn(10, 1))
def test_deepgp_can_compute_negative_elbo_loss(): dgp = deepgp.DeepGP( layers=(deepgp.Layer(kernels.RBFKernel()), deepgp.Layer(kernels.RBFKernel())), likelihood=deepgp.ExpPoisson(), ) elbo = dgp.negative_elbo(torch.randn(10, 1), torch.ones((10, 1)), num_data=10) elbo.backward() elbo = dgp.negative_elbo(torch.randn(10, 1), torch.ones((10, 1)), num_data=10) elbo.backward() assert torch.is_tensor(elbo)
def test_dgplayer_can_compute_predictions(): dgp = deepgp.Layer(kernels.RBFKernel(), input_dim=2, output_dim=3, grid_num=4) output = dgp(torch.rand(10, 2)) assert output.size() == (10, 3)
def test_deepgplayer_checks_input_dims(): dgp = deepgp.Layer(kernels.RBFKernel(), input_dim=2, output_dim=3, grid_num=4) with pytest.raises(ValueError): dgp(torch.rand(10, 10))
def test_deepgplayer_can_turn_off_kl_regularization(): dgp = deepgp.Layer(kernels.RBFKernel(), input_dim=2, output_dim=3, grid_num=4) dgp(torch.rand(10, 2), compute_kl=False) assert dgp.kl_regularization.item() == 0.0
def test_deepgp_can_backward_with_more_than_one_dim(): dgp = deepgp.DeepGP( layers=(deepgp.Layer(kernels.RBFKernel(), input_dim=2, output_dim=1, grid_num=4), ), likelihood=deepgp.ExpPoisson(), ) dgp.forward(torch.randn(10, 2)).mean.sum().backward()
def __init__(self, x_train, y_train, likelihood): super().__init__(x_train, y_train, likelihood) self.mean_module = means.ConstantMean(prior=priors.UniformPrior(0, 5)) # periodic_kernel = kernels.PeriodicKernel(lengthscale_prior=priors.UniformPrior(0.01, 0.5), # period_length_prior=priors.UniformPrior(0.05, 2.5)) rbf_kernel = kernels.RBFKernel( lengthscale_prior=priors.UniformPrior(1, 30)) self.covar_module = kernels.ScaleKernel( rbf_kernel, outputscale_prior=priors.UniformPrior(0, 1))
def __init__(self, x_train, y_train, likelihood): super().__init__(x_train, y_train, likelihood) # SKI requires a grid size hyperparameter. This util can help with that. # Here we are using a grid that has the same number of points as the training data (a ratio of 1.0). # Performance can be sensitive to this parameter, so you may want to adjust it for your own problem on a validation set grid_size = choose_grid_size(x_train, ratio=1.0) self.mean_module = means.ConstantMean() self.covar_module = kernels.ScaleKernel( kernels.GridInterpolationKernel(kernels.RBFKernel(), grid_size=grid_size, num_dims=1))
def set_variational_model(self, init_inducing: torch.Tensor): self.num_latents = init_inducing.size(0) variational_distribution = CholeskyVariationalDistribution( init_inducing.size(-2), batch_shape=[self.num_latents]) self.variational_strategy = variational.LMCVariationalStrategy( gpytorch.variational.VariationalStrategy( self, init_inducing, variational_distribution, learn_inducing_locations=True), num_tasks=self.num_tasks, num_latents=self.num_latents, latent_dim=self.latent_dim) batch_shape = torch.Size([self.num_latents]) self.mean_module = means.ConstantMean(batch_shape=batch_shape) self.covar_module = kernels.ScaleKernel( kernels.RBFKernel(batch_shape=batch_shape), batch_shape=batch_shape)
def gp_mapping_pred(self, inputs, outputs, omegas, sigma_ard): # theta = theta.view(theta.shape[0]) # omegas, sigma_ard = theta[:theta.shape[0]-1],theta[theta.shape[0]-1] Kss = self.gp_mapping_prior(inputs, omegas, sigma_ard) dim = inputs.shape Kss = Kss.view(Kss.shape[1], -1) batch_size = omegas.shape[0] # get \xi values xi = torch.randn(batch_size, 1, dim[1]) ard_kernel = kernels.RBFKernel(ard_num_dims=dim[1]) Kes = ard_kernel.forward(xi.mul(omegas.float()), inputs.mul(omegas.float())).mul(sigma_ard) Kss_inv = torch.inverse(Kss) Kee = ard_kernel.forward(xi.mul(omegas.float()), xi.mul(omegas.float())).mul(sigma_ard) mean = torch.matmul(torch.matmul(Kes, Kss_inv), outputs) mean = mean.view(mean.shape[0], -1) #cholsky decomposition cov = Kee - torch.matmul(torch.matmul(Kes, Kss_inv), Kes.view(Kes.shape[0], Kes.shape[2], -1)) cov = cov.view(cov.shape[0], -1) cov = torch.ones(mean.shape).mul(cov).view(mean.shape[0], -1) return mean, cov
def run(num_epochs=1024, log_interval: int = 1) -> None: train_loader, val_loader = get_data_loaders() num_data = len(train_loader) * train_loader.batch_size model = dsvi.DeepGP( layers=( dsvi.Layer( kernels.ScaleKernel(kernels.RBFKernel()), input_dim=2, output_dim=1, grid_num=128, grid_bound=2.0, ), dsvi.Layer( kernels.ScaleKernel(kernels.RBFKernel()), input_dim=1, output_dim=1, grid_num=8, grid_bound=2.0, ), ), likelihood=dsvi.LogisticBernoulli(), ) device = "cpu" if torch.cuda.is_available(): device = "cuda" optimizer = optim.Adam(model.parameters(), lr=0.01) def train_and_store_loss( engine: ignite.engine.Engine, batch: Tuple[torch.Tensor, torch.Tensor]) -> Dict[str, Any]: model.train() inputs, targets = batch optimizer.zero_grad() loss = model.negative_elbo(inputs, targets.unsqueeze(-1), num_data=num_data, num_samples=3) loss.backward() optimizer.step() return {"loss": loss.item()} trainer = ignite.engine.Engine(train_and_store_loss) evaluator = ignite.engine.create_supervised_evaluator( model, metrics={"accuracy": ignite.metrics.Accuracy()}, output_transform=lambda x, y, y_pred: ((y_pred.mean > 0.5).float(), y), ) desc = "loss: {:.2f}" pbar = tqdm.tqdm(initial=0, leave=False, total=num_epochs, desc=desc.format(0)) @trainer.on(ignite.engine.Events.EPOCH_COMPLETED) def log_training_loss(engine): pbar.desc = desc.format(engine.state.output["loss"]) pbar.update() @trainer.on(ignite.engine.Events.EPOCH_COMPLETED) def log_validation_results(engine): model.eval() evaluator.run(val_loader) metrics = evaluator.state.metrics avg_accuracy = metrics["accuracy"] tqdm.tqdm.write( "Validation Results - Epoch: {} Avg accuracy: {:.2f}".format( engine.state.epoch, avg_accuracy)) trainer.run(train_loader, max_epochs=num_epochs)
def gp_mapping_prior(self, inputs, omegas, sigma_ard): #omegas, sigma_ard = parameters.split(list(parameters.shape)[0]-2) ard_kernel = kernels.RBFKernel(ard_num_dims=list(omegas.shape)[0]) return ard_kernel.forward(inputs.mul(omegas.float()), inputs.mul(omegas.float())).mul( sigma_ard) #, omegas, sigma_ard