def get_bbob(name, n_var=10, **kwargs):
try:
import cocoex as ex
except:
raise Exception(
"COCO test suite not found. \nInstallation Guide: https://github.com/numbbo/coco"
)
args = name.split("-")
n_instance = int(args[-1])
n_function = int(args[-2].replace("f", ""))
assert 1 <= n_function <= 24, f"BBOB has 24 different functions to be chosen. {n_function} is out of range."
suite_filter_options = f"function_indices: {n_function} " \
f"instance_indices: {n_instance} " \
f"dimensions: {n_var}"
problems = ex.Suite("bbob", "", suite_filter_options)
assert len(problems) == 1, "COCO problem not found."
coco = problems.next_problem()
return coco
def main(args):
## arguments ##
parser = argparse.ArgumentParser()
#parser.add_argument('--nfe' , dest='nfe' , type=float, help="Integer : Number of Function Evaluations")
parser.add_argument('--n',
dest='n',
type=float,
help="Integer : Population size")
parser.add_argument('--w',
dest='w',
type=float,
help="Real value: velocity modifier")
parser.add_argument('--c1',
dest='c1',
type=float,
help="Real value: pbest modifier")
parser.add_argument('--c2',
dest='c2',
type=float,
help="Real value: gbest modifier")
parser.add_argument('--m',
dest='m',
type=int,
help="Real value: 1-8, specifying which PSO to run")
#parser.add_argument('--bbob', dest='bbob' , type=str , help="String : BBOB suite e.g.:function_indices:1 dimensions:2 instance_indices:1")
args = parser.parse_args()
## repair and initialization types ##
m = [
0,
(op.repair_truncate, op.repairv_zero, op.initv_half_dif), #1
(op.repair_random, op.repairv_diff, op.initv_half_dif), #2
(op.repair_truncate, op.repairv_zero, op.initv_random), #3
(op.repair_random, op.repairv_diff, op.initv_random), #4
(op.repair_truncate, op.repairv_zero, op.initv_zero), #5
(op.repair_random, op.repairv_diff, op.initv_zero), #6
(op.repair_truncate, op.repairv_zero, op.initv_small_random), #7
(op.repair_random, op.repairv_diff, op.initv_small_random) #8
]
## bbob validation suite ##
suite = cocoex.Suite(
"bbob", "",
"function_indices:2-7,9-12,14,16-19,21-24 dimensions:10 instance_indices:1-15"
)
observer = cocoex.Observer("bbob",
"result_folder: " + "PSO_" + str(args.m))
#minimal_print = cocoex.utilities.MiniPrint()
## nfe ##
nfe = 1e+7
## loop over problems ##
for problem in suite:
problem.observe_with(observer)
sol = pso(args.m, args.n, problem,
(problem.lower_bounds[0], problem.upper_bounds[0]),
problem.dimension, nfe, args.w, args.c1, args.c2, *m[args.m])
#minimal_print(problem, final=problem.index == len(suite) - 1)
return
def main():
suite_name = "bbob"
output_folder = "benchmark-output"
suite = cocoex.Suite(suite_name, "", "")
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
if len(sys.argv) < 2:
sys.stderr.write("invalid number of arguments")
sys.exit(1)
evolution_func = differential_evolution
if sys.argv[1] == "dg":
evolution_func = differential_evolution_dg
elif sys.argv[1] != "classic":
sys.stderr.write("expected either classic or dg as an argument")
sys.exit(1)
seed = get_seed()
print("seed: " + str(seed))
for problem in suite:
if problem.number_of_objectives > 1:
continue
observer.observe(problem)
bounds = np.asarray([problem.lower_bounds, problem.upper_bounds]).T
for _ in evolution_func(problem, bounds, seed, iteration_count=100):
pass
def run_optimizer(optimizer, dim, fID, instance, logfile, lb, ub, max_FEs,
data_path, bbob_opt):
"""Parallel BBOB/COCO experiment wrapper
"""
# Set different seed for different processes
start = time()
seed = np.mod(int(start) + os.getpid(), 1000)
np.random.seed(seed)
data_path = os.path.join(data_path, str(instance))
max_FEs = eval(max_FEs)
suite_filter_options = "dimensions: %d instance_indices: %d year:2019" % (
dim, instance)
suite = cocoex.Suite('bbob', "", suite_filter_options)
observer = cocoex.Observer('bbob', "result_folder: " + data_path)
f = suite.get_problem(fID)
f.observe_with(observer)
assert dim == f.dimension
opt = optimizer(dim, f, -np.inf, max_FEs, f.lower_bounds, f.upper_bounds,
logfile)
opt.run()
f.finalizerun()
with open('out', 'a') as fout:
fout.write(
"{} on f{} in {}D, instance {}: FEs={}, fbest-ftarget={:.4e}, "
"elapsed time [m]: {:.3f}\n".format(optimizer, fID, dim, instance,
f.evaluations,
f.fbest - f.ftarget,
(time() - start) / 60.))
def bbob(solver, output_folder):
### input
suite_name = "bbob"
output_folder = output_folder
budget_multiplier = 100 # increase to 10, 100, ...
solver = solver
### prepare
suite = cocoex.Suite(suite_name, "", "")
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
minimal_print = cocoex.utilities.MiniPrint()
### go
for problem in suite: # this loop will take several minutes or longer
problem.observe_with(
observer) # generates the data for cocopp post-processing
# apply restarts while neither the problem is solved nor the budget is exhausted
while (problem.evaluations < problem.dimension * budget_multiplier
and not problem.final_target_hit):
sw.pso(10, problem, problem.lower_bounds, problem.upper_bounds,
problem.dimension, 3)
minimal_print(problem, final=problem.index == len(suite) - 1)
### post-process data
cocopp.main(
observer.result_folder) # re-run folders look like "...-001" etc
webbrowser.open("file://" + os.getcwd() + "/ppdata/index.html")
def __init__(self):
# Initialise base fitness function class.
super().__init__()
#parameters from ge.txt
self.max_nfe = params['MAX_NFE']
self.runs = params['RUNS']
self.suite = cocoex.Suite(
"bbob", "",
"function_indices:" +str(params['FUNCTION'])+
" dimensions:" +str(params['DIMENSIONS'])+
" instance_indices:" +str(params['INSTANCE_INDICES'])
)
print("Using BBOB suite: ",self.suite)
#learning method
file = open("bbob_final_target_fvalue1.pkl",'rb')
self.ftarget_values = pickle.load(file)
file.close()
self.multiplier = params['MULTIPLIER']
self._ind = -1
self._gen = 0
#log
self.logh = open(params['FILE_PATH']+"/history.csv", 'w') #190312: log
output_list = []
output_list.append("gen")
output_list.append("indv")
output_list.append("hh_fit")
for p in self.suite:
output_list.append(p.id)
self.logh.write(",".join(map(str,output_list))+"\n")
def runSingleSplit_pycma(fid, dim, iids=[1, 2, 3, 4, 5], num_reps=5):
"""
Function running single-split CMA-ES.
:param fid: The function id (from bbob)
:param dim: The dimension to run the bbob-problem in
:param rep1: The configuration to run before the splitpoint
:param rep2: The configuration to run after the splitpoint
:param split_idx: The splitpoint-index at which to switch between rep1 and rep2
:param iids: The instances of the bbob-function to run
:param num_reps: The amount of repetitions to run
:return: The ERT over all num_reps runs on all instances in iids
"""
obs = create_observer("Pycma", None, None)
suite = cocoex.Suite("bbob", "", f"dimensions:{dim}")
HittingTimes = []
for i, iid in enumerate(iids):
for j in range(num_reps):
fitness_function = suite.get_problem_by_function_dimension_instance(
fid, dim, iid)
fitness_function.observe_with(obs)
f = fitnessFunc(fitness_function)
cma = CMAEvolutionStrategy([0] * 5, 0.5)
cma.optimize(f)
HittingTimes.append(cma.result.evaluations)
print(cma.result.xbest)
fitness_function.free()
return np.mean(HittingTimes)
def runSingleSplitExample():
"""
Example run of a single-split CMA-ES.
Runs on F1, 2 and 3 instance 1; 5 repetitions each
Stores results in exdata/Experiments/SingleSplit/
:return:
"""
dim = 5
rep1s = [2703, 399, 3567]
rep2s = [2163, 2163, 2163]
budget = 50000
suite = cocoex.Suite("bbob", "", "dimensions:5 instance_indices:1,2,3,4,5")
for fid_idx in range(3):
fid = 5
split_idx = 11
split_target = get_target(fid, 1, split_idx)
rep1 = rep1s[fid_idx]
rep2 = rep2s[fid_idx]
obs = create_observer(rep1, rep2, split_idx)
for i in range(5):
fitness_function = suite.get_problem_by_function_dimension_instance(
fid, dim, 1)
fitness_function.observe_with(obs)
f = fitnessFunc(fitness_function)
cma = SingleSplitCMAES(dim,
f,
budget,
representation=Utils.intToRepr(rep1),
representation2=Utils.intToRepr(rep2),
seed=i,
split=split_target)
cma.run_optimizer()
fitness_function.free()
print(cma.best_individual)
print(cma.used_budget)
def generate_test_data_for_suite(suite_name,
filename,
solution_array=solution_array):
"""write regression test data into file.
Argument `solution_array(dimension)` is a function which returns a
number of solutions of dimension `dimension`.
"""
if os.path.exists(filename):
raise ValueError("file '" + filename + "' exists already")
suite = cocoex.Suite(suite_name, "", "")
xfc_dict = {}
for i, f in enumerate(suite):
for x in solution_array(f.dimension):
res = (
f(x) if f.number_of_objectives == 1 else list(f(x)),
list(f.constraint(x) if f.number_of_constraints > 0 else []))
if is_finite(res):
xfc_dict[
i, tuple(x)] = res # tuple, because keys must be immutable
else:
print("rejected: ", f.name, i, x, res)
with open(filename, 'w') as f:
f.write(repr(xfc_dict)) # caveat: entries are by definition not sorted
def main(args):
## arguments ##
parser = argparse.ArgumentParser()
#parser.add_argument('--nfe' , dest='nfe' , type=float, help="Integer : Number of Function Evaluations")
parser.add_argument('--n',
dest='n',
type=float,
help="Integer : Population size")
parser.add_argument('--w',
dest='w',
type=float,
help="Real value: velocity modifier")
parser.add_argument('--c1',
dest='c1',
type=float,
help="Real value: pbest modifier")
parser.add_argument('--c2',
dest='c2',
type=float,
help="Real value: gbest modifier")
parser.add_argument('--m',
dest='m',
type=int,
help="Real value: 1-8, specifying which PSO to run")
#parser.add_argument('--bbob', dest='bbob' , type=str , help="String : BBOB suite e.g.:function_indices:1 dimensions:2 instance_indices:1")
args = parser.parse_args()
## repair and initialization types ##
m = [
0,
(op.repair_truncate, op.repairv_zero, op.initv_half_dif), #1
(op.repair_random, op.repairv_diff, op.initv_half_dif), #2
(op.repair_truncate, op.repairv_zero, op.initv_random), #3
(op.repair_random, op.repairv_diff, op.initv_random), #4
(op.repair_truncate, op.repairv_zero, op.initv_zero), #5
(op.repair_random, op.repairv_diff, op.initv_zero), #6
(op.repair_truncate, op.repairv_zero, op.initv_small_random), #7
(op.repair_random, op.repairv_diff, op.initv_small_random) #8
]
## bbob training suite ##
suite = cocoex.Suite(
"bbob", "",
"function_indices:1,8,13,15,20 dimensions:10 instance_indices:1-6")
## nfe ##
nfe = 1e+4
## loop over problems ##
fitness = 0
for problem in suite:
sol = pso(args.m, args.n, problem,
(problem.lower_bounds[0], problem.upper_bounds[0]),
problem.dimension, nfe, args.w, args.c1, args.c2, *m[args.m])
fitness += sol.best.getFitness()
## irace get information from standard output ##
print(fitness)
return
def __init__(self):
self.action_space = args.action_space
self.problem = None
if self.action_space != 784:
suite_name = "bbob"
suite_filter_options = ("dimensions: " +
str(max(self.action_space, 2)))
self.suite = cocoex.Suite(suite_name, "", suite_filter_options)
def __init__(self):
# Initialise base fitness function class.
super().__init__()
self.max_nfe = params['MAX_NFE']
self.runs = params['RUNS']
self.suite = cocoex.Suite(
"bbob", "", "function_indices:" + str(params['FUNCTION']) +
"dimensions:" + str(params['DIMENSIONS']) + "instance_indices:" +
str(params['INSTANCE_INDICES']))
def __init__(self, problem_index):
self.latent = args.latent
self.vae = VaeModel(args.vae)
self.vae.load_model()
self.vae.model.eval()
self.problem = None
suite_name = "bbob"
suite_filter_options = ("dimensions: " + str(self.latent))
self.suite = cocoex.Suite(suite_name, "", suite_filter_options)
self.reset(problem_index)
def bbob_rastrigin(x):
if not hasattr(bbob_rastrigin, 'fun'):
import cocoex
dim = len(x)
suite = cocoex.Suite('bbob',
'year:2017',
'dimensions: {0} function_indices: 15 instance_indices: 1'.format(dim))
for fun in suite:
bbob_rastrigin.fun = fun
break
return bbob_rastrigin.fun(x)
def single_split_with_hyperparams(fid,
dim,
rep1,
rep2,
split_idx,
record_runs=False,
iids=[1, 2, 3, 4, 5],
num_reps=5,
hyperparams=None):
"""
Function running single-split CMA-ES with specific hyperparameters.
:param fid: The function id (from bbob)
:param dim: The dimension to run the bbob-problem in
:param rep1: The configuration to run before the splitpoint
:param rep2: The configuration to run after the splitpoint
:param split_idx: The splitpoint-index at which to switch between rep1 and rep2
:param iids: The instances of the bbob-function to run
:param num_reps: The amount of repetitions to run
:param record_runs: Whether or not to record a .dat-file during the runs of the CMA-ES
:param hyperparams: Dictionary of the hyperparameters to use
:return: The ERT over all num_reps runs on all instances in iids
"""
if record_runs:
obs = create_observer(rep1, rep2, split_idx)
suite = cocoex.Suite("bbob", "", f"dimensions:{dim}")
budget = dim * Config.budget_factor
hittingtimes = []
succeeded = 0
for i, iid in enumerate(iids):
split_target = get_target(fid, iid) + 10**(2 - (split_idx / 5))
for j in range(num_reps):
fitness_function = suite.get_problem_by_function_dimension_instance(
fid, dim, iid)
if record_runs:
fitness_function.observe_with(obs)
f = fitnessFunc(fitness_function)
cma = SingleSplitCMAES(dim,
f,
budget,
representation=Utils.intToRepr(rep1),
representation2=Utils.intToRepr(rep2),
seed=j,
split=split_target)
cma.set_hyperparameters(hyperparams)
cma.run_optimizer()
hittingtimes.append(cma.used_budget)
print(cma.used_budget)
succeeded += fitness_function.final_target_hit
fitness_function.free()
return sum(hittingtimes) / max(succeeded, 1)
def runSingleSplit(fid,
dim,
rep1,
rep2,
split_idx,
iids=[1, 2, 3, 4, 5],
num_reps=5,
budget=None):
"""
Function running single-split CMA-ES.
:param fid: The function id (from bbob)
:param dim: The dimension to run the bbob-problem in
:param rep1: The configuration to run before the splitpoint
:param rep2: The configuration to run after the splitpoint
:param split_idx: The splitpoint-index at which to switch between rep1 and rep2
:param iids: The instances of the bbob-function to run
:param num_reps: The amount of repetitions to run
:return: The ERT over all num_reps runs on all instances in iids
"""
obs = create_observer(rep1, rep2, split_idx)
suite = cocoex.Suite("bbob", "", f"dimensions:{dim}")
if budget is None:
budget = dim * Config.budget_factor
HittingTimes = []
succeeded = 0
for i, iid in enumerate(iids):
split_target = get_target(fid, iid) + 10**(2 - (split_idx / 5))
for j in range(num_reps):
fitness_function = suite.get_problem_by_function_dimension_instance(
fid, dim, iid)
fitness_function.observe_with(obs)
f = fitnessFunc(fitness_function)
cma = SingleSplitCMAES(dim,
f,
budget,
representation=Utils.intToRepr(rep1),
representation2=Utils.intToRepr(rep2),
seed=j,
split=split_target)
cma.run_optimizer()
HittingTimes.append(cma.used_budget)
succeeded += fitness_function.final_target_hit
fitness_function.free()
return sum(HittingTimes) / max(succeeded, 1)
def regression_test_a_suite(suite_name, filename):
"""filename contains previously generated test data to compare against.
Details: on a Windows machine we see differences like
f12 instance 58 in 2D (177, (1447.3149385050367, -830.3270488085931))
1.7499057709942032e+141 vs 6.09043250958e+67 (original): log-err = 0.351...
f17: 3.648247252180286e+57 vs 3.46559033612e+57: log-err = 0.0002
f17 f17: [2.885437508322743e+22, 1322751113639934.8] vs [2.05085412e+22, 1.32275111e+15] or
f14 f17: [31585031.800419718, 6.480639092419489e+28] vs [3.15850318e+07, 1.69518822e+28]: log-err = 0.01
f16: -0.13227493309325666 vs -0.132274933067: rel-err = 9.9e-11
problem f12 instance 60 in 10D: 1.2219569577863538e+76 vs 1.2963795943e+27: log-err = 0.47...
bbob_f001_i02_d40__bbob_f017_i04_d40: [287089787.64410305, 3.1488536291123374e+39] vs [ 2.87089788e+008 9.76803002e+118]: log-err = 0.50156...
large-scale suite problem f17 instance 4 in 40D (5.449929602038278e+136, []) 6.96081091792e+29: log-err = 0.64...
"""
verbose = 1
xfc_dict = literal_eval(open(filename).read())
if verbose:
print("using file %s with %d test cases " % (filename, len(xfc_dict)),
end="")
sys.stdout.flush()
t0 = time.process_time()
suite = cocoex.Suite(suite_name, "year: 0000",
"") # choose "default" year for test
failed_test_counter = 0
for key in sorted(xfc_dict):
f, x = suite[key[0]], key[1]
try:
assert is_equal(f(x), xfc_dict[key][0])
except AssertionError:
print(f.name, "id,x =", key, "stored f(x),con(x) =", xfc_dict[key],
"computed f(x) =", f(x))
failed_test_counter += 1
if f.number_of_constraints > 0:
try:
assert is_equal(f.constraint(x), xfc_dict[key][1])
except AssertionError:
print(f.name, "index,x =", key, "stored f,con =",
xfc_dict[key], "computed con =", f.constraint(x))
failed_test_counter += 1
if failed_test_counter > 0:
raise AssertionError(
"{} assertions failed".format(failed_test_counter))
if verbose:
print("done in %.1fs" % (time.process_time() - t0))
def __init__(self, func_choice):
# Content common to all episodes
self.n_ops = len(mutations)
self.action_space = spaces.Discrete(self.n_ops)
self.observation_space = spaces.Box(-np.inf, np.inf, shape=(199,), dtype = np.float32)
self.func_choice = func_choice
self.FF = 0.5
self.CR = 1.0
self.max_gen = 10
self.window_size = 50
self.number_metric = 5
# BBOB
suite_name = "bbob"
#suite_options = "dimensions: 2, 3, 5, 10, 20, 40"
suite_options = "dimensions: 20"
self.suite = cocoex.Suite(suite_name, "", suite_options)
# First "" takes following arguments: year, instances; Second "" takes following arguments: dimensions, dimension_indices, function_indices, instance_indices
self.observer = cocoex.Observer(suite_name, "result_folder: data")
self.fun_index = 0
def runStaticExample():
"""
Example run of a static CMA-ES.
Runs on F1 and 2; instance 1; 5 repetitions each
Stores results in exdata/Experiments/Static/
:return:
"""
dim = 5
reps = [0, 3]
budget = 50000
suite = cocoex.Suite("bbob", "", "dimensions:5 instance_indices:1,2,3,4,5")
for fid in range(2):
rep = Utils.intToRepr(reps[fid])
obs = create_observer(reps[fid])
for i in range(5):
fitness_function = suite.get_problem_by_function_dimension_instance(
fid + 1, dim, 1)
fitness_function.observe_with(obs)
f = fitnessFunc(fitness_function)
cma = StaticCMA(dim, f, budget, representation=rep, seed=i)
cma.run_optimizer()
fitness_function.free()
print(cma.used_budget)
n = 100
iteration = 20
#pso: w, c1, c2
params_pso = (1, 1, 1)
#de: beta, crossover prob
params_de = (.7, .8)
#sa: T
T = sa.temperature_exp(1000, .2, 100)
# T = sa.temperature_lin(1000, -5, 100)
### prepare
suite = cocoex.Suite(
suite_name, "",
suite_dim) #Suite("bbob", "year:2009", "dimensions:20 instance_indices:1"
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
minimal_print = cocoex.utilities.MiniPrint()
### go
for problem in suite: # this loop will take several minutes or longer
problem.observe_with(
observer) # generates the data for cocopp post-processing
# apply restarts while neither the problem is solved nor the budget is exhausted
while (problem.evaluations < problem.dimension * budget_multiplier
and not problem.final_target_hit):
pso(n, iteration, problem.dimension, problem, problem.lower_bounds,
problem.upper_bounds, *params_pso)
# sa(n, problem.dimension, problem, problem.lower_bounds, problem.upper_bounds, T)
def main_lia():
# -------------------------------------------------------
# set on COCO
# -------------------------------------------------------
suite_name = "bbob"
solver = lia
algorithm_name = "LiA_algorithm" # no spaces allowed
output_folder = algorithm_name # no spaces allowed
suite = cocoex.Suite(suite_name, "", "")
observer = cocoex.Observer(
suite_name, "result_folder: {0} algorithm_name: {1}".format(
output_folder, algorithm_name))
# ---------------------------------------------------------------------------
# initial variables
# ---------------------------------------------------------------------------
minimal_print = cocoex.utilities.MiniPrint()
stoppings = defaultdict(list) # dict of lists, key is the problem index
timings = defaultdict(list) # key is the dimension
print(
'------------------------<< Start LiA analysis >>-------------------------'
)
# ------------------------------------------------------------------------------
# start benchmark functions COCO
# ------------------------------------------------------------------------------
instances, instances_tot = 1, 15
func_dim = 24 * instances_tot
# --------------------------------------------------------------
# ide => 0 -> 2D, 1 -> 3D, 2 -> 5D, 3 -> 10D, 4 -> 20D, 5 -> 40D
# -------------------------------------------------------------
ide, func = np.array([1, 2, 3, 4]).astype('int'), 1
ini_dim = ide * func_dim
ini_fun = ini_dim + (instances_tot * (func - 1))
fin_dim = ini_dim + func_dim
# -------------------------------------------------
# number of instances
# -------------------------------------------------
n_instance = 15
ini_instance = ini_dim
instances = n_instance + ini_instance
fin_instance = ini_instance + 15
# ------------------------------------------------
steps_min, steps_max = [1e-1, 1e-1, 1e-1, 1e-1], [1e-8, 1e-8, 1e-9, 1e-9]
n_groups = [7, 7, 8, 8]
itr_max = [5e2, 2e3, 4e3, 5e3]
act = 1
time0 = time.time()
for index, problem in enumerate(suite):
if act > len(fin_instance) - 1:
break
if index == fin_instance[act]:
ini_instance[act] = index
instances[act] = n_instance + ini_instance[act]
fin_instance[act] = ini_instance[act] + 15
if ini_dim[act] <= index < fin_dim[act] and ini_fun[
act] <= index < instances[act]:
print(index)
print(problem)
# --------------------------------------------
# generate the data for cocopp post-processing
# ---------------------------------------------
problem.observe_with(observer)
problem(np.zeros(problem.dimension))
if not len(timings[problem.dimension]) and len(timings) > 1:
print("\n %s %d-D done in %.1e seconds/evaluations" %
(minimal_print.stime, sorted(timings)[-2],
np.median(timings[sorted(timings)[-2]])),
end='')
# ---------------------------------------------------------------
# star LiA algorithm
# ---------------------------------------------------------------
time1 = time.time()
max_runs = int(itr_max[act])
s_min, s_max = steps_min[act], steps_max[act]
output = solver(problem,
stp_min=s_min,
stp_max=s_max,
itr=max_runs,
ide_dim=act,
n_gr=n_groups[act])
stoppings[problem.index].append(output[1:])
timings[problem.dimension].append(
(time.time() - time1) /
problem.evaluations if problem.evaluations else 0)
with open(output_folder + '_stopping_conditions.pydict',
'wt') as file_:
file_.write(
"# code to read in these data:\n"
"# import ast\n"
"# with open('%s_stopping_conditions.pydict', 'rt') as file_:\n"
"# stoppings = ast.literal_eval(file_.read())\n" %
output_folder)
file_.write(repr(dict(stoppings)))
# ----------------------------------------------------------
# timings
# ----------------------------------------------------------
timings[problem.dimension].append(
(time.time() - time1) /
problem.evaluations if problem.evaluations else 0)
minimal_print(problem, final=problem.index == len(suite) - 1)
if index > fin_dim[act]:
act += 1
# ----------------------------------------------------------
# print timings and final message
# ----------------------------------------------------------
print("\n %s %d-D done in %.1e seconds/evaluations" %
(minimal_print.stime, sorted(timings)[-1],
np.median(timings[sorted(timings)[-1]])))
print("*** Full experiment done in %s ***" %
cocoex.utilities.ascetime(time.time() - time0))
print("Timing summary:\n"
" dimension median seconds/evaluations\n"
" -------------------------------------")
for dimension in sorted(timings):
print(" %3d %.1e" %
(dimension, np.median(timings[dimension])))
print(" -------------------------------------")
# -----------------------------------------------------------------------
# post-process data
# -----------------------------------------------------------------------
cocopp.main(observer.result_folder) # re-run folders look like "...-001"
webbrowser.open("file://" + os.getcwd() + "/ppdata/index.html")
def single_split_hyperparam_single(iid,
rep_nr=None,
hyperparams=None,
hyperparams2=None,
rep1=None,
rep2=None,
fid=None,
split_idx=None,
dim=None,
record_runs=None,
budget=None,
target_idx=None,
lambda_=None,
lambda2_=None,
opt_split=False):
"""
Function handling single runs of single-split CMA-ES during hyperparameter optimization.
:param fid: The function id (from bbob)
:param dim: The dimension to run the bbob-problem in
:param rep1: The configuration to run before the splitpoint
:param rep2: The configuration to run after the splitpoint
:param split_idx: The splitpoint-index at which to switch between rep1 and rep2
:param iid: The instance of the bbob-function to run
:param rep_nr: The repetition number (used for controlled randomness)
:param record_runs: Whether or not to record a .dat-file during the runs of the CMA-ES
:param hyperparams: Dictionary of the hyperparameters to use for C1
:param hyperparams2: Dictionary of the hyperparameters to use for C2
:param lambda_: Population size
:return: The budget used and whether or not the final target was hit
"""
if rep_nr is None:
if len(iid) == 2:
rep_nr = iid[1]
iid = iid[0]
else:
raise Exception("Missing rep_nr parameter")
if record_runs:
obs = create_observer(rep1, rep2, split_idx)
suite = cocoex.Suite("bbob", "", f"dimensions:{dim}")
if budget is None:
budget = dim * Config.budget_factor
split_target = get_target(fid, iid, split_idx)
fitness_function = suite.get_problem_by_function_dimension_instance(
fid, dim, iid)
if record_runs:
fitness_function.observe_with(obs)
if target_idx is not None:
target = get_target(fid, iid, target_idx)
else:
target = None
f = fitnessFunc(fitness_function, target)
cma = SingleSplitCMAES(dim,
f,
budget,
representation=Utils.intToRepr(rep1),
representation2=Utils.intToRepr(rep2),
seed=rep_nr,
split=split_target,
hyperparams=hyperparams,
hyperparams2=hyperparams2,
lambda_=lambda_,
lambda2_=lambda2_)
# cma.set_hyperparameters(hyperparams)
cma.run_optimizer()
target_hit = f.final_target_hit
fitness_function.free()
# print(cma.used_budget, target_hit)
if opt_split:
return cma.used_budget_at_split, cma.switched, cma.used_budget, target_hit
return cma.used_budget, target_hit
avg = np.mean(f)
low = np.min(f)
high = np.max(f)
offset = (1 - exploration_param) * avg + exploration_param * low
return (f - offset) / (high - low + 1e-6)
# %% Setup problem
RUN_OPTIMISATION = True
MIN_ITERATION = 1
MAX_ITERATION = 21
# Define input domain in GPyOpt format and fitness evaluation function
f_id = 71 + 20
suite = cocoex.Suite("bbob", "instances: 1", "")
#for p in suite:
# print(f"{p.name}")
fitnessfunc = suite.get_problem(f_id)
FUNCTION_NAME = fitnessfunc.name
print(f"Optimising {FUNCTION_NAME}")
NUM_INPUT_DIMS = fitnessfunc.dimension
NUM_TOTAL_EVALUATIONS = 30 * NUM_INPUT_DIMS
tests = []
for xi in [-1.0, -0.5, 0.0, 0.5, 1.0]:
for zeta in [-0.5, -0.1, -0.01, 0.0, 0.01, 0.1]:
for it in range(MIN_ITERATION, MAX_ITERATION + 1):
tests.append((it, xi, zeta))
domain = []
### input
suite_name = "bbob"
output_folder = "OUT1_40D_1000it"
fmin = scipy.optimize.fmin
budget_multiplier = 1 # increase to 10, 100, ...
# fmin is re-defined to call our solver
def fmin(fun, lbounds, ubounds, dim, budget):
result = solvers.franken10(50, fun, lbounds, ubounds, dim, 1000)
return result
### prepare
suite = cocoex.Suite(
suite_name, "",
"function_indices:20,21,22,24 dimensions:40 instance_indices:1-15")
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
minimal_print = cocoex.utilities.MiniPrint()
### go
for problem in suite: # this loop will take several minutes or longer
problem.observe_with(
observer) # generates the data for cocopp post-processing
x0 = problem.initial_solution
# apply restarts while neither the problem is solved nor the budget is exhausted
while (problem.evaluations < problem.dimension * budget_multiplier
and not problem.final_target_hit):
fmin(
problem, problem.lower_bounds, problem.upper_bounds,
problem.dimension, problem.dimension * budget_multiplier
raise ValueError("printed help and aborted")
input_params = cocoex.utilities.args_to_dict(
sys.argv[1:],
globals(), {'batch': 'current_batch/batches'},
print=print)
globals().update(input_params) # (re-)assign variables
# extend output folder input parameter, comment out if desired otherwise
# output_folder += '_%s_%dD_on_%s' % (
# fmin.__module__, int(budget_multiplier), suite_name)
if batches > 1:
output_folder += "_batch%03dof%d" % (current_batch, batches)
### prepare
suite = cocoex.Suite(suite_name, "", suite_filter_options)
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
minimal_print = cocoex.utilities.MiniPrint()
stoppings = defaultdict(list) # dict of lists, key is the problem index
timings = defaultdict(list) # key is the dimension
### go
print('*** benchmarking %s from %s on suite %s ***' %
(fmin.__name__, fmin.__module__, suite_name))
time0 = time.time()
for batch_counter, problem in enumerate(
suite): # this loop may take hours or days...
if batch_counter % batches != current_batch % batches:
continue
if not len(timings[problem.dimension]) and len(timings) > 1:
print("\n %s %d-D done in %.1e seconds/evaluations" %
d = {
"max_nfe": max_nfe,
"dimension": problem.dimension,
"my_func": problem,
"bounds": (problem.lower_bounds[0], problem.upper_bounds[0])
}
exec(code, d)
d_fitness[problem.id] = d['XXX_output_XXX']
d_target_hit[problem.id] = 0
if np.abs(d_fitness[problem.id] -
ftarget_values[problem.id]) <= precision:
d_target_hit[problem.id] = 1
result = sum(d_target_hit.values()) / len(suite)
#write results to a file
write_log(d_fitness, result)
if __name__ == "__main__":
precision = float(sys.argv[1])
max_nfe = int(sys.argv[2])
experiments = sys.argv[3:]
suite = cocoex.Suite(
"bbob", "",
"function_indices:1,15 dimensions:20,40 instance_indices:1-10")
for experiment_name in experiments:
experiment_test(experiment_name, max_nfe, precision, suite)
import cocoex as ex
import numpy as np
print(ex.known_suite_names)
suite_name = "bbob" # cocoex.known_suite_names
suite_instance = "" # "year:2016"
suite_options = "dimensions:40" # "dimensions: 2,3,5,10,20 " # if 40 is not desired
suite = ex.Suite(suite_name, suite_instance, suite_options)
fun = suite[0]
range_ = fun.upper_bounds - fun.lower_bounds
center = fun.lower_bounds + range_ / 2
dim = fun.dimension
evals = fun.evaluations
evalc = fun.evaluations_constraints
fin_target = fun.final_target_hit
x0 = fun.initial_solution
xf = fun.best_observed_fvalue1
Id = fun.id
name = fun.name
fun(np.random.rand(40))
for problem_index, problem in enumerate(suite):
print(problem.name)
print(problem.dimension)
print(probelm(np.random.rand(40)))
print()
#In Julia
'''
using PyCall
batches = 1 # number of batches, batch=3/32 works to set both, current_batch and batches
current_batch = 1 # only current_batch modulo batches is relevant
### possibly modify/overwrite above input parameters from input args
if __name__ == "__main__":
input_params = cocoex.utilities.args_to_dict(
sys.argv[1:], globals(), {'batch': 'current_batch/batches'}, print=print)
globals().update(input_params) # (re-)assign variables
# overwrites folder input parameter, comment out if desired otherwise
output_folder = '%s_of_%s_%dD_on_%s' % (fmin.__name__, fmin.__module__,
int(budget_multiplier), suite_name)
### prepare
suite = cocoex.Suite(suite_name, "", "")
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
minimal_print = cocoex.utilities.MiniPrint()
stoppings = defaultdict(list) # dict of lists, key is the problem index
timings = defaultdict(list) # key is the dimension
### go
print('*** benchmarking %s from %s on suite %s ***'
% (fmin.__name__, fmin.__module__, suite_name))
time0 = time.time()
for problem in suite: # this loop may take several minutes or hours or days...
if omit_last_dimension and problem.dimension == max(suite.dimensions):
break
if problem.index % batches != current_batch % batches:
continue
if not len(timings[problem.dimension]) and len(timings) > 1:
### input
suite_name = "bbob"
output_folder = "franken30"
fmin = scipy.optimize.fmin
budget_multiplier = 1000 # increase to 10, 100, ...
# fmin is re-defined to call our solver
def fmin(fun, lbounds, ubounds, dim, budget):
result = solvers.new_franken30(50, fun, lbounds, ubounds, dim, 30)
return result
### prepare
suite = cocoex.Suite(suite_name, "",
"function_indices:20,21,22,24 dimensions:2")
observer = cocoex.Observer(suite_name, "result_folder: " + output_folder)
minimal_print = cocoex.utilities.MiniPrint()
### go
for problem in suite: # this loop will take several minutes or longer
problem.observe_with(
observer) # generates the data for cocopp post-processing
x0 = problem.initial_solution
# apply restarts while neither the problem is solved nor the budget is exhausted
while (problem.evaluations < problem.dimension * budget_multiplier
and not problem.final_target_hit):
fmin(
problem, problem.lower_bounds, problem.upper_bounds,
problem.dimension, problem.dimension * budget_multiplier
) # here we assume that `fmin` evaluates the final/returned solution
break
print("final population")
print("time: ", time.time() - begin)
print("Optimization ending")
return self.population_list
###################################################################
# Test on COCO #
###################################################################
if __name__ == '__main__':
import cocoex as ex
suite = ex.Suite("bbob-biobj", "", "")
observer = ex.Observer("bbob-biobj", "result_folder:doctest")
for fun in suite:
print("Number of objectives: ", fun.number_of_objectives)
fun.observe_with(observer)
R2 = R2_EMOAs(fun)
# Configuration by default from R2 Indicator-Based Multiobjective Search research paper (Dimo Brockhoff)
# Only the iteration number is changed due to the computation time
# Tested for 100 - 150 - 500 - 1000 - 5000 - 10000
# Official results for 150 and 1000 only (tecnology restriction)
R2.optimize(fun, np.array([-1e-1, -1e-1]), 200000, 10, 15, 0.9, 0.5,
(1 / fun.dimension), 20, 100, -100)
