def __call__(self, x): # determine the minimal station mass min_mass, slot_mass = select(self.asteroid, self.station, self.trajectory, self.mass, self.transfer_start, self.transfer_time, x) sdv = select_dvs(self.trajectory_dv, x) y = -score(min_mass, sdv) self.evals.value += 1 if y < self.best_y.value: self.best_y.value = y trajectories = trajectory_selection(x, TRAJECTORY_NUM)[0] stations = dyson_stations(x, STATION_NUM) times = timings(x, STATION_NUM) sc = score(np.amin(slot_mass), sdv) logger().info( "evals = {0}: time = {1:.1f} s = {2:.0f} a = {3:.0f} t = {4:s} s = {5:s} b = {6:s} m = {7:s} dv = {8:s}" .format(self.evals.value, dtime(self.t0), sc, ast_num(x, self.asteroid, self.trajectory), str([round(ti, 2) for ti in times[1:-1]]), str([int(si) for si in stations]), str([int(ti) for ti in trajectories]), str([round(mi, 2) for mi in slot_mass * 1E-15]), str([round(di, 2) for di in sdv]))) return y
def messengerFullLoop(): while True: problem = MessFull() logger().info(problem.name + ' cmaes c++') ret = minimize(problem.fun, bounds=problem.bounds, num_retries = 40000, max_evaluations = 50000, value_limit = 10.0, logger = logger(), useCpp = True)
def messengerFullLoop(): while True: problem = MessFull() logger().info(problem.name + ' de + cmaes c++') ret = minimize(problem.fun, bounds=problem.bounds, num_retries=60000, value_limit=10.0, logger=logger())
def fun(self, x): self.evals.value += 1 y = self.f8fun(x) if y < self.best_y.value: self.best_y.value = y logger().info( str(dtime(self.t0)) + ' ' + str(self.evals.value) + ' ' + str(self.best_y.value) + ' ' + str(list(x))) return y
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 dump_all(self, iter): idx = self.values_all().argsort() self.all_stats = list(np.asarray(self.all_stats)[idx]) logger().info("iteration " + str(iter)) for i in range(len(self.all_stats)): ps = self.all_stats[i] logger().info("problem " + ray.get(ps.name.remote()) + ' ' + str(ray.get(ps.id.remote())) + ' ' + str(ray.get(ps.value.remote())) + ' time = ' + str(dtime(self.t0)))
def nsgaII_test(problem, fname, NGEN=2000, MU=100, value_limits=None): time0 = time.perf_counter() # optimization start time name = problem.name logger().info('optimize ' + name + ' nsgaII') pbounds = np.array(list(zip(problem.bounds.lb, problem.bounds.ub))) pop, logbook, front = nsgaII(2, problem.fun, pbounds, NGEN=NGEN, MU=MU) logger().info(name + ' nsgaII time ' + str(dtime(time0))) name = 'nsgaII_' + str(NGEN) + '_' + str(MU) + name + '_' + fname np.savez_compressed(name, xs=pop, ys=front) if not value_limits is None: front = np.array([ y for y in front if all([y[i] < value_limits[i] for i in range(len(y))]) ]) retry.plot(front, name)
def test_retry_cpp(problem, num): ret = retry.minimize(problem.fun, bounds=problem.bounds, num_retries=num, max_evaluations=50000, logger=logger(), useCpp=True)
def _test_optimizer(opt, problem, num_retries = 32, num = 1): log = logger() log.info(problem.name + ' ' + opt.name) for i in range(num): name = str(i+1) + ' ' + problem.name if num > 1 else problem.name retry.minimize_plot(name, opt, problem.fun, problem.bounds, math.inf, 10.0, num_retries, logger=log)
def test_multiretry(num_retries = min(256, 8*mp.cpu_count()), keep = 0.7, optimizer = de2_cma(1500), logger = logger(), repeat = 10): seqs = Tandem(0).seqs n = len(seqs) problems = [Tandem(i) for i in range(n)] ids = [str(seqs[i]) for i in range(n)] t0 = time.perf_counter() for _ in range(repeat): # check all variants problem_stats = multiretry.minimize(problems, ids, num_retries, keep, optimizer, logger) ps = problem_stats[0] # for _ in range(10): # # improve the best variant using only one node # fval = ray.get(ps.retry.remote(optimizer)) # logger.info("improve best variant " + ray.get(ps.name.remote()) # + ' ' + str(ray.get(ps.id.remote())) # + ' ' + str(ray.get(ps.value.remote())) # + ' time = ' + str(dtime(t0))) # if fval < -1490: # break # optimize best variant starting from scratch using all nodes logger.info("improve best variant " + ray.get(ps.name.remote()) + ' ' + str(ray.get(ps.id.remote())) + ' ' + str(ray.get(ps.value.remote())) + ' time = ' + str(dtime(t0))) problem = problems[ray.get(ps.index.remote())] _rayoptimizer(optimizer, problem, 1, max_time = 1200, log = logger)
def _retry_loop(pid, rgs, store, optimize, num_retries, value_limit, stop_fitness=-math.inf): fun = store.wrapper if store.statistic_num > 0 else store.fun #reinitialize logging config for windows - multi threading fix if 'win' in sys.platform and not store.logger is None: store.logger = logger() lower = store.lower while store.get_runs_compare_incr( num_retries) and store.best_y.value > stop_fitness: try: rg = rgs[pid] sol, y, evals = optimize(fun, Bounds(store.lower, store.upper), None, [rg.uniform(0.05, 0.1)] * len(lower), rg, store) store.add_result(y, sol, evals, value_limit) if not store.plot_name is None: name = store.plot_name + "_retry_" + str( store.get_count_evals()) xs = np.array(store.get_xs()) ys = np.array(store.get_ys()) np.savez_compressed(name, xs=xs, ys=ys) plot(y, name, interp=False) except Exception as ex: print(str(ex))
def test_cma_cordinated_retry(dim=6): # coordinated retry with CMA-ES optimizer with reduced popsize # faster for small dimension, use default for dim > 12 return advretry.minimize(problem.fun, problem.bounds, logger=logger(), optimizer=Cma_cpp(2000, popsize=13))
def _retry_loop(pid, rgs, store, optimize, value_limit, stop_fitness=-math.inf): fun = store.wrapper if store.statistic_num > 0 else store.fun #reinitialize logging config for windows - multi threading fix if 'win' in sys.platform and not store.logger is None: store.logger = logger() while store.get_runs_compare_incr( store.num_retries) and store.best_y.value > stop_fitness: if _crossover(fun, store, optimize, rgs[pid]): continue try: rg = rgs[pid] dim = len(store.lower) sol, y, evals = optimize(fun, Bounds(store.lower, store.upper), None, [rg.uniform(0.05, 0.1)] * dim, rg, store) store.add_result(y, sol, store.lower, store.upper, evals, value_limit) except Exception as ex: continue
def optimize(): solo_mgar = solo_mgar_udp([7000, 8000]) prob = pg.problem(solo_mgar) fprob = single_objective(prob) # logger().info('solar orbiter' + ' de -> cmaes c++ smart retry') # ret = advretry.minimize(fprob.fun, bounds=fprob.bounds, num_retries = 60000, # logger = logger(), optimizer=de_cma(1500)) logger().info('solar orbiter' + ' BiteOpt parallel retry') ret = retry.minimize(fprob.fun, bounds=fprob.bounds, num_retries=32000, logger=logger(), optimizer=Bite_cpp(120000, M=6)) return ret
def _test_archipelago(algo, problem, num=10000, stop_val=-1E99, log=logger()): udp = pygmo_udp(problem.fun, problem.bounds) prob = pg.problem(udp) best_y = math.inf best_x = None t0 = time.perf_counter() for _ in range(num): archi = pg.archipelago(n=mp.cpu_count(), algo=algo, prob=prob, pop_size=64) archi.evolve() archi.wait() ys = archi.get_champions_f() if not ys is None and len(ys) > 0: sort = np.argsort([y[0] for y in ys]) y = ys[sort[0]][0] if y < best_y: best_y = y best_x = archi.get_champions_x()[sort[0]] message = '{0} {1} {2} {3!s}'.format(problem.name, dtime(t0), best_y, list(best_x)) log.info(message) if best_y < stop_val: break return OptimizeResult(x=best_x, fun=best_y, success=True)
def _retry_loop(pid, rgs, fun, weight_bounds, ncon, y_exp, store, optimize, num_retries, value_limits): if 'win' in sys.platform and not store.logger is None: store.logger = logger() lower = store.lower wlb = np.array(weight_bounds.lb) wub = np.array(weight_bounds.ub) while store.get_runs_compare_incr(num_retries): try: rg = rgs[pid] w = rg.uniform(size=len(wub)) w /= _avg_exp(w, y_exp) # correct scaling w = wlb + w * (wub - wlb) wrapper = mo_wrapper(fun, w, ncon, y_exp) x, y, evals = optimize(wrapper.eval, Bounds(store.lower, store.upper), None, [rg.uniform(0.05, 0.1)]*len(lower), rg, store) objs = wrapper.mo_eval(x) # retrieve the objective values if value_limits is None or all([objs[i] < value_limits[i] for i in range(len(w))]): store.add_result(y, x, evals, math.inf) if not store.plot_name is None: name = store.plot_name + "_moretry_" + str(store.get_count_evals()) xs = np.array(store.get_xs()) ys = np.array([fun(x) for x in xs]) np.savez_compressed(name, xs=xs, ys=ys) plot(name, ncon, xs, ys) except Exception as ex: print(str(ex))
def minimize_plot(name, optimizer, fun, bounds, value_limit=math.inf, plot_limit=math.inf, num_retries=1024, workers=mp.cpu_count(), logger=logger(), stop_fitness=-math.inf, statistic_num=5000): time0 = time.perf_counter() # optimization start time name += '_' + optimizer.name logger.info('optimize ' + name) store = Store(fun, bounds, capacity=500, logger=logger, statistic_num=statistic_num) ret = retry(store, optimizer.minimize, value_limit, workers, stop_fitness) impr = store.get_improvements() np.savez_compressed(name, ys=impr) filtered = np.array([imp for imp in impr if imp[1] < plot_limit]) if len(filtered) > 0: impr = filtered logger.info(name + ' time ' + str(dtime(time0))) plot(impr, 'progress_aret.' + name + '.png', label=name, xlabel='time in sec', ylabel=r'$f$') return ret
def minimize_plot(name, fun, nobj, ncon, bounds, popsize=64, max_evaluations=100000, nsga_update=False, pareto_update=0, workers=mp.cpu_count(), logger=logger(), plot_name=None): name += '_mode_' + str(popsize) + '_' + \ ('nsga_update' if nsga_update else ('de_update_' + str(pareto_update))) logger.info('optimize ' + name) xs, ys = minimize(fun, nobj, ncon, bounds, popsize=popsize, max_evaluations=max_evaluations, nsga_update=nsga_update, pareto_update=pareto_update, workers=workers, logger=logger, plot_name=plot_name) np.savez_compressed(name, xs=xs, ys=ys) moretry.plot(name, ncon, xs, ys)
def _test_optimizer(opt_name, problem, num_retries = 4000, num = 20, value_limit = 20.0, log = logger()): log.info(problem.name + ' ' + opt_name) for i in range(num): store = Store(problem.bounds, logger = log) optimizer = Optimizer(store, 0) method = getattr(optimizer, opt_name) ret = retry(problem.fun, store, method, num_retries, value_limit = value_limit)
def test_gclde_cordinated_retry(problem): # coordinated retry with GCLDE->CMA sequence optimizer return advretry.minimize(problem.fun, problem.bounds, logger=logger(), optimizer=Sequence( [GCLDE_cpp(750), Cma_cpp(750, popsize=13)]))
def test_gclde_cordinated_retry(dim=6): # coordinated retry with GCLDE->CMA sequence optimizer return advretry.minimize(obj_f_c, bounds(dim), logger=logger(), optimizer=Sequence( [GCLDE_cpp(750), Cma_cpp(750, popsize=13)]))
def _rayoptimizer(opt, problem, num, max_time = 1200, log = logger()): log.info(problem.name + ' ' + opt.name) minimizers = None # remote actors created by minimize will be reused for i in range(num): ret, minimizers = rayretry.minimize(problem.fun, problem.bounds, 100, None, 20000, 0, log, optimizer=opt, max_time=max_time, minimizers=minimizers) print("solution: ", i+1, ret.fun, str(ret.x)) for minimizer in minimizers: ray.get(minimizer.terminate.remote())
def _test_optimizer(opt, problem, num_retries=32, num=1): log = logger() log.info(problem.name + ' ' + opt.name) for _ in range(num): minimize(problem.fun, problem.bounds, math.inf, num_retries, log, optimizer=opt)
def __init__(self, prob, id, index, num_retries = 64, logger = logger()): self.store = advretry.Store(prob.bounds, logger = logger) self.prob = prob self.name = prob.name self.fun = prob.fun self.num_retries = num_retries self.retries = 0 self.value = 0 self.id = id self.index = index self.ret = None
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 messengerFullLoop(opt, num=1, log=logger()): for i in range(num): problem = MessFull() log.info(problem.name + ' ' + opt.name) name = str(i + 1) + ' ' + problem.name if num > 1 else problem.name advretry.minimize_plot(name, opt, problem.fun, problem.bounds, 12.0, 12.0, 50000, logger=log)
def test_retry_cma_python(problem, num): best = math.inf t0 = time.perf_counter() for i in range(num): ret = retry.minimize(problem.fun, bounds=problem.bounds, num_retries=2000, optimizer=Cma_python(100000), statistic_num=5000, logger=logger()) best = min(ret.fun, best) print("{0}: time = {1:.1f} best = {2:.1f} f(xmin) = {3:.1f}".format( i + 1, dtime(t0), best, ret.fun))
def test_advretry(problem, value_limit, num): best = math.inf t0 = time.perf_counter() for i in range(num): ret = advretry.minimize(problem.fun, bounds=problem.bounds, num_retries=4000, value_limit=value_limit, statistic_num=5000, logger=logger()) best = min(ret.fun, best) print("{0}: time = {1:.1f} best = {2:.1f} f(xmin) = {3:.1f}".format( i + 1, dtime(t0), best, ret.fun))
def __call__(self, X): ts = [] for year, x in enumerate(X): if x > 0: # should we kill a fox this year? ts.append(year + x) # when exactly? I = integrator() I.set_initial_value(pop0, 0) for i in range(len(ts)): pop = integrate( I, ts[i]) # propagate rabbit and fox population to ts[i] pop[1] = max(1, pop[1] - 1) # kill one fox, but keep at least one I.set_initial_value(pop, ts[i]) # value is maximal rabbit population during the following 5 years without fox killings y = -max([integrate(I, t)[0] for t in np.linspace(dim, dim + 5, 50)]) # book keeping and logging self.evals.value += 1 if y < self.best_y.value: self.best_y.value = y logger().info( "nfev = {0}: t = {1:.1f} fval = {2:.3f} fox kill at {3:s} x = {4:s}" .format(self.evals.value, dtime(self.t0), y, str([round(t, 2) for t in ts[:-1]]), str(list(X)))) return y
def test_optimizer(opt, problem, num_retries=120000, num=100, value_limit=10.0, log=logger()): log.info(problem.name + ' ' + opt.name) for _ in range(num): ret = advretry.minimize(problem.fun, problem.bounds, value_limit, num_retries, log, optimizer=opt)