def _get_model(self, batch_shape, num_outputs, n, **tkwargs):
train_x, train_y = _get_random_data(
batch_shape=batch_shape, num_outputs=num_outputs, n=n, **tkwargs
)
train_yvar = torch.full_like(train_y, 0.01)
model = FixedNoiseGP(train_X=train_x, train_Y=train_y, train_Yvar=train_yvar)
return model.to(**tkwargs)
def _get_model(n, fixed_noise=False, use_octf=False, **tkwargs):
train_x1, train_y1 = _get_random_data(batch_shape=torch.Size(),
m=1,
n=10,
**tkwargs)
train_x2, train_y2 = _get_random_data(batch_shape=torch.Size(),
m=1,
n=11,
**tkwargs)
octfs = [Standardize(m=1), Standardize(m=1)] if use_octf else [None, None]
if fixed_noise:
train_y1_var = 0.1 + 0.1 * torch.rand_like(train_y1, **tkwargs)
train_y2_var = 0.1 + 0.1 * torch.rand_like(train_y2, **tkwargs)
model1 = FixedNoiseGP(
train_X=train_x1,
train_Y=train_y1,
train_Yvar=train_y1_var,
outcome_transform=octfs[0],
)
model2 = FixedNoiseGP(
train_X=train_x2,
train_Y=train_y2,
train_Yvar=train_y2_var,
outcome_transform=octfs[1],
)
else:
model1 = SingleTaskGP(train_X=train_x1,
train_Y=train_y1,
outcome_transform=octfs[0])
model2 = SingleTaskGP(train_X=train_x2,
train_Y=train_y2,
outcome_transform=octfs[1])
model = ModelListGP(model1, model2)
return model.to(**tkwargs)
def _get_model(self, batch_shape, num_outputs, n, **tkwargs):
train_x, train_y = _get_random_data(batch_shape=batch_shape,
num_outputs=num_outputs,
n=n,
**tkwargs)
train_yvar = torch.full_like(train_y, 0.01)
model = FixedNoiseGP(train_X=train_x,
train_Y=train_y,
train_Yvar=train_yvar)
return model.to(**tkwargs)
def _get_model(n, fixed_noise=False, **tkwargs):
train_x1, train_x2, train_y1, train_y2 = _get_random_data(n=n, **tkwargs)
if fixed_noise:
train_y1_var = 0.1 + 0.1 * torch.rand_like(train_y1, **tkwargs)
train_y2_var = 0.1 + 0.1 * torch.rand_like(train_y2, **tkwargs)
model1 = FixedNoiseGP(train_X=train_x1,
train_Y=train_y1,
train_Yvar=train_y1_var)
model2 = FixedNoiseGP(train_X=train_x2,
train_Y=train_y2,
train_Yvar=train_y2_var)
else:
model1 = SingleTaskGP(train_X=train_x1, train_Y=train_y1)
model2 = SingleTaskGP(train_X=train_x2, train_Y=train_y2)
model = ModelListGP(model1, model2)
return model.to(**tkwargs)
def _get_model(
X: Tensor,
Y: Tensor,
Yvar: Tensor,
task_feature: Optional[int] = None,
fidelity_features: Optional[List[int]] = None,
**kwargs: Any,
) -> GPyTorchModel:
"""Instantiate a model of type depending on the input data.
Args:
X: A `n x d` tensor of input features.
Y: A `n x m` tensor of input observations.
Yvar: A `n x m` tensor of input variances (NaN if unobserved).
task_feature: The index of the column pertaining to the task feature
(if present).
fidelity_features: List of columns of X that are fidelity parameters.
Returns:
A GPyTorchModel (unfitted).
"""
Yvar = Yvar.clamp_min_(MIN_OBSERVED_NOISE_LEVEL)
is_nan = torch.isnan(Yvar)
any_nan_Yvar = torch.any(is_nan)
all_nan_Yvar = torch.all(is_nan)
if any_nan_Yvar and not all_nan_Yvar:
raise ValueError(
"Mix of known and unknown variances indicates valuation function "
"errors. Variances should all be specified, or none should be."
)
if fidelity_features is None:
fidelity_features = []
if len(fidelity_features) == 0:
# only pass linear_truncated arg if there are fidelities
kwargs = {k: v for k, v in kwargs.items() if k != "linear_truncated"}
if len(fidelity_features) > 0:
if task_feature:
raise NotImplementedError(
"multi-task multi-fidelity models not yet available"
)
# at this point we can assume that there is only a single fidelity parameter
gp = SingleTaskMultiFidelityGP(
train_X=X, train_Y=Y, data_fidelity=fidelity_features[0], **kwargs
)
elif task_feature is None and all_nan_Yvar:
gp = SingleTaskGP(train_X=X, train_Y=Y, **kwargs)
elif task_feature is None:
gp = FixedNoiseGP(train_X=X, train_Y=Y, train_Yvar=Yvar, **kwargs)
elif all_nan_Yvar:
gp = MultiTaskGP(train_X=X, train_Y=Y, task_feature=task_feature, **kwargs)
else:
gp = FixedNoiseMultiTaskGP(
train_X=X,
train_Y=Y.view(-1),
train_Yvar=Yvar.view(-1),
task_feature=task_feature,
**kwargs,
)
return gp
def _get_model_and_data(self, batch_shape, num_outputs, **tkwargs):
train_X, train_Y = _get_random_data(batch_shape=batch_shape,
num_outputs=num_outputs,
**tkwargs)
model_kwargs = {
"train_X": train_X,
"train_Y": train_Y,
"train_Yvar": torch.full_like(train_Y, 0.01),
}
model = FixedNoiseGP(**model_kwargs)
return model, model_kwargs
def _get_model_and_data(
self, batch_shape, m, outcome_transform=None, input_transform=None, **tkwargs
):
train_X, train_Y = _get_random_data(batch_shape=batch_shape, m=m, **tkwargs)
model_kwargs = {
"train_X": train_X,
"train_Y": train_Y,
"train_Yvar": torch.full_like(train_Y, 0.01),
"input_transform": input_transform,
"outcome_transform": outcome_transform,
}
model = FixedNoiseGP(**model_kwargs)
return model, model_kwargs
def _get_model(X: Tensor, Y: Tensor, Yvar: Tensor,
task_feature: Optional[int]) -> GPyTorchModel:
"""Instantiate a model of type depending on the input data."""
Yvar = Yvar.clamp_min_(MIN_OBSERVED_NOISE_LEVEL) # pyre-ignore: [16]
if task_feature is None:
gp = FixedNoiseGP(train_X=X, train_Y=Y, train_Yvar=Yvar)
else:
gp = FixedNoiseMultiTaskGP(
train_X=X,
train_Y=Y.view(-1),
train_Yvar=Yvar.view(-1),
task_feature=task_feature,
)
return gp
def _get_model_and_data(self,
batch_shape,
m,
outcome_transform=None,
**tkwargs):
train_X, train_Y = _get_random_data(batch_shape=batch_shape,
num_outputs=m,
**tkwargs)
model_kwargs = {
"train_X": train_X,
"train_Y": train_Y,
"train_Yvar": torch.full_like(train_Y, 0.01),
}
if outcome_transform is not None:
model_kwargs["outcome_transform"] = outcome_transform
model = FixedNoiseGP(**model_kwargs)
return model, model_kwargs
def __init__(self, stem, init_x, init_y, alpha_eps, lr, **kwargs):
stem = stem.to(init_x.device)
transformed_y, _, sigma2_i = self._transform_targets(init_y, alpha_eps)
if transformed_y.t().shape[0] != 1:
_batch_shape = transformed_y.t().shape[:-1]
else:
_batch_shape = torch.Size()
features = stem(init_x)
gp = FixedNoiseGP(features,
transformed_y,
sigma2_i,
covar_module=ScaleKernel(RBFKernel(
batch_shape=_batch_shape,
ard_num_dims=stem.output_dim),
batch_shape=_batch_shape))
mll = ExactMarginalLogLikelihood(gp.likelihood, gp)
super().__init__(stem, gp, mll, alpha_eps, lr)
self._raw_inputs = [init_x]
self._target_batch_shape = _batch_shape
def _get_model(
X: Tensor,
Y: Tensor,
Yvar: Tensor,
task_feature: Optional[int],
fidelity_features: Optional[List[int]] = None,
fidelity_model_id: Optional[int] = None,
) -> GPyTorchModel:
"""Instantiate a model of type depending on the input data."""
Yvar = Yvar.clamp_min_(MIN_OBSERVED_NOISE_LEVEL) # pyre-ignore: [16]
is_nan = torch.isnan(Yvar)
any_nan_Yvar = torch.any(is_nan)
all_nan_Yvar = torch.all(is_nan)
if any_nan_Yvar and not all_nan_Yvar:
raise ValueError(
"Mix of known and unknown variances indicates "
"valuation function errors. Variances should all be specified, or "
"none should be.")
if fidelity_features is None:
fidelity_features = []
if fidelity_model_id is None or len(fidelity_features) == 0:
if task_feature is None and all_nan_Yvar:
gp = SingleTaskGP(train_X=X, train_Y=Y)
elif task_feature is None:
gp = FixedNoiseGP(train_X=X, train_Y=Y, train_Yvar=Yvar)
elif all_nan_Yvar:
gp = MultiTaskGP(train_X=X, train_Y=Y, task_feature=task_feature)
else:
gp = FixedNoiseMultiTaskGP(
train_X=X,
train_Y=Y.view(-1),
train_Yvar=Yvar.view(-1),
task_feature=task_feature,
)
else:
gp_model = model_list[fidelity_model_id]
# pyre-ignore [29]
gp = gp_model(train_X=X, train_Y=Y, train_data_fidelity=False)
return gp
def fixed_noise_gp_model_constructor(
Xs: List[Tensor],
Ys: List[Tensor],
Yvars: List[Tensor], # Maybe these should be optional where irrelevant?
task_features: List[int],
fidelity_features: List[int],
metric_names: List[str],
state_dict: Optional[Dict[str, Tensor]] = None,
refit_model: bool = True,
**kwargs: Any,
) -> Model:
gp = FixedNoiseGP(train_X=Xs[0], train_Y=Ys[0], train_Yvar=Yvars[0], **kwargs)
gp.to(Xs[0])
if state_dict is not None:
gp.load_state_dict(state_dict)
if state_dict is None or refit_model:
fit_gpytorch_model(ExactMarginalLogLikelihood(gp.likelihood, gp))
return gp
def _get_noiseless_fantasy_model(model: FixedNoiseGP, batch_X_observed: Tensor,
Y_fantasized: Tensor) -> FixedNoiseGP:
r"""Construct a fantasy model from a fitted model and provided fantasies.
The fantasy model uses the hyperparameters from the original fitted model and
assumes the fantasies are noiseless.
Args:
model: a fitted FixedNoiseGP
batch_X_observed: A `b x n x d` tensor of inputs where `b` is the number of
fantasies.
Y_fantasized: A `b x n` tensor of fantasized targets where `b` is the number of
fantasies.
Returns:
The fantasy model.
"""
# initialize a copy of FixedNoiseGP on the original training inputs
# this makes FixedNoiseGP a non-batch GP, so that the same hyperparameters
# are used across all batches (by default, a GP with batched training data
# uses independent hyperparameters for each batch).
fantasy_model = FixedNoiseGP(
train_X=model.train_inputs[0],
train_Y=model.train_targets.unsqueeze(-1),
train_Yvar=model.likelihood.noise_covar.noise.unsqueeze(-1),
)
# update training inputs/targets to be batch mode fantasies
fantasy_model.set_train_data(inputs=batch_X_observed,
targets=Y_fantasized,
strict=False)
# use noiseless fantasies
fantasy_model.likelihood.noise_covar.noise = torch.full_like(
Y_fantasized, 1e-7)
# load hyperparameters from original model
state_dict = deepcopy(model.state_dict())
fantasy_model.load_state_dict(state_dict)
return fantasy_model
def fixed_noise_gp_model_constructor(
Xs: List[Tensor],
Ys: List[Tensor],
Yvars: List[Tensor],
task_features: List[int],
fidelity_features: List[int],
metric_names: List[str],
state_dict: Optional[Dict[str, Tensor]] = None,
refit_model: bool = True,
**kwargs: Any,
) -> Model:
gp = FixedNoiseGP(train_X=Xs[0], train_Y=Ys[0], train_Yvar=Yvars[0], **kwargs)
gp.to(Xs[0])
if state_dict is not None:
# pyre-fixme[6]: Expected `OrderedDict[typing.Any, typing.Any]` for 1st
# param but got `Dict[str, Tensor]`.
gp.load_state_dict(state_dict)
if state_dict is None or refit_model:
fit_gpytorch_model(ExactMarginalLogLikelihood(gp.likelihood, gp))
return gp
def _get_model(
X: Tensor,
Y: Tensor,
Yvar: Tensor,
task_feature: Optional[int] = None,
fidelity_features: Optional[List[int]] = None,
use_input_warping: bool = False,
**kwargs: Any,
) -> GPyTorchModel:
"""Instantiate a model of type depending on the input data.
Args:
X: A `n x d` tensor of input features.
Y: A `n x m` tensor of input observations.
Yvar: A `n x m` tensor of input variances (NaN if unobserved).
task_feature: The index of the column pertaining to the task feature
(if present).
fidelity_features: List of columns of X that are fidelity parameters.
Returns:
A GPyTorchModel (unfitted).
"""
Yvar = Yvar.clamp_min(MIN_OBSERVED_NOISE_LEVEL) # pyre-ignore[16]
is_nan = torch.isnan(Yvar)
any_nan_Yvar = torch.any(is_nan)
all_nan_Yvar = torch.all(is_nan)
if any_nan_Yvar and not all_nan_Yvar:
if task_feature:
# TODO (jej): Replace with inferred noise before making perf judgements.
Yvar[Yvar != Yvar] = MIN_OBSERVED_NOISE_LEVEL
else:
raise ValueError(
"Mix of known and unknown variances indicates valuation function "
"errors. Variances should all be specified, or none should be."
)
if use_input_warping:
warp_tf = get_warping_transform(
d=X.shape[-1],
task_feature=task_feature,
batch_shape=X.shape[:-2], # pyre-ignore [6]
)
else:
warp_tf = None
if fidelity_features is None:
fidelity_features = []
if len(fidelity_features) == 0:
# only pass linear_truncated arg if there are fidelities
kwargs = {k: v for k, v in kwargs.items() if k != "linear_truncated"}
if len(fidelity_features) > 0:
if task_feature:
raise NotImplementedError( # pragma: no cover
"multi-task multi-fidelity models not yet available"
)
# at this point we can assume that there is only a single fidelity parameter
gp = SingleTaskMultiFidelityGP(
train_X=X,
train_Y=Y,
data_fidelity=fidelity_features[0],
input_transform=warp_tf,
**kwargs,
)
elif task_feature is None and all_nan_Yvar:
gp = SingleTaskGP(train_X=X, train_Y=Y, input_transform=warp_tf, **kwargs)
elif task_feature is None:
gp = FixedNoiseGP(
train_X=X, train_Y=Y, train_Yvar=Yvar, input_transform=warp_tf, **kwargs
)
else:
# instantiate multitask GP
all_tasks, _, _ = MultiTaskGP.get_all_tasks(X, task_feature)
num_tasks = len(all_tasks)
prior_dict = kwargs.get("prior")
prior = None
if prior_dict is not None:
prior_type = prior_dict.get("type", None)
if issubclass(prior_type, LKJCovariancePrior):
sd_prior = prior_dict.get("sd_prior", GammaPrior(1.0, 0.15))
sd_prior._event_shape = torch.Size([num_tasks])
eta = prior_dict.get("eta", 0.5)
if not isinstance(eta, float) and not isinstance(eta, int):
raise ValueError(f"eta must be a real number, your eta was {eta}")
prior = LKJCovariancePrior(num_tasks, eta, sd_prior)
else:
raise NotImplementedError(
"Currently only LKJ prior is supported,"
f"your prior type was {prior_type}."
)
if all_nan_Yvar:
gp = MultiTaskGP(
train_X=X,
train_Y=Y,
task_feature=task_feature,
rank=kwargs.get("rank"),
task_covar_prior=prior,
input_transform=warp_tf,
)
else:
gp = FixedNoiseMultiTaskGP(
train_X=X,
train_Y=Y,
train_Yvar=Yvar,
task_feature=task_feature,
rank=kwargs.get("rank"),
task_covar_prior=prior,
input_transform=warp_tf,
)
return gp
