def test_train_and_eval(self):
# We're manually going to set the hyperparameters to something they shouldn't be
likelihood = MultitaskGaussianLikelihood(num_tasks=4)
model = LMCModel()
# Find optimal model hyperparameters
model.train()
likelihood.train()
optimizer = torch.optim.Adam([
{'params': model.parameters()},
{'params': likelihood.parameters()},
], lr=0.01)
# Our loss object. We're using the VariationalELBO, which essentially just computes the ELBO
mll = gpytorch.mlls.VariationalELBO(likelihood, model, num_data=train_y.size(0))
# We use more CG iterations here because the preconditioner introduced in the NeurIPS paper seems to be less
# effective for VI.
for i in range(400):
# Within each iteration, we will go over each minibatch of data
optimizer.zero_grad()
output = model(train_x)
loss = -mll(output, train_y)
loss.backward()
optimizer.step()
for param in model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
for param in likelihood.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
# Test the model
model.eval()
likelihood.eval()
# Make predictions for both sets of test points, and check MAEs.
with torch.no_grad(), gpytorch.settings.max_eager_kernel_size(1):
batch_predictions = likelihood(model(train_x))
preds1 = batch_predictions.mean[:, 0]
preds2 = batch_predictions.mean[:, 1]
preds3 = batch_predictions.mean[:, 2]
preds4 = batch_predictions.mean[:, 3]
mean_abs_error1 = torch.mean(torch.abs(train_y[..., 0] - preds1))
mean_abs_error2 = torch.mean(torch.abs(train_y[..., 1] - preds2))
mean_abs_error3 = torch.mean(torch.abs(train_y[..., 2] - preds3))
mean_abs_error4 = torch.mean(torch.abs(train_y[..., 3] - preds4))
self.assertLess(mean_abs_error1.squeeze().item(), 0.15)
self.assertLess(mean_abs_error2.squeeze().item(), 0.15)
self.assertLess(mean_abs_error3.squeeze().item(), 0.15)
self.assertLess(mean_abs_error4.squeeze().item(), 0.15)
# Smoke test for getting predictive uncertainties
lower, upper = batch_predictions.confidence_region()
self.assertEqual(lower.shape, train_y.shape)
self.assertEqual(upper.shape, train_y.shape)
def test_train_on_single_set_test_on_batch(self):
# We're manually going to set the hyperparameters to something they shouldn't be
likelihood = MultitaskGaussianLikelihood(
log_noise_prior=gpytorch.priors.NormalPrior(loc=torch.zeros(1),
scale=torch.ones(1),
log_transform=True),
num_tasks=2,
)
gp_model = ExactGPModel(train_x1, train_y1, likelihood)
mll = gpytorch.ExactMarginalLogLikelihood(likelihood, gp_model)
# Find optimal model hyperparameters
gp_model.train()
likelihood.train()
optimizer = optim.Adam(list(gp_model.parameters()) +
list(likelihood.parameters()),
lr=0.1)
optimizer.n_iter = 0
gp_model.train()
likelihood.train()
optimizer = optim.Adam(gp_model.parameters(), lr=0.1)
for _ in range(50):
optimizer.zero_grad()
output = gp_model(train_x1)
loss = -mll(output, train_y1).sum()
loss.backward()
optimizer.step()
for param in gp_model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
for param in likelihood.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
# Test the model
gp_model.eval()
likelihood.eval()
# Make predictions for both sets of test points, and check MAEs.
batch_predictions = likelihood(gp_model(test_x12))
preds1 = batch_predictions.mean[0]
preds2 = batch_predictions.mean[1]
mean_abs_error1 = torch.mean(torch.abs(test_y1 - preds1))
mean_abs_error2 = torch.mean(torch.abs(test_y2 - preds2))
self.assertLess(mean_abs_error1.squeeze().item(), 0.05)
self.assertLess(mean_abs_error2.squeeze().item(), 0.05)
def test_train_and_eval(self):
# We're manually going to set the hyperparameters to something they shouldn't be
likelihood = MultitaskGaussianLikelihood(num_tasks=2)
gp_model = ExactGPModel(train_x, train_y12, likelihood)
mll = gpytorch.ExactMarginalLogLikelihood(likelihood, gp_model)
# Find optimal model hyperparameters
gp_model.train()
likelihood.train()
optimizer = optim.Adam(gp_model.parameters(), lr=0.1)
optimizer.n_iter = 0
for _ in range(75):
optimizer.zero_grad()
output = gp_model(train_x)
loss = -mll(output, train_y12).sum()
loss.backward()
optimizer.step()
for param in gp_model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
for param in likelihood.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
# Test the model
gp_model.eval()
likelihood.eval()
# Make predictions for both sets of test points, and check MAEs.
with torch.no_grad(), gpytorch.settings.max_eager_kernel_size(1):
batch_predictions = likelihood(gp_model(test_x))
preds1 = batch_predictions.mean[:, 0]
preds2 = batch_predictions.mean[:, 1]
mean_abs_error1 = torch.mean(torch.abs(test_y1 - preds1))
mean_abs_error2 = torch.mean(torch.abs(test_y2 - preds2))
self.assertLess(mean_abs_error1.squeeze().item(), 0.01)
self.assertLess(mean_abs_error2.squeeze().item(), 0.01)
# Smoke test for getting predictive uncertainties
lower, upper = batch_predictions.confidence_region()
self.assertEqual(lower.shape, test_y12.shape)
self.assertEqual(upper.shape, test_y12.shape)
