def test_fixed_noise_fantasy_updates_batch(self, cuda=False):
train_x, test_x, train_y, test_y = self._get_data(cuda=cuda)
noise = torch.full_like(train_y, 2e-4)
test_noise = torch.full_like(test_y, 3e-4)
likelihood = FixedNoiseGaussianLikelihood(noise)
gp_model = ExactGPModel(train_x, train_y, likelihood)
mll = gpytorch.ExactMarginalLogLikelihood(likelihood, gp_model)
gp_model.covar_module.base_kernel.initialize(lengthscale=exp(1))
gp_model.mean_module.initialize(constant=0)
if cuda:
gp_model.cuda()
likelihood.cuda()
# Find optimal model hyperparameters
gp_model.train()
likelihood.train()
optimizer = optim.Adam(list(gp_model.parameters()) + list(likelihood.parameters()), lr=0.15)
for _ in range(50):
optimizer.zero_grad()
with gpytorch.settings.debug(False):
output = gp_model(train_x)
loss = -mll(output, train_y)
loss.backward()
optimizer.step()
for param in gp_model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
optimizer.step()
with gpytorch.settings.fast_pred_var():
# Test the model
gp_model.eval()
likelihood.eval()
test_function_predictions = likelihood(gp_model(test_x), noise=test_noise)
# Cut data down, and then add back via the fantasy interface
gp_model.set_train_data(train_x[:5], train_y[:5], strict=False)
gp_model.likelihood.noise_covar = FixedGaussianNoise(noise=noise[:5])
likelihood(gp_model(test_x), noise=test_noise)
fantasy_x = train_x[5:].clone().unsqueeze(0).unsqueeze(-1).repeat(3, 1, 1).requires_grad_(True)
fantasy_y = train_y[5:].unsqueeze(0).repeat(3, 1)
fant_model = gp_model.get_fantasy_model(fantasy_x, fantasy_y, noise=noise[5:].unsqueeze(0).repeat(3, 1))
fant_function_predictions = likelihood(fant_model(test_x), noise=test_noise)
self.assertAllClose(test_function_predictions.mean, fant_function_predictions.mean[0], atol=1e-4)
fant_function_predictions.mean.sum().backward()
self.assertTrue(fantasy_x.grad is not None)
def get_fantasy_likelihood(self, **kwargs):
if "noise" not in kwargs:
raise RuntimeError(
"FixedNoiseGaussianLikelihood.fantasize requires a `noise` kwarg"
)
old_noise_covar = self.noise_covar
self.noise_covar = None
fantasy_liklihood = deepcopy(self)
self.noise_covar = old_noise_covar
old_noise = old_noise_covar.noise
new_noise = kwargs.get("noise")
if old_noise.dim() != new_noise.dim():
old_noise = old_noise.expand(*new_noise.shape[:-1],
old_noise.shape[-1])
fantasy_liklihood.noise_covar = FixedGaussianNoise(
noise=torch.cat([old_noise, new_noise], -1))
return fantasy_liklihood
def __init__(
self,
noise: Tensor,
learn_additional_noise: Optional[bool] = False,
batch_shape: Optional[torch.Size] = torch.Size(),
**kwargs: Any,
) -> None:
super().__init__(noise_covar=FixedGaussianNoise(noise=noise))
if learn_additional_noise:
noise_prior = kwargs.get("noise_prior", None)
noise_constraint = kwargs.get("noise_constraint", None)
self.second_noise_covar = HomoskedasticNoise(
noise_prior=noise_prior,
noise_constraint=noise_constraint,
batch_shape=batch_shape)
else:
self.second_noise_covar = None