ray.tune.search.nevergrad.NevergradSearch#

class ray.tune.search.nevergrad.NevergradSearch(optimizer: Union[None, Type[None]] = None, optimizer_kwargs: Optional[Dict] = None, space: Optional[Dict] = None, metric: Optional[str] = None, mode: Optional[str] = None, points_to_evaluate: Optional[List[Dict]] = None)[source]#

Bases: ray.tune.search.searcher.Searcher

Uses Nevergrad to optimize hyperparameters.

Nevergrad is an open source tool from Facebook for derivative free optimization. More info can be found at: https://github.com/facebookresearch/nevergrad.

You will need to install Nevergrad via the following command:

$ pip install nevergrad

Parameters

optimizer – Optimizer class provided from Nevergrad. See here for available optimizers: https://facebookresearch.github.io/nevergrad/optimizers_ref.html#optimizers This can also be an instance of a ConfiguredOptimizer. See the section on configured optimizers in the above link.
optimizer_kwargs – Kwargs passed in when instantiating the optimizer
space – Nevergrad parametrization to be passed to optimizer on instantiation, or list of parameter names if you passed an optimizer object.
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.

Tune automatically converts search spaces to Nevergrad’s format:

import nevergrad as ng

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

current_best_params = [{
    "width": 10,
    "height": 0,
    "activation": relu",
}]

ng_search = NevergradSearch(
    optimizer=ng.optimizers.OnePlusOne,
    metric="mean_loss",
    mode="min",
    points_to_evaluate=current_best_params)

run(my_trainable, config=config, search_alg=ng_search)

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

import nevergrad as ng

space = ng.p.Dict(
    width=ng.p.Scalar(lower=0, upper=20),
    height=ng.p.Scalar(lower=-100, upper=100),
    activation=ng.p.Choice(choices=["relu", "tanh"])
)

ng_search = NevergradSearch(
    optimizer=ng.optimizers.OnePlusOne,
    space=space,
    metric="mean_loss",
    mode="min")

run(my_trainable, search_alg=ng_search)

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_complete(trial_id: str, result: Optional[Dict] = None, error: bool = False)[source]#

Notification for the completion of trial.

The result is internally negated when interacting with Nevergrad so that Nevergrad Optimizers can “maximize” this value, as it minimizes on default.

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()

Ray 3.0.0.dev0

ray.tune.search.nevergrad.NevergradSearch

ray.tune.search.nevergrad.NevergradSearch#