ray.tune.search.dragonfly.DragonflySearch
ray.tune.search.dragonfly.DragonflySearch#
- class ray.tune.search.dragonfly.DragonflySearch(optimizer: Optional[str] = None, domain: Optional[str] = None, space: Optional[Union[Dict, List[Dict]]] = None, metric: Optional[str] = None, mode: Optional[str] = None, points_to_evaluate: Optional[List[Dict]] = None, evaluated_rewards: Optional[List] = None, random_state_seed: Optional[int] = None, **kwargs)[source]#
Bases:
ray.tune.search.searcher.Searcher
Uses Dragonfly to optimize hyperparameters.
Dragonfly provides an array of tools to scale up Bayesian optimisation to expensive large scale problems, including high dimensional optimisation. parallel evaluations in synchronous or asynchronous settings, multi-fidelity optimisation (using cheap approximations to speed up the optimisation process), and multi-objective optimisation. For more info:
Dragonfly Website: https://github.com/dragonfly/dragonfly
Dragonfly Documentation: https://dragonfly-opt.readthedocs.io/
To use this search algorithm, install Dragonfly:
$ pip install dragonfly-opt
This interface requires using FunctionCallers and optimizers provided by Dragonfly.
This searcher will automatically filter out any NaN, inf or -inf results.
- Parameters
optimizer – Optimizer provided from dragonfly. Choose an optimiser that extends BlackboxOptimiser. If this is a string,
domain
must be set andoptimizer
must be one of [random, bandit, genetic].domain – Optional domain. Should only be set if you don’t pass an optimizer as the
optimizer
argument. Has to be one of [cartesian, euclidean].space – Search space. Should only be set if you don’t pass an optimizer as the
optimizer
argument. Defines the search space and requires adomain
to be set. Can be automatically converted from theparam_space
dict passed totune.Tuner()
.metric – The training result objective value attribute. If None but a mode was passed, the anonymous metric
_metric
will be used per default.mode – One of {min, max}. Determines whether objective is minimizing or maximizing the metric attribute.
points_to_evaluate – Initial parameter suggestions to be run first. This is for when you already have some good parameters you want to run first to help the algorithm make better suggestions for future parameters. Needs to be a list of dicts containing the configurations.
evaluated_rewards – If you have previously evaluated the parameters passed in as points_to_evaluate you can avoid re-running those trials by passing in the reward attributes as a list so the optimiser can be told the results without needing to re-compute the trial. Must be the same length as points_to_evaluate.
random_state_seed – Seed for reproducible results. Defaults to None. Please note that setting this to a value will change global random state for
numpy
on initalization and loading from checkpoint.
Tune automatically converts search spaces to Dragonfly’s format:
from ray import tune config = { "LiNO3_vol": tune.uniform(0, 7), "Li2SO4_vol": tune.uniform(0, 7), "NaClO4_vol": tune.uniform(0, 7) } df_search = DragonflySearch( optimizer="bandit", domain="euclidean", metric="objective", mode="max") tuner = tune.Tuner( my_func, tune_config=tune.TuneConfig( search_alg=df_search ), param_space=config ) tuner.fit()
If you would like to pass the search space/optimizer manually, the code would look like this:
from ray import tune space = [{ "name": "LiNO3_vol", "type": "float", "min": 0, "max": 7 }, { "name": "Li2SO4_vol", "type": "float", "min": 0, "max": 7 }, { "name": "NaClO4_vol", "type": "float", "min": 0, "max": 7 }] df_search = DragonflySearch( optimizer="bandit", domain="euclidean", space=space, metric="objective", mode="max") tuner = tune.Tuner( my_func, tune_config=tune.TuneConfig( search_alg=df_search ), ) tuner.fit()
- add_evaluated_point(parameters: Dict, value: float, error: bool = False, pruned: bool = False, intermediate_values: Optional[List[float]] = None)[source]#
Pass results from a point that has been evaluated separately.
This method allows for information from outside the suggest - on_trial_complete loop to be passed to the search algorithm. This functionality depends on the underlying search algorithm and may not be always available.
- Parameters
parameters – Parameters used for the trial.
value – Metric value obtained in the trial.
error – True if the training process raised an error.
pruned – True if trial was pruned.
intermediate_values – List of metric values for intermediate iterations of the result. None if not applicable.
- set_search_properties(metric: Optional[str], mode: Optional[str], config: Dict, **spec) bool [source]#
Pass search properties to searcher.
This method acts as an alternative to instantiating search algorithms with their own specific search spaces. Instead they can accept a Tune config through this method. A searcher should return
True
if setting the config was successful, orFalse
if it was unsuccessful, e.g. when the search space has already been set.- Parameters
metric – Metric to optimize
mode – One of [“min”, “max”]. Direction to optimize.
config – Tune config dict.
**spec – Any kwargs for forward compatiblity. Info like Experiment.PUBLIC_KEYS is provided through here.
- suggest(trial_id: str) Optional[Dict] [source]#
Queries the algorithm to retrieve the next set of parameters.
- Parameters
trial_id – Trial ID used for subsequent notifications.
- Returns
- Configuration for a trial, if possible.
If FINISHED is returned, Tune will be notified that no more suggestions/configurations will be provided. If None is returned, Tune will skip the querying of the searcher for this step.
- Return type
dict | FINISHED | None
- on_trial_complete(trial_id: str, result: Optional[Dict] = None, error: bool = False)[source]#
Passes result to Dragonfly unless early terminated or errored.
- save(checkpoint_path: str)[source]#
Save state to path for this search algorithm.
- Parameters
checkpoint_path – File where the search algorithm state is saved. This path should be used later when restoring from file.
Example:
search_alg = Searcher(...) tuner = tune.Tuner( cost, tune_config=tune.TuneConfig( search_alg=search_alg, num_samples=5 ), param_space=config ) results = tuner.fit() search_alg.save("./my_favorite_path.pkl")
Changed in version 0.8.7: Save is automatically called by
Tuner().fit()
. You can useTuner().restore()
to restore from an experiment directory such as/ray_results/trainable
.
- restore(checkpoint_path: str)[source]#
Restore state for this search algorithm
- Parameters
checkpoint_path – File where the search algorithm state is saved. This path should be the same as the one provided to “save”.
Example:
search_alg.save("./my_favorite_path.pkl") search_alg2 = Searcher(...) search_alg2 = ConcurrencyLimiter(search_alg2, 1) search_alg2.restore(checkpoint_path) tuner = tune.Tuner( cost, tune_config=tune.TuneConfig( search_alg=search_alg2, num_samples=5 ), ) tuner.fit()