in nevergrad/optimization/optimizerlib.py [0:0]
def _internal_ask_candidate(self) -> p.Parameter:
# pylint: disable=too-many-return-statements, too-many-branches
noise_handling = self.noise_handling
if not self._num_ask:
out = self.parametrization.spawn_child()
out._meta["sigma"] = self._sigma
return out
# for noisy version
if noise_handling is not None:
limit = (0.05 if isinstance(noise_handling, str) else noise_handling[1]) * len(self.archive) ** 3
strategy = noise_handling if isinstance(noise_handling, str) else noise_handling[0]
if self._num_ask <= limit:
if strategy in ["cubic", "random"]:
idx = self._rng.choice(len(self.archive))
return list(self.archive.values())[idx].parameter.spawn_child() # type: ignore
elif strategy == "optimistic":
return self.current_bests["optimistic"].parameter.spawn_child()
# crossover
mutator = mutations.Mutator(self._rng)
pessimistic = self.current_bests["pessimistic"].parameter.spawn_child()
if self.num_objectives > 1 and self.use_pareto: # multiobjective
# revert to using a sample of the pareto front (not "pessimistic" though)
pareto = (
self.pareto_front()
) # we can't use choice directly, because numpy does not like iterables
pessimistic = pareto[self._rng.choice(len(pareto))].spawn_child()
ref = self.parametrization
if self.crossover and self._num_ask % 2 == 1 and len(self.archive) > 2:
data = mutator.crossover(
pessimistic.get_standardized_data(reference=ref),
mutator.get_roulette(self.archive, num=2),
rotation=self.rotation,
)
return pessimistic.set_standardized_data(data, reference=ref)
# mutating
mutation = self.mutation
if mutation in ("gaussian", "cauchy"): # standard case
step = (
self._rng.normal(0, 1, self.dimension)
if mutation == "gaussian"
else self._rng.standard_cauchy(self.dimension)
)
out = pessimistic.set_standardized_data(self._sigma * step)
out._meta["sigma"] = self._sigma
return out
else:
pessimistic_data = pessimistic.get_standardized_data(reference=ref)
if mutation == "crossover":
if self._num_ask % 2 == 0 or len(self.archive) < 3:
data = mutator.portfolio_discrete_mutation(
pessimistic_data, arity=self.arity_for_discrete_mutation
)
else:
data = mutator.crossover(pessimistic_data, mutator.get_roulette(self.archive, num=2))
elif mutation == "adaptive":
data = mutator.portfolio_discrete_mutation(
pessimistic_data,
intensity=max(1, int(self._adaptive_mr * self.dimension)),
arity=self.arity_for_discrete_mutation,
)
elif mutation == "discreteBSO":
assert self.budget is not None, "DiscreteBSO needs a budget."
intensity = int(self.dimension - self._num_ask * self.dimension / self.budget)
if intensity < 1:
intensity = 1
data = mutator.portfolio_discrete_mutation(
pessimistic_data,
intensity=intensity,
arity=self.arity_for_discrete_mutation,
)
elif mutation == "coordinatewise_adaptive":
self._modified_variables = np.array([True] * self.dimension)
data = mutator.coordinatewise_mutation(
pessimistic_data,
self._velocity,
self._modified_variables,
arity=self.arity_for_discrete_mutation,
)
elif mutation == "lengler":
alpha = 1.54468
intensity = int(max(1, self.dimension * (alpha * np.log(self.num_ask) / self.num_ask)))
data = mutator.portfolio_discrete_mutation(
pessimistic_data,
intensity=intensity,
arity=self.arity_for_discrete_mutation,
)
elif mutation == "doerr":
# Selection, either random, or greedy, or a mutation rate.
assert self._doerr_index == -1, "We should have used this index in tell."
if self._rng.uniform() < self._doerr_epsilon:
index = self._rng.choice(range(len(self._doerr_mutation_rates)))
self._doerr_index = index
else:
index = self._doerr_mutation_rewards.index(max(self._doerr_mutation_rewards))
self._doerr_index = -1
intensity = self._doerr_mutation_rates[index]
data = mutator.portfolio_discrete_mutation(
pessimistic_data,
intensity=intensity,
arity=self.arity_for_discrete_mutation,
)
else:
func: tp.Any = { # type: ignore
"discrete": mutator.discrete_mutation,
"fastga": mutator.doerr_discrete_mutation,
"doublefastga": mutator.doubledoerr_discrete_mutation,
"portfolio": mutator.portfolio_discrete_mutation,
}[mutation]
data = func(pessimistic_data, arity=self.arity_for_discrete_mutation)
if self.sparse > 0:
data = np.asarray(data)
zeroing = self._rng.randint(data.size + 1, size=data.size).reshape(
data.shape
) < 1 + self._rng.randint(self.sparse)
data[zeroing] = 0.0
return pessimistic.set_standardized_data(data, reference=ref)