def main(): #numVars, numObjs, numConstr, lower, upper = bounds_re('RE21') #rep = re_problem('RE21', weight_bounds = Bounds([0, 10], [0.001, 100]) ) #rep = re_problem('RE31', weight_bounds = Bounds([0.1, 0.0001, 0.1], [1, 0.001, 1]) ) #rep = re_problem('RE24', weight_bounds = Bounds([0.1, 0.1], [1, 1]) ) rep = re_problem('RE42', weight_bounds=Bounds([0.2, 0.2, 0.2, 1000], [1, 1, 1, 1000])) minimize_plot(rep, de_cma(1000), '_decma', num_retries=320, exp=2.0)
def messengerFullLoop(): while True: problem = MessFull() logger().info(problem.name + ' de + cmaes c++') minimize(problem.fun, bounds=problem.bounds, num_retries=50000, value_limit=12.0, logger=logger(), optimizer=de_cma(1500))
def main(): numRuns = 100 min_evals = 1500 _test_optimizer(de_cma(min_evals), Gtoc1(), num_retries=10000, num=numRuns, value_limit=-300000.0, stop_val=-1581949) _test_optimizer(de_cma(min_evals), Cassini1(), num_retries=4000, num=numRuns, value_limit=20.0, stop_val=4.93075) _test_optimizer(de_cma(min_evals), Cassini2(), num_retries=6000, num=numRuns, value_limit=20.0, stop_val=8.38305) _test_optimizer(de_cma(min_evals), Messenger(), num_retries=8000, num=numRuns, value_limit=20.0, stop_val=8.62995) _test_optimizer(de_cma(min_evals), Rosetta(), num_retries=4000, num=numRuns, value_limit=20.0, stop_val=1.34335) _test_optimizer(de_cma(min_evals), Sagas(), num_retries=4000, num=numRuns, value_limit=100.0, stop_val=18.188) _test_optimizer(de_cma(min_evals), Tandem(5), num_retries=20000, num=numRuns, value_limit=-300.0, stop_val=-1500) _test_optimizer(de_cma(min_evals), MessFull(), num_retries=50000, num=numRuns, value_limit=12.0, stop_val=1.960)
def test_multiretry(num_retries = 512, keep = 0.7, optimizer = de_cma(1500), logger = logger(), repeat = 50): seqs = Tandem(0).seqs n = len(seqs) problems = [Tandem(i) for i in range(n)] ids = [str(seqs[i]) for i in range(n)] for _ in range(100): problem_stats = multiretry.minimize(problems, ids, num_retries, keep, optimizer, logger) ps = problem_stats[0] for _ in range(repeat): logger.info("problem " + ps.prob.name + ' ' + str(ps.id)) ps.retry(optimizer)
def test_de_cma_parallel_retry(problem): # parallel optimization retry using a DE -> CMA-ES sequence t0 = time.perf_counter() evals = 0 for i in range(1000): ret = retry.minimize(problem.fun, problem.bounds, logger=logger(), optimizer=de_cma(50000), value_limit=10) evals += ret.nfev print("{0}: time = {1:.1f} fun = {2:.3f} nfev = {3}".format( i + 1, dtime(t0), ret.fun, evals)) return ret
def test_multiretry(num_retries=128, keep=0.7, optimizer=de_cma(1500), logger=logger(), repeat=50): problems = [] ids = [] for seq in sequences(): problems.append(Cassini1multi(planets=seq)) ids.append(str(seq)) for _ in range(100): problem_stats = multiretry.minimize(problems, ids, num_retries, keep, optimizer, logger) ps = problem_stats[0] for _ in range(repeat): logger.info("problem " + ps.prob.name + ' ' + str(ps.id)) ps.retry(optimizer)
def init(self, bounds, workers, value_limit, num_retries, popsize, min_evaluations, max_eval_fac, check_interval, capacity, stop_fittness, optimizer): if optimizer is None: optimizer = de_cma(self.min_evaluations, popsize, stop_fittness) if max_eval_fac is None: max_eval_fac = int(min(50, 1 + num_retries // check_interval)) self.store = Store(bounds, max_eval_fac, check_interval, capacity, None, num_retries) self.improved = mp.RawValue(ct.c_bool, False) self.bounds = bounds self.workers = mp.cpu_count() if workers is None else workers self.value_limit = value_limit self.num_retries = num_retries self.popsize = popsize self.min_evaluations = min_evaluations self.max_eval_fac = max_eval_fac self.check_interval = check_interval self.capacity = capacity self.stop_fittness = stop_fittness self.optimizer = optimizer self.procs = []
def optimize(): name = 'tsin3000.60' # 60 trajectories to choose from # name = 'tsin3000.10' # 10 fixed trajectories transfers = pd.read_csv('data/' + name + '.xz', sep=' ', usecols=[1, 2, 3, 4, 5, 6, 7], compression='xz', names=[ 'asteroid', 'station', 'trajectory', 'mass', 'dv', 'transfer_start', 'transfer_time' ]) # uncomment to write a clear text csv # transfers.to_csv('data/' + name + '.txt', sep=' ', header=False) global TRAJECTORY_NUM, ASTEROID_NUM # adjust number of asteroids / trajectories TRAJECTORY_NUM = int(np.amax(transfers["trajectory"]) + 1) ASTEROID_NUM = int(np.amax(transfers["asteroid"]) + 1) # bounds for the objective function dim = 10 + 2 * STATION_NUM - 1 lower_bound = np.zeros(dim) # lower_bound[10+STATION_NUM:dim] = 0.00001 upper_bound = np.zeros(dim) lower_bound[:] = 0.0000001 upper_bound[10:] = 0.9999999 upper_bound[:10] = TRAJECTORY_NUM - 0.00001 # trajectory indices bounds = Bounds(lower_bound, upper_bound) # smart boundary management (SMB) with DE->CMA store = advretry.Store(fitness(transfers), bounds, num_retries=10000, max_eval_fac=5.0, logger=logger()) advretry.retry(store, de_cma(10000).minimize) # smart boundary management (SMB) with CMA-ES # store = advretry.Store(fitness(transfers), bounds, num_retries=10000, max_eval_fac=5.0, logger=logger()) # advretry.retry(store, Cma_cpp(10000).minimize) # BiteOpt algorithm multi threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, Bite_cpp(1000000, M=1).minimize, num_retries=3200) # CMA-ES multi threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, Cma_cpp(1000000).minimize, num_retries=3200) # scipy minimize algorithm multi threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, Minimize(1000000).minimize, num_retries=3200) # fcmaes differential evolution multi threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, De_cpp(1000000).minimize, num_retries=3200) # scipy differential evolution multi threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, Differential_evolution(1000000).minimize, num_retries=3200) # scipy dual annealing multi threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, Dual_annealing(1000000).minimize, num_retries=3200) # scipy differential evolution single threaded # store = retry.Store(fitness(transfers), bounds, logger=logger()) # retry.retry(store, Differential_evolution(1000000).minimize, num_retries=320, workers=1) return store.get_xs(), store.get_ys()
def minimize( fun, bounds=None, value_limit=math.inf, num_retries=1000, logger=None, workers=mp.cpu_count(), popsize=31, max_evaluations=50000, capacity=500, stop_fittness=None, optimizer=None, ): """Minimization of a scalar function of one or more variables using parallel CMA-ES retry. Parameters ---------- fun : callable The objective function to be minimized. ``fun(x, *args) -> float`` where ``x`` is an 1-D array with shape (n,) and ``args`` is a tuple of the fixed parameters needed to completely specify the function. bounds : sequence or `Bounds`, optional Bounds on variables. There are two ways to specify the bounds: 1. Instance of the `scipy.Bounds` class. 2. Sequence of ``(min, max)`` pairs for each element in `x`. None is used to specify no bound. value_limit : float, optional Upper limit for optimized function values to be stored. num_retries : int, optional Number of optimization retries. logger : logger, optional logger for log output of the retry mechanism. If None, logging is switched off. Default is a logger which logs both to stdout and appends to a file ``optimizer.log``. workers : int, optional number of parallel processes used. Default is mp.cpu_count() popsize = int, optional CMA-ES population size used for all CMA-ES runs. Not used for differential evolution. Ignored if parameter optimizer is defined. max_evaluations : int, optional Forced termination of all optimization runs after ``max_evaluations`` function evaluations. Only used if optimizer is undefined, otherwise this setting is defined in the optimizer. capacity : int, optional capacity of the evaluation store. stop_fittness : float, optional Limit for fitness value. optimization runs terminate if this value is reached. optimizer : optimizer.Optimizer, optional optimizer to use. Default is a sequence of differential evolution and CMA-ES. Returns ------- res : scipy.OptimizeResult The optimization result is represented as an ``OptimizeResult`` object. Important attributes are: ``x`` the solution array, ``fun`` the best function value, ``nfev`` the number of function evaluations, ``success`` a Boolean flag indicating if the optimizer exited successfully. """ if optimizer is None: optimizer = de_cma(max_evaluations, popsize, stop_fittness) store = Store(bounds, capacity=capacity, logger=logger) return retry(fun, store, optimizer.minimize, num_retries, value_limit, workers)
def main(): test_optimizer(de_cma(1500), Cassini1minlp())
# Copyright (c) Dietmar Wolz. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory. import math from fcmaes.astro import MessFull, Messenger, Gtoc1, Cassini1, Cassini2, Rosetta, Tandem, Sagas from fcmaes.optimizer import logger, de_cma, da_cma, Cma_cpp, De_cpp, Da_cpp, Dual_annealing, Differential_evolution from fcmaes.retry import minimize problems = [Cassini1(), Cassini2(), Rosetta(), Tandem(5), Messenger(), Gtoc1(), MessFull(), Sagas()] max_evals = 50000 algos = [de_cma(max_evals), da_cma(max_evals), Cma_cpp(max_evals), De_cpp(max_evals), Da_cpp(max_evals), Dual_annealing(max_evals), Differential_evolution(max_evals)] def test_all(num_retries = 10000, num = 10): for problem in problems: for algo in algos: _test_optimizer(algo, problem, num_retries, num) def _test_optimizer(opt, problem, num_retries = 32, num = 10): log = logger() log.info(problem.name + ' ' + opt.name) for _ in range(num): ret = minimize(problem.fun, problem.bounds, math.inf, num_retries, log, optimizer=opt) def main(): test_all()
def main(): test_optimizer(de_cma(1500), Tandem_minlp())
def minimize(problems, ids=None, num_retries=min(256, 8 * mp.cpu_count()), keep=0.7, optimizer=de_cma(1500), logger=None, datafile=None): """Minimization of a list of optimization problems by first applying parallel retry to filter the best ones and then applying coordinated retry to evaluate these further. Can replace mixed integer optimization if the integer variables are narrowly bound. In this case all combinations of these integer values can be enumerated to generate a list of problem instances each representing one combination. See for instance https://www.esa.int/gsp/ACT/projects/gtop/tandem where there is a problem instance for each planet sequence. Parameters ---------- problems: list list of objects providing name, fun and bounds attributes like fcmaes.astro.Astrofun ids: list, optional list of objects corresponding to the list of problems used in logging to identify the problem variant currently logged. If None, the index of the problem variant is used instead. num_retries: int, optional number of coordinated retries applied in the problem filter for each problem in each iteration. keep: float, optional rate of the problems kept after each iteration. 100*(1 - keep) % will be deleted. optimizer: optimizer.Optimizer, optional optimizer to use for the problem filter. logger, optional logger for log output. If None, logging is switched off. Default is a logger which logs both to stdout and appends to a file. datafile, optional file to persist / retrieve the internal state of the optimizations. Returns ------- dictionary( optimizer -> ret): scipy.OptimizeResult The optimization result is represented as an ``OptimizeResult`` object. Important attributes are: ``x`` the solution array, ``fun`` the best function value, ``nfev`` the number of function evaluations, ``success`` a Boolean flag indicating if the optimizer exited successfully. """ solver = multiretry(logger) n = len(problems) for i in range(n): id = str(i + 1) if ids is None else ids[i] solver.add(problem_stats(problems[i], id, i, num_retries, logger)) if not datafile is None: solver.load(datafile) while solver.size() > 1: solver.retry(optimizer) to_remove = int(round((1.0 - keep) * solver.size())) if to_remove == 0 and keep < 1.0: to_remove = 1 solver.remove_worst(to_remove) solver.dump() if not datafile is None: solver.save(datafile) idx = solver.values_all().argsort() return list(np.asarray(solver.all_stats)[idx])
problems = [ Cassini1(), Cassini2(), Rosetta(), Tandem(5), Messenger(), Gtoc1(), MessFull(), Sagas(), Cassini1minlp() ] max_evals = 50000 algos = [ de_cma(max_evals), de2_cma(max_evals), da_cma(max_evals), Cma_cpp(max_evals), De_cpp(max_evals), Hh_cpp(max_evals), Da_cpp(max_evals), Bite_cpp(max_evals), Csma_cpp(max_evals), Dual_annealing(max_evals), Differential_evolution(max_evals) ] def test_all(num_retries=10000, num=1): for problem in problems:
de_minimize_plot(zdt1(20), '100k64') de_minimize_plot(schaffer(20), '100k64') de_minimize_plot(poloni(20), '100k64') de_minimize_plot(fonseca(20), '100k64') nsga_minimize_plot(zdt1(20), '100k64') nsga_minimize_plot(schaffer(20), '100k64') nsga_minimize_plot(poloni(20), '100k64') nsga_minimize_plot(fonseca(20), '100k64') minimize_plot(zdt1(20), Bite_cpp(M=16), '50k1k') minimize_plot(schaffer(20), Bite_cpp(M=16), '50k1k') minimize_plot(poloni(20), Bite_cpp(M=16), '50k1k', exp=1.0) minimize_plot(fonseca(20), Bite_cpp(M=16), '50k1k', exp=3.0) minimize_plot(zdt1(20), de_cma(), '50k1k') minimize_plot(schaffer(20), de_cma(), '50k1k') minimize_plot(poloni(20), de_cma(), '50k1k', exp=1.0) minimize_plot(fonseca(20), de_cma(), '50k1k', exp=3.0) minimize_plot(zdt1(20), random_search(), '50k1k') minimize_plot(schaffer(20), random_search(), '50k1k') minimize_plot(poloni(20), random_search(), '50k1k', exp=1.0) minimize_plot(fonseca(20), random_search(), '50k1k', exp=3.0) minimize_plot(cassini1_mo(), de_cma(50000), '50k4k', num_retries=4096, value_limits=[40, 7000]) minimize_plot(cassini1_mo(),
max_nodes = 100 problems = [ Cassini1(), Cassini2(), Rosetta(), Tandem(5), Messenger(), Gtoc1(), MessFull(), Sagas(), Cassini1minlp() ] algos = [ de2_cma(min_evals), de_cma(min_evals), da_cma(min_evals), Cma_cpp(min_evals), De_cpp(min_evals), Hh_cpp(min_evals), Da_cpp(min_evals), Dual_annealing(min_evals), Differential_evolution(min_evals) ] def messengerFullLoop(opt, num, max_time=1200, log=logger()): problem = MessFull() minimizers = None # remote actors created by minimize will be reused log.info(problem.name + ' ' + opt.name) for i in range(num):
def minimize(fun, bounds, value_limit=math.inf, num_retries=5000, logger=None, workers=mp.cpu_count(), popsize=31, min_evaluations=1500, max_eval_fac=None, check_interval=100, capacity=500, stop_fitness=-math.inf, optimizer=None, statistic_num=0, datafile=None): """Minimization of a scalar function of one or more variables using smart parallel optimization retry. Parameters ---------- fun : callable The objective function to be minimized. ``fun(x, *args) -> float`` where ``x`` is an 1-D array with shape (n,) and ``args`` is a tuple of the fixed parameters needed to completely specify the function. bounds : sequence or `Bounds`, optional Bounds on variables. There are two ways to specify the bounds: 1. Instance of the `scipy.Bounds` class. 2. Sequence of ``(min, max)`` pairs for each element in `x`. None is used to specify no bound. value_limit : float, optional Upper limit for optimized function values to be stored. This limit needs to be carefully set to a value which is seldom found by optimization retry to keep the store free of bad runs. The crossover offspring of bad parents can cause the algorithm to get stuck at local minima. num_retries : int, optional Number of optimization retries. logger : logger, optional logger for log output of the retry mechanism. If None, logging is switched off. Default is a logger which logs both to stdout and appends to a file ``optimizer.log``. workers : int, optional number of parallel processes used. Default is mp.cpu_count() popsize = int, optional CMA-ES population size used for all CMA-ES runs. Not used for differential evolution. Ignored if parameter optimizer is defined. min_evaluations : int, optional Initial limit of the number of function evaluations. Only used if optimizer is undefined, otherwise this setting is defined in the optimizer. max_eval_fac : int, optional Final limit of the number of function evaluations = max_eval_fac*min_evaluations check_interval : int, optional After ``check_interval`` runs the store is sorted and the evaluation limit is incremented by ``evals_step_size`` capacity : int, optional capacity of the evaluation store. Higher value means broader search. stop_fitness : float, optional Limit for fitness value. optimization runs terminate if this value is reached. optimizer : optimizer.Optimizer, optional optimizer to use. Default is a sequence of differential evolution and CMA-ES. Since advanced retry sets the initial step size it works best if CMA-ES is used / in the sequence of optimizers. datafile, optional file to persist / retrieve the internal state of the optimizations. Returns ------- res : scipy.OptimizeResult The optimization result is represented as an ``OptimizeResult`` object. Important attributes are: ``x`` the solution array, ``fun`` the best function value, ``nfev`` the number of function evaluations, ``success`` a Boolean flag indicating if the optimizer exited successfully. """ if optimizer is None: optimizer = de_cma(min_evaluations, popsize, stop_fitness) if max_eval_fac is None: max_eval_fac = int(min(50, 1 + num_retries // check_interval)) store = Store(fun, bounds, max_eval_fac, check_interval, capacity, logger, num_retries, statistic_num, datafile) if not datafile is None: try: store.load(datafile) except: pass return retry(store, optimizer.minimize, value_limit, workers, stop_fitness)
def minimize(fun, bounds, weight_bounds, ncon = 0, value_exp = 2.0, value_limits = None, num_retries = 1024, logger = None, workers = mp.cpu_count(), popsize = 31, max_evaluations = 50000, capacity = None, optimizer = None, statistic_num = 0, plot_name = None ): """Minimization of a multi objective function of one or more variables using parallel optimization retry. Parameters ---------- fun : callable The objective function to be minimized. ``fun(x, *args) -> float`` where ``x`` is an 1-D array with shape (n,) and ``args`` is a tuple of the fixed parameters needed to completely specify the function. bounds : sequence or `Bounds`, optional Bounds on variables. There are two ways to specify the bounds: 1. Instance of the `scipy.Bounds` class. 2. Sequence of ``(min, max)`` pairs for each element in `x`. None is used to specify no bound. weight_bounds : `Bounds`, optional Bounds on objective weights. ncon : int, optional number of constraints value_exp : float, optional exponent applied to the objective values for the weighted sum. value_limits : sequence of floats, optional Upper limit for optimized objective values to be stored. num_retries : int, optional Number of optimization retries. logger : logger, optional logger for log output of the retry mechanism. If None, logging is switched off. Default is a logger which logs both to stdout and appends to a file ``optimizer.log``. workers : int, optional number of parallel processes used. Default is mp.cpu_count() popsize = int, optional CMA-ES population size used for all CMA-ES runs. Not used for differential evolution. Ignored if parameter optimizer is defined. max_evaluations : int, optional Forced termination of all optimization runs after ``max_evaluations`` function evaluations. Only used if optimizer is undefined, otherwise this setting is defined in the optimizer. capacity : int, optional capacity of the evaluation store. optimizer : optimizer.Optimizer, optional optimizer to use. Default is a sequence of differential evolution and CMA-ES. plot_name : plot_name, optional if defined the pareto front is plotted during the optimization to monitor progress Returns ------- xs, ys: list of argument vectors and corresponding value vectors of the optimization results. """ if optimizer is None: optimizer = de_cma(max_evaluations, popsize) if capacity is None: capacity = num_retries store = retry.Store(fun, bounds, capacity = capacity, logger = logger, statistic_num = statistic_num, plot_name = plot_name) xs = np.array(mo_retry(fun, weight_bounds, ncon, value_exp, store, optimizer.minimize, num_retries, value_limits, workers)) ys = np.array([fun(x) for x in xs]) return xs, ys