def _model_best_point(
self,
bounds: List[Tuple[float, float]],
objective_weights: np.ndarray,
outcome_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
linear_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
fixed_features: Optional[Dict[int, float]],
model_gen_options: Optional[TConfig],
target_fidelities: Optional[Dict[int, float]],
) -> Optional[np.ndarray]: # pragma: no cover
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_gen"))
obj_w, oc_c, l_c, _ = self._validate_and_convert_to_tensors(
objective_weights=objective_weights,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
pending_observations=None,
)
try:
# pyre-fixme[16]: `Optional` has no attribute `best_point`.
X = self.model.best_point(
bounds=bounds,
objective_weights=obj_w,
outcome_constraints=oc_c,
linear_constraints=l_c,
fixed_features=fixed_features,
model_gen_options=model_gen_options,
target_fidelities=target_fidelities,
)
return None if X is None else X.detach().cpu().clone().numpy()
except NotImplementedError:
return None
def _model_cross_validate(
self,
Xs_train: List[np.ndarray],
Ys_train: List[np.ndarray],
Yvars_train: List[np.ndarray],
X_test: np.ndarray,
) -> Tuple[np.ndarray, np.ndarray]:
if not self.model: # pragma: no cover
raise ValueError(
FIT_MODEL_ERROR.format(action="_model_cross_validate"))
# pyre-fixme[35]: Target cannot be annotated.
Xs_train: List[Tensor] = self._array_list_to_tensors(Xs_train)
# pyre-fixme[35]: Target cannot be annotated.
Ys_train: List[Tensor] = self._array_list_to_tensors(Ys_train)
# pyre-fixme[35]: Target cannot be annotated.
Yvars_train: List[Tensor] = self._array_list_to_tensors(Yvars_train)
# pyre-fixme[35]: Target cannot be annotated.
X_test: Tensor = self._array_to_tensor(X_test)
# pyre-fixme[16]: `Optional` has no attribute `cross_validate`.
f_test, cov_test = self.model.cross_validate(Xs_train=Xs_train,
Ys_train=Ys_train,
Yvars_train=Yvars_train,
X_test=X_test)
return (
f_test.detach().cpu().clone().numpy(),
cov_test.detach().cpu().clone().numpy(),
)
def _model_gen(
self,
n: int,
bounds: List[Tuple[float, float]],
objective_weights: np.ndarray,
outcome_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
linear_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
fixed_features: Optional[Dict[int, float]],
pending_observations: Optional[List[np.ndarray]],
model_gen_options: Optional[TConfig],
rounding_func: Callable[[np.ndarray], np.ndarray],
) -> Tuple[np.ndarray, np.ndarray]:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_gen"))
obj_w, oc_c, l_c, pend_obs = self._validate_and_convert_to_tensors(
objective_weights=objective_weights,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
pending_observations=pending_observations,
)
tensor_rounding_func = self._array_callable_to_tensor_callable(
rounding_func)
X, w = self.model.gen(
n=n,
bounds=bounds,
objective_weights=obj_w,
outcome_constraints=oc_c,
linear_constraints=l_c,
fixed_features=fixed_features,
pending_observations=pend_obs,
model_gen_options=model_gen_options,
rounding_func=tensor_rounding_func,
)
return X.detach().cpu().clone().numpy(), w.detach().cpu().clone(
).numpy()
def _model_predict(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_predict"))
# pyre-fixme[16]: `Optional` has no attribute `predict`.
f, var = self.model.predict(X=self._array_to_tensor(X))
return f.detach().cpu().clone().numpy(), var.detach().cpu().clone(
).numpy()
def _model_update(
self,
Xs: List[np.ndarray],
Ys: List[np.ndarray],
Yvars: List[np.ndarray],
search_space_digest: SearchSpaceDigest,
candidate_metadata: Optional[List[List[TCandidateMetadata]]],
metric_names: List[str],
) -> None:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_update"))
# pyre-fixme[35]: Target cannot be annotated.
Xs: List[Tensor] = self._array_list_to_tensors(Xs)
# pyre-fixme[35]: Target cannot be annotated.
Ys: List[Tensor] = self._array_list_to_tensors(Ys)
# pyre-fixme[35]: Target cannot be annotated.
Yvars: List[Tensor] = self._array_list_to_tensors(Yvars)
# pyre-fixme[16]: `Optional` has no attribute `update`.
self.model.update(
Xs=Xs,
Ys=Ys,
Yvars=Yvars,
search_space_digest=search_space_digest,
metric_names=self.outcomes,
candidate_metadata=candidate_metadata,
)
def _model_update(
self,
Xs: List[np.ndarray],
Ys: List[np.ndarray],
Yvars: List[np.ndarray],
candidate_metadata: Optional[List[List[TCandidateMetadata]]],
bounds: List[Tuple[float, float]],
task_features: List[int],
feature_names: List[str],
metric_names: List[str],
fidelity_features: List[int],
target_fidelities: Optional[Dict[int, float]],
) -> None:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_update"))
# pyre-fixme[35]: Target cannot be annotated.
Xs: List[Tensor] = self._array_list_to_tensors(Xs)
# pyre-fixme[35]: Target cannot be annotated.
Ys: List[Tensor] = self._array_list_to_tensors(Ys)
# pyre-fixme[35]: Target cannot be annotated.
Yvars: List[Tensor] = self._array_list_to_tensors(Yvars)
# pyre-fixme[16]: `Optional` has no attribute `update`.
self.model.update(
Xs=Xs,
Ys=Ys,
Yvars=Yvars,
candidate_metadata=candidate_metadata,
bounds=bounds,
task_features=task_features,
feature_names=self.parameters,
metric_names=self.outcomes,
fidelity_features=list(target_fidelities.keys())
if target_fidelities else None,
)
def _model_update(self, Xs: List[np.ndarray], Ys: List[np.ndarray],
Yvars: List[np.ndarray]) -> None:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_update"))
Xs: List[Tensor] = self._array_list_to_tensors(Xs)
Ys: List[Tensor] = self._array_list_to_tensors(Ys)
Yvars: List[Tensor] = self._array_list_to_tensors(Yvars)
self.model.update(Xs=Xs, Ys=Ys, Yvars=Yvars)
def _model_evaluate_acquisition_function(self,
X: np.ndarray) -> np.ndarray:
if not self.model: # pragma: no cover
raise ValueError(
FIT_MODEL_ERROR.format(
action="_model_evaluate_acquisition_function"))
evals = not_none(self.model).evaluate_acquisition_function(
X=self._array_to_tensor(X))
return evals.detach().cpu().clone().numpy()
def _model_gen(
self,
n: int,
bounds: List[Tuple[float, float]],
objective_weights: np.ndarray,
outcome_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
linear_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
fixed_features: Optional[Dict[int, float]],
pending_observations: Optional[List[np.ndarray]],
model_gen_options: Optional[TConfig],
rounding_func: Callable[[np.ndarray], np.ndarray],
target_fidelities: Optional[Dict[int, float]],
objective_thresholds: Optional[np.ndarray] = None,
) -> Tuple[np.ndarray, np.ndarray, TGenMetadata, List[TCandidateMetadata]]:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_gen"))
(
obj_w,
oc_c,
l_c,
pend_obs,
obj_t,
) = validate_and_apply_final_transform(
objective_weights=objective_weights,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
pending_observations=pending_observations,
objective_thresholds=objective_thresholds,
final_transform=self._array_to_tensor,
)
tensor_rounding_func = self._array_callable_to_tensor_callable(
rounding_func)
augmented_model_gen_options = {
**self._default_model_gen_options,
**(model_gen_options or {}),
}
# pyre-fixme[16]: `Optional` has no attribute `gen`.
X, w, gen_metadata, candidate_metadata = self.model.gen(
n=n,
bounds=bounds,
objective_weights=obj_w,
outcome_constraints=oc_c,
objective_thresholds=obj_t,
linear_constraints=l_c,
fixed_features=fixed_features,
pending_observations=pend_obs,
model_gen_options=augmented_model_gen_options,
rounding_func=tensor_rounding_func,
target_fidelities=target_fidelities,
)
return (
X.detach().cpu().clone().numpy(),
w.detach().cpu().clone().numpy(),
gen_metadata,
candidate_metadata,
)
def _model_update(
self,
Xs: List[np.ndarray],
Ys: List[np.ndarray],
Yvars: List[np.ndarray],
candidate_metadata: Optional[List[List[TCandidateMetadata]]] = None,
) -> None:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_update"))
Xs: List[Tensor] = self._array_list_to_tensors(Xs)
Ys: List[Tensor] = self._array_list_to_tensors(Ys)
Yvars: List[Tensor] = self._array_list_to_tensors(Yvars)
# pyre-fixme[16]: `Optional` has no attribute `update`.
self.model.update(Xs=Xs,
Ys=Ys,
Yvars=Yvars,
candidate_metadata=candidate_metadata)
def _model_cross_validate(
self,
Xs_train: List[np.ndarray],
Ys_train: List[np.ndarray],
Yvars_train: List[np.ndarray],
X_test: np.ndarray,
) -> Tuple[np.ndarray, np.ndarray]:
if not self.model: # pragma: no cover
raise ValueError(
FIT_MODEL_ERROR.format(action="_model_cross_validate"))
Xs_train: List[Tensor] = self._array_list_to_tensors(Xs_train)
Ys_train: List[Tensor] = self._array_list_to_tensors(Ys_train)
Yvars_train: List[Tensor] = self._array_list_to_tensors(Yvars_train)
X_test: Tensor = self._array_to_tensor(X_test)
f_test, cov_test = self.model.cross_validate(Xs_train=Xs_train,
Ys_train=Ys_train,
Yvars_train=Yvars_train,
X_test=X_test)
return (
f_test.detach().cpu().clone().numpy(),
cov_test.detach().cpu().clone().numpy(),
)
def _model_evaluate_acquisition_function(
self,
X: np.ndarray,
search_space_digest: SearchSpaceDigest,
objective_weights: np.ndarray,
objective_thresholds: Optional[np.ndarray] = None,
outcome_constraints: Optional[Tuple[np.ndarray, np.ndarray]] = None,
linear_constraints: Optional[Tuple[np.ndarray, np.ndarray]] = None,
fixed_features: Optional[Dict[int, float]] = None,
pending_observations: Optional[List[np.ndarray]] = None,
acq_options: Optional[Dict[str, Any]] = None,
) -> np.ndarray:
if not self.model: # pragma: no cover
raise ValueError(
FIT_MODEL_ERROR.format(action="_model_evaluate_acquisition_function")
)
obj_w, oc_c, l_c, pend_obs, obj_thresh = validate_and_apply_final_transform(
objective_weights=objective_weights,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
pending_observations=pending_observations,
objective_thresholds=objective_thresholds,
final_transform=self._array_to_tensor,
)
evals = not_none(self.model).evaluate_acquisition_function(
X=self._array_to_tensor(X),
search_space_digest=search_space_digest,
objective_weights=obj_w,
objective_thresholds=obj_thresh,
outcome_constraints=oc_c,
linear_constraints=l_c,
fixed_features=fixed_features,
pending_observations=pend_obs,
acq_options=acq_options,
)
return evals.detach().cpu().clone().numpy()
def _model_cross_validate(
self,
Xs_train: List[np.ndarray],
Ys_train: List[np.ndarray],
Yvars_train: List[np.ndarray],
X_test: np.ndarray,
bounds: List[Tuple[float, float]],
task_features: List[int],
feature_names: List[str],
metric_names: List[str],
fidelity_features: List[int],
) -> Tuple[np.ndarray, np.ndarray]:
if not self.model: # pragma: no cover
raise ValueError(
FIT_MODEL_ERROR.format(action="_model_cross_validate"))
# pyre-fixme[35]: Target cannot be annotated.
Xs_train: List[Tensor] = self._array_list_to_tensors(Xs_train)
# pyre-fixme[35]: Target cannot be annotated.
Ys_train: List[Tensor] = self._array_list_to_tensors(Ys_train)
# pyre-fixme[35]: Target cannot be annotated.
Yvars_train: List[Tensor] = self._array_list_to_tensors(Yvars_train)
# pyre-fixme[35]: Target cannot be annotated.
X_test: Tensor = self._array_to_tensor(X_test)
# pyre-fixme[16]: `Optional` has no attribute `cross_validate`.
f_test, cov_test = self.model.cross_validate(
Xs_train=Xs_train,
Ys_train=Ys_train,
Yvars_train=Yvars_train,
X_test=X_test,
bounds=bounds,
task_features=task_features,
feature_names=feature_names,
metric_names=metric_names,
fidelity_features=fidelity_features,
)
return (
f_test.detach().cpu().clone().numpy(),
cov_test.detach().cpu().clone().numpy(),
)
def _model_predict(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_predict"))
f, var = not_none(self.model).predict(X=self._array_to_tensor(X))
return f.detach().cpu().clone().numpy(), var.detach().cpu().clone(
).numpy()
def _model_gen(
self,
n: int,
bounds: List[Tuple[float, float]],
objective_weights: np.ndarray,
outcome_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
linear_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
fixed_features: Optional[Dict[int, float]],
pending_observations: Optional[List[np.ndarray]],
model_gen_options: Optional[TConfig],
rounding_func: Callable[[np.ndarray], np.ndarray],
target_fidelities: Optional[Dict[int, float]],
) -> Tuple[np.ndarray, np.ndarray, TGenMetadata, List[TCandidateMetadata]]:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_gen"))
obj_w, oc_c, l_c, pend_obs = self._validate_and_convert_to_tensors(
objective_weights=objective_weights,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
pending_observations=pending_observations,
)
ref_point = None
if self._transformed_ref_point:
ref_point = not_none(self._transformed_ref_point)
elif self.ref_point:
ref_point = self.ref_point
logger.warning(
"No attribute _transformed_ref_point. Using untransformed ref_point."
)
if ref_point is not None:
ref_point_list = [
ref_point[name] for name in not_none(self.outcomes)
if name in ref_point
]
else:
ref_point_list = None
tensor_rounding_func = self._array_callable_to_tensor_callable(
rounding_func)
augmented_model_gen_options = {
**self._default_model_gen_options,
**(model_gen_options or {}),
}
# pyre-fixme[16]: `Optional` has no attribute `gen`.
X, w, gen_metadata, candidate_metadata = self.model.gen(
n=n,
bounds=bounds,
objective_weights=obj_w,
outcome_constraints=oc_c,
linear_constraints=l_c,
fixed_features=fixed_features,
pending_observations=pend_obs,
model_gen_options=augmented_model_gen_options,
rounding_func=tensor_rounding_func,
target_fidelities=target_fidelities,
ref_point=ref_point_list,
)
return (
X.detach().cpu().clone().numpy(),
w.detach().cpu().clone().numpy(),
gen_metadata,
candidate_metadata,
)
def _model_gen(
self,
n: int,
bounds: List[Tuple[float, float]],
objective_weights: np.ndarray,
outcome_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
linear_constraints: Optional[Tuple[np.ndarray, np.ndarray]],
fixed_features: Optional[Dict[int, float]],
pending_observations: Optional[List[np.ndarray]],
model_gen_options: Optional[TConfig],
rounding_func: Callable[[np.ndarray], np.ndarray],
target_fidelities: Optional[Dict[int, float]],
objective_thresholds: Optional[np.ndarray] = None,
) -> Tuple[np.ndarray, np.ndarray, TGenMetadata, List[TCandidateMetadata]]:
if not self.model: # pragma: no cover
raise ValueError(FIT_MODEL_ERROR.format(action="_model_gen"))
obj_w, oc_c, l_c, pend_obs, obj_t = validate_and_apply_final_transform(
objective_weights=objective_weights,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
pending_observations=pending_observations,
objective_thresholds=objective_thresholds,
final_transform=self._array_to_tensor,
)
tensor_rounding_func = self._array_callable_to_tensor_callable(rounding_func)
augmented_model_gen_options = {
**self._default_model_gen_options,
**(model_gen_options or {}),
}
# TODO(ehotaj): For some reason, we're getting models which do not support MOO
# even when optimization_config has multiple objectives, so we can't use
# self.is_moo_problem here.
is_moo_problem = self.is_moo_problem and isinstance(
self.model, (BoTorchModel, MultiObjectiveBotorchModel)
)
extra_kwargs = {"objective_thresholds": obj_t} if is_moo_problem else {}
X, w, gen_metadata, candidate_metadata = not_none(self.model).gen(
n=n,
bounds=bounds,
objective_weights=obj_w,
outcome_constraints=oc_c,
linear_constraints=l_c,
fixed_features=fixed_features,
pending_observations=pend_obs,
model_gen_options=augmented_model_gen_options,
rounding_func=tensor_rounding_func,
target_fidelities=target_fidelities,
**extra_kwargs
)
if is_moo_problem:
# If objective_thresholds are supplied by the user, then the transformed
# user-specified objective thresholds are in gen_metadata. Otherwise,
# inferred objective thresholds are in gen_metadata.
gen_metadata[
"objective_thresholds"
] = self._untransform_objective_thresholds(
objective_thresholds=gen_metadata["objective_thresholds"],
objective_weights=obj_w,
bounds=bounds,
fixed_features=fixed_features,
)
return (
X.detach().cpu().clone().numpy(),
w.detach().cpu().clone().numpy(),
gen_metadata,
candidate_metadata,
)
