def load_experiment_from_database(self, experiment_name: str) -> None: """Load an existing experiment from database using the `DBSettings` passed to this `AxClient` on instantiation. Args: experiment_name: Name of the experiment. Returns: Experiment object. """ if not self.db_settings: raise ValueError( # pragma: no cover "Cannot load an experiment in the absence of the DB settings." "Please initialize `AxClient` with DBSettings.") experiment, generation_strategy = load_experiment_and_generation_strategy( experiment_name=experiment_name, db_settings=self.db_settings) self._experiment = experiment if generation_strategy is None: # pragma: no cover self._generation_strategy = choose_generation_strategy( search_space=self._experiment.search_space, enforce_sequential_optimization=self. _enforce_sequential_optimization, random_seed=self._random_seed, ) else: self._generation_strategy = generation_strategy
def create_experiment( self, parameters: List[Dict[str, Union[TParamValue, List[TParamValue]]]], name: Optional[str] = None, objective_name: Optional[str] = None, minimize: bool = False, parameter_constraints: Optional[List[str]] = None, outcome_constraints: Optional[List[str]] = None, status_quo: Optional[TParameterization] = None, ) -> None: """Create a new experiment and save it if DBSettings available. Args: parameters: List of dictionaries representing parameters in the experiment search space. Required elements in the dictionaries are: "name" (name of this parameter, string), "type" (type of the parameter: "range", "fixed", or "choice", string), and "bounds" for range parameters (list of two values, lower bound first), "values" for choice parameters (list of values), and "value" for fixed parameters (single value). objective: Name of the metric used as objective in this experiment. This metric must be present in `raw_data` argument to `complete_trial`. name: Name of the experiment to be created. minimize: Whether this experiment represents a minimization problem. parameter_constraints: List of string representation of parameter constraints, such as "x3 >= x4" or "x3 + x4 + x5 >= 2". For sum constraints, any number of arguments is accepted, and acceptable operators are "<=" and ">=". outcome_constraints: List of string representation of outcome constraints of form "metric_name >= bound", like "m1 <= 3." status_quo: Parameterization of the current state of the system. If set, this will be added to each trial to be evaluated alongside test configurations. """ if self.db_settings and not name: raise ValueError( # pragma: no cover "Must give the experiment a name if `db_settings` is not None." ) self._experiment = make_experiment( name=name, parameters=parameters, objective_name=objective_name, minimize=minimize, parameter_constraints=parameter_constraints, outcome_constraints=outcome_constraints, status_quo=status_quo, ) if self._generation_strategy is None: self._generation_strategy = choose_generation_strategy( search_space=self._experiment.search_space, enforce_sequential_optimization=self. _enforce_sequential_optimization, random_seed=self._random_seed, ) self._save_experiment_and_generation_strategy_to_db_if_possible()
def create_experiment( self, parameters: List[Dict[str, Union[TParamValue, List[TParamValue]]]], name: Optional[str] = None, objective_name: Optional[str] = None, minimize: bool = False, parameter_constraints: Optional[List[str]] = None, outcome_constraints: Optional[List[str]] = None, ) -> None: """Create a new experiment and save it if DBSettings available. Args: parameters: List of dictionaries representing parameters in the experiment search space. Required elements in the dictionaries are: "name" (name of this parameter, string), "type" (type of the parameter: "range", "fixed", or "choice", string), and "bounds" for range parameters (list of two values, lower bound first), "values" for choice parameters (list of values), and "value" for fixed parameters (single value). objective: Name of the metric used as objective in this experiment. This metric must be present in `raw_data` argument to `log_data`. name: Name of the experiment to be created. minimize: Whether this experiment represents a minimization problem. parameter_constraints: List of string representation of parameter constraints, such as "x3 >= x4" or "x3 + x4 >= 2". outcome_constraints: List of string representation of outcome constraints of form "metric_name >= bound", like "m1 <= 3." """ if self.db_settings and not name: raise ValueError( # pragma: no cover "Must give the experiment a name if `db_settings` is not None." ) self._experiment = make_experiment( name=name, parameters=parameters, objective_name=objective_name, minimize=minimize, parameter_constraints=parameter_constraints, outcome_constraints=outcome_constraints, ) if self.generation_strategy is None: self.generation_strategy = choose_generation_strategy( search_space=self._experiment.search_space, enforce_sequential_optimization=self. _enforce_sequential_optimization, ) self._save_experiment_if_possible()
def __init__( self, experiment: Experiment, total_trials: int = 20, arms_per_trial: int = 1, wait_time: int = 0, run_async: bool = False, # TODO[Lena], ) -> None: assert not run_async, "OptimizationLoop does not yet support async." self.wait_time = wait_time self.total_trials = total_trials self.arms_per_trial = arms_per_trial assert len(experiment.trials) == 0, ( "Optimization Loop should not be initialized with an experiment " "that has trials already.") self.experiment = experiment self.generation_strategy = choose_generation_strategy( search_space=experiment.search_space, arms_per_trial=self.arms_per_trial) self.current_trial = 0
def get_generation_strategy() -> GenerationStrategy: return choose_generation_strategy(search_space=get_search_space())
def create_experiment( self, parameters: List[Dict[str, Union[TParamValue, List[TParamValue]]]], name: Optional[str] = None, objective_name: Optional[str] = None, minimize: bool = False, parameter_constraints: Optional[List[str]] = None, outcome_constraints: Optional[List[str]] = None, status_quo: Optional[TParameterization] = None, overwrite_existing_experiment: bool = False, experiment_type: Optional[str] = None, ) -> None: """Create a new experiment and save it if DBSettings available. Args: parameters: List of dictionaries representing parameters in the experiment search space. Required elements in the dictionaries are: "name" (name of this parameter, string), "type" (type of the parameter: "range", "fixed", or "choice", string), and "bounds" for range parameters (list of two values, lower bound first), "values" for choice parameters (list of values), and "value" for fixed parameters (single value). objective: Name of the metric used as objective in this experiment. This metric must be present in `raw_data` argument to `complete_trial`. name: Name of the experiment to be created. minimize: Whether this experiment represents a minimization problem. parameter_constraints: List of string representation of parameter constraints, such as "x3 >= x4" or "x3 + x4 + x5 >= 2". For sum constraints, any number of arguments is accepted, and acceptable operators are "<=" and ">=". outcome_constraints: List of string representation of outcome constraints of form "metric_name >= bound", like "m1 <= 3." status_quo: Parameterization of the current state of the system. If set, this will be added to each trial to be evaluated alongside test configurations. overwrite_existing_experiment: If `DBSettings` were provided on instantiation and the experiment being created has the same name as some experiment already stored, whether to overwrite the existing experiment. Defaults to False. """ if self.db_settings and not name: raise ValueError( # pragma: no cover "Must give the experiment a name if `db_settings` is not None." ) if self.db_settings: existing = None try: existing, _ = load_experiment_and_generation_strategy( experiment_name=not_none(name), db_settings=self.db_settings ) except ValueError: # Experiment does not exist, nothing to do. pass if existing and overwrite_existing_experiment: logger.info(f"Overwriting existing experiment {name}.") elif existing: raise ValueError( f"Experiment {name} exists; set the `overwrite_existing_" "experiment` to `True` to overwrite with new experiment " "or use `ax_client.load_experiment_from_database` to " "continue an existing experiment." ) self._experiment = make_experiment( name=name, parameters=parameters, objective_name=objective_name, minimize=minimize, parameter_constraints=parameter_constraints, outcome_constraints=outcome_constraints, status_quo=status_quo, experiment_type=experiment_type, ) if self._generation_strategy is None: self._generation_strategy = choose_generation_strategy( search_space=self._experiment.search_space, enforce_sequential_optimization=self._enforce_sequential_optimization, random_seed=self._random_seed, ) self._save_experiment_and_generation_strategy_to_db_if_possible()