def run_example5(): import pygmo as pg from pykep import epoch from pykep.planet import jpl_lp from pykep.trajopt import mga_1dsm # We define an Earth-Venus-Earth problem (single-objective) seq = [jpl_lp('earth'), jpl_lp('venus'), jpl_lp('earth')] udp = mga_1dsm( seq=seq, t0=[epoch(5844), epoch(6209)], tof=[0.7 * 365.25, 3 * 365.25], vinf=[0.5, 2.5], add_vinf_dep=False, add_vinf_arr=True, multi_objective=False ) pg.problem(udp) # We solve it!! uda = pg.sade(gen=100) archi = pg.archipelago(algo=uda, prob=udp, n=8, pop_size=20) print( "Running a Self-Adaptive Differential Evolution Algorithm .... on 8 parallel islands") archi.evolve(10) archi.wait() sols = archi.get_champions_f() idx = sols.index(min(sols)) print("Done!! Solutions found are: ", archi.get_champions_f()) udp.pretty(archi.get_champions_x()[idx]) udp.plot(archi.get_champions_x()[idx])
def goto_mars(): # We define an Earth-Mars problem (single-objective) seq = [jpl_lp('earth'), jpl_lp('mars')] udp = mga_1dsm(seq=seq, t0=[epoch(18 * 365.25 + 1), epoch(25 * 365.25 + 1)], tof=[0.7 * 365.25, 7 * 365.25], vinf=[0.5, 5], add_vinf_dep=False, add_vinf_arr=True, multi_objective=False) pg.problem(udp) # We solve it!! uda = pg.sade(gen=200) archi = pg.archipelago(algo=uda, prob=udp, n=8, pop_size=30) print( "Running a Self-Adaptive Differential Evolution Algorithm .... on 8 parallel islands" ) archi.evolve(10) archi.wait() sols = archi.get_champions_f() idx = sols.index(min(sols)) print("Done!! Solutions found are: ", archi.get_champions_f()) print(f"\nThe best solution with Dv = {min(sols)[0]}:\n") udp.pretty(archi.get_champions_x()[idx]) udp.plot(archi.get_champions_x()[idx], savepath="plot.png")
def run_example5(): import pygmo as pg from pykep import epoch from pykep.planet import jpl_lp from pykep.trajopt import mga_1dsm # We define an Earth-Venus-Earth problem (single-objective) seq = [jpl_lp('earth'), jpl_lp('venus'), jpl_lp('earth')] udp = mga_1dsm(seq=seq, t0=[epoch(5844), epoch(6209)], tof=[0.7 * 365.25, 3 * 365.25], vinf=[0.5, 2.5], add_vinf_dep=False, add_vinf_arr=True, multi_objective=False) pg.problem(udp) # We solve it!! uda = pg.sade(gen=100) archi = pg.archipelago(algo=uda, prob=udp, n=8, pop_size=20) print( "Running a Self-Adaptive Differential Evolution Algorithm .... on 8 parallel islands" ) archi.evolve(10) archi.wait() sols = archi.get_champions_f() idx = sols.index(min(sols)) print("Done!! Solutions found are: ", archi.get_champions_f()) udp.pretty(archi.get_champions_x()[idx]) udp.plot(archi.get_champions_x()[idx])
def __init__(self, Task, config={}): self.config = config self.Task = Task self.set_parameters() if config != {}: self.problem = pg.problem( Mixed_objective_optimization_function(Task, self.config)) else: self.problem = pg.problem( Mixed_objective_optimization_function(Task)) self.rea_sim = simulation.Reactive_simulation(self.Task, config=self.config)
def solve(self, otol=1e-5, zguess=None, seperate=False): if seperate: self.segments = self.pool.map(lambda seg: seg.solve(), self.segments) #[seg.solve() for seg in self.segments] else: # set optimisation params self.otol = otol # instantiate optimisation problem prob = pg.problem(self) # instantiate algorithm algo = pg.ipopt() algo.set_numeric_option("tol", self.otol) algo = pg.algorithm(algo) algo.set_verbosity(1) # instantiate and evolve population if zguess is None: pop = pg.population(prob, 1) else: pop = pg.population(prob, 0) pop.push_back(zguess) pop = algo.evolve(pop) # extract soltution self.zopt = pop.champion_x self.fitness(self.zopt) # combine records self.process_records()
def run_benchmark(cp, x_train, y_train, funset): ib, params, bounds = define_cgp_system( cp.getint('CGPPARAMS', 'n_nodes'), x_train.shape[1] if len(x_train.shape) > 1 else 1, y_train.shape[1] if len(y_train.shape) > 1 else 1, funset, cp.getint('CGPPARAMS', 'max_back')) cf = cost_function(x_train, y_train, params, bounds) prob = pg.problem(cf) algo = pg.algorithm( pg.simulated_annealing(Ts=cp.getfloat('OPTIMPARAMS', 'Ts'), Tf=cp.getfloat('OPTIMPARAMS', 'Tf'), n_T_adj=cp.getint('OPTIMPARAMS', 'n_T_adj'), n_range_adj=cp.getint('OPTIMPARAMS', 'n_range_adj'), bin_size=cp.getint('OPTIMPARAMS', 'bin_size'), start_range=cp.getfloat('OPTIMPARAMS', 'start_range'))) algo.set_verbosity(100) pop = pg.population(prob, 1) pop = algo.evolve(pop) uda = algo.extract(pg.simulated_annealing) return [x[2] for x in uda.get_log()]
def find_pulses( cptm: ContinousPulseTransitionsMaker = ContinousPulseTransitionsMaker( 30, (5, 10), 20, 0.3 ), generations: int = DEFAULT_GENERATIONS, population_size: int = DEFAULT_POPULATION_SIZE, seed: int = DEFAULT_SEED, ) -> typing.Tuple[float, ...]: udp = pg.problem(cptm) algorithm = pg.algorithm(pg.gaco(gen=generations, seed=seed)) # algorithm.set_verbosity(1) algorithm.set_verbosity(0) population = pg.population(udp, population_size) resulting_population = algorithm.evolve(population) best_x = resulting_population.champion_x best_fitness = resulting_population.champion_f pulses = cptm._convert_x_to_pulses(best_x) is_valid = best_fitness[1] <= 0 and best_fitness[2] <= 0 if is_valid: print("Found valid solution.") else: msg = "WARNING: FOUND INVALID SOLUTION!" if best_fitness[1] > 0: msg += " Solution is too small." else: msg += " Solution is too big." print(msg) return pulses
def runTest(self): from dcgpy import symbolic_regression, generate_koza_quintic, kernel_set_double, gd4cgp import pygmo as pg import pickle X, Y = generate_koza_quintic() # Interface for the UDPs udp = symbolic_regression(points=X, labels=Y, rows=1, cols=20, levels_back=21, arity=2, kernels=kernel_set_double( ["sum", "diff", "mul", "pdiv"])(), n_eph=2, multi_objective=False, parallel_batches=0) prob = pg.problem(udp) pop = pg.population(prob, 10) # Interface for the UDAs uda = gd4cgp(max_iter=10, lr=0.1, lr_min=1e-6) algo = pg.algorithm(uda) algo.set_verbosity(0) # Testing some evolutions pop = algo.evolve(pop) # In parallel archi = pg.archipelago(prob=prob, algo=algo, n=16, pop_size=4) archi.evolve() archi.wait_check() # Pickling. self.assertTrue(repr(algo) == repr(pickle.loads(pickle.dumps(algo))))
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 evaluate_vectors_in_csv(csvpath, codec_arg, rate_control_arg): print("Evaluating vectors of: " + codec_arg + " " + rate_control_arg) cfg.mog_alg = "eval-from-csv" cfg.epoch = 0 cfg.NO_GENERATIONS = 0 cfg.load_params_from_json(codec_arg, rate_control_arg) opt_prob = pyg.problem(sweetspot_problem()) pop = pyg.population(prob=opt_prob) param_sets = [] with open(csvpath) as csv_file: csv_data = csv.reader(csv_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for row in csv_data: x = row[0] x = x.replace('\n', '').replace('[', '').replace(']', '').replace("'", "").replace('"', "") x = re.sub('\s+', ',', x.strip()) x = x.split(",") x = [elem for elem in x if elem != ""] param_sets.append(x) param_sets = np.asfarray(param_sets,float) cfg.POP_SIZE = len(param_sets) # Evaluate decision vectors for i in trange(len(param_sets)): pset = param_sets[i] pop.push_back(pset)
def run_benchmark_coevolution(cp, x_train, y_train, funset): ib, params, bounds = define_cgp_system( cp.getint('CGPPARAMS', 'n_nodes'), x_train.shape[1] if len(x_train.shape) > 1 else 1, y_train.shape[1] if len(y_train.shape) > 1 else 1, funset, cp.getint('CGPPARAMS', 'max_back')) # setup the coevolution elements ts = TrainersSet(ib, 16, fitness_function, x_train, y_train) predictors = GaPredictors(x_train, y_train, 10, 24) predictors.evaluate_fitness(ts) x_reduced, y_reduced = predictors.best_predictors_data() GENS_STEP = 50 cf = cost_function(x_reduced, y_reduced, params, bounds) prob = pg.problem(cf) algo = pg.algorithm( pg.pso(gen=GENS_STEP, omega=cp.getfloat('OPTIMPARAMS', 'omega'), eta1=cp.getfloat('OPTIMPARAMS', 'eta1'), eta2=cp.getfloat('OPTIMPARAMS', 'eta2'), memory=True)) algo.set_verbosity(1) pop = pg.population(prob, cp.getint('DEFAULT', 'population_size')) n_gens = GENS_STEP while n_gens < 500: pop = algo.evolve(pop) # calculate exact fitness of champion and # add it to the trainers set champion = NPIndividual(pop.champion_x, cf.bounds, cf.params) try: champion.fitness = fitness_function(champion, x_train, y_train) ts.add_trainer(champion) except ValueError: print('unsuccessful adding of champion') # update random population ts.update_random_population() predictors.predictors_evolution_step(ts) print('changing the subset, best predictor: ', predictors.best_predictor.fitness) x_reduced, y_reduced = predictors.best_predictors_data() pop.problem.extract(object).X = x_reduced pop.problem.extract(object).Y = y_reduced n_gens += GENS_STEP uda = algo.extract(pg.pso) champion = NPIndividual(pop.champion_x, cf.bounds, cf.params) champion.fitness = fitness_function(champion, x_train, y_train) fitnesses = [x[2] for x in uda.get_log()] fitnesses.append(champion.fitness) return fitnesses
def __init__(self, func_id, pop_size=100, dim=10, max_iters=100): self.dim = dim self.pop_size = pop_size self.xMin = -100 # Search space limits self.xMax = 100 # self.maxIters = max_iters self.func_id = func_id self.fitnessEvals = 0 # Original parameters self.c1 = 2.0 self.c2 = 2.0 self.w = 1.0 self.wdamp = 1.0 # Yarpiz default # self.c1 = 1.4962 # self.c2 = 1.4962 # self.w = 0.7298 # self.wdamp = 1.0 self.problem = pg.problem( pg.cec2014(prob_id=self.func_id, dim=self.dim)) self.psoProblem = { 'CostFunction': self.get_fitness, 'nVar': self.dim, 'xMin': self. xMin, # Alternatively you can use a "numpy array" with nVar elements, instead of scalar 'xMax': self. xMax, # Alternatively you can use a "numpy array" with nVar elements, instead of scalar }
def test2(): mma = pg.algorithm(pg.nlopt("mma")) p_toy = pg.problem(toy_problem_2()) archi = pg.archipelago(n=6, algo=mma, prob=p_toy, pop_size=1) archi.evolve() archi.wait_check() print("end of test2")
def _fit_impl(self, objective, parameters): ndim = len(parameters.infos()) minimums = ndim * [-np.inf] maximums = ndim * [+np.inf] initials = np.empty((ndim, self._size)) # for i, pinfo in enumerate(parameters.infos().values()): for i, name in enumerate(parameters.names()): pinfo = parameters.infos()[name] minimum = pinfo.minimum() maximum = pinfo.maximum() value = pinfo.initial_value() scale = pinfo.initial_scale() has_init = pinfo.has_initial() init_min = value - 0.5 * scale if has_init else minimum init_max = value + 0.5 * scale if has_init else maximum init_min = max(init_min, minimum) init_max = min(init_max, maximum) initials[i, :] = random.uniform(init_min, init_max, self._size) minimums[i] = minimum maximums[i] = maximum # print(parameters.names()) #exit() prb = pg.problem(Problem(objective, parameters, minimums, maximums)) alg = pg.algorithm(self._setup_algorithm(parameters)) alg.set_verbosity(self._verbosity) pop = pg.population(prb, size=self._size, seed=self._seed) for i in range(self._size): pop.set_x(i, initials[:, i]) pop = alg.evolve(pop) solution = dict(mode=pop.champion_x) result = make_fitter_result(objective, parameters, solutions=solution) return result
def solver(dimension, lower_bound, upper_bound, optim, bias, popsize): global algo global pop global niter global log global curve prob = pg.problem( rastrigin_prob(dimension, lower_bound, upper_bound, optim, bias)) algo = pg.algorithm( pg.sga(gen=2000, cr=0.9, eta_c=2.0, m=0.02, param_m=1.0, param_s=2, crossover='binomial', mutation='gaussian', selection='truncated')) algo.set_verbosity(1) pop = pg.population(prob, popsize) pop = algo.evolve(pop) log = algo.extract(pg.sga).get_log() curve = [x[2] for x in log] niter = log[-1][0] return prob, algo, pop, log, niter, curve
def get_solution(func_id=1, dim=10, input_data_filepath=None): ''' func_list: Function id, between 1 and 31. dim : Problem dimensionality Returns a solution corresponding the global optima of the function given by func_id. ''' import pygmo as pg from glob import glob # solution = dict() if func_id < 23: prob = pg.problem(pg.cec2014(prob_id=func_id, dim=dim)) filepath = dirs.input if input_data_filepath is None else input_data_filepath shift_data = np.loadtxt(filepath + "/shift_data_{}.txt".format(func_id)) # solution[func_id] = prob.fitness(shift_data[:dim])[0] solution = prob.fitness(shift_data[:dim])[0] if func_id >= 23: raise NotImplementedError( "f_{:2d} not yet implemented".format(func_id)) return None return solution
def get_equilibrium(nn_controller, random_seed=0, mass=0.38905): class controller_equilibrium: def __init__(self, nn_controller): self.nn_controller = nn_controller def fitness(self, state): g0 = 9.81 return [ np.linalg.norm( self.nn_controller.compute_control(state) - np.array([g0 * mass, 0])) ] def get_bounds(self): return ([-1, 0, -1, 0, 0], [1, 0, 1, 0, 0]) # optimisation parameters # increase if necessary to ensure convergence n_generations = 700 n_individuals = 100 prob = pygmo.problem(controller_equilibrium(nn_controller)) algo = pygmo.algorithm( pygmo.de(gen=n_generations, tol=0, ftol=0, seed=random_seed)) pop = pygmo.population(prob, size=n_individuals, seed=random_seed) pop.push_back([0, 0, 0, 0, 0]) algo.set_verbosity(100) pop = algo.evolve(pop) return pop.champion_x
def _create_problem(func, bounds, gradient_, dim, batch_evaluator, n_cores): class Problem: def fitness(self, x): return [func(x)] def get_bounds(self): return bounds def gradient(self, dv): return gradient_(dv) def batch_fitness(self, dvs): dv_list = dvs.reshape(-1, dim) eval_list = batch_evaluator( func=func, arguments=dv_list, n_cores=n_cores, # Error handling is done on a higher level error_handling="raise", ) evals = np.array(eval_list) return evals problem = pg.problem(Problem()) return problem
def __init__(self, potential, training, dbm=None, db_write_interval=10, # database algorithm='pygmo.de', algorithm_kwargs=None, # algorithm features=None, weights=None, problem_kwargs=None, # problem run_id=None): self.algorithm_name = algorithm if self.algorithm_name not in available_algorithms: raise ValueError(f'algorithm {self.algorithm_name} not available') _problem_kwargs = { 'potential': potential, 'training': training, 'dbm': dbm, 'db_write_interval': db_write_interval, 'features': features, 'weights': weights, 'run_id': run_id, **problem_kwargs } if available_algorithms[self.algorithm_name][1] == 'S': internal_problem = DFTFITSingleProblem(**_problem_kwargs) else: internal_problem = DFTFITMultiProblem(**_problem_kwargs) self._internal_problem = internal_problem self._problem = pygmo.problem(internal_problem) self.algorithm_kwargs = algorithm_kwargs or {}
def runTest(self): from dcgpy import symbolic_regression, generate_koza_quintic, kernel_set_double import pygmo as pg X, Y = generate_koza_quintic() udp = symbolic_regression(points=X, labels=Y, rows=1, cols=20, levels_back=21, arity=2, kernels=kernel_set_double(["sum", "diff"])(), n_eph=2, multi_objective=False, parallel_batches=0) prob = pg.problem(udp) pop = pg.population(prob, 10) udp.pretty(pop.champion_x) udp.prettier(pop.champion_x) # Unconstrained self.assertEqual(prob.get_nc(), 0) self.assertEqual(prob.get_nic(), 0) # Single objective self.assertEqual(prob.get_nobj(), 1) # Dimensions self.assertEqual(prob.get_nix(), 20 * (2 + 1) + 1) self.assertEqual(prob.get_nx(), 2 + prob.get_nix()) # Has gradient and hessians self.assertEqual(prob.has_gradient(), True) self.assertEqual(prob.has_hessians(), True)
def run_example3(): import pygmo as pg from pykep.examples import add_gradient, algo_factory # problem udp = add_gradient(mga_lt_EVMe(), with_grad=False) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # algorithm uda = algo_factory("snopt7", False) uda2 = pg.mbh(uda, 5, 0.05) algo = pg.algorithm(uda2) algo.set_verbosity(1) # 3 - Population pop = pg.population(prob, 1) # 4 - Solve the problem (evolve) print("Running Monotonic Basin Hopping ....") pop = algo.evolve(pop) print("Is the solution found a feasible trajectory? " + str(prob.feasibility_x(pop.champion_x))) udp.udp_inner.plot(pop.champion_x)
def __init__(self, dim=2, func_id=1, pop_size=20): self.dim = dim # Problem dimensionality self.xMin = -100 # Search space limits self.xMax = 100 # self.pop_size = pop_size # Population size self.func_id = func_id self.fitnessEvals = 0 # Initial fitness evaluations # Algorithm parameters self.minSigma = 0.0001 self.tau1 = 4 * 1 / (np.sqrt(2 * self.pop_size)) self.tau2 = 4 * 1 / (np.sqrt(2 * np.sqrt(self.pop_size))) self.mutateProb = 1.0 self.numTourneyPlays = 10 # Fitness Function definition if self.func_id < 23: self.problem = pg.problem( pg.cec2014(prob_id=self.func_id, dim=self.dim)) else: raise ValueError("f_{:2d} not yet implemented".format( self.func_id)) return -1 # Initialize population DataFrame and compute initial Fitness self.init_states()
def pygmo_es(): ARCHIPELAGO = True iterations = 10 uda = salimans_nes(iter=iterations) # user defined algorithm udp = saddle_space() # user defined problem prob = pg.problem(udp) # Beautiful white snow if ARCHIPELAGO: archi = pg.archipelago(algo=uda, prob=prob, n=1, pop_size=4) archi.evolve() # print(archi) # prints description of islands contained in archipelago # archi.wait() sols = archi.get_champions_f() idx = sols.index(min(sols)) sols_x = archi.get_champions_x() sol = sols[idx], sols_x[idx] else: pop = pg.population(prob=prob, size=4) pop.set_x(0, [-2.277654673852600, 0.047996554429844, 3.810000000000000]) pop.set_x(1, [-0.138042744751570, -0.144259374836607, 3.127288444444444]) pop.set_x(2, [-2.086814820119193, -0.000122173047640, 3.111181716545691]) uda.evolve(pop) sol = (pop.champion_f, pop.champion_x) print("Done! best solution is:") print(sol) return sol
def __init__(self, func_id, pop_size=100, dim=10, max_iters=100): self.dim = dim self.pop_size = pop_size self.xMin = -100 # Search space limits self.xMax = 100 # self.vMin = self.xMin / 2 # Velocity limits self.vMax = self.xMax / 2 # self.func_id = func_id self.fitnessEvals = 0 # # Debug # self.c1 = 1.0 # self.c2 = 1.0 # self.w = 1.0 # self.wdamp = 1.0 # GOPSO default self.c1 = 1.49618 self.c2 = 1.49618 self.w = 0.72984 self.wdamp = 1.0 self.problem = pg.problem( pg.cec2014(prob_id=self.func_id, dim=self.dim)) self.init_states()
def run_example4(): import pygmo as pg from pykep.examples import add_gradient, algo_factory N = 20 # problem udp = add_gradient(mga_lt_earth_mars_sundmann(nseg=N), with_grad=False) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # algorithm uda = algo_factory("snopt7", False) uda2 = pg.mbh(uda, 5, 0.05) algo = pg.algorithm(uda2) algo.set_verbosity(1) # 3 - Population pop = pg.population(prob, 1) # 4 - Solve the problem (evolve) print("Running Monotonic Basin Hopping ....") pop = algo.evolve(pop) print("Is the solution found a feasible trajectory? " + str(prob.feasibility_x(pop.champion_x))) udp.udp_inner.plot(pop.champion_x)
def check_good_solution(x): solo_mgar = solo_mgar_udp([7000, 8000]) prob = pg.problem(solo_mgar) print(str(prob.fitness(x))) solo_mgar.pretty(x) solo_mgar.plot(x) solo_mgar.plot_distance_and_flybys(x)
def genetic_algorithm(explr_p): prob = pg.problem(GeneticAlgoProblem()) #sade = pg.sade(gen=1, ftol=1e-20, xtol=1e-20) population_size = 5 if obj_fcn == 'griewank' or dim_x == 3: total_evals = 500 elif obj_fcn == 'shekel' and dim_x == 20: total_evals = 5000 else: total_evals = 1000 generations = total_evals / population_size optimizer = pg.cmaes(gen=generations, ftol=1e-20, xtol=1e-20) algo = pg.algorithm(optimizer) algo.set_verbosity(1) pop = pg.population(prob, size=population_size) pop = algo.evolve(pop) print pop.champion_f champion_x = pop.champion_x uda = algo.extract(pg.cmaes) log = np.array(uda.get_log()) n_fcn_evals = log[:, 1] pop_best_at_generation = -log[:, 2] evaled_x = None evaled_y = pop_best_at_generation max_y = [pop_best_at_generation[0]] for y in pop_best_at_generation[1:]: if y > max_y[-1]: max_y.append(y) else: max_y.append(max_y[-1]) return evaled_x, evaled_y, max_y, 0
def nsga2(ppn): print('*** NSGA-II ALGORITHM ***') # INSTANCIATE A PYGMO PROBLEM CONSTRUCTING IT FROM A UDP inittime = perf_counter() prob = pg.problem(PPNOProblem(ppn)) generations = trials = nochanges = 0 best_f = best_x = None # INSTANCIATE THE PYGMO ALGORITM NSGA-II algo = pg.algorithm(pg.nsga2(gen=GENERATIONS_PER_TRIAL)) # INSTANCIATE A POPULATION pop = pg.population(prob, size=POPULATION_SIZE) while True: # RUN THE EVOLUION pop = algo.evolve(pop) trials += 1 generations += GENERATIONS_PER_TRIAL # EXTRACT RESULTS AND SEARCH THE BEST fits, vectors = pop.get_f(), pop.get_x() new_f = new_x = None for fit, vector in zip(fits, vectors): # VALID SOLUTION if fit[1] <= 0: if isinstance(new_f, type(None)): new_f = fit new_x = vector elif new_f[0] > fit[0]: new_f = fit new_x = vector if not isinstance(new_f, type(None)): if isinstance(best_f, type(None)): best_f = new_f best_x = new_x else: if best_f[0] > new_f[0]: best_f = new_f best_x = new_x nochanges = 0 else: nochanges += 1 if not isinstance(best_f, type(None)): print('Generations: %i ' % (generations), end='') print('Cost: %.2f Pressure deficit: %0.3f ' % (best_f[0], best_f[1])) if (perf_counter() - inittime) >= MAX_TIME: print('Maximum evolution time was reached.') break elif trials >= MAX_TRIALS: print('Maximum number of trials was reached.') break elif nochanges >= MAX_NO_CHANGES: print('Objective function value was repeated %i times.' % (nochanges)) break return (best_f, best_x)
def solve(self, otol=1e-5): # set optimisation params self.otol = otol # instantiate optimisation problem prob = pg.problem(self) # instantiate algorithm algo = pg.ipopt() algo.set_numeric_option("tol", self.otol) algo = pg.algorithm(algo) algo.set_verbosity(1) # instantiate and evolve population pop = pg.population(prob, 1) pop = algo.evolve(pop) # extract soltution self.zopt = pop.champion_x self.fitness(self.zopt) # process records self.process_records() return self
def main(argv): help_message = 'test.py <inputfile> <outputfile>' if len(argv) < 2: print(help_message) sys.exit(2) else: inputfile = argv[0] outputfile = argv[1] print("Reading data from " + inputfile) # Setting up the user defined problem in pygmo prob = pg.problem(TestOptimizer(inputfile)) solution_size = 8 # Start with an initial set of 100 sets pop = pg.population(prob, size=solution_size) # Set the algorithm to non-dominated sorting GA algo = pg.algorithm(pg.nsga2(gen=40)) # Optimize pop = algo.evolve(pop) # This returns a set of optimal vectors and corresponding fitness values fits, vectors = pop.get_f(), pop.get_x() print("Writing output to " + outputfile) jsonfile = pygeoj.load(filepath=inputfile) num_districts = len(jsonfile) counter = 0 for feature in jsonfile: for sol in range(solution_size): feature.properties = {"sol" + str(sol): str(vectors[sol][counter])} counter += 1 # Save output jsonfile.save(outputfile)
def main(): # instantiate dynamics dyn = Dynamics() # instantiate leg leg = Leg(dyn, alpha=0, bound=True) # set boudaries t0 = 0 s0 = np.array([1000, 1000, *np.random.randn(4)], dtype=float) l0 = np.random.randn(len(s0)) tf = 1000 sf = np.zeros(len(s0)) leg.set(t0, s0, l0, tf, sf) # define problem udp = Problem(leg, atol=1e-8, rtol=1e-8) prob = pg.problem(udp) # instantiate algorithm uda = pg7.snopt7(True, "/usr/lib/libsnopt7_c.so") uda.set_integer_option("Major iterations limit", 4000) uda.set_integer_option("Iterations limit", 40000) uda.set_numeric_option("Major optimality tolerance", 1e-2) uda.set_numeric_option("Major feasibility tolerance", 1e-4) algo = pg.algorithm(uda) # instantiate population with one chromosome pop = pg.population(prob, 1) #pop = pg.population(prob, 0) #pop.push_back([1000, *l0]) # optimise pop = algo.evolve(pop)
def optimize(): fprob = single_objective(pg.problem(udp)) print('interferometer optimization') # Python Differential Evolution implementation, uses ask/tell for parallel function evaluation. ret = de.minimize(fprob.fun, bounds=fprob.bounds, workers=16, popsize=32, max_evaluations=50000) # Python CMAES implementation, uses ask/tell for parallel function evaluation. #ret = cmaes.minimize(fprob.fun, bounds=fprob.bounds, workers=16, popsize=32, max_evaluations=50000) # Parallel retry using DE #ret = retry.minimize(fprob.fun, bounds=fprob.bounds, optimizer=De_cpp(20000, popsize=32), workers=16, num_retries=64) # Parallel retry using Bite # ret = retry.minimize(fprob.fun, bounds=fprob.bounds, optimizer=Bite_cpp(20000, M=1), workers=16, num_retries=64) # Parallel retry using CMA-ES #ret = retry.minimize(udp.fitness, bounds=bounds, optimizer=Cma_cpp(20000, popsize=32), workers=16, num_retries=64) # Smart retry using DE #ret = advretry.minimize(fprob.fun, bounds=fprob.bounds, optimizer=De_cpp(1500, popsize=32), workers=16) # Smart retry using CMA-ES #ret = advretry.minimize(fprob.fun, bounds=fprob.bounds, optimizer=Cma_cpp(1500, popsize=32), workers=16) # Smart retry using DE->CMA sequence #ret = advretry.minimize(fprob.fun, bounds=fprob.bounds, optimizer=de_cma(1500, popsize=32), workers=16) print("best result is " + str(ret.fun) + ' x = ' + ", ".join(str(x) for x in ret.x))
def run_example11(n_seg=30): """ This example demonstrates the use of the class lt_margo developed for the internal ESA CDF study on the interplanetary mission named MARGO. The class was used to produce the preliminary traget selection for the mission resulting in 88 selected possible targets (http://www.esa.int/spaceinimages/Images/2017/11/Deep-space_CubeSat) (http://www.esa.int/gsp/ACT/mad/projects/lt_to_NEA.html) """ import pykep as pk import pygmo as pg import numpy as np from matplotlib import pyplot as plt from pykep.examples import add_gradient, algo_factory # 0 - Target asteroid from MPCORB mpcorbline = "K14Y00D 24.3 0.15 K1794 105.44160 34.12337 117.64264 1.73560 0.0865962 0.88781021 1.0721510 2 MPO369254 104 1 194 days 0.24 M-v 3Eh MPCALB 2803 2014 YD 20150618" # 1 - Algorithm algo = algo_factory("snopt7") # 2 - Problem udp = add_gradient(pk.trajopt.lt_margo( target=pk.planet.mpcorb(mpcorbline), n_seg=n_seg, grid_type="uniform", t0=[pk.epoch(8000), pk.epoch(9000)], tof=[200, 365.25 * 3], m0=20.0, Tmax=0.0017, Isp=3000.0, earth_gravity=False, sep=True, start="earth"), with_grad=False ) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # 3 - Population pop = pg.population(prob, 1) # 4 - Solve the problem (evolve) pop = algo.evolve(pop) # 5 - Inspect the solution print("Feasible?:", prob.feasibility_x(pop.champion_x)) # 6 - plot trajectory axis = udp.udp_inner.plot_traj(pop.champion_x, plot_segments=True) plt.title("The trajectory in the heliocentric frame") # 7 - plot control udp.udp_inner.plot_dists_thrust(pop.champion_x) # 8 - pretty udp.udp_inner.pretty(pop.champion_x) plt.ion() plt.show()
def user_defined_problem(): prob = pg.problem(sphere_function(3)) print(prob) algo = pg.algorithm(pg.bee_colony(gen = 200, limit = 20)) pop = pg.population(prob, 10) pop = algo.evolve(pop) print(pop.champion_f) print(pop)
def run_example8(nseg=40): """ This example demonstrates the direct method (sims-flanagan) on a planet to planet scenario. """ import pykep as pk import pygmo as pg import numpy as np from matplotlib import pyplot as plt from pykep.examples import add_gradient, algo_factory # 1 - Algorithm algo = algo_factory("snopt7") # 2 - Problem udp = add_gradient(pk.trajopt.direct_pl2pl( p0="earth", pf="mars", mass=1000, thrust=0.1, isp=3000, vinf_arr=1e-6, vinf_dep=3.5, hf=False, nseg=nseg, t0=[1100, 1400], tof=[200, 750]), with_grad=False ) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # 3 - Population pop = pg.population(prob, 1) # 4 - Solve the problem (evolve) pop = algo.evolve(pop) # 5 - Inspect the solution if prob.feasibility_x(pop.champion_x): print("Optimal Found!!") else: print("No solution found, try again :)") udp.udp_inner.pretty(pop.champion_x) axis = udp.udp_inner.plot_traj(pop.champion_x) plt.title("The trajectory in the heliocentric frame") axis = udp.udp_inner.plot_control(pop.champion_x) plt.title("The control profile (throttle)") plt.ion() plt.show()
def run_example6(n_seg=5): """ This example demonstrates the optimization of a multiple randezvous mission (low-thrust). Such a mission (including more asteroids) is also called asteroid hopping The spacecraft performances, as well as the three asteroids visited, are taken from the GTOC7 problem description. """ import pygmo as pg from pykep.trajopt import mr_lt_nep from pykep.planet import gtoc7 from pykep.examples import add_gradient, algo_factory from matplotlib import pyplot as plt # If you have no access to snopt7, try slsqp (multiple starts may be # necessary) algo = algo_factory("snopt7") udp = add_gradient( mr_lt_nep( t0=[9600., 9700.], seq=[gtoc7(5318), gtoc7(14254), gtoc7(7422), gtoc7(5028)], n_seg=n_seg, mass=[800., 2000.], leg_tof=[100., 365.25], rest=[30., 365.25], Tmax=0.3, Isp=3000., traj_tof=365.25 * 3., objective='mass', c_tol=1e-05 ), with_grad=False) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() pop = pg.population(prob, 1) pop = algo.evolve(pop) solution = pop.champion_x if prob.feasibility_x(solution): print("FEASIBILE!!!") ax = udp.udp_inner.plot(solution) else: print("INFEASIBLE :(") ax = None plt.ion() plt.show()
def quick_start_demo(): # 1 - Instantiate a pygmo problem constructing it from a UDP # (user defined problem). prob = pg.problem(pg.schwefel(30)) # 2 - Instantiate a pagmo algorithm algo = pg.algorithm(pg.sade(gen=100)) # 3 - Instantiate an archipelago with 16 islands having each 20 individuals archi = pg.archipelago(16, algo=algo, prob=prob, pop_size=20) # 4 - Run the evolution in parallel on the 16 separate islands 10 times. archi.evolve(10) # 5 - Wait for the evolutions to be finished archi.wait() # 6 - Print the fitness of the best solution in each island res = [isl.get_population().champion_f for isl in archi] print(res)
def run_example7(solver="snopt7"): """ This example demonstrates the indirect method (cartesian) on a orbit to orbit scenario. The orbits are those of Earth and Mars. """ import pykep as pk import pygmo as pg import numpy as np from matplotlib import pyplot as plt from pykep.examples import add_gradient, algo_factory # Some pre-computed solutions (obtaining spending some iterations and # restarts from random initial guesses) z_mass_optimal = [397.88267909228767, 2.0719343674552215, 2.7313941033119407, 11.882803539732214, 10.567639551625298, 0.50803671389927796, -11.056641527923768, 12.176151455434058, 4.1269457596809245, 3.4434953247725324] z_quadratic_control = [381.32031472240106, 1.0102363292172423, 1.8134352964367946, 19.522442569527868, - 6.7894353762521105, -3.3749783899165928, 7.0438655057343054, 19.923912672512174, 0.93896446800741751, 3.5483645070393743] z_quadratic_control2 = [459.51623108767666, -1.616057488705803, 0.33049652475302532, -17.735981532357027, - 3.2374905349904912, 2.2249621531880934, 2.9550456430212937, -20.226761256676323, -2.9684113654904061, 3.1471248891703905] z_quadratic_control3 = [519.45371103815569, 0.39617485433378341, 2.7008977766929818, 7.9136210333255468, - 11.03747486077437, -3.0776988186969136, 9.1796869310249747, 6.5013311040515687, -0.2054349910826633, 3.0084671211666865] # A random initial solution z_random = np.hstack( [[np.random.uniform(100, 700)], 2 * np.random.randn(9)]) # We use an initial guess within 10% of a known optima, you can experiment what happens # with a different choice z = z_quadratic_control + z_quadratic_control * np.random.randn(10) * 0.1 #z = z_random # 1 - Algorithm algo = algo_factory(solver) # 2 - Problem. We define a minimum quadratic control problem (alpha=0) with free time # (hamiltonian will be forced to be 0). We provide the option for estimating the gradient numerically for # algorithms that require it. udp = add_gradient(pk.trajopt.indirect_or2or( elem0=[149598261129.93335, 0.016711230601231957, 2.640492490927786e-07, 3.141592653589793, 4.938194050401601, 0], elemf=[227943822376.03537, 0.09339409892101332, 0.032283207367640024, 0.8649771996521327, 5.000312830124232, 0], mass=1000, thrust=0.3, isp=2500, atol=1e-12, rtol=1e-12, tof=[100, 700], freetime=True, alpha=0, bound=True, mu=pk.MU_SUN), with_grad=False) prob = pg.problem(udp) prob.c_tol = [1e-7] * 10 # 3 - Population (i.e. initial guess) pop = pg.population(prob) pop.push_back(z) # 4 - Solve the problem (evolve) pop = algo.evolve(pop) # 5 - Inspect the solution if prob.feasibility_x(pop.champion_x): print("Optimal Found!!") # We call the fitness to set the leg udp.udp_inner.fitness(pop.champion_x) arr = udp.udp_inner.leg.get_states(1e-12, 1e-12) print("Final mass is: ", arr[-1, 7]) else: print("No solution found, try again :)") # plot trajectory axis = udp.udp_inner.plot_traj( pop.champion_x, quiver=True, mark="k", length=1) plt.title("The trajectory in the heliocentric frame") # plot control udp.udp_inner.plot_control(pop.champion_x) plt.title("The control profile (throttle)") plt.ion() plt.show() # Show the trajectory data udp.udp_inner.pretty(pop.champion_x)
def __init__(self, udp, with_grad=False): self.udp_inner = udp self.prob = pg.problem(udp) self.with_grad = with_grad
def run_example10(): """ This example demonstrates the indirect method (cartesian) on a point to point fixed time scenario. The boundary conditions are taken from a run of the indirect method. """ import pykep as pk import pygmo as pg import numpy as np from matplotlib import pyplot as plt from pykep.examples import add_gradient, algo_factory # 1 - Algorithm algo = algo_factory("snopt7") # 2 - Problem udp = add_gradient(pk.trajopt.indirect_pt2pt( x0=[44914296854.488266, -145307873786.94177, 1194292.6437741749, 31252.149474878544, 9873.214642584162, -317.08718075574404, 1000], xf=[-30143999066.728119, -218155987244.44385, -3829753551.2279921, 24917.707565772216, -1235.74045124602, -638.05209482866155, 905.47894037275546], thrust=0.1, isp=3000, mu=pk.MU_SUN, tof=[616.77087591237546, 616.77087591237546], freetime=False, alpha=0, # quadratic control bound=True), with_grad=False ) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # 3 - Population pop = pg.population(prob) z = np.hstack(([np.random.uniform(udp.udp_inner.tof[0], udp.udp_inner.tof[1])], 10 * np.random.randn(7))) pop.push_back(z) # 4 - Solve the problem (evolve) pop = algo.evolve(pop) # 5 - Continue the solution to mass optimal homotopy_path = [0.5, 0.75, 0.9, 1] for alpha in homotopy_path: z = pop.champion_x print("alpha: ", alpha) udp = add_gradient(pk.trajopt.indirect_pt2pt( x0=[44914296854.488266, -145307873786.94177, 1194292.6437741749, 31252.149474878544, 9873.214642584162, -317.08718075574404, 1000], xf=[-30143999066.728119, -218155987244.44385, -3829753551.2279921, 24917.707565772216, -1235.74045124602, -638.05209482866155, 905.47894037275546], thrust=0.1, isp=3000, mu=pk.MU_SUN, tof=[616.77087591237546, 616.77087591237546], freetime=False, alpha=alpha, # quadratic control bound=True), with_grad=False ) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # 7 - Solve it pop = pg.population(prob) pop.push_back(z) pop = algo.evolve(pop) # 8 - Inspect the solution print("Feasible?:", prob.feasibility_x(pop.champion_x)) # plot trajectory axis = udp.udp_inner.plot_traj(pop.champion_x, quiver=True, mark="k") plt.title("The trajectory in the heliocentric frame") # plot control udp.udp_inner.plot_control(pop.champion_x) plt.title("The control profile (throttle)") plt.ion() plt.show() udp.udp_inner.pretty(pop.champion_x) print("\nDecision vector: ", list(pop.champion_x))
def run_example9(): """ This example demonstrates the indirect method (cartesian) on a point to planet variable time scenario. The starting conditions are taken from a run of the indirect method. """ import pykep as pk import pygmo as pg import numpy as np from matplotlib import pyplot as plt from pykep.examples import add_gradient, algo_factory # 1 - Algorithm algo = algo_factory("snopt7") # 2 - Problem udp = add_gradient(pk.trajopt.indirect_pt2pl( x0=[44459220055.461708, -145448367557.6174, 1195278.0377499966, 31208.214734303529, 9931.5012318647168, -437.07278242521573, 1000], t0=1285.6637861007277, pf="mars", thrust=0.1, isp=3000, mu=pk.MU_SUN, tof=[600, 720], alpha=0, # quadratic control bound=True), with_grad=False ) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # 3 - Population pop = pg.population(prob) z = np.hstack(([np.random.uniform(udp.udp_inner.tof[0], udp.udp_inner.tof[1])], 10 * np.random.randn(7))) pop.push_back(z) # 4 - Solve the problem (evolve) pop = algo.evolve(pop) homotopy_path = [0.2, 0.4, 0.6, 0.8, 0.9, 0.98, 0.99, 0.995, 1] for alpha in homotopy_path: z = pop.champion_x print("alpha is: ", alpha) udp = add_gradient(pk.trajopt.indirect_pt2pl( x0=[44459220055.461708, -145448367557.6174, 1195278.0377499966, 31208.214734303529, 9931.5012318647168, -437.07278242521573, 1000], t0=1285.6637861007277, pf="mars", thrust=0.1, isp=3000, mu=pk.MU_SUN, tof=[600, 720], alpha=alpha, # quadratic control bound=True), with_grad=False ) prob = pg.problem(udp) prob.c_tol = [1e-5] * prob.get_nc() # 7 - Solve it pop = pg.population(prob) pop.push_back(z) pop = algo.evolve(pop) # 8 - Inspect the solution print("Feasible?:", prob.feasibility_x(pop.champion_x)) # plot trajectory axis = udp.udp_inner.plot_traj(pop.champion_x, quiver=True, mark='k') plt.title("The trajectory in the heliocentric frame") # plot control udp.udp_inner.plot_control(pop.champion_x) plt.title("The control profile (throttle)") plt.ion() plt.show() udp.udp_inner.pretty(pop.champion_x) print("\nDecision vector: ", list(pop.champion_x))
udp = mga(seq=seq, t0=[-1000., 0.], tof=[[30, 400], [100, 470], [30, 400], [400, 2000], [1000, 6000]], vinf=3., tof_encoding='direct', orbit_insertion=True, e_target=0.98, rp_target=108950000) udp = mga(seq=seq, t0=[-1000., 0.], tof=7000., vinf=3., tof_encoding='eta', orbit_insertion=True, e_target=0.98, rp_target=108950000) #udp = mga(seq=seq, t0=[-1000., 0.], tof=[[130,200], [430,470], [30, 70], [900, 1200], [4000, 5000]], vinf=0., alpha_encoding=False) prob = pg.problem(udp) uda = pg.cmaes(1500, force_bounds=True, sigma0=0.5, ftol=1e-4) #uda = pg.sade(4500) algo = pg.algorithm(uda) algo.set_verbosity(10) res = list() # for i in range(100): pop = pg.population(prob, 100) pop = algo.evolve(pop) res.append(pop.champion_f)