def __init__(self, train_x, train_y, likelihood): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), num_tasks=2) self.base_kernel_list = [RBFKernel()] self.covar_module = LCMKernel(self.base_kernel_list, num_tasks=2, rank=1)
def create_mean(self): return MultitaskMean([ ConstantMean(batch_shape=torch.Size([2, 3])), ZeroMean(), ZeroMean() ], num_tasks=3)
def __init__(self, train_x, train_y, likelihood): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), n_tasks=2) self.data_covar_module = RBFKernel() self.covar_module = MultitaskKernel(self.data_covar_module, n_tasks=2, rank=1)
def __init__(self, train_inputs, train_targets, likelihood, batch_size=1): super(ExactGPModel, self).__init__(train_inputs, train_targets, likelihood) self.mean_module = MultitaskMean( ConstantMean(batch_size=batch_size, prior=gpytorch.priors.SmoothedBoxPrior(-1, 1)), num_tasks=2 ) if batch_size > 1: self.covar_module = MultitaskKernel( RBFKernel( batch_size=batch_size, lengthscale_prior=gpytorch.priors.NormalPrior( loc=torch.zeros(batch_size, 1, 1), scale=torch.ones(batch_size, 1, 1) ), ), num_tasks=2, rank=1, ) else: self.covar_module = MultitaskKernel( RBFKernel( lengthscale_prior=gpytorch.priors.NormalPrior( loc=torch.zeros(batch_size, 1, 1), scale=torch.ones(batch_size, 1, 1) ), ), num_tasks=2, rank=1, )
def __init__(self, train_x, train_y, likelihood): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), num_tasks=2) self.data_covar_module = GridInterpolationKernel(RBFKernel(), grid_size=100, num_dims=1) self.covar_module = MultitaskKernel(self.data_covar_module, num_tasks=2, rank=1)
def setUp(self): self.mean = MultitaskMean( [ConstantMean(), ZeroMean(), ZeroMean(), ConstantMean()], n_tasks=4) self.mean.base_means[0].constant.data.fill_(5) self.mean.base_means[3].constant.data.fill_(7)
def __init__(self, train_inputs, train_targets, likelihood, batch_shape=torch.Size()): super(ExactGPModel, self).__init__(train_inputs, train_targets, likelihood) self.mean_module = MultitaskMean( ConstantMean(batch_shape=batch_shape, prior=gpytorch.priors.SmoothedBoxPrior(-1, 1)), num_tasks=2 ) self.covar_module = MultitaskKernel( RBFKernel( batch_shape=batch_shape, lengthscale_prior=gpytorch.priors.NormalPrior(loc=torch.tensor(0.0), scale=torch.tensor(1.0)), ), num_tasks=2, rank=1, )
def __init__(self, input_size, target_size, device='cpu'): if device == 'gpu' and torch.cuda.is_available(): self.device = torch.device('cuda:0') else: self.device = torch.device('cpu') self.input_size = input_size self.target_size = target_size _likelihood = MultitaskGaussianLikelihood(num_tasks=self.target_size) super(MultiTaskGPRegressor, self).__init__(train_inputs=None, train_targets=None, likelihood=_likelihood) self.mean_module = MultitaskMean(ZeroMean(), num_tasks=self.target_size) self.covar_module = MultitaskKernel(RBFKernel(), num_tasks=self.target_size, rank=1) self.input_trans = None self.target_trans = None
def __init__(self, x: torch.Tensor, xe: torch.Tensor, y: torch.Tensor, lik: GaussianLikelihood, **conf): super().__init__((x, xe), y.squeeze(), lik) mean = conf.get('mean', ConstantMean()) kern = conf.get( 'kern', ScaleKernel(MaternKernel(nu=1.5, ard_num_dims=x.shape[1]), outputscale_prior=GammaPrior(0.5, 0.5))) kern_emb = conf.get('kern_emb', MaternKernel(nu=2.5)) self.multi_task = y.shape[1] > 1 self.mean = mean if not self.multi_task else MultitaskMean( mean, num_tasks=y.shape[1]) if x.shape[1] > 0: self.kern = kern if not self.multi_task else MultitaskKernel( kern, num_tasks=y.shape[1]) if xe.shape[1] > 0: assert 'num_uniqs' in conf num_uniqs = conf['num_uniqs'] emb_sizes = conf.get('emb_sizes', None) self.emb_trans = EmbTransform(num_uniqs, emb_sizes=emb_sizes) self.kern_emb = kern_emb if not self.multi_task else MultitaskKernel( kern_emb, num_tasks=y.shape[1])
def setUp(self): self.mean = MultitaskMean(ConstantMean(), n_tasks=4) self.mean.base_means[0].constant.data.fill_(0) self.mean.base_means[1].constant.data.fill_(1) self.mean.base_means[2].constant.data.fill_(2) self.mean.base_means[3].constant.data.fill_(3)
def __init__( self, train_x, train_y, likelihood, rank, num_mixtures, X_scaler, ): super().__init__(train_x, train_y, likelihood) num_dims = train_x.shape[1] num_tasks = train_y.shape[1] self.mean_module = MultitaskMean(Square2DPolynomialMean(), num_tasks=num_tasks) xmax = X_scaler.inverse_transform(np.ones((1, 2)))[0] xmin = X_scaler.inverse_transform(np.zeros((1, 2)))[0] llcoeff = (xmax - xmin)[0] / (xmax - xmin)[1] lower_ll_mean = 0.1 upper_ll_mean = 1e2 lower_ll_scale = 0.1 upper_ll_scale = 1e2 lower_mean_constraint = np.array( [1. / upper_ll_mean, 1. / (upper_ll_mean * llcoeff)]) upper_mean_constraint = np.array( [1. / lower_ll_mean, 1. / (lower_ll_mean * llcoeff)]) lower_scale_constraint = np.array( [1. / upper_ll_scale, 1. / (upper_ll_scale * llcoeff)]) upper_scale_constraint = np.array( [1. / lower_ll_scale, 1. / (lower_ll_scale * llcoeff)]) lower_mean_constraint = tensor( lower_mean_constraint, dtype=torch.float32, device=DEVICE, ) upper_mean_constraint = tensor( upper_mean_constraint, dtype=torch.float32, device=DEVICE, ) lower_scale_constraint = tensor( lower_scale_constraint, dtype=torch.float32, device=DEVICE, ) upper_scale_constraint = tensor( upper_scale_constraint, dtype=torch.float32, device=DEVICE, ) covar_module = PatchedSpectralMixtureKernel( num_mixtures, ard_num_dims=num_dims, mixture_scales_constraint=Interval( lower_scale_constraint, upper_scale_constraint, ), mixture_means_constraint=Interval( lower_mean_constraint, upper_mean_constraint, ), ) if IS_CUDA: covar_module = covar_module.cuda(device=DEVICE) covar_module.initialize_from_data(train_x, train_y) self.covar_module = MultitaskKernel( covar_module, num_tasks=num_tasks, rank=rank, ) self.init_multitask_from_data(Y=train_y, rank=rank)
def __init__( self, train_X: Tensor, train_Y: Tensor, likelihood: Optional[MultitaskGaussianLikelihood] = None, data_covar_module: Optional[Module] = None, task_covar_prior: Optional[Prior] = None, rank: Optional[int] = None, input_transform: Optional[InputTransform] = None, outcome_transform: Optional[OutcomeTransform] = None, **kwargs: Any, ) -> None: r"""Multi-task GP with Kronecker structure, using a simple ICM kernel. Args: train_X: A `batch_shape x n x d` tensor of training features. train_Y: A `batch_shape x n x m` tensor of training observations. likelihood: A `MultitaskGaussianLikelihood`. If omitted, uses a `MultitaskGaussianLikelihood` with a `GammaPrior(1.1, 0.05)` noise prior. data_covar_module: The module computing the covariance (Kernel) matrix in data space. If omitted, use a `MaternKernel`. task_covar_prior : A Prior on the task covariance matrix. Must operate on p.s.d. matrices. A common prior for this is the `LKJ` prior. If omitted, uses `LKJCovariancePrior` with `eta` parameter as specified in the keyword arguments (if not specified, use `eta=1.5`). rank: The rank of the ICM kernel. If omitted, use a full rank kernel. kwargs: Additional arguments to override default settings of priors, including: - eta: The eta parameter on the default LKJ task_covar_prior. A value of 1.0 is uninformative, values <1.0 favor stronger correlations (in magnitude), correlations vanish as eta -> inf. - sd_prior: A scalar prior over nonnegative numbers, which is used for the default LKJCovariancePrior task_covar_prior. - likelihood_rank: The rank of the task covariance matrix to fit. Defaults to 0 (which corresponds to a diagonal covariance matrix). Example: >>> train_X = torch.rand(10, 2) >>> train_Y = torch.cat([f_1(X), f_2(X)], dim=-1) >>> model = KroneckerMultiTaskGP(train_X, train_Y) """ with torch.no_grad(): transformed_X = self.transform_inputs( X=train_X, input_transform=input_transform) if outcome_transform is not None: train_Y, _ = outcome_transform(train_Y) self._validate_tensor_args(X=transformed_X, Y=train_Y) self._num_outputs = train_Y.shape[-1] batch_shape, ard_num_dims = train_X.shape[:-2], train_X.shape[-1] num_tasks = train_Y.shape[-1] if rank is None: rank = num_tasks if likelihood is None: noise_prior = GammaPrior(1.1, 0.05) noise_prior_mode = (noise_prior.concentration - 1) / noise_prior.rate likelihood = MultitaskGaussianLikelihood( num_tasks=num_tasks, batch_shape=batch_shape, noise_prior=noise_prior, noise_constraint=GreaterThan( MIN_INFERRED_NOISE_LEVEL, transform=None, initial_value=noise_prior_mode, ), rank=kwargs.get("likelihood_rank", 0), ) if task_covar_prior is None: task_covar_prior = LKJCovariancePrior( n=num_tasks, eta=torch.tensor(kwargs.get("eta", 1.5)).to(train_X), sd_prior=kwargs.get( "sd_prior", SmoothedBoxPrior(math.exp(-6), math.exp(1.25), 0.05), ), ) super().__init__(train_X, train_Y, likelihood) self.mean_module = MultitaskMean( base_means=ConstantMean(batch_shape=batch_shape), num_tasks=num_tasks) if data_covar_module is None: data_covar_module = MaternKernel( nu=2.5, ard_num_dims=ard_num_dims, lengthscale_prior=GammaPrior(3.0, 6.0), batch_shape=batch_shape, ) else: data_covar_module = data_covar_module self.covar_module = MultitaskKernel( data_covar_module=data_covar_module, num_tasks=num_tasks, rank=rank, batch_shape=batch_shape, task_covar_prior=task_covar_prior, ) if outcome_transform is not None: self.outcome_transform = outcome_transform if input_transform is not None: self.input_transform = input_transform self.to(train_X)
def __init__(self, train_x, train_y, likelihood): super().__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), num_tasks=2) self.covar_module = MultitaskKernel(RBFKernel(), num_tasks=2, rank=1)
def create_mean(self): return MultitaskMean( [ConstantMean(), ZeroMean(), ZeroMean()], num_tasks=3)
def __init__(self, train_x, train_y, likelihood, num_tasks=2): super(MultitaskGPModel, self).__init__(train_x, train_y, likelihood) self.mean_module = MultitaskMean(ConstantMean(), num_tasks=num_tasks) self.covar_module = MultitaskKernel(MaternKernel(), num_tasks=num_tasks)