def reset(self):
super(ModeaEnv, self).reset_()
self.dim = self.instance[0]
self.function_id = self.instance[1]
self.instance_id = self.instance[2]
self.representation = self.ensureFullLengthRepresentation(self.instance[3])
opts = getOpts(self.representation[: len(options)])
self.lambda_ = self.representation[len(options)]
self.mu = self.representation[len(options) + 1]
values = getVals(self.representation[len(options) + 2 :])
self.function, self.target = bn.instantiate(int(self.function_id))
self.es = CustomizedES(
self.dim, self.function, self.budget, self.mu, self.lambda_, opts, values
)
parameter_opts = self.es.parameters.getParameterOpts()
# print("Local restart on")
if parameter_opts["lambda_"]:
self.lambda_init = parameter_opts["lambda_"]
elif parameter_opts["local_restart"] in ["IPOP", "BIPOP"]:
self.lambda_init = int(4 + np.floor(3 * np.log(parameter_opts["n"])))
else:
self.lambda_init = None
parameter_opts["lambda_"] = self.lambda_init
# BIPOP Specific parameters
self.lambda_ = {"small": None, "large": self.lambda_init}
self.budgets = {"small": None, "large": None}
self.regime = "first"
self.update_parameters()
return self.get_state(self)
def initializedESAlgorithm(self):
representation = self.ensureFullLengthRepresentation(self.esconfig)
opts = getOpts(representation[:len(options)])
values = getVals(representation[len(options)+2:])
values = getVals(self.esconfig)
customES = Algorithms.CustomizedES(self.dimension, self.problemInstance, budget=self.totalBudget, opts=opts, values=values)
customES.mutateParameters = customES.parameters.adaptCovarianceMatrix
self.optimizer = customES
def printResults():
os.chdir(ga_location)
x = np.load('final_GA_results.npz')
results = x['results'].item()
for dim in dimensions:
print("{}-dimensional:".format(dim))
for func in functions:
print(" F{}:\t{} {}".format(
func, results[dim][func]['best_result'],
getPrintName(getOpts(results[dim][func]['best_result']))))
def _problemCases():
fid = 1
ndim = 10
iids = range(Config.ES_num_runs)
# Known problems
print("Combinations known to cause problems:")
rep = ensureFullLengthRepresentation(getBitString({'sequential': True}))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(getBitString({'tpa': True}))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
getBitString({'selection': 'pairwise'}))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
getBitString({
'tpa': True,
'selection': 'pairwise'
}))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
# these are the actual failures
rep = ensureFullLengthRepresentation(
getBitString({
'sequential': True,
'selection': 'pairwise'
}))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
getBitString({
'sequential': True,
'tpa': True,
'selection': 'pairwise'
}))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 113, 0.18770573922911427])
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 107, 0.37768142336353183])
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
[0, 1, 1, 0, 1, 0, 1, 1, 0, 2, 2, None, None])
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
[0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 27, 0.9383818903266666])
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
rep = ensureFullLengthRepresentation(
[0, 0, 1, 1, 0, 0, 1, 0, 1, 2, 2, 3, 0.923162952008686])
print(getPrintName(getOpts(rep[:-2])))
evaluateCustomizedESs(rep, iids=iids, fid=fid, ndim=ndim)
def runCustomizedES(representation, iid, rep, ndim, fid, budget):
"""
Runs a customized ES on a particular instance of a BBOB function in some dimensionality with given budget.
This function takes care of the BBOB setup and the translation of the representation to input arguments for
the customizedES.
:param representation: Representation of a customized ES (structure and parameter initialization)
:param iid: Instance ID for the BBOB function
:param rep: Repetition number (for output storage purposes only)
:param ndim: Dimensionality to run the ES in
:param fid: BBOB function ID
:param budget: Evaluation budget for the ES
:return: Tuple(target optimum value of the evaluated function, list of fitness-values over time)
"""
print(reprToString(representation), iid, rep)
# Setup BBOB function + logging
bbob_opts['algid'] = representation
datapath_ext = '{repr}/{ndim}d-f{fid}/i{iid}-r{rep}/'.format(
ndim=ndim,
fid=fid,
repr=reprToString(representation),
iid=iid,
rep=rep)
guaranteeFolderExists(datapath + datapath_ext)
f = fgeneric.LoggingFunction(datapath + datapath_ext, **bbob_opts)
f_target = f.setfun(*bbobbenchmarks.instantiate(fid, iinstance=iid),
dftarget=Config.default_target).ftarget
# Interpret the representation into parameters for the ES
opts = getOpts(representation[:len(options)])
lambda_ = representation[len(options)]
mu = representation[len(options) + 1]
values = getVals(representation[len(options) + 2:])
# Run the ES defined by opts once with the given budget
results = _customizedES(ndim,
f.evalfun,
budget,
lambda_=lambda_,
mu=mu,
opts=opts,
values=values)
f.finalizerun()
return f_target, results
def step(self, action):
done = super(ModeaEnv, self).step_()
# Todo: currently this doesn't support targets
if (
self.budget <= self.es.used_budget
or self.es.parameters.checkLocalRestartConditions(self.es.used_budget)
):
done = True
self.representation = self.ensureFullLengthRepresentation(action)
opts = getOpts(self.representation[: len(options)])
self.adapt_es_opts(opts)
# TODO: add ipop run (restarts)
self.es.runOneGeneration()
self.es.recordStatistics()
return self.get_state(), self.get_reward(), done, {}
def reset(self):
super(ModeaEnv, self).reset_()
self.dim = self.instance[0]
self.function_id = self.instance[1]
self.instance_id = self.instance[2]
self.representation = self.ensureFullLengthRepresentation(self.instance[3])
opts = getOpts(self.representation[: len(options)])
self.lambda_ = self.representation[len(options)]
self.mu = self.representation[len(options) + 1]
values = getVals(self.representation[len(options) + 2 :])
self.function = bn.instantiate(int(self.function_id))[0]
self.es = CustomizedES(
self.dim, self.function, self.budget, self.mu, self.lambda_, opts, values
)
self.es.mutateParameters = self.es.parameters.adaptCovarianceMatrix
self.adapt_es_opts(opts)
return self.get_state()
def step(self, action):
done = super(ModeaEnv, self).step_()
self.representation = self.ensureFullLengthRepresentation(action)
opts = getOpts(self.representation[: len(options)])
self.switchConfiguration(opts)
self.es.runOneGeneration()
self.es.recordStatistics()
if (
self.es.budget <= self.es.used_budget
or self.es.parameters.checkLocalRestartConditions(self.es.used_budget)
):
done = done or self.restart()
if self.es.total_used_budget < self.es.total_budget:
self.update_parameters()
else:
done = True
return self.get_state(self), self.get_reward(self), done, {}
def test_input_too_long(self):
expected_output = dict(((opt[0], opt[1][0]) for opt in options))
self.assertDictEqual(getOpts([0] * (self.length + 1)), expected_output)
def test_incorrect_values(self):
with self.assertRaises(IndexError):
getOpts([3] * self.length)
def test_input_too_short(self):
with self.assertRaises(IndexError):
getOpts([0] * (self.length - 1))
