def prior_output(self): res = super(AbstractVariationalGP, self).__call__(self.inducing_points) if not isinstance(res, GaussianRandomVariable): raise RuntimeError( "%s.forward must return a GaussianRandomVariable" % self.__class__.__name__) res = GaussianRandomVariable(res.mean(), res.covar().evaluate_kernel()) return res
def forward(self, x1, x2, **kwargs): covar = self._get_covariance(x1, x2) if self.training: if not torch.equal(x1, x2): raise RuntimeError("x1 should equal x2 in training mode") zero_mean = torch.zeros_like(x1.select(-1, 0)) new_variational_strategy = MVNVariationalStrategy( GaussianRandomVariable(zero_mean, self._covar_diag(x1)), GaussianRandomVariable(zero_mean, covar) ) self.update_variational_strategy("inducing_point_strategy", new_variational_strategy) return covar
def __call__(self, inputs, **kwargs): if inputs.ndimension() == 1: inputs = inputs.unsqueeze(-1).unsqueeze(-1) elif inputs.ndimension() == 2: inputs = inputs.unsqueeze(-1) elif inputs.ndimension() != 3: raise RuntimeError( "AdditiveGridInducingVariationalGP expects a 3d tensor.") n_data, n_components, n_dimensions = inputs.size() if n_dimensions != self.grid.size(0): raise RuntimeError( "The number of dimensions should match the inducing points " " number of dimensions.") if n_components != self.n_components: raise RuntimeError( "The number of components should match the number specified.") if n_dimensions != 1: raise RuntimeError( "At the moment, AdditiveGridInducingVariationalGP only supports " "1d (Toeplitz) interpolation.") output = super(AdditiveGridInducingVariationalGP, self).__call__(inputs, **kwargs) if self.sum_output: mean = output.mean().sum(0) covar = output.covar().sum_batch() return GaussianRandomVariable(mean, covar) else: return output
def forward(self, *inputs, **params): n = len(self.train_xs[0]) if hasattr(self, 'train_xs') else 0 m = len(inputs[0]) # Compute mean and full data (train/test) covar if n: train_x_vars = [Variable(train_x) for train_x in self.train_xs] full_inputs = [torch.cat([train_x_var, input]) for train_x_var, input in zip(train_x_vars, inputs)] else: full_inputs = inputs gaussian_rv_output, log_noise = self.gp_observation_model.forward(*full_inputs, **params) full_mean, full_covar = gaussian_rv_output.representation() # Get mean/covar components test_mean = full_mean[n:] test_test_covar = full_covar[n:, n:] # If there's data, use it if n: train_y_var = Variable(self.train_y) train_mean = full_mean[:n] train_train_covar = AddDiag()(full_covar[:n, :n], log_noise.exp()) test_train_covar = full_covar[n:, :n] train_test_covar = full_covar[:n, n:] # Update test mean alpha = Invmv()(train_train_covar, train_y_var - train_mean) test_mean = test_mean.add(torch.mv(test_train_covar, alpha)) # Update test-test covar test_test_covar_correction = torch.mm(test_train_covar, Invmm()(train_train_covar, train_test_covar)) test_test_covar = test_test_covar.sub(test_test_covar_correction) return GaussianRandomVariable(test_mean, test_test_covar), log_noise
def forward(self, x): mean_x = self.mean_module(x, constant=self.params.constant_mean) covar_x = self.covar_module( x, log_lengthscale=self.params.log_lengthscale) latent_pred = GaussianRandomVariable(mean_x, covar_x) return latent_pred, self.params.log_noise
def forward(self, x): projected_x = self.feature_extractor(x) projected_x = projected_x - projected_x.min(0)[0] projected_x = 2 * (projected_x / projected_x.max(0)[0]) - 1 mean_x = self.mean_module(projected_x) covar_x = self.covar_module(projected_x) #covar_x = covar_x.mul(self.log_outputscale.exp()) return GaussianRandomVariable(mean_x, covar_x)
def forward(self, x, i): # Get predictive mean mean_x = self.mean_module(x) # Get all covariances, we'll look up the task-speicific ones covar_x = self.covar_module(x) # # Get the covariance for task i covar_i = self.task_covar_module(i) covar_xi = covar_x.mul(covar_i) return GaussianRandomVariable(mean_x, covar_xi)
def forward(self,x): # Learned mean is near-zero mean_x = self.mean_module(x) # Get predictive and scale covar_x = self.covar_module(x) covar_x = covar_x.mul(self.log_outputscale.exp()) # Store as Gaussian latent_pred = GaussianRandomVariable(mean_x, covar_x) return latent_pred
def forward(self, x): mean_x = self.mean_module(x, constant=Variable(torch.Tensor([0]))) covar_x = self.covar_module( x, log_mixture_weights=self.params.log_mixture_weights, log_mixture_means=self.params.log_mixture_means, log_mixture_scales=self.params.log_mixture_scales) latent_pred = GaussianRandomVariable(mean_x, covar_x) return latent_pred, self.params.log_noise
def forward(self, *inputs, **params): if not self.training: inducing_point_vars = [ inducing_pt for inducing_pt in self.inducing_points ] full_inputs = [ torch.cat([inducing_point_var, input]) for inducing_point_var, input in zip( inducing_point_vars, inputs) ] else: full_inputs = inputs gaussian_rv_output = self.prior_model.forward(*full_inputs, **params) full_mean, full_covar = gaussian_rv_output.representation() if not self.training: # Get mean/covar components n = self.num_inducing test_mean = full_mean[n:] induc_induc_covar = full_covar[:n, :n] induc_test_covar = full_covar[:n, n:] test_induc_covar = full_covar[n:, :n] test_test_covar = full_covar[n:, n:] # Calculate posterior components if not hasattr(self, 'alpha'): self.alpha = gpytorch.variational_posterior_alpha( induc_induc_covar, self.variational_mean) test_mean = gpytorch.variational_posterior_mean( test_induc_covar, self.alpha) test_covar = gpytorch.variational_posterior_covar( test_induc_covar, induc_test_covar, self.chol_variational_covar, test_test_covar, induc_induc_covar) output = GaussianRandomVariable(test_mean, test_covar) return output else: full_covar = gpytorch.add_jitter(full_covar) f_prior = GaussianRandomVariable(full_mean, full_covar) return f_prior
def forward(self, x, i): mean_x = self.mean_module(x, constant=self.model_params.constant_mean) covar_x = self.covar_module(x, log_lengthscale=self.model_params.log_lengthscale) covar_i = self.task_covar_module(i, index_covar_factor=self.task_params.task_matrix, index_log_var=self.task_params.task_log_vars) covar_xi = covar_x.mul(covar_i) latent_pred = GaussianRandomVariable(mean_x, covar_xi) return latent_pred, self.model_params.log_noise
def forward(self, *inputs, **params): has_posterior = len(self.train_xs[0]) if hasattr(self, 'train_xs') else 0 n = len(self.inducing_points[0]) if has_posterior: inducing_point_vars = [ Variable(train_x) for train_x in self.train_xs ] full_inputs = [ torch.cat([inducing_point_var, input]) for inducing_point_var, input in zip( inducing_point_vars, inputs) ] else: full_inputs = inputs gaussian_rv_output = self.gp_observation_model.forward( *full_inputs, **params) full_mean, full_covar = gaussian_rv_output.representation() if not has_posterior: test_mean = full_mean test_covar = full_covar else: train_train_covar = full_covar[:n, :n] test_train_covar = full_covar[n:, :n] train_test_covar = full_covar[:n, n:] alpha = Invmv()(train_train_covar, self.variational_parameters.variational_mean) test_mean = torch.mv(test_train_covar, alpha) chol_covar = self.variational_parameters.chol_variational_covar variational_covar = chol_covar.t().mm(chol_covar) test_covar = variational_covar - train_train_covar # test_covar = K_{mn}K_{nn}^{-1}(S - K_{nn}) test_covar = torch.mm(test_train_covar, Invmm()(train_train_covar, test_covar)) # right_factor = K_{nn}^{-1}K_{nm} right_factor = Invmm()(train_train_covar, train_test_covar) # test_covar = K_{mn}K_{nn}^{-1}(S - K_{nn})K_{nn}^{-1}K_{nm} test_covar = full_covar[n:, n:] + test_covar.mm(right_factor) return GaussianRandomVariable(test_mean, test_covar)
def variational_output(self): chol_variational_covar = self.chol_variational_covar # Negate each row with a negative diagonal (the Cholesky decomposition # of a matrix requires that the diagonal elements be positive). if chol_variational_covar.ndimension() == 2: chol_variational_covar = chol_variational_covar.triu() inside = chol_variational_covar.diag().sign().unsqueeze( 1).expand_as(chol_variational_covar).triu() elif chol_variational_covar.ndimension() == 3: batch_size, diag_size, _ = chol_variational_covar.size() # Batch mode chol_variational_covar_size = list( chol_variational_covar.size())[-2:] mask = torch.ones(*chol_variational_covar_size, dtype=chol_variational_covar.dtype, device=chol_variational_covar.device).triu_() mask = mask.unsqueeze(0).expand( *([chol_variational_covar.size(0)] + chol_variational_covar_size)) batch_index = torch.arange(0, batch_size, dtype=torch.long, device=mask.device) batch_index = batch_index.unsqueeze(1).repeat(1, diag_size).view(-1) diag_index = torch.arange(0, diag_size, dtype=torch.long, device=mask.device) diag_index = diag_index.unsqueeze(1).repeat(batch_size, 1).view(-1) diag = chol_variational_covar[batch_index, diag_index, diag_index].view( batch_size, diag_size) chol_variational_covar = chol_variational_covar.mul(mask) inside = diag.sign().unsqueeze(-1).expand_as( chol_variational_covar).mul(mask) else: raise RuntimeError( "Invalid number of variational covar dimensions") chol_variational_covar = inside.mul(chol_variational_covar) variational_covar = CholLazyTensor( chol_variational_covar.transpose(-1, -2)) return GaussianRandomVariable(self.variational_mean, variational_covar)
def forward(self, x, i): n = len(x) mean_x = self.mean_module(x, constant=self.model_params.constant_mean) covar_x = self.covar_module(x, log_lengthscale=self.model_params.log_lengthscale) covar_i = Variable(torch.zeros(n, n)) for j in range(self.num_task_samples): task_assignments = self.latent_tasks.task_assignments.sample() task_assignments = task_assignments.index_select(0, i) covar_ji = self.task_covar_module(task_assignments, index_covar_factor=self.task_params.task_matrix, index_log_var=self.task_params.task_log_vars) covar_i += covar_ji.mul_(1. / self.num_task_samples) covar_xi = covar_x.mul(covar_i) latent_pred = GaussianRandomVariable(mean_x, covar_xi) return latent_pred, self.model_params.log_noise
def forward(self, x): mean_x = self.mean_module(x) covar_x = self.covar_module(x) # Return moddl output as GaussianRandomVariable return GaussianRandomVariable(mean_x, covar_x)
def forward(self, x): mean_x = self.mean_module(x) covar_x = self.covar_module(x) covar_x = covar_x.mul(self.log_outputscale.exp().expand_as(covar_x)) latent_pred = GaussianRandomVariable(mean_x, covar_x) return latent_pred
def forward(self, x, i): mean_x = self.mean_module(x) covar_x = self.covar_module(x) covar_i = self.task_covar_module(i) covar_xi = covar_x.mul(covar_i) return GaussianRandomVariable(mean_x, covar_xi)
def forward(self, x): mean_x = self.mean_module(x) covar_x = self.covar_module(x).add_diag(Variable(torch.Tensor([1e-2]))) return GaussianRandomVariable(mean_x, covar_x)
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 forward(self, x): mean_x = self.mean_module(x) covar_x = ConstantMulLazyVariable(self.covar_module(x), self.log_outputscale.exp()) latent_pred = GaussianRandomVariable(mean_x, covar_x) return latent_pred
def forward(self, input, log_noise): assert (isinstance(input, GaussianRandomVariable)) mean, covar = input.representation() noise = AddDiag()(covar, log_noise.exp()) return GaussianRandomVariable(mean, noise)
def forward(self,x): mean_x = self.mean_module(x) covar_x = self.covar_module(x) covar_x = covar_x.mul(self.log_outputscale.exp()) return GaussianRandomVariable(mean_x, covar_x)
def prior_output(self): out = super(AdditiveGridInducingVariationalGP, self).prior_output() mean = out.mean() covar = out.covar().repeat(self.n_components, 1, 1) return GaussianRandomVariable(mean, covar)
def forward(self, x): mean_x = self.mean_module(x) covar_x = self.covar_module(x) return GaussianRandomVariable(mean_x, covar_x)
def forward(self, x): features = self.feature_extractor(x) features = gpytorch.utils.scale_to_bounds(features, 0, 1) mean_x = self.mean_module(features) covar_x = self.covar_module(features) return GaussianRandomVariable(mean_x, covar_x)