ray.tune.search.bohb.TuneBOHB#

class ray.tune.search.bohb.TuneBOHB(space: Optional[Union[Dict, ConfigSpace.ConfigurationSpace]] = None, bohb_config: Optional[Dict] = None, metric: Optional[str] = None, mode: Optional[str] = None, points_to_evaluate: Optional[List[Dict]] = None, seed: Optional[int] = None, max_concurrent: int = 0)[source]#

Bases: ray.tune.search.searcher.Searcher

BOHB suggestion component.

Requires HpBandSter and ConfigSpace to be installed. You can install HpBandSter and ConfigSpace with: pip install hpbandster ConfigSpace.

This should be used in conjunction with HyperBandForBOHB.

Parameters
  • space – Continuous ConfigSpace search space. Parameters will be sampled from this space which will be used to run trials.

  • bohb_config – configuration for HpBandSter BOHB algorithm

  • 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.

  • seed – Optional random seed to initialize the random number generator. Setting this should lead to identical initial configurations at each run.

  • max_concurrent – Number of maximum concurrent trials. If this Searcher is used in a ConcurrencyLimiter, the max_concurrent value passed to it will override the value passed here. Set to <= 0 for no limit on concurrency.

Tune automatically converts search spaces to TuneBOHB’s format:

config = {
    "width": tune.uniform(0, 20),
    "height": tune.uniform(-100, 100),
    "activation": tune.choice(["relu", "tanh"])
}

algo = TuneBOHB(metric="mean_loss", mode="min")
bohb = HyperBandForBOHB(
    time_attr="training_iteration",
    metric="mean_loss",
    mode="min",
    max_t=100)
run(my_trainable, config=config, scheduler=bohb, search_alg=algo)

If you would like to pass the search space manually, the code would look like this:

import ConfigSpace as CS

config_space = CS.ConfigurationSpace()
config_space.add_hyperparameter(
    CS.UniformFloatHyperparameter("width", lower=0, upper=20))
config_space.add_hyperparameter(
    CS.UniformFloatHyperparameter("height", lower=-100, upper=100))
config_space.add_hyperparameter(
    CS.CategoricalHyperparameter(
        name="activation", choices=["relu", "tanh"]))

algo = TuneBOHB(
    config_space, metric="mean_loss", mode="min")
bohb = HyperBandForBOHB(
    time_attr="training_iteration",
    metric="mean_loss",
    mode="min",
    max_t=100)
run(my_trainable, scheduler=bohb, search_alg=algo)
set_max_concurrency(max_concurrent: int) bool[source]#

Set max concurrent trials this searcher can run.

This method will be called on the wrapped searcher by the ConcurrencyLimiter. It is intended to allow for searchers which have custom, internal logic handling max concurrent trials to inherit the value passed to ConcurrencyLimiter.

If this method returns False, it signifies that no special logic for handling this case is present in the searcher.

Parameters

max_concurrent – Number of maximum concurrent trials.

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, or False 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_result(trial_id: str, result: Dict)[source]#

Optional notification for result during training.

Note that by default, the result dict may include NaNs or may not include the optimization metric. It is up to the subclass implementation to preprocess the result to avoid breaking the optimization process.

Parameters
  • trial_id – A unique string ID for the trial.

  • result – Dictionary of metrics for current training progress. Note that the result dict may include NaNs or may not include the optimization metric. It is up to the subclass implementation to preprocess the result to avoid breaking the optimization process.

on_trial_complete(trial_id: str, result: Optional[Dict] = None, error: bool = False)[source]#

Notification for the completion of trial.

Typically, this method is used for notifying the underlying optimizer of the result.

Parameters
  • trial_id – A unique string ID for the trial.

  • result – Dictionary of metrics for current training progress. Note that the result dict may include NaNs or may not include the optimization metric. It is up to the subclass implementation to preprocess the result to avoid breaking the optimization process. Upon errors, this may also be None.

  • error – True if the training process raised an error.

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 use Tuner().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()