def adapt_es_opts(self, opts):
self.es.opts = opts
parameter_opts = self.es.parameters.getParameterOpts()
# __init__ of CustomizedES without new instance of ES
# not a great solution, if package gets updates we should change this
lambda_, eff_lambda, mu = self.es.calculateDependencies(
opts, self.lambda_, self.mu
)
selector = Sel.pairwise if opts["selection"] == "pairwise" else Sel.best
# This is done for safety reasons
# Else offset and all_offspring may be None
self.es.parameters.offset = np.column_stack(
[ind.mutation_vector for ind in self.es.new_population]
)
self.es.parameters.all_offspring = np.column_stack(
[ind.genotype for ind in self.es.new_population]
)
# Same here. Probably the representation space should be restricted
self.es.parameters.tpa_result = -1
def select(pop, new_pop, _, param):
return selector(pop, new_pop, param)
if opts["base-sampler"] == "quasi-sobol":
sampler = Sam.QuasiGaussianSobolSampling(self.dim)
elif opts["base-sampler"] == "quasi-halton" and Sam.halton_available:
sampler = Sam.QuasiGaussianHaltonSampling(self.dim)
else:
sampler = Sam.GaussianSampling(self.dim)
if opts["orthogonal"]:
orth_lambda = eff_lambda
if opts["mirrored"]:
orth_lambda = max(orth_lambda // 2, 1)
sampler = Sam.OrthogonalSampling(
self.dim, lambda_=orth_lambda, base_sampler=sampler
)
if opts["mirrored"]:
sampler = Sam.MirroredSampling(self.dim, base_sampler=sampler)
if opts["sequential"] and opts["selection"] == "pairwise":
parameter_opts["seq_cutoff"] = 2
mutate = partial(
Mut.CMAMutation, sampler=sampler, threshold_convergence=opts["threshold"]
)
self.es.mutate = mutate
self.es.parameters = self.es.instantiateParameters(parameter_opts)
self.es.seq_cutoff = self.es.parameters.mu_int * self.es.parameters.seq_cutoff
def __init__(self,
n,
fitnessFunction,
budget,
mu=None,
lambda_=None,
elitist=False):
parameters = Parameters(n, budget, mu, lambda_, elitist=elitist)
population = [FloatIndividual(n) for _ in range(parameters.mu_int)]
# Artificial init
wcm = parameters.wcm
for individual in population:
individual.genotype = wcm
# We use functions here to 'hide' the additional passing of parameters that are algorithm specific
recombine = Rec.weighted
mutate = partial(Mut.CMAMutation, sampler=Sam.GaussianSampling(n))
def select(pop, new_pop, _, params):
return Sel.best(pop, new_pop, params)
mutateParameters = parameters.adaptCovarianceMatrix
functions = {
'recombine': recombine,
'mutate': mutate,
'select': select,
'mutateParameters': mutateParameters,
}
super(CMAESOptimizer, self).__init__(population, fitnessFunction,
budget, functions, parameters)
def get_sampler(self, options):
'''
Method for getting a correct sampler
based on a dictionary of options.
'''
if options["base-sampler"] == 'quasi-sobol':
sampler = Sampling.QuasiGaussianSobolSampling(self.parameters.n)
elif options["base-sampler"] == 'quasi-halton' and Sampling.halton_available:
sampler = Sampling.QuasiGaussianHaltonSampling(self.parameters.n)
else:
sampler = Sampling.GaussianSampling(self.parameters.n)
if options["orthogonal"]:
orth_lambda = self.parameters.eff_lambda
if options['mirrored']:
orth_lambda = max(orth_lambda // 2, 1)
sampler = Sampling.OrthogonalSampling(self.parameters.n, lambda_=orth_lambda, base_sampler=sampler)
if options['mirrored']:
sampler = Sampling.MirroredSampling(self.parameters.n, base_sampler=sampler)
return sampler
def __init__(self, n, fitnessFunction, budget):
parameters = Parameters(n, budget, 1, 1)
population = [FloatIndividual(n)]
# We use functions here to 'hide' the additional passing of parameters that are algorithm specific
recombine = Rec.onePlusOne
mutate = partial(Mut.addRandomOffset, sampler=Sam.GaussianSampling(n))
select = Sel.onePlusOneSelection
mutateParameters = parameters.oneFifthRule
functions = {
'recombine': recombine,
'mutate': mutate,
'select': select,
'mutateParameters': mutateParameters,
}
super(OnePlusOneOptimizer,
self).__init__(population, fitnessFunction, budget, functions,
parameters)
def switchConfiguration(self, opts):
selector = Sel.pairwise if opts["selection"] == "pairwise" else Sel.best
def select(pop, new_pop, _, param):
return selector(pop, new_pop, param)
# Pick the lowest-level sampler
if opts["base-sampler"] == "quasi-sobol":
sampler = Sam.QuasiGaussianSobolSampling(self.es.n)
elif opts["base-sampler"] == "quasi-halton" and Sam.halton_available:
sampler = Sam.QuasiGaussianHaltonSampling(self.es.n)
else:
sampler = Sam.GaussianSampling(self.es.n)
# Create an orthogonal sampler using the determined base_sampler
if opts["orthogonal"]:
orth_lambda = self.es.parameters.eff_lambda
if opts["mirrored"]:
orth_lambda = max(orth_lambda // 2, 1)
sampler = Sam.OrthogonalSampling(
self.es.n, lambda_=orth_lambda, base_sampler=sampler
)
# Create a mirrored sampler using the sampler (structure) chosen so far
if opts["mirrored"]:
sampler = Sam.MirroredSampling(self.es.n, base_sampler=sampler)
parameter_opts = {
"weights_option": opts["weights_option"],
"active": opts["active"],
"elitist": opts["elitist"],
"sequential": opts["sequential"],
"tpa": opts["tpa"],
"local_restart": opts["ipop"],
}
# In case of pairwise selection, sequential evaluation may only stop after 2mu instead of mu individuals
if opts["sequential"] and opts["selection"] == "pairwise":
parameter_opts["seq_cutoff"] = 2
self.es.parameters.seq_cutoff = 2
# Init all individuals of the first population at the same random point in the search space
# We use functions/partials here to 'hide' the additional passing of parameters that are algorithm specific
recombine = Rec.weighted
mutate = partial(
Mut.CMAMutation, sampler=sampler, threshold_convergence=opts["threshold"]
)
functions = {
"recombine": recombine,
"mutate": mutate,
"select": select,
# 'mutateParameters': None
}
self.setConfigurationParameters(functions, parameter_opts)
lambda_, eff_lambda, mu = self.es.calculateDependencies(opts, None, None)
self.es.parameters.lambda_ = lambda_
self.es.parameters.eff_lambda = eff_lambda
self.es.parameters.mu = mu
self.es.parameters.weights = self.es.parameters.getWeights(
self.es.parameters.weights_option
)
self.es.parameters.mu_eff = 1 / np.sum(np.square(self.es.parameters.weights))
mu_eff = self.es.parameters.mu_eff # Local copy
n = self.es.parameters.n
self.es.parameters.c_sigma = (mu_eff + 2) / (mu_eff + n + 5)
self.es.parameters.c_c = (4 + mu_eff / n) / (n + 4 + 2 * mu_eff / n)
self.es.parameters.c_1 = 2 / ((n + 1.3) ** 2 + mu_eff)
self.es.parameters.c_mu = min(
1 - self.es.parameters.c_1,
self.es.parameters.alpha_mu
* (
(mu_eff - 2 + 1 / mu_eff)
/ ((n + 2) ** 2 + float(self.es.parameters.alpha_mu) * mu_eff / 2)
),
)
self.es.parameters.damps = (
1
+ 2 * np.max([0, np.sqrt((mu_eff - 1) / (n + 1)) - 1])
+ self.es.parameters.c_sigma
)
self.es.seq_cutoff = self.es.parameters.mu_int * self.es.parameters.seq_cutoff
def __init__(self,
n,
fitnessFunction,
budget,
mu=None,
lambda_=None,
opts=None,
values=None):
if opts is None:
opts = dict()
self.addDefaults(opts)
self.n = n
l_bound = ones((n, 1)) * -5
u_bound = ones((n, 1)) * 5
lambda_, eff_lambda, mu = self.calculateDependencies(opts, lambda_, mu)
selector = Sel.pairwise if opts['selection'] == 'pairwise' else Sel.best
def select(pop, new_pop, _, param):
return selector(pop, new_pop, param)
# Pick the lowest-level sampler
if opts['base-sampler'] == 'quasi-sobol':
sampler = Sam.QuasiGaussianSobolSampling(n)
elif opts['base-sampler'] == 'quasi-halton' and Sam.halton_available:
sampler = Sam.QuasiGaussianHaltonSampling(n)
else:
sampler = Sam.GaussianSampling(n)
# Create an orthogonal sampler using the determined base_sampler
if opts['orthogonal']:
orth_lambda = eff_lambda
if opts['mirrored']:
orth_lambda = max(orth_lambda // 2, 1)
sampler = Sam.OrthogonalSampling(n,
lambda_=orth_lambda,
base_sampler=sampler)
# Create a mirrored sampler using the sampler (structure) chosen so far
if opts['mirrored']:
sampler = Sam.MirroredSampling(n, base_sampler=sampler)
parameter_opts = {
'n': n,
'budget': budget,
'mu': mu,
'lambda_': lambda_,
'u_bound': u_bound,
'l_bound': l_bound,
'weights_option': opts['weights_option'],
'active': opts['active'],
'elitist': opts['elitist'],
'sequential': opts['sequential'],
'tpa': opts['tpa'],
'local_restart': opts['ipop'],
'values': values,
}
# In case of pairwise selection, sequential evaluation may only stop after 2mu instead of mu individuals
mu_int = int(1 + floor(mu * (eff_lambda - 1)))
if opts['sequential'] and opts['selection'] == 'pairwise':
parameter_opts['seq_cutoff'] = 2
population = [FloatIndividual(n) for _ in range(mu_int)]
# Init all individuals of the first population at the same random point in the search space
wcm = (np.random.randn(n, 1) * (u_bound - l_bound)) + l_bound
parameter_opts['wcm'] = wcm
for individual in population:
individual.genotype = copy(wcm)
# We use functions/partials here to 'hide' the additional passing of parameters that are algorithm specific
recombine = Rec.weighted
mutate = partial(Mut.CMAMutation,
sampler=sampler,
threshold_convergence=opts['threshold'])
functions = {
'recombine': recombine,
'mutate': mutate,
'select': select,
'mutateParameters': None
}
super(CustomizedES, self).__init__(population, fitnessFunction, budget,
functions, parameter_opts)