def _predict(
self, observation_features: List[ObservationFeatures]
) -> List[ObservationData]:
X = observation_features_to_array(self.parameters, observation_features)
f, cov = self._model_predict(X=X)
# Convert arrays to observations
return array_to_observation_data(f=f, cov=cov, outcomes=self.outcomes)
def get_training_data(
self,
experiment: Experiment,
map_data: MapData,
keep_every_k_per_arm: Optional[int] = None,
) -> EarlyStoppingTrainingData:
"""Processes the raw (untransformed) training data into arrays for
use in modeling.
Args:
experiment: Experiment that contains the data.
map_data: The MapData from the experiment, as can be obtained by
via `_check_validity_and_get_data`.
keep_every_k_per_arm Subsample the learning curve by keeping every
kth entry. Useful for limiting training data for modeling.
Returns:
An `EarlyStoppingTrainingData` that contains training data arrays X, Y,
and Yvar + a list of arm names.
"""
if keep_every_k_per_arm is not None:
map_data = _subsample_map_data(
map_data=map_data, keep_every_k_per_arm=keep_every_k_per_arm)
observations = observations_from_map_data(experiment=experiment,
map_data=map_data,
map_keys_as_parameters=True)
obs_features, obs_data, arm_names = _unpack_observations(observations)
parameters = list(experiment.search_space.parameters.keys())
outcome = not_none(
experiment.optimization_config).objective.metric_names[0]
X = observation_features_to_array(parameters=parameters +
list(map_data.map_keys),
obsf=obs_features)
Y, Yvar = observation_data_to_array(outcomes=[outcome],
observation_data=obs_data)
return EarlyStoppingTrainingData(X=X,
Y=Y,
Yvar=Yvar,
arm_names=arm_names)
def _evaluate_acquisition_function(
self,
observation_features: List[ObservationFeatures],
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,
) -> List[float]:
return self._model_evaluate_acquisition_function(
X=observation_features_to_array(self.parameters, observation_features),
search_space_digest=search_space_digest,
objective_weights=objective_weights,
objective_thresholds=objective_thresholds,
outcome_constraints=outcome_constraints,
linear_constraints=linear_constraints,
fixed_features=fixed_features,
pending_observations=pending_observations,
acq_options=acq_options,
).tolist()
def _evaluate_acquisition_function(
self,
observation_features: List[ObservationFeatures]) -> List[float]:
X = observation_features_to_array(self.parameters,
observation_features)
return self._model_evaluate_acquisition_function(X=X).tolist()