def test_forward(self):
a = nn.Parameter(torch.Tensor([5]))
b = Variable(torch.ones(3, 3))
output = gpytorch.add_diag(b, a)
actual = torch.Tensor([[6, 1, 1], [1, 6, 1], [1, 1, 6]])
self.assertLess(torch.norm(output.data - actual), 1e-7)
def test_add_diag(self):
lv = InvQuadLazyVariable(self.base_mat_var, self.left_mat_var,
self.right_mat_var, self.diag_var)
ev = lv.evaluate()
res = lv.add_diag(torch.Tensor([0.5])).evaluate()
actual = gpytorch.add_diag(ev, torch.Tensor([0.5]))
assert ((res - actual).norm() / actual.norm()).item() < 1e-3
def test_backward():
grad = torch.randn(3, 3)
a = nn.Parameter(torch.Tensor([3]))
b = Variable(torch.ones(3, 3), requires_grad=True)
output = gpytorch.add_diag(b, a)
output.backward(gradient=grad)
assert (math.fabs(a.grad.data[0] - grad.trace()) < 1e-6)
assert (torch.norm(b.grad.data - grad) < 1e-6)
def add_diag(self, diag):
return NonLazyVariable(gpytorch.add_diag(self.tensor, diag))
def forward(self, input):
assert (isinstance(input, GaussianRandomVariable))
mean, covar = input.representation()
noise = gpytorch.add_diag(covar, self.log_noise.exp())
return GaussianRandomVariable(mean, noise)
def __call__(self, *args, **kwargs):
output = None
# Posterior mode
if self.posterior:
train_xs = self.train_inputs
train_y = self.train_target
if all([
torch.equal(train_x.data, input.data)
for train_x, input in zip(train_xs, args)
]):
logging.warning('The input matches the stored training data. '
'Did you forget to call model.train()?')
# Exact inference
if self.exact_inference:
n_train = len(train_xs[0])
full_inputs = [
torch.cat([train_x, input])
for train_x, input in zip(train_xs, args)
]
full_output = super(GPModel,
self).__call__(*full_inputs, **kwargs)
full_mean, full_covar = full_output.representation()
train_mean = full_mean[:n_train]
test_mean = full_mean[n_train:]
train_train_covar = gpytorch.add_diag(
full_covar[:n_train, :n_train],
self.likelihood.log_noise.exp())
train_test_covar = full_covar[:n_train, n_train:]
test_train_covar = full_covar[n_train:, :n_train]
test_test_covar = full_covar[n_train:, n_train:]
# Calculate posterior components
if not self.has_computed_alpha[0]:
alpha_strategy = gpytorch.posterior_strategy(
train_train_covar)
alpha = alpha_strategy.exact_posterior_alpha(
train_mean, train_y)
self.alpha.copy_(alpha.data)
self.has_computed_alpha.fill_(1)
else:
alpha = Variable(self.alpha)
if not self.has_computed_lanczos[
0] and gpytorch.functions.fast_pred_var:
lanczos_strategy = gpytorch.posterior_strategy(
train_train_covar)
q_mat, t_mat = lanczos_strategy.exact_posterior_lanczos()
self.lanczos_q_mat[:, :q_mat.size(1)].copy_(q_mat)
self.lanczos_t_mat[:t_mat.size(0), :t_mat.size(1)].copy_(
t_mat)
self.has_computed_lanczos.fill_(1)
mean_strategy = gpytorch.posterior_strategy(test_train_covar)
test_mean = mean_strategy.exact_posterior_mean(
test_mean, alpha)
if gpytorch.functions.fast_pred_var:
covar_strategy = gpytorch.posterior_strategy(full_covar)
test_covar = covar_strategy.exact_posterior_covar_fast(
Variable(self.lanczos_q_mat),
Variable(self.lanczos_t_mat))
else:
covar_strategy = gpytorch.posterior_strategy(
train_train_covar)
test_covar = covar_strategy.exact_posterior_covar(
test_train_covar, train_test_covar, test_test_covar)
output = GaussianRandomVariable(test_mean, test_covar)
# Approximate inference
else:
output = super(GPModel, self).__call__(*args, **kwargs)
# Training or Prior mode
else:
output = super(GPModel, self).__call__(*args, **kwargs)
if self.conditioning:
# Reset alpha cache
_, covar = output.representation()
self.has_computed_alpha.fill_(0)
self.alpha.resize_(
gpytorch.posterior_strategy(covar).alpha_size())
self.has_computed_lanczos.fill_(0)
lanczos_q_size, lanczos_t_size = gpytorch.posterior_strategy(
covar).lanczos_size()
self.lanczos_q_mat.resize_(lanczos_q_size).zero_()
lanczos_t_mat_init = torch.eye(*lanczos_t_size).type_as(
self.lanczos_t_mat)
self.lanczos_t_mat.resize_(lanczos_t_size).copy_(
lanczos_t_mat_init)
# Don't go through the output if we're training a variational inference model
if self.training and not self.exact_inference:
return output
# Now go through the likelihood
if isinstance(output, Variable) or isinstance(
output, RandomVariable) or isinstance(output, LazyVariable):
output = (output, )
return self.likelihood(*output)
def __call__(self, *args, **kwargs):
output = None
# Posterior mode
if self.posterior:
train_xs = self.train_inputs
train_y = self.train_target
if all([
torch.equal(train_x.data, input.data)
for train_x, input in zip(train_xs, args)
]):
logging.warning('The input matches the stored training data. '
'Did you forget to call model.train()?')
n_train = len(train_xs[0])
full_inputs = [
torch.cat([train_x, input])
for train_x, input in zip(train_xs, args)
]
full_output = super(GPModel, self).__call__(*full_inputs, **kwargs)
full_mean, full_covar = full_output.representation()
# Exact inference
if self.exact_inference:
n_train = len(train_xs[0])
full_inputs = [
torch.cat([train_x, input])
for train_x, input in zip(train_xs, args)
]
full_output = super(GPModel,
self).__call__(*full_inputs, **kwargs)
full_mean, full_covar = full_output.representation()
train_mean = full_mean[:n_train]
test_mean = full_mean[n_train:]
train_train_covar = gpytorch.add_diag(
full_covar[:n_train, :n_train],
self.likelihood.log_noise.exp())
train_test_covar = full_covar[:n_train, n_train:]
test_train_covar = full_covar[n_train:, :n_train]
test_test_covar = full_covar[n_train:, n_train:]
# Calculate posterior components
if not self.has_computed_alpha[0]:
alpha_strategy = gpytorch.posterior_strategy(
train_train_covar)
alpha = alpha_strategy.exact_posterior_alpha(
train_mean, train_y)
self.alpha.copy_(alpha.data)
self.has_computed_alpha.fill_(1)
else:
alpha = Variable(self.alpha)
mean_strategy = gpytorch.posterior_strategy(test_train_covar)
test_mean = mean_strategy.exact_posterior_mean(
test_mean, alpha)
covar_strategy = gpytorch.posterior_strategy(train_train_covar)
test_covar = covar_strategy.exact_posterior_covar(
test_train_covar, train_test_covar, test_test_covar)
output = GaussianRandomVariable(test_mean, test_covar)
# Approximate inference
else:
# Ensure variational parameters have been initalized
if not self.variational_mean.numel():
raise RuntimeError(
'Variational parameters have not been initalized.'
'Condition on data.')
# Get inducing points
if hasattr(self, 'inducing_points'):
inducing_points = Variable(self.inducing_points)
else:
inducing_points = train_xs[0]
n_induc = len(inducing_points)
full_input = torch.cat([inducing_points, args[0]])
full_output = super(GPModel,
self).__call__(full_input, **kwargs)
full_mean, full_covar = full_output.representation()
test_mean = full_mean[n_induc:]
induc_induc_covar = full_covar[:n_induc, :n_induc]
induc_test_covar = full_covar[:n_induc, n_induc:]
test_induc_covar = full_covar[n_induc:, :n_induc]
test_test_covar = full_covar[n_induc:, n_induc:]
# Calculate posterior components
if not self.has_computed_alpha[0]:
alpha_strategy = gpytorch.posterior_strategy(
induc_induc_covar)
alpha = alpha_strategy.variational_posterior_alpha(
self.variational_mean)
self.alpha.copy_(alpha.data)
self.has_computed_alpha.fill_(1)
else:
alpha = Variable(self.alpha)
mean_strategy = gpytorch.posterior_strategy(test_induc_covar)
test_mean = mean_strategy.variational_posterior_mean(alpha)
covar_strategy = gpytorch.posterior_strategy(test_induc_covar)
test_covar = covar_strategy.variational_posterior_covar(
induc_test_covar, self.chol_variational_covar,
test_test_covar, induc_induc_covar)
output = GaussianRandomVariable(test_mean, test_covar)
# Training or Prior mode
else:
output = super(GPModel, self).__call__(*args, **kwargs)
# Add some jitter
if not self.exact_inference:
mean, covar = output.representation()
covar = gpytorch.add_jitter(covar)
output = GaussianRandomVariable(mean, covar)
if self.conditioning:
# Reset alpha cache
_, covar = output.representation()
self.has_computed_alpha.fill_(0)
self.alpha.resize_(
gpytorch.posterior_strategy(covar).alpha_size())
# Now go through the likelihood
if isinstance(output, Variable) or isinstance(
output, RandomVariable) or isinstance(output, LazyVariable):
output = (output, )
return self.likelihood(*output)
