class NSGAIISampler(BaseSampler):
"""Multi-objective sampler using the NSGA-II algorithm.
NSGA-II stands for "Nondominated Sorting Genetic Algorithm II",
which is a well known, fast and elitist multi-objective genetic algorithm.
For further information about NSGA-II, please refer to the following paper:
- `A fast and elitist multiobjective genetic algorithm: NSGA-II
<https://ieeexplore.ieee.org/document/996017>`_
Args:
population_size:
Number of individuals (trials) in a generation.
mutation_prob:
Probability of mutating each parameter when creating a new individual.
If :obj:`None` is specified, the value ``1.0 / len(parent_trial.params)`` is used
where ``parent_trial`` is the parent trial of the target individual.
crossover_prob:
Probability that a crossover (parameters swapping between parents) will occur
when creating a new individual.
swapping_prob:
Probability of swapping each parameter of the parents during crossover.
seed:
Seed for random number generator.
constraints_func:
An optional function that computes the objective constraints. It must take a
:class:`~optuna.trial.FrozenTrial` and return the constraints. The return value must
be a sequence of :obj:`float` s. A value strictly larger than 0 means that a
constraints is violated. A value equal to or smaller than 0 is considered feasible.
If constraints_func returns more than one value for a trial, that trial is considered
feasible if and only if all values are equal to 0 or smaller.
The constraint_func will be evaluated after each successful trial.
The function won't be called when trials fail or they are pruned, but this behavior is
subject to change in the future releases.
The constraints are handled by the constrained domination. A trial x is said to
constrained-dominate a trial y, if any of the following conditions is true:
1. Trial x is feasible and trial y is not.
2. Trial x and y are both infeasible, but trial x has a smaller overall violation.
3. Trial x and y are feasible and trial x dominates trial y.
.. note::
Added in v2.5.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.5.0.
"""
def __init__(
self,
*,
population_size: int = 50,
mutation_prob: Optional[float] = None,
crossover_prob: float = 0.9,
swapping_prob: float = 0.5,
seed: Optional[int] = None,
constraints_func: Optional[Callable[[FrozenTrial],
Sequence[float]]] = None,
) -> None:
# TODO(ohta): Reconsider the default value of each parameter.
if not isinstance(population_size, int):
raise TypeError("`population_size` must be an integer value.")
if population_size < 2:
raise ValueError(
"`population_size` must be greater than or equal to 2.")
if not (mutation_prob is None or 0.0 <= mutation_prob <= 1.0):
raise ValueError(
"`mutation_prob` must be None or a float value within the range [0.0, 1.0]."
)
if not (0.0 <= crossover_prob <= 1.0):
raise ValueError(
"`crossover_prob` must be a float value within the range [0.0, 1.0]."
)
if not (0.0 <= swapping_prob <= 1.0):
raise ValueError(
"`swapping_prob` must be a float value within the range [0.0, 1.0]."
)
if constraints_func is not None:
warnings.warn(
"The constraints_func option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
self._population_size = population_size
self._mutation_prob = mutation_prob
self._crossover_prob = crossover_prob
self._swapping_prob = swapping_prob
self._random_sampler = RandomSampler(seed=seed)
self._rng = np.random.RandomState(seed)
self._constraints_func = constraints_func
def reseed_rng(self) -> None:
self._random_sampler.reseed_rng()
self._rng = np.random.RandomState()
def infer_relative_search_space(
self, study: Study,
trial: FrozenTrial) -> Dict[str, BaseDistribution]:
return {}
def sample_relative(
self,
study: Study,
trial: FrozenTrial,
search_space: Dict[str, BaseDistribution],
) -> Dict[str, Any]:
parent_generation, parent_population = self._collect_parent_population(
study)
trial_id = trial._trial_id
generation = parent_generation + 1
study._storage.set_trial_system_attr(trial_id, _GENERATION_KEY,
generation)
if parent_generation >= 0:
p0 = self._select_parent(study, parent_population)
if self._rng.rand() < self._crossover_prob:
p1 = self._select_parent(study, [
t for t in parent_population if t._trial_id != p0._trial_id
])
else:
p1 = p0
study._storage.set_trial_system_attr(trial_id, _PARENTS_KEY,
[p0._trial_id, p1._trial_id])
return {}
def sample_independent(
self,
study: Study,
trial: FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
if _PARENTS_KEY not in trial.system_attrs:
return self._random_sampler.sample_independent(
study, trial, param_name, param_distribution)
p0_id, p1_id = trial.system_attrs[_PARENTS_KEY]
p0 = study._storage.get_trial(p0_id)
p1 = study._storage.get_trial(p1_id)
param = p0.params.get(param_name, None)
parent_params_len = len(p0.params)
if param is None or self._rng.rand() < self._swapping_prob:
param = p1.params.get(param_name, None)
parent_params_len = len(p1.params)
mutation_prob = self._mutation_prob
if mutation_prob is None:
mutation_prob = 1.0 / max(1.0, parent_params_len)
if param is None or self._rng.rand() < mutation_prob:
return self._random_sampler.sample_independent(
study, trial, param_name, param_distribution)
return param
def _collect_parent_population(
self, study: Study) -> Tuple[int, List[FrozenTrial]]:
trials = study.get_trials(deepcopy=False)
generation_to_runnings = defaultdict(list)
generation_to_population = defaultdict(list)
for trial in trials:
if _GENERATION_KEY not in trial.system_attrs:
continue
generation = trial.system_attrs[_GENERATION_KEY]
if trial.state != optuna.trial.TrialState.COMPLETE:
if trial.state == optuna.trial.TrialState.RUNNING:
generation_to_runnings[generation].append(trial)
continue
# Do not use trials whose states are not COMPLETE, or `constraint` will be unavailable.
generation_to_population[generation].append(trial)
hasher = hashlib.sha256()
parent_population: List[FrozenTrial] = []
parent_generation = -1
while True:
generation = parent_generation + 1
population = generation_to_population[generation]
# Under multi-worker settings, the population size might become larger than
# `self._population_size`.
if len(population) < self._population_size:
break
# [NOTE]
# It's generally safe to assume that once the above condition is satisfied,
# there are no additional individuals added to the generation (i.e., the members of
# the generation have been fixed).
# If the number of parallel workers is huge, this assumption can be broken, but
# this is a very rare case and doesn't significantly impact optimization performance.
# So we can ignore the case.
# The cache key is calculated based on the key of the previous generation and
# the remaining running trials in the current population.
# If there are no running trials, the new cache key becomes exactly the same as
# the previous one, and the cached content will be overwritten. This allows us to
# skip redundant cache key calculations when this method is called for the subsequent
# trials.
for trial in generation_to_runnings[generation]:
hasher.update(bytes(str(trial.number), "utf-8"))
cache_key = "{}:{}".format(_POPULATION_CACHE_KEY_PREFIX,
hasher.hexdigest())
cached_generation, cached_population_numbers = study.system_attrs.get(
cache_key, (-1, []))
if cached_generation >= generation:
generation = cached_generation
population = [trials[n] for n in cached_population_numbers]
else:
population.extend(parent_population)
population = self._select_elite_population(study, population)
# To reduce the number of system attribute entries,
# we cache the population information only if there are no running trials
# (i.e., the information of the population has been fixed).
# Usually, if there are no too delayed running trials, the single entry
# will be used.
if len(generation_to_runnings[generation]) == 0:
population_numbers = [t.number for t in population]
study.set_system_attr(cache_key,
(generation, population_numbers))
parent_generation = generation
parent_population = population
return parent_generation, parent_population
def _select_elite_population(
self, study: Study,
population: List[FrozenTrial]) -> List[FrozenTrial]:
elite_population: List[FrozenTrial] = []
population_per_rank = self._fast_non_dominated_sort(
population, study.directions)
for population in population_per_rank:
if len(elite_population) + len(population) < self._population_size:
elite_population.extend(population)
else:
n = self._population_size - len(elite_population)
_crowding_distance_sort(population)
elite_population.extend(population[:n])
break
return elite_population
def _select_parent(self, study: Study,
population: Sequence[FrozenTrial]) -> FrozenTrial:
# TODO(ohta): Consider to allow users to specify the number of parent candidates.
population_size = len(population)
candidate0 = population[self._rng.choice(population_size)]
candidate1 = population[self._rng.choice(population_size)]
dominates = _dominates if self._constraints_func is None else _constrained_dominates
# TODO(ohta): Consider crowding distance.
if dominates(candidate0, candidate1, study.directions):
return candidate0
else:
return candidate1
def _fast_non_dominated_sort(
self,
population: List[FrozenTrial],
directions: List[optuna.study.StudyDirection],
) -> List[List[FrozenTrial]]:
dominated_count: DefaultDict[int, int] = defaultdict(int)
dominates_list = defaultdict(list)
dominates = _dominates if self._constraints_func is None else _constrained_dominates
for p, q in itertools.combinations(population, 2):
if dominates(p, q, directions):
dominates_list[p.number].append(q.number)
dominated_count[q.number] += 1
elif dominates(q, p, directions):
dominates_list[q.number].append(p.number)
dominated_count[p.number] += 1
population_per_rank = []
while population:
non_dominated_population = []
i = 0
while i < len(population):
if dominated_count[population[i].number] == 0:
individual = population[i]
if i == len(population) - 1:
population.pop()
else:
population[i] = population.pop()
non_dominated_population.append(individual)
else:
i += 1
for x in non_dominated_population:
for y in dominates_list[x.number]:
dominated_count[y] -= 1
assert non_dominated_population
population_per_rank.append(non_dominated_population)
return population_per_rank
def after_trial(
self,
study: Study,
trial: FrozenTrial,
state: TrialState,
values: Optional[Sequence[float]],
) -> None:
assert state in [
TrialState.COMPLETE, TrialState.FAIL, TrialState.PRUNED
]
if state == TrialState.COMPLETE and self._constraints_func is not None:
constraints = None
try:
con = self._constraints_func(trial)
if not isinstance(con, (tuple, list)):
warnings.warn(
f"Constraints should be a sequence of floats but got {type(con).__name__}."
)
constraints = tuple(con)
except Exception:
raise
finally:
assert constraints is None or isinstance(constraints, tuple)
study._storage.set_trial_system_attr(
trial._trial_id,
_CONSTRAINTS_KEY,
constraints,
)
self._random_sampler.after_trial(study, trial, state, values)
class TPESampler(BaseSampler):
"""Sampler using TPE (Tree-structured Parzen Estimator) algorithm.
This sampler is based on *independent sampling*.
See also :class:`~optuna.samplers.BaseSampler` for more details of 'independent sampling'.
On each trial, for each parameter, TPE fits one Gaussian Mixture Model (GMM) ``l(x)`` to
the set of parameter values associated with the best objective values, and another GMM
``g(x)`` to the remaining parameter values. It chooses the parameter value ``x`` that
maximizes the ratio ``l(x)/g(x)``.
For further information about TPE algorithm, please refer to the following papers:
- `Algorithms for Hyper-Parameter Optimization
<https://papers.nips.cc/paper/4443-algorithms-for-hyper-parameter-optimization.pdf>`_
- `Making a Science of Model Search: Hyperparameter Optimization in Hundreds of
Dimensions for Vision Architectures <http://proceedings.mlr.press/v28/bergstra13.pdf>`_
- `Multiobjective tree-structured parzen estimator for computationally expensive optimization
problems <https://dl.acm.org/doi/10.1145/3377930.3389817>`_
Example:
.. testcode::
import optuna
from optuna.samplers import TPESampler
def objective(trial):
x = trial.suggest_float("x", -10, 10)
return x ** 2
study = optuna.create_study(sampler=TPESampler())
study.optimize(objective, n_trials=10)
Args:
consider_prior:
Enhance the stability of Parzen estimator by imposing a Gaussian prior when
:obj:`True`. The prior is only effective if the sampling distribution is
either :class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
or :class:`~optuna.distributions.IntLogUniformDistribution`.
prior_weight:
The weight of the prior. This argument is used in
:class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
:class:`~optuna.distributions.IntLogUniformDistribution`, and
:class:`~optuna.distributions.CategoricalDistribution`.
consider_magic_clip:
Enable a heuristic to limit the smallest variances of Gaussians used in
the Parzen estimator.
consider_endpoints:
Take endpoints of domains into account when calculating variances of Gaussians
in Parzen estimator. See the original paper for details on the heuristics
to calculate the variances.
n_startup_trials:
The random sampling is used instead of the TPE algorithm until the given number
of trials finish in the same study.
n_ei_candidates:
Number of candidate samples used to calculate the expected improvement.
gamma:
A function that takes the number of finished trials and returns the number
of trials to form a density function for samples with low grains.
See the original paper for more details.
weights:
A function that takes the number of finished trials and returns a weight for them.
See `Making a Science of Model Search: Hyperparameter Optimization in Hundreds of
Dimensions for Vision Architectures <http://proceedings.mlr.press/v28/bergstra13.pdf>`_
for more details.
.. note::
In the multi-objective case, this argument is only used to compute the weights of
bad trials, i.e., trials to construct `g(x)` in the `paper
<https://papers.nips.cc/paper/4443-algorithms-for-hyper-parameter-optimization.pdf>`_
). The weights of good trials, i.e., trials to construct `l(x)`, are computed by a
rule based on the hypervolume contribution proposed in the `paper of MOTPE
<https://dl.acm.org/doi/10.1145/3377930.3389817>`_.
seed:
Seed for random number generator.
multivariate:
If this is :obj:`True`, the multivariate TPE is used when suggesting parameters.
The multivariate TPE is reported to outperform the independent TPE. See `BOHB: Robust
and Efficient Hyperparameter Optimization at Scale
<http://proceedings.mlr.press/v80/falkner18a.html>`_ for more details.
.. note::
Added in v2.2.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.2.0.
group:
If this and ``multivariate`` are :obj:`True`, the multivariate TPE with the group
decomposed search space is used when suggesting parameters.
The sampling algorithm decomposes the search space based on past trials and samples
from the joint distribution in each decomposed subspace.
The decomposed subspaces are a partition of the whole search space. Each subspace
is a maximal subset of the whole search space, which satisfies the following:
for a trial in completed trials, the intersection of the subspace and the search space
of the trial becomes subspace itself or an empty set.
Sampling from the joint distribution on the subspace is realized by multivariate TPE.
.. note::
Added in v2.8.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.8.0.
Example:
.. testcode::
import optuna
def objective(trial):
x = trial.suggest_categorical("x", ["A", "B"])
if x == "A":
return trial.suggest_float("y", -10, 10)
else:
return trial.suggest_int("z", -10, 10)
sampler = optuna.samplers.TPESampler(multivariate=True, group=True)
study = optuna.create_study(sampler=sampler)
study.optimize(objective, n_trials=10)
warn_independent_sampling:
If this is :obj:`True` and ``multivariate=True``, a warning message is emitted when
the value of a parameter is sampled by using an independent sampler.
If ``multivariate=False``, this flag has no effect.
constant_liar:
If :obj:`True`, penalize running trials to avoid suggesting parameter configurations
nearby.
.. note::
Abnormally terminated trials often leave behind a record with a state of
`RUNNING` in the storage.
Such "zombie" trial parameters will be avoided by the constant liar algorithm
during subsequent sampling.
When using an :class:`~optuna.storages.RDBStorage`, it is possible to enable the
``heartbeat_interval`` to change the records for abnormally terminated trials to
`FAIL`.
.. note::
It is recommended to set this value to :obj:`True` during distributed
optimization to avoid having multiple workers evaluating similar parameter
configurations. In particular, if each objective function evaluation is costly
and the durations of the running states are significant, and/or the number of
workers is high.
.. note::
Added in v2.8.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.8.0.
Raises:
ValueError:
If ``multivariate`` is :obj:`False` and ``group`` is :obj:`True`.
"""
def __init__(
self,
consider_prior: bool = True,
prior_weight: float = 1.0,
consider_magic_clip: bool = True,
consider_endpoints: bool = False,
n_startup_trials: int = 10,
n_ei_candidates: int = 24,
gamma: Callable[[int], int] = default_gamma,
weights: Callable[[int], np.ndarray] = default_weights,
seed: Optional[int] = None,
*,
multivariate: bool = False,
group: bool = False,
warn_independent_sampling: bool = True,
constant_liar: bool = False,
) -> None:
self._parzen_estimator_parameters = _ParzenEstimatorParameters(
consider_prior,
prior_weight,
consider_magic_clip,
consider_endpoints,
weights,
multivariate,
)
self._prior_weight = prior_weight
self._n_startup_trials = n_startup_trials
self._n_ei_candidates = n_ei_candidates
self._gamma = gamma
self._weights = weights
self._warn_independent_sampling = warn_independent_sampling
self._rng = np.random.RandomState(seed)
self._random_sampler = RandomSampler(seed=seed)
self._multivariate = multivariate
self._group = group
self._group_decomposed_search_space: Optional[_GroupDecomposedSearchSpace] = None
self._search_space_group: Optional[_SearchSpaceGroup] = None
self._search_space = IntersectionSearchSpace(include_pruned=True)
self._constant_liar = constant_liar
if multivariate:
warnings.warn(
"``multivariate`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
if group:
if not multivariate:
raise ValueError(
"``group`` option can only be enabled when ``multivariate`` is enabled."
)
warnings.warn(
"``group`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
self._group_decomposed_search_space = _GroupDecomposedSearchSpace(True)
if constant_liar:
warnings.warn(
"``constant_liar`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
def reseed_rng(self) -> None:
self._rng = np.random.RandomState()
self._random_sampler.reseed_rng()
def infer_relative_search_space(
self, study: Study, trial: FrozenTrial
) -> Dict[str, BaseDistribution]:
if not self._multivariate:
return {}
search_space: Dict[str, BaseDistribution] = {}
if self._group:
assert self._group_decomposed_search_space is not None
self._search_space_group = self._group_decomposed_search_space.calculate(study)
for sub_space in self._search_space_group.search_spaces:
for name, distribution in sub_space.items():
if distribution.single():
continue
search_space[name] = distribution
return search_space
for name, distribution in self._search_space.calculate(study).items():
if distribution.single():
continue
search_space[name] = distribution
return search_space
def _log_independent_sampling(
self, n_complete_trials: int, trial: FrozenTrial, param_name: str
) -> None:
if self._warn_independent_sampling and self._multivariate:
# The first trial samples independently.
if n_complete_trials >= max(self._n_startup_trials, 1):
_logger.warning(
f"The parameter '{param_name}' in trial#{trial.number} is sampled "
"independently instead of being sampled by multivariate TPE sampler. "
"(optimization performance may be degraded). "
"You can suppress this warning by setting `warn_independent_sampling` "
"to `False` in the constructor of `TPESampler`, "
"if this independent sampling is intended behavior."
)
def sample_relative(
self, study: Study, trial: FrozenTrial, search_space: Dict[str, BaseDistribution]
) -> Dict[str, Any]:
if self._group:
assert self._search_space_group is not None
params = {}
for sub_space in self._search_space_group.search_spaces:
search_space = {}
for name, distribution in sub_space.items():
if not distribution.single():
search_space[name] = distribution
params.update(self._sample_relative(study, trial, search_space))
return params
else:
return self._sample_relative(study, trial, search_space)
def _sample_relative(
self, study: Study, trial: FrozenTrial, search_space: Dict[str, BaseDistribution]
) -> Dict[str, Any]:
if search_space == {}:
return {}
param_names = list(search_space.keys())
values, scores = _get_observation_pairs(
study, param_names, self._multivariate, self._constant_liar
)
# If the number of samples is insufficient, we run random trial.
n = len(scores)
if n < self._n_startup_trials:
return {}
# We divide data into below and above.
indices_below, indices_above = _split_observation_pairs(scores, self._gamma(n))
# `None` items are intentionally converted to `nan` and then filtered out.
# For `nan` conversion, the dtype must be float.
config_values = {k: np.asarray(v, dtype=float) for k, v in values.items()}
below = _build_observation_dict(config_values, indices_below)
above = _build_observation_dict(config_values, indices_above)
# We then sample by maximizing log likelihood ratio.
if study._is_multi_objective():
weights_below = _calculate_weights_below_for_multi_objective(
config_values, scores, indices_below
)
mpe_below = _ParzenEstimator(
below, search_space, self._parzen_estimator_parameters, weights_below
)
else:
mpe_below = _ParzenEstimator(below, search_space, self._parzen_estimator_parameters)
mpe_above = _ParzenEstimator(above, search_space, self._parzen_estimator_parameters)
samples_below = mpe_below.sample(self._rng, self._n_ei_candidates)
log_likelihoods_below = mpe_below.log_pdf(samples_below)
log_likelihoods_above = mpe_above.log_pdf(samples_below)
ret = TPESampler._compare(samples_below, log_likelihoods_below, log_likelihoods_above)
for param_name, dist in search_space.items():
ret[param_name] = dist.to_external_repr(ret[param_name])
return ret
def sample_independent(
self,
study: Study,
trial: FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
values, scores = _get_observation_pairs(
study, [param_name], self._multivariate, self._constant_liar
)
n = len(scores)
self._log_independent_sampling(n, trial, param_name)
if n < self._n_startup_trials:
return self._random_sampler.sample_independent(
study, trial, param_name, param_distribution
)
indices_below, indices_above = _split_observation_pairs(scores, self._gamma(n))
# `None` items are intentionally converted to `nan` and then filtered out.
# For `nan` conversion, the dtype must be float.
config_values = {k: np.asarray(v, dtype=float) for k, v in values.items()}
below = _build_observation_dict(config_values, indices_below)
above = _build_observation_dict(config_values, indices_above)
if study._is_multi_objective():
weights_below = _calculate_weights_below_for_multi_objective(
config_values, scores, indices_below
)
mpe_below = _ParzenEstimator(
below,
{param_name: param_distribution},
self._parzen_estimator_parameters,
weights_below,
)
else:
mpe_below = _ParzenEstimator(
below, {param_name: param_distribution}, self._parzen_estimator_parameters
)
mpe_above = _ParzenEstimator(
above, {param_name: param_distribution}, self._parzen_estimator_parameters
)
samples_below = mpe_below.sample(self._rng, self._n_ei_candidates)
log_likelihoods_below = mpe_below.log_pdf(samples_below)
log_likelihoods_above = mpe_above.log_pdf(samples_below)
ret = TPESampler._compare(samples_below, log_likelihoods_below, log_likelihoods_above)
return param_distribution.to_external_repr(ret[param_name])
@classmethod
def _compare(
cls,
samples: Dict[str, np.ndarray],
log_l: np.ndarray,
log_g: np.ndarray,
) -> Dict[str, Union[float, int]]:
sample_size = next(iter(samples.values())).size
if sample_size:
score = log_l - log_g
if sample_size != score.size:
raise ValueError(
"The size of the 'samples' and that of the 'score' "
"should be same. "
"But (samples.size, score.size) = ({}, {})".format(sample_size, score.size)
)
best = np.argmax(score)
return {k: v[best].item() for k, v in samples.items()}
else:
raise ValueError(
"The size of 'samples' should be more than 0."
"But samples.size = {}".format(sample_size)
)
@staticmethod
def hyperopt_parameters() -> Dict[str, Any]:
"""Return the the default parameters of hyperopt (v0.1.2).
:class:`~optuna.samplers.TPESampler` can be instantiated with the parameters returned
by this method.
Example:
Create a :class:`~optuna.samplers.TPESampler` instance with the default
parameters of `hyperopt <https://github.com/hyperopt/hyperopt/tree/0.1.2>`_.
.. testcode::
import optuna
from optuna.samplers import TPESampler
def objective(trial):
x = trial.suggest_float("x", -10, 10)
return x ** 2
sampler = TPESampler(**TPESampler.hyperopt_parameters())
study = optuna.create_study(sampler=sampler)
study.optimize(objective, n_trials=10)
Returns:
A dictionary containing the default parameters of hyperopt.
"""
return {
"consider_prior": True,
"prior_weight": 1.0,
"consider_magic_clip": True,
"consider_endpoints": False,
"n_startup_trials": 20,
"n_ei_candidates": 24,
"gamma": hyperopt_default_gamma,
"weights": default_weights,
}
def after_trial(
self,
study: Study,
trial: FrozenTrial,
state: TrialState,
values: Optional[Sequence[float]],
) -> None:
self._random_sampler.after_trial(study, trial, state, values)
class NSGAIISampler(BaseSampler):
"""Multi-objective sampler using the NSGA-II algorithm.
NSGA-II stands for "Nondominated Sorting Genetic Algorithm II",
which is a well known, fast and elitist multi-objective genetic algorithm.
For further information about NSGA-II, please refer to the following paper:
- `A fast and elitist multiobjective genetic algorithm: NSGA-II
<https://ieeexplore.ieee.org/document/996017>`_
Args:
population_size:
Number of individuals (trials) in a generation.
mutation_prob:
Probability of mutating each parameter when creating a new individual.
If :obj:`None` is specified, the value ``1.0 / len(parent_trial.params)`` is used
where ``parent_trial`` is the parent trial of the target individual.
crossover_prob:
Probability that a crossover (parameters swapping between parents) will occur
when creating a new individual.
swapping_prob:
Probability of swapping each parameter of the parents during crossover.
seed:
Seed for random number generator.
"""
def __init__(
self,
*,
population_size: int = 50,
mutation_prob: Optional[float] = None,
crossover_prob: float = 0.9,
swapping_prob: float = 0.5,
seed: Optional[int] = None,
) -> None:
# TODO(ohta): Reconsider the default value of each parameter.
if not isinstance(population_size, int):
raise TypeError("`population_size` must be an integer value.")
if population_size < 2:
raise ValueError(
"`population_size` must be greater than or equal to 2.")
if not (mutation_prob is None or 0.0 <= mutation_prob <= 1.0):
raise ValueError(
"`mutation_prob` must be None or a float value within the range [0.0, 1.0]."
)
if not (0.0 <= crossover_prob <= 1.0):
raise ValueError(
"`crossover_prob` must be a float value within the range [0.0, 1.0]."
)
if not (0.0 <= swapping_prob <= 1.0):
raise ValueError(
"`swapping_prob` must be a float value within the range [0.0, 1.0]."
)
self._population_size = population_size
self._mutation_prob = mutation_prob
self._crossover_prob = crossover_prob
self._swapping_prob = swapping_prob
self._random_sampler = RandomSampler(seed=seed)
self._rng = np.random.RandomState(seed)
def reseed_rng(self) -> None:
self._random_sampler.reseed_rng()
self._rng = np.random.RandomState()
def infer_relative_search_space(
self, study: Study,
trial: FrozenTrial) -> Dict[str, BaseDistribution]:
return {}
def sample_relative(
self,
study: Study,
trial: FrozenTrial,
search_space: Dict[str, BaseDistribution],
) -> Dict[str, Any]:
parent_generation, parent_population = self._collect_parent_population(
study)
trial_id = trial._trial_id
generation = parent_generation + 1
study._storage.set_trial_system_attr(trial_id, _GENERATION_KEY,
generation)
if parent_generation >= 0:
p0 = self._select_parent(study, parent_population)
if self._rng.rand() < self._crossover_prob:
p1 = self._select_parent(study, [
t for t in parent_population if t._trial_id != p0._trial_id
])
else:
p1 = p0
study._storage.set_trial_system_attr(trial_id, _PARENTS_KEY,
[p0._trial_id, p1._trial_id])
return {}
def sample_independent(
self,
study: Study,
trial: FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
if _PARENTS_KEY not in trial.system_attrs:
return self._random_sampler.sample_independent(
study, trial, param_name, param_distribution)
p0_id, p1_id = trial.system_attrs[_PARENTS_KEY]
p0 = study._storage.get_trial(p0_id)
p1 = study._storage.get_trial(p1_id)
param = p0.params.get(param_name, None)
parent_params_len = len(p0.params)
if param is None or self._rng.rand() < self._swapping_prob:
param = p1.params.get(param_name, None)
parent_params_len = len(p1.params)
mutation_prob = self._mutation_prob
if mutation_prob is None:
mutation_prob = 1.0 / max(1.0, parent_params_len)
if param is None or self._rng.rand() < mutation_prob:
return self._random_sampler.sample_independent(
study, trial, param_name, param_distribution)
return param
def _collect_parent_population(
self, study: Study) -> Tuple[int, List[FrozenTrial]]:
trials = study._storage.get_all_trials(study._study_id, deepcopy=False)
generation_to_runnings = defaultdict(list)
generation_to_population = defaultdict(list)
for trial in trials:
if _GENERATION_KEY not in trial.system_attrs:
continue
generation = trial.system_attrs[_GENERATION_KEY]
if trial.state != optuna.trial.TrialState.COMPLETE:
if trial.state == optuna.trial.TrialState.RUNNING:
generation_to_runnings[generation].append(trial)
continue
generation_to_population[generation].append(trial)
hasher = hashlib.sha256()
parent_population: List[FrozenTrial] = []
parent_generation = -1
while True:
generation = parent_generation + 1
population = generation_to_population[generation]
# Under multi-worker settings, the population size might become larger than
# `self._population_size`.
if len(population) < self._population_size:
break
# [NOTE]
# It's generally safe to assume that once the above condition is satisfied,
# there are no additional individuals added to the generation (i.e., the members of
# the generation have been fixed).
# If the number of parallel workers is huge, this assumption can be broken, but
# this is a very rare case and doesn't significantly impact optimization performance.
# So we can ignore the case.
# The cache key is calculated based on the key of the previous generation and
# the remaining running trials in the current population.
# If there are no running trials, the new cache key becomes exactly the same as
# the previous one, and the cached content will be overwritten. This allows us to
# skip redundant cache key calculations when this method is called for the subsequent
# trials.
for trial in generation_to_runnings[generation]:
hasher.update(bytes(str(trial.number), "utf-8"))
cache_key = "{}:{}".format(_POPULATION_CACHE_KEY_PREFIX,
hasher.hexdigest())
cached_generation, cached_population_numbers = study.system_attrs.get(
cache_key, (-1, []))
if cached_generation >= generation:
generation = cached_generation
population = [trials[n] for n in cached_population_numbers]
else:
population.extend(parent_population)
population = self._select_elite_population(study, population)
# To reduce the number of system attribute entries,
# we cache the population information only if there are no running trials
# (i.e., the information of the population has been fixed).
# Usually, if there are no too delayed running trials, the single entry
# will be used.
if len(generation_to_runnings[generation]) == 0:
population_numbers = [t.number for t in population]
study.set_system_attr(cache_key,
(generation, population_numbers))
parent_generation = generation
parent_population = population
return parent_generation, parent_population
def _select_elite_population(
self, study: Study,
population: List[FrozenTrial]) -> List[FrozenTrial]:
elite_population: List[FrozenTrial] = []
population_per_rank = _fast_non_dominated_sort(population,
study.directions)
for population in population_per_rank:
if len(elite_population) + len(population) < self._population_size:
elite_population.extend(population)
else:
n = self._population_size - len(elite_population)
_crowding_distance_sort(population)
elite_population.extend(population[:n])
break
return elite_population
def _select_parent(self, study: Study,
population: List[FrozenTrial]) -> FrozenTrial:
# TODO(ohta): Consider to allow users to specify the number of parent candidates.
candidate0 = self._rng.choice(population)
candidate1 = self._rng.choice(population)
# TODO(ohta): Consider crowding distance.
if _dominates(candidate0, candidate1, study.directions):
return candidate0
else:
return candidate1
class TPESampler(BaseSampler):
"""Sampler using TPE (Tree-structured Parzen Estimator) algorithm.
This sampler is based on *independent sampling*.
See also :class:`~optuna.samplers.BaseSampler` for more details of 'independent sampling'.
On each trial, for each parameter, TPE fits one Gaussian Mixture Model (GMM) ``l(x)`` to
the set of parameter values associated with the best objective values, and another GMM
``g(x)`` to the remaining parameter values. It chooses the parameter value ``x`` that
maximizes the ratio ``l(x)/g(x)``.
For further information about TPE algorithm, please refer to the following papers:
- `Algorithms for Hyper-Parameter Optimization
<https://papers.nips.cc/paper/4443-algorithms-for-hyper-parameter-optimization.pdf>`_
- `Making a Science of Model Search: Hyperparameter Optimization in Hundreds of
Dimensions for Vision Architectures <http://proceedings.mlr.press/v28/bergstra13.pdf>`_
Example:
.. testcode::
import optuna
from optuna.samplers import TPESampler
def objective(trial):
x = trial.suggest_float("x", -10, 10)
return x ** 2
study = optuna.create_study(sampler=TPESampler())
study.optimize(objective, n_trials=10)
Args:
consider_prior:
Enhance the stability of Parzen estimator by imposing a Gaussian prior when
:obj:`True`. The prior is only effective if the sampling distribution is
either :class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
or :class:`~optuna.distributions.IntLogUniformDistribution`.
prior_weight:
The weight of the prior. This argument is used in
:class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
:class:`~optuna.distributions.IntLogUniformDistribution`, and
:class:`~optuna.distributions.CategoricalDistribution`.
consider_magic_clip:
Enable a heuristic to limit the smallest variances of Gaussians used in
the Parzen estimator.
consider_endpoints:
Take endpoints of domains into account when calculating variances of Gaussians
in Parzen estimator. See the original paper for details on the heuristics
to calculate the variances.
n_startup_trials:
The random sampling is used instead of the TPE algorithm until the given number
of trials finish in the same study.
n_ei_candidates:
Number of candidate samples used to calculate the expected improvement.
gamma:
A function that takes the number of finished trials and returns the number
of trials to form a density function for samples with low grains.
See the original paper for more details.
weights:
A function that takes the number of finished trials and returns a weight for them.
See `Making a Science of Model Search: Hyperparameter Optimization in Hundreds of
Dimensions for Vision Architectures <http://proceedings.mlr.press/v28/bergstra13.pdf>`_
for more details.
seed:
Seed for random number generator.
multivariate:
If this is :obj:`True`, the multivariate TPE is used when suggesting parameters.
The multivariate TPE is reported to outperform the independent TPE. See `BOHB: Robust
and Efficient Hyperparameter Optimization at Scale
<http://proceedings.mlr.press/v80/falkner18a.html>`_ for more details.
.. note::
Added in v2.2.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.2.0.
group:
If this and ``multivariate`` are :obj:`True`, the multivariate TPE with the group
decomposed search space is used when suggesting parameters.
The sampling algorithm decomposes the search space based on past trials and samples
from the joint distribution in each decomposed subspace.
The decomposed subspaces are a partition of the whole search space. Each subspace
is a maximal subset of the whole search space, which satisfies the following:
for a trial in completed trials, the intersection of the subspace and the search space
of the trial becomes subspace itself or an empty set.
Sampling from the joint distribution on the subspace is realized by multivariate TPE.
.. note::
Added in v2.8.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.8.0.
Example:
.. testcode::
import optuna
def objective(trial):
x = trial.suggest_categorical("x", ["A", "B"])
if x == "A":
return trial.suggest_float("y", -10, 10)
else:
return trial.suggest_int("z", -10, 10)
sampler = optuna.samplers.TPESampler(multivariate=True, group=True)
study = optuna.create_study(sampler=sampler)
study.optimize(objective, n_trials=10)
warn_independent_sampling:
If this is :obj:`True` and ``multivariate=True``, a warning message is emitted when
the value of a parameter is sampled by using an independent sampler.
If ``multivariate=False``, this flag has no effect.
constant_liar:
If :obj:`True`, penalize running trials to avoid suggesting parameter configurations
nearby.
.. note::
It is recommended to set this value to :obj:`True` during distributed
optimization to avoid having multiple workers evaluating similar parameter
configurations. In particular, if each objective function evaluation is costly
and the durations of the running states are significant, and/or the number of
workers is high.
.. note::
Added in v2.8.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.8.0.
Raises:
ValueError:
If ``multivariate`` is :obj:`False` and ``group`` is :obj:`True`.
"""
def __init__(
self,
consider_prior: bool = True,
prior_weight: float = 1.0,
consider_magic_clip: bool = True,
consider_endpoints: bool = False,
n_startup_trials: int = 10,
n_ei_candidates: int = 24,
gamma: Callable[[int], int] = default_gamma,
weights: Callable[[int], np.ndarray] = default_weights,
seed: Optional[int] = None,
*,
multivariate: bool = False,
group: bool = False,
warn_independent_sampling: bool = True,
constant_liar: bool = False,
) -> None:
self._parzen_estimator_parameters = _ParzenEstimatorParameters(
consider_prior, prior_weight, consider_magic_clip, consider_endpoints, weights
)
self._prior_weight = prior_weight
self._n_startup_trials = n_startup_trials
self._n_ei_candidates = n_ei_candidates
self._gamma = gamma
self._weights = weights
self._warn_independent_sampling = warn_independent_sampling
self._rng = np.random.RandomState(seed)
self._random_sampler = RandomSampler(seed=seed)
self._multivariate = multivariate
self._group = group
self._group_decomposed_search_space: Optional[_GroupDecomposedSearchSpace] = None
self._search_space_group: Optional[_SearchSpaceGroup] = None
self._search_space = IntersectionSearchSpace(include_pruned=True)
self._constant_liar = constant_liar
if multivariate:
warnings.warn(
"``multivariate`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
if group:
if not multivariate:
raise ValueError(
"``group`` option can only be enabled when ``multivariate`` is enabled."
)
warnings.warn(
"``group`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
self._group_decomposed_search_space = _GroupDecomposedSearchSpace(True)
if constant_liar:
warnings.warn(
"``constant_liar`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
def reseed_rng(self) -> None:
self._rng = np.random.RandomState()
self._random_sampler.reseed_rng()
def infer_relative_search_space(
self, study: Study, trial: FrozenTrial
) -> Dict[str, BaseDistribution]:
if not self._multivariate:
return {}
n_complete_trials = len(study.get_trials(deepcopy=False))
search_space: Dict[str, BaseDistribution] = {}
if self._group:
assert self._group_decomposed_search_space is not None
self._search_space_group = self._group_decomposed_search_space.calculate(study)
for sub_space in self._search_space_group.search_spaces:
for name, distribution in sub_space.items():
if not isinstance(distribution, _DISTRIBUTION_CLASSES):
self._log_independent_sampling(n_complete_trials, trial, name)
continue
search_space[name] = distribution
return search_space
for name, distribution in self._search_space.calculate(study).items():
if not isinstance(distribution, _DISTRIBUTION_CLASSES):
self._log_independent_sampling(n_complete_trials, trial, name)
continue
search_space[name] = distribution
return search_space
def _log_independent_sampling(
self, n_complete_trials: int, trial: FrozenTrial, param_name: str
) -> None:
if self._warn_independent_sampling:
if n_complete_trials >= self._n_startup_trials:
_logger.warning(
f"The parameter '{param_name}' in trial#{trial.number} is sampled "
"independently instead of being sampled by multivariate TPE sampler. "
"(optimization performance may be degraded). "
"You can suppress this warning by setting `warn_independent_sampling` "
"to `False` in the constructor of `TPESampler`, "
"if this independent sampling is intended behavior."
)
def sample_relative(
self, study: Study, trial: FrozenTrial, search_space: Dict[str, BaseDistribution]
) -> Dict[str, Any]:
self._raise_error_if_multi_objective(study)
if self._group:
assert self._search_space_group is not None
params = {}
for sub_space in self._search_space_group.search_spaces:
search_space = {}
for name, distribution in sub_space.items():
if isinstance(distribution, _DISTRIBUTION_CLASSES):
search_space[name] = distribution
params.update(self._sample_relative(study, trial, search_space))
return params
else:
return self._sample_relative(study, trial, search_space)
def _sample_relative(
self, study: Study, trial: FrozenTrial, search_space: Dict[str, BaseDistribution]
) -> Dict[str, Any]:
if search_space == {}:
return {}
param_names = list(search_space.keys())
values, scores = _get_multivariate_observation_pairs(
study, param_names, self._constant_liar
)
# If the number of samples is insufficient, we run random trial.
n = len(scores)
if n < self._n_startup_trials:
return {}
# We divide data into below and above.
below, above = self._split_multivariate_observation_pairs(values, scores)
# We then sample by maximizing log likelihood ratio.
mpe_below = _MultivariateParzenEstimator(
below, search_space, self._parzen_estimator_parameters
)
mpe_above = _MultivariateParzenEstimator(
above, search_space, self._parzen_estimator_parameters
)
samples_below = mpe_below.sample(self._rng, self._n_ei_candidates)
log_likelihoods_below = mpe_below.log_pdf(samples_below)
log_likelihoods_above = mpe_above.log_pdf(samples_below)
ret = TPESampler._compare_multivariate(
samples_below, log_likelihoods_below, log_likelihoods_above
)
for param_name, dist in search_space.items():
ret[param_name] = dist.to_external_repr(ret[param_name])
return ret
def sample_independent(
self,
study: Study,
trial: FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
self._raise_error_if_multi_objective(study)
values, scores = _get_observation_pairs(study, param_name, self._constant_liar)
n = len(values)
if n < self._n_startup_trials:
return self._random_sampler.sample_independent(
study, trial, param_name, param_distribution
)
below_param_values, above_param_values = self._split_observation_pairs(values, scores)
if isinstance(param_distribution, distributions.UniformDistribution):
return self._sample_uniform(param_distribution, below_param_values, above_param_values)
elif isinstance(param_distribution, distributions.LogUniformDistribution):
return self._sample_loguniform(
param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.DiscreteUniformDistribution):
return self._sample_discrete_uniform(
param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.IntUniformDistribution):
return self._sample_int(param_distribution, below_param_values, above_param_values)
elif isinstance(param_distribution, distributions.IntLogUniformDistribution):
return self._sample_int_loguniform(
param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.CategoricalDistribution):
index = self._sample_categorical_index(
param_distribution, below_param_values, above_param_values
)
return param_distribution.choices[index]
else:
distribution_list = [
distributions.UniformDistribution.__name__,
distributions.LogUniformDistribution.__name__,
distributions.DiscreteUniformDistribution.__name__,
distributions.IntUniformDistribution.__name__,
distributions.IntLogUniformDistribution.__name__,
distributions.CategoricalDistribution.__name__,
]
raise NotImplementedError(
"The distribution {} is not implemented. "
"The parameter distribution should be one of the {}".format(
param_distribution, distribution_list
)
)
def _split_observation_pairs(
self, config_vals: List[Optional[float]], loss_vals: List[Tuple[float, float]]
) -> Tuple[np.ndarray, np.ndarray]:
config_values = np.asarray(config_vals)
loss_values = np.asarray(loss_vals, dtype=[("step", float), ("score", float)])
n_below = self._gamma(len(config_values))
loss_ascending = np.argsort(loss_values)
below = config_values[np.sort(loss_ascending[:n_below])]
below = np.asarray([v for v in below if v is not None], dtype=float)
above = config_values[np.sort(loss_ascending[n_below:])]
above = np.asarray([v for v in above if v is not None], dtype=float)
return below, above
def _split_multivariate_observation_pairs(
self,
config_vals: Dict[str, List[Optional[float]]],
loss_vals: List[Tuple[float, float]],
) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:
config_values = {k: np.asarray(v, dtype=float) for k, v in config_vals.items()}
loss_values = np.asarray(loss_vals, dtype=[("step", float), ("score", float)])
n_below = self._gamma(len(loss_values))
index_loss_ascending = np.argsort(loss_values)
# `np.sort` is used to keep chronological order.
index_below = np.sort(index_loss_ascending[:n_below])
index_above = np.sort(index_loss_ascending[n_below:])
below = {}
above = {}
for param_name, param_val in config_values.items():
below[param_name] = param_val[index_below]
above[param_name] = param_val[index_above]
return below, above
def _sample_uniform(
self, distribution: distributions.UniformDistribution, below: np.ndarray, above: np.ndarray
) -> float:
low = distribution.low
high = distribution.high
return self._sample_numerical(low, high, below, above)
def _sample_loguniform(
self,
distribution: distributions.LogUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
low = distribution.low
high = distribution.high
return self._sample_numerical(low, high, below, above, is_log=True)
def _sample_discrete_uniform(
self,
distribution: distributions.DiscreteUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
q = distribution.q
r = distribution.high - distribution.low
# [low, high] is shifted to [0, r] to align sampled values at regular intervals.
low = 0 - 0.5 * q
high = r + 0.5 * q
# Shift below and above to [0, r]
above -= distribution.low
below -= distribution.low
best_sample = self._sample_numerical(low, high, below, above, q=q) + distribution.low
return min(max(best_sample, distribution.low), distribution.high)
def _sample_int(
self,
distribution: distributions.IntUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
d = distributions.DiscreteUniformDistribution(
low=distribution.low, high=distribution.high, q=distribution.step
)
return int(self._sample_discrete_uniform(d, below, above))
def _sample_int_loguniform(
self,
distribution: distributions.IntLogUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
low = distribution.low - 0.5
high = distribution.high + 0.5
sample = self._sample_numerical(low, high, below, above, is_log=True)
best_sample = np.round(sample)
return int(min(max(best_sample, distribution.low), distribution.high))
def _sample_numerical(
self,
low: float,
high: float,
below: np.ndarray,
above: np.ndarray,
q: Optional[float] = None,
is_log: bool = False,
) -> float:
if is_log:
low = np.log(low)
high = np.log(high)
below = np.log(below)
above = np.log(above)
size = (self._n_ei_candidates,)
parzen_estimator_below = _ParzenEstimator(
mus=below, low=low, high=high, parameters=self._parzen_estimator_parameters
)
samples_below = self._sample_from_gmm(
parzen_estimator=parzen_estimator_below, low=low, high=high, q=q, size=size
)
log_likelihoods_below = self._gmm_log_pdf(
samples=samples_below,
parzen_estimator=parzen_estimator_below,
low=low,
high=high,
q=q,
)
parzen_estimator_above = _ParzenEstimator(
mus=above, low=low, high=high, parameters=self._parzen_estimator_parameters
)
log_likelihoods_above = self._gmm_log_pdf(
samples=samples_below,
parzen_estimator=parzen_estimator_above,
low=low,
high=high,
q=q,
)
ret = float(
TPESampler._compare(
samples=samples_below, log_l=log_likelihoods_below, log_g=log_likelihoods_above
)[0]
)
return math.exp(ret) if is_log else ret
def _sample_categorical_index(
self,
distribution: distributions.CategoricalDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
choices = distribution.choices
below = below.astype(int)
above = above.astype(int)
upper = len(choices)
# We can use `np.arange(len(distribution.choices))` instead of sampling from `l(x)`
# when the cardinality of categorical parameters is lower than `n_ei_candidates`.
# Though it seems to be theoretically correct, it leads to performance degradation
# on the NAS benchmark experiment in https://arxiv.org/abs/1902.09635.
# See https://github.com/optuna/optuna/pull/1603 for more details.
size = (self._n_ei_candidates,)
weights_below = self._weights(len(below))
counts_below = np.bincount(below, minlength=upper, weights=weights_below)
weighted_below = counts_below + self._prior_weight
weighted_below /= weighted_below.sum()
samples_below = self._sample_from_categorical_dist(weighted_below, size)
log_likelihoods_below = TPESampler._categorical_log_pdf(samples_below, weighted_below)
weights_above = self._weights(len(above))
counts_above = np.bincount(above, minlength=upper, weights=weights_above)
weighted_above = counts_above + self._prior_weight
weighted_above /= weighted_above.sum()
log_likelihoods_above = TPESampler._categorical_log_pdf(samples_below, weighted_above)
return int(
TPESampler._compare(
samples=samples_below, log_l=log_likelihoods_below, log_g=log_likelihoods_above
)[0]
)
def _sample_from_gmm(
self,
parzen_estimator: _ParzenEstimator,
low: float,
high: float,
q: Optional[float] = None,
size: Tuple = (),
) -> np.ndarray:
weights = parzen_estimator.weights
mus = parzen_estimator.mus
sigmas = parzen_estimator.sigmas
weights, mus, sigmas = map(np.asarray, (weights, mus, sigmas))
if low >= high:
raise ValueError(
"The 'low' should be lower than the 'high'. "
"But (low, high) = ({}, {}).".format(low, high)
)
active = np.argmax(self._rng.multinomial(1, weights, size=size), axis=-1)
trunc_low = (low - mus[active]) / sigmas[active]
trunc_high = (high - mus[active]) / sigmas[active]
samples = np.full((), fill_value=high + 1.0, dtype=np.float64)
while (samples >= high).any():
samples = np.where(
samples < high,
samples,
truncnorm.rvs(
trunc_low,
trunc_high,
size=size,
loc=mus[active],
scale=sigmas[active],
random_state=self._rng,
),
)
if q is None:
return samples
else:
return np.round(samples / q) * q
def _gmm_log_pdf(
self,
samples: np.ndarray,
parzen_estimator: _ParzenEstimator,
low: float,
high: float,
q: Optional[float] = None,
) -> np.ndarray:
weights = parzen_estimator.weights
mus = parzen_estimator.mus
sigmas = parzen_estimator.sigmas
samples, weights, mus, sigmas = map(np.asarray, (samples, weights, mus, sigmas))
if samples.size == 0:
return np.asarray([], dtype=float)
if weights.ndim != 1:
raise ValueError(
"The 'weights' should be 1-dimension. "
"But weights.shape = {}".format(weights.shape)
)
if mus.ndim != 1:
raise ValueError(
"The 'mus' should be 1-dimension. But mus.shape = {}".format(mus.shape)
)
if sigmas.ndim != 1:
raise ValueError(
"The 'sigmas' should be 1-dimension. But sigmas.shape = {}".format(sigmas.shape)
)
p_accept = np.sum(
weights
* (
TPESampler._normal_cdf(high, mus, sigmas)
- TPESampler._normal_cdf(low, mus, sigmas)
)
)
if q is None:
distance = samples[..., None] - mus
mahalanobis = (distance / np.maximum(sigmas, EPS)) ** 2
Z = np.sqrt(2 * np.pi) * sigmas
coefficient = weights / Z / p_accept
return TPESampler._logsum_rows(-0.5 * mahalanobis + np.log(coefficient))
else:
cdf_func = TPESampler._normal_cdf
upper_bound = np.minimum(samples + q / 2.0, high)
lower_bound = np.maximum(samples - q / 2.0, low)
probabilities = np.sum(
weights[..., None]
* (
cdf_func(upper_bound[None], mus[..., None], sigmas[..., None])
- cdf_func(lower_bound[None], mus[..., None], sigmas[..., None])
),
axis=0,
)
return np.log(probabilities + EPS) - np.log(p_accept + EPS)
def _sample_from_categorical_dist(
self, probabilities: np.ndarray, size: Tuple[int]
) -> np.ndarray:
if size == (0,):
return np.asarray([], dtype=float)
assert size
if probabilities.size == 1 and isinstance(probabilities[0], np.ndarray):
probabilities = probabilities[0]
assert probabilities.ndim == 1
n_draws = np.prod(size).item()
sample = self._rng.multinomial(n=1, pvals=probabilities, size=n_draws)
assert sample.shape == size + probabilities.shape
return_val = np.dot(sample, np.arange(probabilities.size)).reshape(size)
return return_val
@classmethod
def _categorical_log_pdf(cls, sample: np.ndarray, p: np.ndarray) -> np.ndarray:
if sample.size:
return np.log(np.asarray(p)[sample])
else:
return np.asarray([])
@classmethod
def _compare(cls, samples: np.ndarray, log_l: np.ndarray, log_g: np.ndarray) -> np.ndarray:
samples, log_l, log_g = map(np.asarray, (samples, log_l, log_g))
if samples.size:
score = log_l - log_g
if samples.size != score.size:
raise ValueError(
"The size of the 'samples' and that of the 'score' "
"should be same. "
"But (samples.size, score.size) = ({}, {})".format(samples.size, score.size)
)
best = np.argmax(score)
return np.asarray([samples[best]] * samples.size)
else:
return np.asarray([])
@classmethod
def _compare_multivariate(
cls,
multivariate_samples: Dict[str, np.ndarray],
log_l: np.ndarray,
log_g: np.ndarray,
) -> Dict[str, Union[float, int]]:
sample_size = next(iter(multivariate_samples.values())).size
if sample_size:
score = log_l - log_g
if sample_size != score.size:
raise ValueError(
"The size of the 'samples' and that of the 'score' "
"should be same. "
"But (samples.size, score.size) = ({}, {})".format(sample_size, score.size)
)
best = np.argmax(score)
return {k: v[best].item() for k, v in multivariate_samples.items()}
else:
raise ValueError(
"The size of 'samples' should be more than 0."
"But samples.size = {}".format(sample_size)
)
@classmethod
def _logsum_rows(cls, x: np.ndarray) -> np.ndarray:
x = np.asarray(x)
m = x.max(axis=1)
return np.log(np.exp(x - m[:, None]).sum(axis=1)) + m
@classmethod
def _normal_cdf(cls, x: float, mu: np.ndarray, sigma: np.ndarray) -> np.ndarray:
mu, sigma = map(np.asarray, (mu, sigma))
denominator = x - mu
numerator = np.maximum(np.sqrt(2) * sigma, EPS)
z = denominator / numerator
return 0.5 * (1 + scipy.special.erf(z))
@staticmethod
def hyperopt_parameters() -> Dict[str, Any]:
"""Return the the default parameters of hyperopt (v0.1.2).
:class:`~optuna.samplers.TPESampler` can be instantiated with the parameters returned
by this method.
Example:
Create a :class:`~optuna.samplers.TPESampler` instance with the default
parameters of `hyperopt <https://github.com/hyperopt/hyperopt/tree/0.1.2>`_.
.. testcode::
import optuna
from optuna.samplers import TPESampler
def objective(trial):
x = trial.suggest_float("x", -10, 10)
return x ** 2
sampler = TPESampler(**TPESampler.hyperopt_parameters())
study = optuna.create_study(sampler=sampler)
study.optimize(objective, n_trials=10)
Returns:
A dictionary containing the default parameters of hyperopt.
"""
return {
"consider_prior": True,
"prior_weight": 1.0,
"consider_magic_clip": True,
"consider_endpoints": False,
"n_startup_trials": 20,
"n_ei_candidates": 24,
"gamma": hyperopt_default_gamma,
"weights": default_weights,
}
def after_trial(
self,
study: Study,
trial: FrozenTrial,
state: TrialState,
values: Optional[Sequence[float]],
) -> None:
self._random_sampler.after_trial(study, trial, state, values)
class MOTPESampler(TPESampler):
"""Multi-objective sampler using the MOTPE algorithm.
This sampler is a multiobjective version of :class:`~optuna.samplers.TPESampler`.
For further information about MOTPE algorithm, please refer to the following paper:
- `Multiobjective tree-structured parzen estimator for computationally expensive optimization
problems <https://dl.acm.org/doi/abs/10.1145/3377930.3389817>`_
Args:
consider_prior:
Enhance the stability of Parzen estimator by imposing a Gaussian prior when
:obj:`True`. The prior is only effective if the sampling distribution is
either :class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
or :class:`~optuna.distributions.IntLogUniformDistribution`.
prior_weight:
The weight of the prior. This argument is used in
:class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
:class:`~optuna.distributions.IntLogUniformDistribution`, and
:class:`~optuna.distributions.CategoricalDistribution`.
consider_magic_clip:
Enable a heuristic to limit the smallest variances of Gaussians used in
the Parzen estimator.
consider_endpoints:
Take endpoints of domains into account when calculating variances of Gaussians
in Parzen estimator. See the original paper for details on the heuristics
to calculate the variances.
n_startup_trials:
The random sampling is used instead of the MOTPE algorithm until the given number
of trials finish in the same study. 11 * number of variables - 1 is recommended in the
original paper.
n_ehvi_candidates:
Number of candidate samples used to calculate the expected hypervolume improvement.
gamma:
A function that takes the number of finished trials and returns the number of trials to
form a density function for samples with low grains. See the original paper for more
details.
weights_above:
A function that takes the number of finished trials and returns a weight for them. As
default, weights are automatically calculated by the MOTPE's default strategy.
seed:
Seed for random number generator.
.. note::
Initialization with Latin hypercube sampling may improve optimization performance.
However, the current implementation only supports initialization with random sampling.
Example:
.. testcode::
import optuna
seed = 128
num_variables = 2
n_startup_trials = 11 * num_variables - 1
def objective(trial):
x = []
for i in range(1, num_variables + 1):
x.append(trial.suggest_float(f"x{i}", 0.0, 2.0 * i))
return x
sampler = optuna.samplers.MOTPESampler(
n_startup_trials=n_startup_trials, n_ehvi_candidates=24, seed=seed
)
study = optuna.create_study(directions=["minimize"] * num_variables, sampler=sampler)
study.optimize(objective, n_trials=n_startup_trials + 10)
"""
def __init__(
self,
*,
consider_prior: bool = True,
prior_weight: float = 1.0,
consider_magic_clip: bool = True,
consider_endpoints: bool = True,
n_startup_trials: int = 10,
n_ehvi_candidates: int = 24,
gamma: Callable[[int], int] = default_gamma,
weights_above: Callable[[int], np.ndarray] = _default_weights_above,
seed: Optional[int] = None,
) -> None:
super().__init__(
consider_prior=consider_prior,
prior_weight=prior_weight,
consider_magic_clip=consider_magic_clip,
consider_endpoints=consider_endpoints,
n_startup_trials=n_startup_trials,
n_ei_candidates=n_ehvi_candidates,
gamma=gamma,
weights=weights_above,
seed=seed,
)
self._n_ehvi_candidates = n_ehvi_candidates
self._mo_random_sampler = RandomSampler(seed=seed)
def reseed_rng(self) -> None:
self._rng = np.random.RandomState()
self._mo_random_sampler.reseed_rng()
def infer_relative_search_space(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
) -> Dict[str, BaseDistribution]:
return {}
def sample_relative(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
search_space: Dict[str, BaseDistribution],
) -> Dict[str, Any]:
return {}
def sample_independent(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
if len(study.directions) < 2:
raise ValueError(
"Number of objectives must be >= 2. "
"Please use optuna.samplers.TPESampler for single-objective optimization."
)
values, scores = _get_observation_pairs(study, param_name)
n = len(values)
if n < self._n_startup_trials:
return self._mo_random_sampler.sample_independent(
study, trial, param_name, param_distribution
)
below_param_values, above_param_values = self._split_mo_observation_pairs(
study, trial, values, scores
)
if isinstance(param_distribution, distributions.UniformDistribution):
return self._sample_mo_uniform(
study, trial, param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.LogUniformDistribution):
return self._sample_mo_loguniform(
study, trial, param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.DiscreteUniformDistribution):
return self._sample_mo_discrete_uniform(
study, trial, param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.IntUniformDistribution):
return self._sample_mo_int(
study, trial, param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.IntLogUniformDistribution):
return self._sample_mo_int_loguniform(
study, trial, param_distribution, below_param_values, above_param_values
)
elif isinstance(param_distribution, distributions.CategoricalDistribution):
index = self._sample_mo_categorical_index(
study, trial, param_distribution, below_param_values, above_param_values
)
return param_distribution.choices[index]
else:
distribution_list = [
distributions.UniformDistribution.__name__,
distributions.LogUniformDistribution.__name__,
distributions.DiscreteUniformDistribution.__name__,
distributions.IntUniformDistribution.__name__,
distributions.IntLogUniformDistribution.__name__,
distributions.CategoricalDistribution.__name__,
]
raise NotImplementedError(
"The distribution {} is not implemented. "
"The parameter distribution should be one of the {}".format(
param_distribution, distribution_list
)
)
def _split_mo_observation_pairs(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
config_vals: List[Optional[float]],
loss_vals: List[List[float]],
) -> Tuple[np.ndarray, np.ndarray]:
"""Split observations into observations for l(x) and g(x) with the ratio of gamma:1-gamma.
Weights for l(x) are also calculated in this method.
This splitting strategy consists of the following two steps:
1. Nondonation rank-based selection
2. Hypervolume subset selection problem (HSSP)-based selection
Please refer to the `original paper <https://dl.acm.org/doi/abs/10.1145/3377930.3389817>`_
for more details.
"""
cvals = np.asarray(config_vals)
lvals = np.asarray(loss_vals)
# Solving HSSP for variables number of times is a waste of time.
# We cache the result of splitting.
if _SPLITCACHE_KEY in trial.system_attrs:
split_cache = trial.system_attrs[_SPLITCACHE_KEY]
indices_below = np.asarray(split_cache["indices_below"])
weights_below = np.asarray(split_cache["weights_below"])
indices_above = np.asarray(split_cache["indices_above"])
else:
nondomination_ranks = _calculate_nondomination_rank(lvals)
n_below = self._gamma(len(lvals))
assert 0 <= n_below <= len(lvals)
indices = np.array(range(len(lvals)))
indices_below = np.array([], dtype=int)
# Nondomination rank-based selection
i = 0
while len(indices_below) + sum(nondomination_ranks == i) <= n_below:
indices_below = np.append(indices_below, indices[nondomination_ranks == i])
i += 1
# Hypervolume subset selection problem (HSSP)-based selection
subset_size = n_below - len(indices_below)
if subset_size > 0:
rank_i_lvals = lvals[nondomination_ranks == i]
rank_i_indices = indices[nondomination_ranks == i]
worst_point = np.max(rank_i_lvals, axis=0)
reference_point = np.maximum(1.1 * worst_point, 0.9 * worst_point)
reference_point[reference_point == 0] = EPS
selected_indices = self._solve_hssp(
rank_i_lvals, rank_i_indices, subset_size, reference_point
)
indices_below = np.append(indices_below, selected_indices)
assert len(indices_below) == n_below
indices_above = np.setdiff1d(indices, indices_below)
attrs = {
"indices_below": indices_below.tolist(),
"indices_above": indices_above.tolist(),
}
weights_below = self._calculate_weights_below(lvals, indices_below)
attrs["weights_below"] = weights_below.tolist()
study._storage.set_trial_system_attr(trial._trial_id, _SPLITCACHE_KEY, attrs)
below = cvals[indices_below]
study._storage.set_trial_system_attr(
trial._trial_id,
_WEIGHTS_BELOW_KEY,
[w for w, v in zip(weights_below, below) if v is not None],
)
below = np.asarray([v for v in below if v is not None], dtype=float)
above = cvals[indices_above]
above = np.asarray([v for v in above if v is not None], dtype=float)
return below, above
def _sample_mo_uniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.UniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
low = distribution.low
high = distribution.high
return self._sample_mo_numerical(study, trial, low, high, below, above)
def _sample_mo_loguniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.LogUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
low = distribution.low
high = distribution.high
return self._sample_mo_numerical(study, trial, low, high, below, above, is_log=True)
def _sample_mo_discrete_uniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.DiscreteUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
q = distribution.q
r = distribution.high - distribution.low
# [low, high] is shifted to [0, r] to align sampled values at regular intervals.
low = 0 - 0.5 * q
high = r + 0.5 * q
# Shift below and above to [0, r]
above -= distribution.low
below -= distribution.low
best_sample = (
self._sample_mo_numerical(study, trial, low, high, below, above, q=q)
+ distribution.low
)
return min(max(best_sample, distribution.low), distribution.high)
def _sample_mo_int(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.IntUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
d = distributions.DiscreteUniformDistribution(
low=distribution.low, high=distribution.high, q=distribution.step
)
return int(self._sample_mo_discrete_uniform(study, trial, d, below, above))
def _sample_mo_int_loguniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.IntLogUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
low = distribution.low - 0.5
high = distribution.high + 0.5
sample = self._sample_mo_numerical(study, trial, low, high, below, above, is_log=True)
best_sample = np.round(sample)
return int(min(max(best_sample, distribution.low), distribution.high))
def _sample_mo_numerical(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
low: float,
high: float,
below: np.ndarray,
above: np.ndarray,
q: Optional[float] = None,
is_log: bool = False,
) -> float:
if is_log:
low = np.log(low)
high = np.log(high)
below = np.log(below)
above = np.log(above)
size = (self._n_ehvi_candidates,)
weights_below: Callable[[int], np.ndarray]
weights_below = lambda _: np.asarray( # NOQA
study._storage.get_trial(trial._trial_id).system_attrs[_WEIGHTS_BELOW_KEY],
dtype=float,
)
parzen_estimator_parameters_below = _ParzenEstimatorParameters(
self._parzen_estimator_parameters.consider_prior,
self._parzen_estimator_parameters.prior_weight,
self._parzen_estimator_parameters.consider_magic_clip,
self._parzen_estimator_parameters.consider_endpoints,
weights_below,
)
parzen_estimator_below = _ParzenEstimator(
mus=below, low=low, high=high, parameters=parzen_estimator_parameters_below
)
samples_below = self._sample_from_gmm(
parzen_estimator=parzen_estimator_below,
low=low,
high=high,
q=q,
size=size,
)
log_likelihoods_below = self._gmm_log_pdf(
samples=samples_below,
parzen_estimator=parzen_estimator_below,
low=low,
high=high,
q=q,
)
weights_above = self._weights
parzen_estimator_parameters_above = _ParzenEstimatorParameters(
self._parzen_estimator_parameters.consider_prior,
self._parzen_estimator_parameters.prior_weight,
self._parzen_estimator_parameters.consider_magic_clip,
self._parzen_estimator_parameters.consider_endpoints,
weights_above,
)
parzen_estimator_above = _ParzenEstimator(
mus=above, low=low, high=high, parameters=parzen_estimator_parameters_above
)
log_likelihoods_above = self._gmm_log_pdf(
samples=samples_below,
parzen_estimator=parzen_estimator_above,
low=low,
high=high,
q=q,
)
ret = float(
TPESampler._compare(
samples=samples_below, log_l=log_likelihoods_below, log_g=log_likelihoods_above
)[0]
)
return math.exp(ret) if is_log else ret
def _sample_mo_categorical_index(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.CategoricalDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
choices = distribution.choices
below = list(map(int, below))
above = list(map(int, above))
upper = len(choices)
size = (self._n_ehvi_candidates,)
weights_below = study._storage.get_trial(trial._trial_id).system_attrs[_WEIGHTS_BELOW_KEY]
counts_below = np.bincount(below, minlength=upper, weights=weights_below)
weighted_below = counts_below + self._prior_weight
weighted_below /= weighted_below.sum()
samples_below = self._sample_from_categorical_dist(weighted_below, size)
log_likelihoods_below = TPESampler._categorical_log_pdf(samples_below, weighted_below)
weights_above = self._weights(len(above))
counts_above = np.bincount(above, minlength=upper, weights=weights_above)
weighted_above = counts_above + self._prior_weight
weighted_above /= weighted_above.sum()
log_likelihoods_above = TPESampler._categorical_log_pdf(samples_below, weighted_above)
return int(
TPESampler._compare(
samples=samples_below, log_l=log_likelihoods_below, log_g=log_likelihoods_above
)[0]
)
@staticmethod
def _compute_hypervolume(solution_set: np.ndarray, reference_point: np.ndarray) -> float:
return optuna.multi_objective._hypervolume.WFG().compute(solution_set, reference_point)
def _solve_hssp(
self,
rank_i_loss_vals: np.ndarray,
rank_i_indices: np.ndarray,
subset_size: int,
reference_point: np.ndarray,
) -> np.ndarray:
"""Solve a hypervolume subset selection problem (HSSP) via a greedy algorithm.
This method is a 1-1/e approximation algorithm to solve HSSP.
For further information about algorithms to solve HSSP, please refer to the following
paper:
- `Greedy Hypervolume Subset Selection in Low Dimensions
<https://ieeexplore.ieee.org/document/7570501>`_
"""
selected_vecs = [] # type: List[np.ndarray]
selected_indices = [] # type: List[int]
contributions = [
self._compute_hypervolume(np.asarray([v]), reference_point) for v in rank_i_loss_vals
]
hv_selected = 0.0
while len(selected_indices) < subset_size:
max_index = np.argmax(contributions)
contributions[max_index] = -1 # mark as selected
selected_index = rank_i_indices[max_index]
selected_vec = rank_i_loss_vals[max_index]
for j, v in enumerate(rank_i_loss_vals):
if contributions[j] == -1:
continue
p = np.max([selected_vec, v], axis=0)
contributions[j] -= (
self._compute_hypervolume(np.asarray(selected_vecs + [p]), reference_point)
- hv_selected
)
selected_vecs += [selected_vec]
selected_indices += [selected_index]
hv_selected = self._compute_hypervolume(np.asarray(selected_vecs), reference_point)
return np.asarray(selected_indices, dtype=int)
def _calculate_weights_below(
self,
lvals: np.ndarray,
indices_below: np.ndarray,
) -> np.ndarray:
# Calculate weights based on hypervolume contributions.
n_below = len(indices_below)
if n_below == 0:
return np.asarray([])
elif n_below == 1:
return np.asarray([1.0])
else:
lvals_below = lvals[indices_below].tolist()
worst_point = np.max(lvals_below, axis=0)
reference_point = np.maximum(1.1 * worst_point, 0.9 * worst_point)
reference_point[reference_point == 0] = EPS
hv = self._compute_hypervolume(np.asarray(lvals_below), reference_point)
contributions = np.asarray(
[
hv
- self._compute_hypervolume(
np.asarray(lvals_below[:i] + lvals_below[i + 1 :]), reference_point
)
for i in range(n_below)
]
)
contributions += EPS
weights_below = np.clip(contributions / np.max(contributions), 0, 1)
return weights_below
def after_trial(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
state: optuna.trial.TrialState,
values: Optional[Sequence[float]],
) -> None:
self._mo_random_sampler.after_trial(study, trial, state, values)
class NSGAIISampler(BaseSampler):
"""Multi-objective sampler using the NSGA-II algorithm.
NSGA-II stands for "Nondominated Sorting Genetic Algorithm II",
which is a well known, fast and elitist multi-objective genetic algorithm.
For further information about NSGA-II, please refer to the following paper:
- `A fast and elitist multiobjective genetic algorithm: NSGA-II
<https://ieeexplore.ieee.org/document/996017>`_
Args:
population_size:
Number of individuals (trials) in a generation.
``population_size`` must be greater than or equal to ``crossover.n_parents``.
For :class:`~optuna.samplers.nsgaii.UNDXCrossover` and
:class:`~optuna.samplers.nsgaii.SPXCrossover`, ``n_parents=3``, and for the other
algorithms, ``n_parents=2``.
mutation_prob:
Probability of mutating each parameter when creating a new individual.
If :obj:`None` is specified, the value ``1.0 / len(parent_trial.params)`` is used
where ``parent_trial`` is the parent trial of the target individual.
crossover:
Crossover to be applied when creating child individuals.
The available crossovers are listed here:
https://optuna.readthedocs.io/en/stable/reference/samplers/nsgaii.html.
:class:`~optuna.samplers.nsgaii.UniformCrossover` is always applied to parameters
sampled from :class:`~optuna.distributions.CategoricalDistribution`, and by
default for parameters sampled from other distributions unless this argument
is specified.
For more information on each of the crossover method, please refer to
specific crossover documentation.
crossover_prob:
Probability that a crossover (parameters swapping between parents) will occur
when creating a new individual.
swapping_prob:
Probability of swapping each parameter of the parents during crossover.
seed:
Seed for random number generator.
constraints_func:
An optional function that computes the objective constraints. It must take a
:class:`~optuna.trial.FrozenTrial` and return the constraints. The return value must
be a sequence of :obj:`float` s. A value strictly larger than 0 means that a
constraints is violated. A value equal to or smaller than 0 is considered feasible.
If ``constraints_func`` returns more than one value for a trial, that trial is
considered feasible if and only if all values are equal to 0 or smaller.
The ``constraints_func`` will be evaluated after each successful trial.
The function won't be called when trials fail or they are pruned, but this behavior is
subject to change in the future releases.
The constraints are handled by the constrained domination. A trial x is said to
constrained-dominate a trial y, if any of the following conditions is true:
1. Trial x is feasible and trial y is not.
2. Trial x and y are both infeasible, but trial x has a smaller overall violation.
3. Trial x and y are feasible and trial x dominates trial y.
.. note::
Added in v2.5.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.5.0.
"""
def __init__(
self,
*,
population_size: int = 50,
mutation_prob: Optional[float] = None,
crossover: Optional[BaseCrossover] = None,
crossover_prob: float = 0.9,
swapping_prob: float = 0.5,
seed: Optional[int] = None,
constraints_func: Optional[Callable[[FrozenTrial],
Sequence[float]]] = None,
) -> None:
# TODO(ohta): Reconsider the default value of each parameter.
if not isinstance(population_size, int):
raise TypeError("`population_size` must be an integer value.")
if population_size < 2:
raise ValueError(
"`population_size` must be greater than or equal to 2.")
if not (mutation_prob is None or 0.0 <= mutation_prob <= 1.0):
raise ValueError(
"`mutation_prob` must be None or a float value within the range [0.0, 1.0]."
)
if not (0.0 <= crossover_prob <= 1.0):
raise ValueError(
"`crossover_prob` must be a float value within the range [0.0, 1.0]."
)
if not (0.0 <= swapping_prob <= 1.0):
raise ValueError(
"`swapping_prob` must be a float value within the range [0.0, 1.0]."
)
if constraints_func is not None:
warnings.warn(
"The constraints_func option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
if crossover is None:
crossover = UniformCrossover(swapping_prob)
if not isinstance(crossover, BaseCrossover):
raise ValueError(
f"'{crossover}' is not a valid crossover."
" For valid crossovers see"
" https://optuna.readthedocs.io/en/stable/reference/samplers.html."
)
if population_size < crossover.n_parents:
raise ValueError(
f"Using {crossover},"
f" the population size should be greater than or equal to {crossover.n_parents}."
f" The specified `population_size` is {population_size}.")
self._population_size = population_size
self._mutation_prob = mutation_prob
self._crossover = crossover
self._crossover_prob = crossover_prob
self._swapping_prob = swapping_prob
self._random_sampler = RandomSampler(seed=seed)
self._rng = np.random.RandomState(seed)
self._constraints_func = constraints_func
self._search_space = IntersectionSearchSpace()
def reseed_rng(self) -> None:
self._random_sampler.reseed_rng()
self._rng.seed()
def infer_relative_search_space(
self, study: Study,
trial: FrozenTrial) -> Dict[str, BaseDistribution]:
search_space: Dict[str, BaseDistribution] = {}
for name, distribution in self._search_space.calculate(study).items():
if distribution.single():
# The `untransform` method of `optuna._transform._SearchSpaceTransform`
# does not assume a single value,
# so single value objects are not sampled with the `sample_relative` method,
# but with the `sample_independent` method.
continue
search_space[name] = distribution
return search_space
def sample_relative(
self,
study: Study,
trial: FrozenTrial,
search_space: Dict[str, BaseDistribution],
) -> Dict[str, Any]:
parent_generation, parent_population = self._collect_parent_population(
study)
trial_id = trial._trial_id
generation = parent_generation + 1
study._storage.set_trial_system_attr(trial_id, _GENERATION_KEY,
generation)
dominates_func = _dominates if self._constraints_func is None else _constrained_dominates
if parent_generation >= 0:
# We choose a child based on the specified crossover method.
if self._rng.rand() < self._crossover_prob:
child_params = perform_crossover(
self._crossover,
study,
parent_population,
search_space,
self._rng,
self._swapping_prob,
dominates_func,
)
else:
parent_population_size = len(parent_population)
parent_params = parent_population[self._rng.choice(
parent_population_size)].params
child_params = {
name: parent_params[name]
for name in search_space.keys()
}
n_params = len(child_params)
if self._mutation_prob is None:
mutation_prob = 1.0 / max(1.0, n_params)
else:
mutation_prob = self._mutation_prob
params = {}
for param_name in child_params.keys():
if self._rng.rand() >= mutation_prob:
params[param_name] = child_params[param_name]
return params
return {}
def sample_independent(
self,
study: Study,
trial: FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
# Following parameters are randomly sampled here.
# 1. A parameter in the initial population/first generation.
# 2. A parameter to mutate.
# 3. A parameter excluded from the intersection search space.
return self._random_sampler.sample_independent(study, trial,
param_name,
param_distribution)
def _collect_parent_population(
self, study: Study) -> Tuple[int, List[FrozenTrial]]:
trials = study.get_trials(deepcopy=False)
generation_to_runnings = defaultdict(list)
generation_to_population = defaultdict(list)
for trial in trials:
if _GENERATION_KEY not in trial.system_attrs:
continue
generation = trial.system_attrs[_GENERATION_KEY]
if trial.state != optuna.trial.TrialState.COMPLETE:
if trial.state == optuna.trial.TrialState.RUNNING:
generation_to_runnings[generation].append(trial)
continue
# Do not use trials whose states are not COMPLETE, or `constraint` will be unavailable.
generation_to_population[generation].append(trial)
hasher = hashlib.sha256()
parent_population: List[FrozenTrial] = []
parent_generation = -1
while True:
generation = parent_generation + 1
population = generation_to_population[generation]
# Under multi-worker settings, the population size might become larger than
# `self._population_size`.
if len(population) < self._population_size:
break
# [NOTE]
# It's generally safe to assume that once the above condition is satisfied,
# there are no additional individuals added to the generation (i.e., the members of
# the generation have been fixed).
# If the number of parallel workers is huge, this assumption can be broken, but
# this is a very rare case and doesn't significantly impact optimization performance.
# So we can ignore the case.
# The cache key is calculated based on the key of the previous generation and
# the remaining running trials in the current population.
# If there are no running trials, the new cache key becomes exactly the same as
# the previous one, and the cached content will be overwritten. This allows us to
# skip redundant cache key calculations when this method is called for the subsequent
# trials.
for trial in generation_to_runnings[generation]:
hasher.update(bytes(str(trial.number), "utf-8"))
cache_key = "{}:{}".format(_POPULATION_CACHE_KEY_PREFIX,
hasher.hexdigest())
cached_generation, cached_population_numbers = study.system_attrs.get(
cache_key, (-1, []))
if cached_generation >= generation:
generation = cached_generation
population = [trials[n] for n in cached_population_numbers]
else:
population.extend(parent_population)
population = self._select_elite_population(study, population)
# To reduce the number of system attribute entries,
# we cache the population information only if there are no running trials
# (i.e., the information of the population has been fixed).
# Usually, if there are no too delayed running trials, the single entry
# will be used.
if len(generation_to_runnings[generation]) == 0:
population_numbers = [t.number for t in population]
study.set_system_attr(cache_key,
(generation, population_numbers))
parent_generation = generation
parent_population = population
return parent_generation, parent_population
def _select_elite_population(
self, study: Study,
population: List[FrozenTrial]) -> List[FrozenTrial]:
elite_population: List[FrozenTrial] = []
population_per_rank = self._fast_non_dominated_sort(
population, study.directions)
for population in population_per_rank:
if len(elite_population) + len(population) < self._population_size:
elite_population.extend(population)
else:
n = self._population_size - len(elite_population)
_crowding_distance_sort(population)
elite_population.extend(population[:n])
break
return elite_population
def _fast_non_dominated_sort(
self,
population: List[FrozenTrial],
directions: List[optuna.study.StudyDirection],
) -> List[List[FrozenTrial]]:
dominated_count: DefaultDict[int, int] = defaultdict(int)
dominates_list = defaultdict(list)
dominates = _dominates if self._constraints_func is None else _constrained_dominates
for p, q in itertools.combinations(population, 2):
if dominates(p, q, directions):
dominates_list[p.number].append(q.number)
dominated_count[q.number] += 1
elif dominates(q, p, directions):
dominates_list[q.number].append(p.number)
dominated_count[p.number] += 1
population_per_rank = []
while population:
non_dominated_population = []
i = 0
while i < len(population):
if dominated_count[population[i].number] == 0:
individual = population[i]
if i == len(population) - 1:
population.pop()
else:
population[i] = population.pop()
non_dominated_population.append(individual)
else:
i += 1
for x in non_dominated_population:
for y in dominates_list[x.number]:
dominated_count[y] -= 1
assert non_dominated_population
population_per_rank.append(non_dominated_population)
return population_per_rank
def after_trial(
self,
study: Study,
trial: FrozenTrial,
state: TrialState,
values: Optional[Sequence[float]],
) -> None:
assert state in [
TrialState.COMPLETE, TrialState.FAIL, TrialState.PRUNED
]
if self._constraints_func is not None:
_process_constraints_after_trial(self._constraints_func, study,
trial, state)
self._random_sampler.after_trial(study, trial, state, values)
class NSGAIISampler(BaseSampler):
"""Multi-objective sampler using the NSGA-II algorithm.
NSGA-II stands for "Nondominated Sorting Genetic Algorithm II",
which is a well known, fast and elitist multi-objective genetic algorithm.
For further information about NSGA-II, please refer to the following paper:
- `A fast and elitist multiobjective genetic algorithm: NSGA-II
<https://ieeexplore.ieee.org/document/996017>`_
Args:
population_size:
Number of individuals (trials) in a generation.
mutation_prob:
Probability of mutating each parameter when creating a new individual.
If :obj:`None` is specified, the value ``1.0 / len(parent_trial.params)`` is used
where ``parent_trial`` is the parent trial of the target individual.
crossover:
Crossover to be applied when creating child individuals.
The available crossovers are
`uniform` (default), `blxalpha`, `sbx`, `vsbx`, `undx`, and `spx`.
For :class:`~optuna.distributions.CategoricalDistribution`,
uniform crossover will be applied,
and for other distributions, the specified crossover will be applied.
For more information on each of the crossover method, please refer to the following.
- uniform: Select each parameter with equal probability
from the two parent individuals.
- `Gilbert Syswerda. 1989. Uniform Crossover in Genetic Algorithms.
In Proceedings of the 3rd International Conference on Genetic Algorithms.
Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2–9.
<https://www.researchgate.net/publication/201976488_Uniform_Crossover_in_Genetic_Algorithms>`_
- blxalpha: It uniformly samples child individuals from the hyper-rectangles created
by the two parent individuals.
- `Eshelman, L. and J. D. Schaffer.
Real-Coded Genetic Algorithms and Interval-Schemata. FOGA (1992).
<https://www.sciencedirect.com/science/article/abs/pii/B9780080948324500180>`_
- sbx: Generate a child from two parent individuals
according to the polynomial probability distribution.
- `Deb, K. and R. Agrawal.
“Simulated Binary Crossover for Continuous Search Space.”
Complex Syst. 9 (1995): n. pag.
<https://www.complex-systems.com/abstracts/v09_i02_a02/>`_
- vsbx: In SBX, the probability of occurrence of child individuals
becomes zero in some parameter regions.
vSBX generates child individuals without excluding any region of the parameter space,
while maintaining the excellent properties of SBX.
- `Pedro J. Ballester, Jonathan N. Carter.
Real-Parameter Genetic Algorithms for Finding Multiple Optimal Solutions
in Multi-modal Optimization. GECCO 2003: 706-717
<https://link.springer.com/chapter/10.1007/3-540-45105-6_86>`_
- undx: Generate child individuals from the three parents
using a multivariate normal distribution.
- `H. Kita, I. Ono and S. Kobayashi,
Multi-parental extension of the unimodal normal distribution crossover
for real-coded genetic algorithms,
Proceedings of the 1999 Congress on Evolutionary Computation-CEC99
(Cat. No. 99TH8406), 1999, pp. 1581-1588 Vol. 2
<https://ieeexplore.ieee.org/document/782672>`_
- spx: It uniformly samples child individuals from within a single simplex
that is similar to the simplex produced by the parent individual.
- `Shigeyoshi Tsutsui and Shigeyoshi Tsutsui and David E. Goldberg and
David E. Goldberg and Kumara Sastry and Kumara Sastry
Progress Toward Linkage Learning in Real-Coded GAs with Simplex Crossover.
IlliGAL Report. 2000.
<https://www.researchgate.net/publication/2388486_Progress_Toward_Linkage_Learning_in_Real-Coded_GAs_with_Simplex_Crossover>`_
crossover_prob:
Probability that a crossover (parameters swapping between parents) will occur
when creating a new individual.
swapping_prob:
Probability of swapping each parameter of the parents during crossover.
seed:
Seed for random number generator.
constraints_func:
An optional function that computes the objective constraints. It must take a
:class:`~optuna.trial.FrozenTrial` and return the constraints. The return value must
be a sequence of :obj:`float` s. A value strictly larger than 0 means that a
constraints is violated. A value equal to or smaller than 0 is considered feasible.
If ``constraints_func`` returns more than one value for a trial, that trial is
considered feasible if and only if all values are equal to 0 or smaller.
The ``constraints_func`` will be evaluated after each successful trial.
The function won't be called when trials fail or they are pruned, but this behavior is
subject to change in the future releases.
The constraints are handled by the constrained domination. A trial x is said to
constrained-dominate a trial y, if any of the following conditions is true:
1. Trial x is feasible and trial y is not.
2. Trial x and y are both infeasible, but trial x has a smaller overall violation.
3. Trial x and y are feasible and trial x dominates trial y.
.. note::
Added in v2.5.0 as an experimental feature. The interface may change in newer
versions without prior notice. See
https://github.com/optuna/optuna/releases/tag/v2.5.0.
Raises:
ValueError:
If ``crossover`` is not in `[uniform, blxalpha, sbx, vsbx, undx, spx]`.
Or, if ``population_size <= n_parents``.
The `n_parents` is determined by each crossover.
For `undx` and `spx`, ``n_parents=3``, and for the other algorithms, ``n_parents=2``.
"""
def __init__(
self,
*,
population_size: int = 50,
mutation_prob: Optional[float] = None,
crossover: str = "uniform",
crossover_prob: float = 0.9,
swapping_prob: float = 0.5,
seed: Optional[int] = None,
constraints_func: Optional[Callable[[FrozenTrial],
Sequence[float]]] = None,
) -> None:
# TODO(ohta): Reconsider the default value of each parameter.
if not isinstance(population_size, int):
raise TypeError("`population_size` must be an integer value.")
if population_size < 2:
raise ValueError(
"`population_size` must be greater than or equal to 2.")
if not (mutation_prob is None or 0.0 <= mutation_prob <= 1.0):
raise ValueError(
"`mutation_prob` must be None or a float value within the range [0.0, 1.0]."
)
if not (0.0 <= crossover_prob <= 1.0):
raise ValueError(
"`crossover_prob` must be a float value within the range [0.0, 1.0]."
)
if not (0.0 <= swapping_prob <= 1.0):
raise ValueError(
"`swapping_prob` must be a float value within the range [0.0, 1.0]."
)
if constraints_func is not None:
warnings.warn(
"The constraints_func option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
if crossover not in [
"uniform", "blxalpha", "sbx", "vsbx", "undx", "spx"
]:
raise ValueError(
f"'{crossover}' is not a valid crossover name."
" The available crossovers are"
" `uniform` (default), `blxalpha`, `sbx`, `vsbx`, `undx`, and `spx`."
)
if crossover != "uniform":
warnings.warn(
"``crossover`` option is an experimental feature."
" The interface can change in the future.",
ExperimentalWarning,
)
n_parents = get_n_parents(crossover)
if population_size < n_parents:
raise ValueError(
f"Using {crossover},"
f" the population size should be greater than or equal to {n_parents}."
f" The specified `population_size` is {population_size}.")
self._population_size = population_size
self._mutation_prob = mutation_prob
self._crossover = crossover
self._crossover_prob = crossover_prob
self._swapping_prob = swapping_prob
self._random_sampler = RandomSampler(seed=seed)
self._rng = np.random.RandomState(seed)
self._constraints_func = constraints_func
self._search_space = IntersectionSearchSpace()
def reseed_rng(self) -> None:
self._random_sampler.reseed_rng()
self._rng = np.random.RandomState()
def infer_relative_search_space(
self, study: Study,
trial: FrozenTrial) -> Dict[str, BaseDistribution]:
search_space: Dict[str, BaseDistribution] = {}
for name, distribution in self._search_space.calculate(study).items():
if distribution.single():
# The `untransform` method of `optuna._transform._SearchSpaceTransform`
# does not assume a single value,
# so single value objects are not sampled with the `sample_relative` method,
# but with the `sample_independent` method.
continue
search_space[name] = distribution
return search_space
def sample_relative(
self,
study: Study,
trial: FrozenTrial,
search_space: Dict[str, BaseDistribution],
) -> Dict[str, Any]:
parent_generation, parent_population = self._collect_parent_population(
study)
trial_id = trial._trial_id
generation = parent_generation + 1
study._storage.set_trial_system_attr(trial_id, _GENERATION_KEY,
generation)
dominates_func = _dominates if self._constraints_func is None else _constrained_dominates
if parent_generation >= 0:
# We choose a child based on the specified crossover method.
if self._rng.rand() < self._crossover_prob:
child_params = crossover(
self._crossover,
study,
parent_population,
search_space,
self._rng,
self._swapping_prob,
dominates_func,
)
else:
parent_population_size = len(parent_population)
parent_params = parent_population[self._rng.choice(
parent_population_size)].params
child_params = {
name: parent_params[name]
for name in search_space.keys()
}
n_params = len(child_params)
if self._mutation_prob is None:
mutation_prob = 1.0 / max(1.0, n_params)
else:
mutation_prob = self._mutation_prob
params = {}
for param_name in child_params.keys():
if self._rng.rand() >= mutation_prob:
params[param_name] = child_params[param_name]
return params
return {}
def sample_independent(
self,
study: Study,
trial: FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
# Following parameters are randomly sampled here.
# 1. A parameter in the initial population/first generation.
# 2. A parameter to mutate.
# 3. A parameter excluded from the intersection search space.
return self._random_sampler.sample_independent(study, trial,
param_name,
param_distribution)
def _collect_parent_population(
self, study: Study) -> Tuple[int, List[FrozenTrial]]:
trials = study.get_trials(deepcopy=False)
generation_to_runnings = defaultdict(list)
generation_to_population = defaultdict(list)
for trial in trials:
if _GENERATION_KEY not in trial.system_attrs:
continue
generation = trial.system_attrs[_GENERATION_KEY]
if trial.state != optuna.trial.TrialState.COMPLETE:
if trial.state == optuna.trial.TrialState.RUNNING:
generation_to_runnings[generation].append(trial)
continue
# Do not use trials whose states are not COMPLETE, or `constraint` will be unavailable.
generation_to_population[generation].append(trial)
hasher = hashlib.sha256()
parent_population: List[FrozenTrial] = []
parent_generation = -1
while True:
generation = parent_generation + 1
population = generation_to_population[generation]
# Under multi-worker settings, the population size might become larger than
# `self._population_size`.
if len(population) < self._population_size:
break
# [NOTE]
# It's generally safe to assume that once the above condition is satisfied,
# there are no additional individuals added to the generation (i.e., the members of
# the generation have been fixed).
# If the number of parallel workers is huge, this assumption can be broken, but
# this is a very rare case and doesn't significantly impact optimization performance.
# So we can ignore the case.
# The cache key is calculated based on the key of the previous generation and
# the remaining running trials in the current population.
# If there are no running trials, the new cache key becomes exactly the same as
# the previous one, and the cached content will be overwritten. This allows us to
# skip redundant cache key calculations when this method is called for the subsequent
# trials.
for trial in generation_to_runnings[generation]:
hasher.update(bytes(str(trial.number), "utf-8"))
cache_key = "{}:{}".format(_POPULATION_CACHE_KEY_PREFIX,
hasher.hexdigest())
cached_generation, cached_population_numbers = study.system_attrs.get(
cache_key, (-1, []))
if cached_generation >= generation:
generation = cached_generation
population = [trials[n] for n in cached_population_numbers]
else:
population.extend(parent_population)
population = self._select_elite_population(study, population)
# To reduce the number of system attribute entries,
# we cache the population information only if there are no running trials
# (i.e., the information of the population has been fixed).
# Usually, if there are no too delayed running trials, the single entry
# will be used.
if len(generation_to_runnings[generation]) == 0:
population_numbers = [t.number for t in population]
study.set_system_attr(cache_key,
(generation, population_numbers))
parent_generation = generation
parent_population = population
return parent_generation, parent_population
def _select_elite_population(
self, study: Study,
population: List[FrozenTrial]) -> List[FrozenTrial]:
elite_population: List[FrozenTrial] = []
population_per_rank = self._fast_non_dominated_sort(
population, study.directions)
for population in population_per_rank:
if len(elite_population) + len(population) < self._population_size:
elite_population.extend(population)
else:
n = self._population_size - len(elite_population)
_crowding_distance_sort(population)
elite_population.extend(population[:n])
break
return elite_population
def _fast_non_dominated_sort(
self,
population: List[FrozenTrial],
directions: List[optuna.study.StudyDirection],
) -> List[List[FrozenTrial]]:
dominated_count: DefaultDict[int, int] = defaultdict(int)
dominates_list = defaultdict(list)
dominates = _dominates if self._constraints_func is None else _constrained_dominates
for p, q in itertools.combinations(population, 2):
if dominates(p, q, directions):
dominates_list[p.number].append(q.number)
dominated_count[q.number] += 1
elif dominates(q, p, directions):
dominates_list[q.number].append(p.number)
dominated_count[p.number] += 1
population_per_rank = []
while population:
non_dominated_population = []
i = 0
while i < len(population):
if dominated_count[population[i].number] == 0:
individual = population[i]
if i == len(population) - 1:
population.pop()
else:
population[i] = population.pop()
non_dominated_population.append(individual)
else:
i += 1
for x in non_dominated_population:
for y in dominates_list[x.number]:
dominated_count[y] -= 1
assert non_dominated_population
population_per_rank.append(non_dominated_population)
return population_per_rank
def after_trial(
self,
study: Study,
trial: FrozenTrial,
state: TrialState,
values: Optional[Sequence[float]],
) -> None:
assert state in [
TrialState.COMPLETE, TrialState.FAIL, TrialState.PRUNED
]
if state == TrialState.COMPLETE and self._constraints_func is not None:
constraints = None
try:
con = self._constraints_func(trial)
if not isinstance(con, (tuple, list)):
warnings.warn(
f"Constraints should be a sequence of floats but got {type(con).__name__}."
)
constraints = tuple(con)
except Exception:
raise
finally:
assert constraints is None or isinstance(constraints, tuple)
study._storage.set_trial_system_attr(
trial._trial_id,
_CONSTRAINTS_KEY,
constraints,
)
self._random_sampler.after_trial(study, trial, state, values)
class MOTPESampler(BaseSampler):
"""Multi-objective sampler using the MOTPE algorithm.
This sampler is a multiobjective version of :class:`~optuna.samplers.TPESampler`.
For further information about MOTPE algorithm, please refer to the following paper:
- `Multiobjective tree-structured parzen estimator for computationally expensive optimization
problems <https://dl.acm.org/doi/abs/10.1145/3377930.3389817>`_
Args:
consider_prior:
Enhance the stability of Parzen estimator by imposing a Gaussian prior when
:obj:`True`. The prior is only effective if the sampling distribution is
either :class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
or :class:`~optuna.distributions.IntLogUniformDistribution`.
prior_weight:
The weight of the prior. This argument is used in
:class:`~optuna.distributions.UniformDistribution`,
:class:`~optuna.distributions.DiscreteUniformDistribution`,
:class:`~optuna.distributions.LogUniformDistribution`,
:class:`~optuna.distributions.IntUniformDistribution`,
:class:`~optuna.distributions.IntLogUniformDistribution`, and
:class:`~optuna.distributions.CategoricalDistribution`.
consider_magic_clip:
Enable a heuristic to limit the smallest variances of Gaussians used in
the Parzen estimator.
consider_endpoints:
Take endpoints of domains into account when calculating variances of Gaussians
in Parzen estimator. See the original paper for details on the heuristics
to calculate the variances.
n_startup_trials:
The random sampling is used instead of the MOTPE algorithm until the given number
of trials finish in the same study. 11 * number of variables - 1 is recommended in the
original paper.
n_ehvi_candidates:
Number of candidate samples used to calculate the expected hypervolume improvement.
gamma:
A function that takes the number of finished trials and returns the number of trials to
form a density function for samples with low grains. See the original paper for more
details.
weights_above:
A function that takes the number of finished trials and returns a weight for them. As
default, weights are automatically calculated by the MOTPE's default strategy.
seed:
Seed for random number generator.
.. note::
Initialization with Latin hypercube sampling may improve optimization performance.
However, the current implementation only supports initialization with random sampling.
Example:
.. testcode::
import optuna
seed = 128
num_variables = 2
n_startup_trials = 11 * num_variables - 1
def objective(trial):
x = []
for i in range(1, num_variables + 1):
x.append(trial.suggest_float(f"x{i}", 0.0, 2.0 * i))
return x
sampler = optuna.samplers.MOTPESampler(
n_startup_trials=n_startup_trials, n_ehvi_candidates=24, seed=seed
)
study = optuna.create_study(directions=["minimize"] * num_variables, sampler=sampler)
study.optimize(objective, n_trials=n_startup_trials + 10)
"""
def __init__(
self,
*,
consider_prior: bool = True,
prior_weight: float = 1.0,
consider_magic_clip: bool = True,
consider_endpoints: bool = True,
n_startup_trials: int = 10,
n_ehvi_candidates: int = 24,
gamma: Callable[[int], int] = default_gamma,
weights_above: Callable[[int], np.ndarray] = _default_weights_above,
seed: Optional[int] = None,
) -> None:
self._parzen_estimator_parameters = _ParzenEstimatorParameters(
consider_prior, prior_weight, consider_magic_clip,
consider_endpoints, weights_above)
self._prior_weight = prior_weight
self._n_startup_trials = n_startup_trials
self._n_ehvi_candidates = n_ehvi_candidates
self._gamma = gamma
self._weights = weights_above
self._warn_independent_sampling = True
self._rng = np.random.RandomState(seed)
self._mo_random_sampler = RandomSampler(seed=seed)
self._search_space = IntersectionSearchSpace(include_pruned=True)
self._split_cache: Dict[int, Any] = {}
self._weights_below: Dict[int, Any] = {}
def reseed_rng(self) -> None:
self._rng = np.random.RandomState()
self._mo_random_sampler.reseed_rng()
def infer_relative_search_space(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
) -> Dict[str, BaseDistribution]:
return {}
def sample_relative(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
search_space: Dict[str, BaseDistribution],
) -> Dict[str, Any]:
return {}
def sample_independent(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
param_name: str,
param_distribution: BaseDistribution,
) -> Any:
if len(study.directions) < 2:
raise ValueError(
"Number of objectives must be >= 2. "
"Please use optuna.samplers.TPESampler for single-objective optimization."
)
values, scores = _get_observation_pairs(study, param_name)
n = len(values)
if n < self._n_startup_trials:
return self._mo_random_sampler.sample_independent(
study, trial, param_name, param_distribution)
below_param_values, above_param_values = self._split_mo_observation_pairs(
study, trial, values, scores)
if isinstance(param_distribution, distributions.UniformDistribution):
return self._sample_mo_uniform(study, trial, param_distribution,
below_param_values,
above_param_values)
elif isinstance(param_distribution,
distributions.LogUniformDistribution):
return self._sample_mo_loguniform(study, trial, param_distribution,
below_param_values,
above_param_values)
elif isinstance(param_distribution,
distributions.DiscreteUniformDistribution):
return self._sample_mo_discrete_uniform(study, trial,
param_distribution,
below_param_values,
above_param_values)
elif isinstance(param_distribution,
distributions.IntUniformDistribution):
return self._sample_mo_int(study, trial, param_distribution,
below_param_values, above_param_values)
elif isinstance(param_distribution,
distributions.IntLogUniformDistribution):
return self._sample_mo_int_loguniform(study, trial,
param_distribution,
below_param_values,
above_param_values)
elif isinstance(param_distribution,
distributions.CategoricalDistribution):
index = self._sample_mo_categorical_index(study, trial,
param_distribution,
below_param_values,
above_param_values)
return param_distribution.choices[index]
else:
distribution_list = [
distributions.UniformDistribution.__name__,
distributions.LogUniformDistribution.__name__,
distributions.DiscreteUniformDistribution.__name__,
distributions.IntUniformDistribution.__name__,
distributions.IntLogUniformDistribution.__name__,
distributions.CategoricalDistribution.__name__,
]
raise NotImplementedError(
"The distribution {} is not implemented. "
"The parameter distribution should be one of the {}".format(
param_distribution, distribution_list))
def _split_mo_observation_pairs(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
config_vals: List[Optional[float]],
loss_vals: List[List[float]],
) -> Tuple[np.ndarray, np.ndarray]:
"""Split observations into observations for l(x) and g(x) with the ratio of gamma:1-gamma.
Weights for l(x) are also calculated in this method.
This splitting strategy consists of the following two steps:
1. Nondonation rank-based selection
2. Hypervolume subset selection problem (HSSP)-based selection
Please refer to the `original paper <https://dl.acm.org/doi/abs/10.1145/3377930.3389817>`_
for more details.
"""
cvals = np.asarray(config_vals)
lvals = np.asarray(loss_vals)
# Solving HSSP for variables number of times is a waste of time.
# We cache the result of splitting.
is_cached = trial._trial_id in self._split_cache
if is_cached:
split_cache = self._split_cache[trial._trial_id]
indices_below = np.asarray(split_cache["indices_below"])
weights_below = np.asarray(split_cache["weights_below"])
indices_above = np.asarray(split_cache["indices_above"])
else:
nondomination_ranks = _calculate_nondomination_rank(lvals)
n_below = self._gamma(len(lvals))
assert 0 <= n_below <= len(lvals)
indices = np.array(range(len(lvals)))
indices_below = np.empty(n_below, dtype=int)
# Nondomination rank-based selection
i = 0
last_idx = 0
while last_idx + sum(nondomination_ranks == i) <= n_below:
length = indices[nondomination_ranks == i].shape[0]
indices_below[last_idx:last_idx +
length] = indices[nondomination_ranks == i]
last_idx += length
i += 1
# Hypervolume subset selection problem (HSSP)-based selection
subset_size = n_below - last_idx
if subset_size > 0:
rank_i_lvals = lvals[nondomination_ranks == i]
rank_i_indices = indices[nondomination_ranks == i]
worst_point = np.max(rank_i_lvals, axis=0)
reference_point = np.maximum(1.1 * worst_point,
0.9 * worst_point)
reference_point[reference_point == 0] = EPS
selected_indices = self._solve_hssp(rank_i_lvals,
rank_i_indices,
subset_size,
reference_point)
indices_below[last_idx:] = selected_indices
indices_above = np.setdiff1d(indices, indices_below)
attrs = {
"indices_below": indices_below.tolist(),
"indices_above": indices_above.tolist(),
}
weights_below = self._calculate_weights_below(lvals, indices_below)
attrs["weights_below"] = weights_below.tolist()
self._split_cache[trial._trial_id] = attrs
below = cvals[indices_below]
self._weights_below[trial._trial_id] = np.asarray(
[w for w, v in zip(weights_below, below) if v is not None],
dtype=float)
below = np.asarray([v for v in below if v is not None], dtype=float)
above = cvals[indices_above]
above = np.asarray([v for v in above if v is not None], dtype=float)
return below, above
def _sample_mo_uniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.UniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
low = distribution.low
high = distribution.high
return self._sample_mo_numerical(study, trial, low, high, below, above)
def _sample_mo_loguniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.LogUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
low = distribution.low
high = distribution.high
return self._sample_mo_numerical(study,
trial,
low,
high,
below,
above,
is_log=True)
def _sample_mo_discrete_uniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.DiscreteUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> float:
q = distribution.q
r = distribution.high - distribution.low
# [low, high] is shifted to [0, r] to align sampled values at regular intervals.
low = 0 - 0.5 * q
high = r + 0.5 * q
# Shift below and above to [0, r]
above -= distribution.low
below -= distribution.low
best_sample = (self._sample_mo_numerical(
study, trial, low, high, below, above, q=q) + distribution.low)
return min(max(best_sample, distribution.low), distribution.high)
def _sample_mo_int(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.IntUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
d = distributions.DiscreteUniformDistribution(low=distribution.low,
high=distribution.high,
q=distribution.step)
return int(
self._sample_mo_discrete_uniform(study, trial, d, below, above))
def _sample_mo_int_loguniform(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.IntLogUniformDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
low = distribution.low - 0.5
high = distribution.high + 0.5
sample = self._sample_mo_numerical(study,
trial,
low,
high,
below,
above,
is_log=True)
best_sample = np.round(sample)
return int(min(max(best_sample, distribution.low), distribution.high))
def _sample_mo_numerical(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
low: float,
high: float,
below: np.ndarray,
above: np.ndarray,
q: Optional[float] = None,
is_log: bool = False,
) -> float:
if is_log:
low = np.log(low)
high = np.log(high)
below = np.log(below)
above = np.log(above)
size = (self._n_ehvi_candidates, )
weights_below: Callable[[int], np.ndarray]
weights_below = lambda _: self._weights_below[trial._trial_id] # NOQA
parzen_estimator_parameters_below = _ParzenEstimatorParameters(
self._parzen_estimator_parameters.consider_prior,
self._parzen_estimator_parameters.prior_weight,
self._parzen_estimator_parameters.consider_magic_clip,
self._parzen_estimator_parameters.consider_endpoints,
weights_below,
)
parzen_estimator_below = _ParzenEstimator(
mus=below,
low=low,
high=high,
parameters=parzen_estimator_parameters_below)
samples_below = self._sample_from_gmm(
parzen_estimator=parzen_estimator_below,
low=low,
high=high,
q=q,
size=size,
)
log_likelihoods_below = self._gmm_log_pdf(
samples=samples_below,
parzen_estimator=parzen_estimator_below,
low=low,
high=high,
q=q,
)
weights_above = self._weights
parzen_estimator_parameters_above = _ParzenEstimatorParameters(
self._parzen_estimator_parameters.consider_prior,
self._parzen_estimator_parameters.prior_weight,
self._parzen_estimator_parameters.consider_magic_clip,
self._parzen_estimator_parameters.consider_endpoints,
weights_above,
)
parzen_estimator_above = _ParzenEstimator(
mus=above,
low=low,
high=high,
parameters=parzen_estimator_parameters_above)
log_likelihoods_above = self._gmm_log_pdf(
samples=samples_below,
parzen_estimator=parzen_estimator_above,
low=low,
high=high,
q=q,
)
ret = float(
self._compare(samples=samples_below,
log_l=log_likelihoods_below,
log_g=log_likelihoods_above)[0])
return math.exp(ret) if is_log else ret
def _sample_mo_categorical_index(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
distribution: distributions.CategoricalDistribution,
below: np.ndarray,
above: np.ndarray,
) -> int:
choices = distribution.choices
below = below.astype(int)
above = above.astype(int)
upper = len(choices)
size = (self._n_ehvi_candidates, )
weights_below = self._weights_below[trial._trial_id]
counts_below = np.bincount(below,
minlength=upper,
weights=weights_below)
weighted_below = counts_below + self._prior_weight
weighted_below /= weighted_below.sum()
samples_below = self._sample_from_categorical_dist(
weighted_below, size)
log_likelihoods_below = self._categorical_log_pdf(
samples_below, weighted_below)
weights_above = self._weights(len(above))
counts_above = np.bincount(above,
minlength=upper,
weights=weights_above)
weighted_above = counts_above + self._prior_weight
weighted_above /= weighted_above.sum()
log_likelihoods_above = self._categorical_log_pdf(
samples_below, weighted_above)
return int(
self._compare(samples=samples_below,
log_l=log_likelihoods_below,
log_g=log_likelihoods_above)[0])
@staticmethod
def _compute_hypervolume(solution_set: np.ndarray,
reference_point: np.ndarray) -> float:
return optuna.multi_objective._hypervolume.WFG().compute(
solution_set, reference_point)
def _solve_hssp(
self,
rank_i_loss_vals: np.ndarray,
rank_i_indices: np.ndarray,
subset_size: int,
reference_point: np.ndarray,
) -> np.ndarray:
"""Solve a hypervolume subset selection problem (HSSP) via a greedy algorithm.
This method is a 1-1/e approximation algorithm to solve HSSP.
For further information about algorithms to solve HSSP, please refer to the following
paper:
- `Greedy Hypervolume Subset Selection in Low Dimensions
<https://ieeexplore.ieee.org/document/7570501>`_
"""
selected_vecs = [] # type: List[np.ndarray]
selected_indices = [] # type: List[int]
contributions = [
self._compute_hypervolume(np.asarray([v]), reference_point)
for v in rank_i_loss_vals
]
hv_selected = 0.0
while len(selected_indices) < subset_size:
max_index = int(np.argmax(contributions))
contributions[max_index] = -1 # mark as selected
selected_index = rank_i_indices[max_index]
selected_vec = rank_i_loss_vals[max_index]
for j, v in enumerate(rank_i_loss_vals):
if contributions[j] == -1:
continue
p = np.max([selected_vec, v], axis=0)
contributions[j] -= (self._compute_hypervolume(
np.asarray(selected_vecs + [p]), reference_point) -
hv_selected)
selected_vecs += [selected_vec]
selected_indices += [selected_index]
hv_selected = self._compute_hypervolume(np.asarray(selected_vecs),
reference_point)
return np.asarray(selected_indices, dtype=int)
def _calculate_weights_below(
self,
lvals: np.ndarray,
indices_below: np.ndarray,
) -> np.ndarray:
# Calculate weights based on hypervolume contributions.
n_below = len(indices_below)
if n_below == 0:
return np.asarray([])
elif n_below == 1:
return np.asarray([1.0])
else:
lvals_below = lvals[indices_below].tolist()
worst_point = np.max(lvals_below, axis=0)
reference_point = np.maximum(1.1 * worst_point, 0.9 * worst_point)
reference_point[reference_point == 0] = EPS
hv = self._compute_hypervolume(np.asarray(lvals_below),
reference_point)
contributions = np.asarray([
hv - self._compute_hypervolume(
np.asarray(lvals_below[:i] + lvals_below[i + 1:]),
reference_point) for i in range(n_below)
])
contributions += EPS
weights_below = np.clip(contributions / np.max(contributions), 0,
1)
return weights_below
def after_trial(
self,
study: optuna.study.Study,
trial: optuna.trial.FrozenTrial,
state: optuna.trial.TrialState,
values: Optional[Sequence[float]],
) -> None:
if trial._trial_id in self._split_cache:
del self._split_cache[trial._trial_id]
if trial._trial_id in self._weights_below:
del self._weights_below[trial._trial_id]
self._mo_random_sampler.after_trial(study, trial, state, values)
def _sample_from_gmm(
self,
parzen_estimator: _ParzenEstimator,
low: float,
high: float,
q: Optional[float] = None,
size: Tuple = (),
) -> np.ndarray:
weights = parzen_estimator.weights
mus = parzen_estimator.mus
sigmas = parzen_estimator.sigmas
weights, mus, sigmas = map(np.asarray, (weights, mus, sigmas))
if low >= high:
raise ValueError(
"The 'low' boundary should be below the 'high' boundary, "
f"but (low, high) = ({low}, {high}).")
active = np.argmax(self._rng.multinomial(1, weights, size=size),
axis=-1)
trunc_low = (low - mus[active]) / sigmas[active]
trunc_high = (high - mus[active]) / sigmas[active]
samples = np.full((), fill_value=high + 1.0, dtype=np.float64)
while (samples >= high).any():
samples = np.where(
samples < high,
samples,
truncnorm.rvs(
trunc_low,
trunc_high,
size=size,
loc=mus[active],
scale=sigmas[active],
random_state=self._rng,
),
)
if q is None:
return samples
else:
return np.round(samples / q) * q
def _gmm_log_pdf(
self,
samples: np.ndarray,
parzen_estimator: _ParzenEstimator,
low: float,
high: float,
q: Optional[float] = None,
) -> np.ndarray:
weights = parzen_estimator.weights
mus = parzen_estimator.mus
sigmas = parzen_estimator.sigmas
samples, weights, mus, sigmas = map(np.asarray,
(samples, weights, mus, sigmas))
if samples.size == 0:
return np.asarray([], dtype=float)
if weights.ndim != 1:
raise ValueError("The 'weights' should have only one dimension, "
f"but weights.shape = {weights.shape}")
if mus.ndim != 1:
raise ValueError(
f"The 'mus' should have only one dimension, but mus.shape = {mus.shape}"
)
if sigmas.ndim != 1:
raise ValueError(
f"The 'sigmas' should have only one dimension, but sigmas.shape = {sigmas.shape}"
)
p_accept = np.sum(weights * (self._normal_cdf(high, mus, sigmas) -
self._normal_cdf(low, mus, sigmas)))
if q is None:
distance = samples[..., None] - mus
mahalanobis = (distance / np.maximum(sigmas, EPS))**2
Z = np.sqrt(2 * np.pi) * sigmas
coefficient = weights / Z / p_accept
return self._logsum_rows(-0.5 * mahalanobis + np.log(coefficient))
else:
cdf_func = self._normal_cdf
upper_bound = np.minimum(samples + q / 2.0, high)
lower_bound = np.maximum(samples - q / 2.0, low)
probabilities = np.sum(
weights[..., None] *
(cdf_func(upper_bound[None], mus[..., None], sigmas[..., None])
- cdf_func(lower_bound[None], mus[..., None], sigmas[...,
None])),
axis=0,
)
return np.log(probabilities + EPS) - np.log(p_accept + EPS)
def _sample_from_categorical_dist(self, probabilities: np.ndarray,
size: Tuple[int]) -> np.ndarray:
if size == (0, ):
return np.asarray([], dtype=float)
assert size
if probabilities.size == 1 and isinstance(probabilities[0],
np.ndarray):
probabilities = probabilities[0]
assert probabilities.ndim == 1
n_draws = np.prod(size).item()
sample = self._rng.multinomial(n=1, pvals=probabilities, size=n_draws)
assert sample.shape == size + probabilities.shape
return_val = np.dot(sample,
np.arange(probabilities.size)).reshape(size)
return return_val
@classmethod
def _categorical_log_pdf(cls, sample: np.ndarray,
p: np.ndarray) -> np.ndarray:
if sample.size:
return np.log(np.asarray(p)[sample])
else:
return np.asarray([])
@classmethod
def _compare(cls, samples: np.ndarray, log_l: np.ndarray,
log_g: np.ndarray) -> np.ndarray:
samples, log_l, log_g = map(np.asarray, (samples, log_l, log_g))
if samples.size:
score = log_l - log_g
if samples.size != score.size:
raise ValueError(
"The size of the 'samples' and that of the 'score' "
"should be same. "
"But (samples.size, score.size) = ({}, {})".format(
samples.size, score.size))
best = np.argmax(score)
return np.asarray([samples[best]] * samples.size)
else:
return np.asarray([])
@classmethod
def _logsum_rows(cls, x: np.ndarray) -> np.ndarray:
x = np.asarray(x)
m = x.max(axis=1)
return np.log(np.exp(x - m[:, None]).sum(axis=1)) + m
@classmethod
def _normal_cdf(cls, x: float, mu: np.ndarray,
sigma: np.ndarray) -> np.ndarray:
mu, sigma = map(np.asarray, (mu, sigma))
denominator = x - mu
numerator = np.maximum(np.sqrt(2) * sigma, EPS)
z = denominator / numerator
return 0.5 * (1 + scipy.special.erf(z))