def run(self, benchmark): """Execute the algorithm Argument -------- benchmark : str """ if PSO.__flags.seed: algorithm = pg.pso(self.__flags.generations, self.__flags.omega, self.__flags.eta1, self.__flags.eta2, self.__flags.max_vel, self.__flags.variant, self.__flags.neighb_type, self.__flags.neighb_param, self.__flags.memory, self.__flags.seed) else: algorithm = pg.pso(self.__flags.generations, self.__flags.omega, self.__flags.eta1, self.__flags.eta2, self.__flags.max_vel, self.__flags.variant, self.__flags.neighb_type, self.__flags.neighb_param, self.__flags.memory) # Execute super().exec(algorithm, benchmark)
def run(self, converge_info=False, pop_info=False): """ Run the optimisation process using PSO algorithm. :param converge_info: optional run the optimisation with convergence information :param converge_info: optional run the optimisation with population information :return: """ print("Start the optimisation process...") if pop_info != False: uda = pg.pso(gen=1) algo = pg.algorithm(uda) algo.set_verbosity(1) pop = pg.population(self.problem, self.pop_size) self.pop_history = [pop] for i in range(int(pop_info)): pop = algo.evolve(pop) self.pop_history.append(pop) self.log = algo.extract(type(uda)).get_log() self.pop = pop elif converge_info == True: uda = pg.pso(gen=self.generation) algo = pg.algorithm(uda) algo.set_verbosity(1) pop = pg.population(self.problem, self.pop_size) self.log = algo.extract(type(uda)).get_log() self.pop = pop else: uda = pg.pso(gen=self.generation) algo = pg.algorithm(uda) pop = pg.population(self.problem, self.pop_size) pop = algo.evolve(pop) self.champion = pop.champion_x return pop.champion_f, pop.champion_x
def run(self): self.algo = pg.algorithm( pg.pso(gen=self.param['gen'], eta1=self.param['eta1'], eta2=self.param['eta2'])) self.algo.set_verbosity(1) for i in range(self.param['sessions']): print("\n" + str(i + 1) + " out of " + str(self.param['sessions']) + " started. \n") self.algo.set_seed(randint(0, 1000)) self.pop = pg.population(self.problem, size=self.param['pop_size'], seed=randint(0, 1000)) self.pop = self.algo.evolve(self.pop) self.process_results() self.save_results() print(self.pop) print("\n" + str(i + 1) + " out of " + str(self.param['sessions']) + " saved.")
def run(self): algo = pg.algorithm(pg.pso(gen=self.generation)) pop = pg.population(self.problem, self.pop_size) print("Start optimisation process...") pop = algo.evolve(pop) self.champion = pop.champion_x return pop.champion_f, pop.champion_x
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 island_run(self): algo = pg.algorithm(pg.pso(gen=self.generation)) pop = pg.population(self.problem, self.pop_size) island = pg.island(algo=algo, pop=pop, udi=pg.mp_island()) island.evolve() island.wait() pop = island.get_population() return pop.champion_f, pop.champion_x
def ref_pygmo(state,comuna,mov=0.2,qp=0,tsim = 300,tci=None,movfunct='sawtooth'): # Total number of inhabitants endpoint="http://192.168.2.220:8080/covid19/findComunaByIdState?idState="+state+"&&comuna="+comuna r = requests.get(endpoint) #, params = {"w":"774508"}) mydict = r.json() info=pd.DataFrame(mydict) # Active infected endpoint = "http://192.168.2.223:5006/getActiveNewCasesByComuna?comuna="+comuna r = requests.get(endpoint) #, params = {"w":"774508"}) mydict = r.json() data=pd.DataFrame(mydict) if not data.actives.any(): return # Build time vector tr=np.zeros(len(data)) for i in range(1,len(data)): diff=dt.datetime.strptime(data.dates[i], '%Y-%m-%d')-dt.datetime.strptime(data.dates[i-1], '%Y-%m-%d') tr[i]=diff.days+tr[i-1] if(len(tr)==1): return # Get actives: Ir = list(data.actives) S0 = info[info['cut']==comuna].numPopulation.iloc[0] I0 = Ir[0] R0 = 0 h=0.01 lb=[0.01,0.1,0.05,1.5] ub=[3.5,0.3,0.1,5.5] bounds = (lb,ub) prob = pg.problem(SEIRModel_pygmo(Ir,tr,S0,I0,R0,h,mov,qp,movfunct,bounds)) algo = pg.algorithm(pg.pso(gen = 50)) pop = pg.population(prob,50) pop = algo.evolve(pop) print(pop.champion_f) print(pop.champion_x) xopt = pop.champion_x fopt = pop.champion_f print('error '+str(fopt)) err_rel = fopt/LA.norm(Ir) print('relative error '+str(err_rel)) sim=intger(S0,xopt[3]*I0,I0,R0,min(tr),tsim,h,xopt[0],xopt[1],xopt[2],mov,qp,tr[-1],movfunct) b_date=dt.datetime.strptime(data.dates.loc[0], '%Y-%m-%d') tout = range(int(tsim)) sim['t'] = tout return({'Ir':Ir,'tr':tr, 'params':xopt, 'err':fopt,'err_rel':err_rel,'sim':sim, 'init_date':b_date})
def run(self, params: dict): self.params = copy.copy(params) self.prob = pg.problem(self.problem) num_ind = self.params.pop('num_ind') #self.algo = pg.algorithm(pg.sga(**self.params)) self.algo = pg.algorithm(pg.pso(**self.params)) self.algo.set_verbosity(1) self.pop = pg.population(self.prob, num_ind) self.pop = self.algo.evolve(self.pop) return self.pop
def find_intermediate(desired_point): # pro = intermediate_pass_problem("intermediate_pass", desired_point) algo = pg.algorithm(pg.pso(gen=10)) prob = pg.problem(intermediate_pass_problem("intermediate_pass", desired_point)) pop = pg.population(prob, 10) pop = algo.evolve(pop) print(pop) print("Done plotting the best point") return [pop.champion_x[0], pop.champion_x[1]]
def find_best(): print("Finding the best point for this cost function. Please wait...") a = best_location_problem("best_location") algo = pg.algorithm(pg.pso(gen=10)) prob = pg.problem(best_location_problem("name is cool")) pop = pg.population(prob, 10) pop = algo.evolve(pop) print(pop) print("Done plotting the best point") return [pop.champion_x[0], pop.champion_x[1]]
def get_island(evaluate, params, hooks): # config # D = 8 decision space dimension # N0 = 100 initial population # Ng = 100 total generation D, Ng, N0 = itemgetter('D', 'Ng', 'N0')(params) algo = pg.algorithm(pg.pso(gen=Ng)) algo.set_verbosity(int(Ng / 10)) prob = pg.problem(evaluate_wrapper(D, evaluate)) island = pg.island(algo=algo, prob=prob, size=N0, udi=pg.mp_island()) return island
def solver(dimension, lower_bound, upper_bound, optim, bias, popsize): global algo global pop global niter global log global curve prob = pg.problem(ackley_prob(dimension, lower_bound, upper_bound, optim, bias)) algo = pg.algorithm(pg.pso(gen=8000, omega=0.6, eta1=2, eta2=4, max_vel=0.5, variant=5, neighb_type=2, neighb_param=4)) algo.set_verbosity(1) pop = pg.population(prob, popsize) pop = algo.evolve(pop) log = algo.extract(pg.pso).get_log() curve = [x[2] for x in log] niter = log[-1][0] return prob, algo, pop, log, niter, curve
async def optimize(evaluate, configs): # config # D = 8 decision space dimension # N0 = 100 initial population # Ng = 100 total generation D, Ng, N0 = itemgetter('D', 'Ng', 'N0')(configs) algo = pg.algorithm(pg.pso(gen=Ng)) algo.set_verbosity(int(Ng / 10)) prob = pg.problem(evaluate_wrapper(D, evaluate)) pop = pg.population(prob, N0) await asyncio.sleep(0) pop = algo.evolve(pop) gbest = (pop.champion_x, pop.champion_f) return gbest
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.pso(gen=cp.getint('DEFAULT', 'gens'), omega=cp.getfloat('OPTIMPARAMS', 'omega'), eta1=cp.getfloat('OPTIMPARAMS', 'eta1'), eta2=cp.getfloat('OPTIMPARAMS', 'eta2'))) algo.set_verbosity(1) pop = pg.population(prob, cp.getint('DEFAULT', 'population_size')) pop = algo.evolve(pop) uda = algo.extract(pg.pso) return [x[2] for x in uda.get_log()]
def run(self, pop_size=100, gen=100, **kwargs): """ Run optimization with parameters. A range of options can be pass into optimization depth_of_discharge=1, discharge_rate=0.005, battery_eff=0.9, discharge_eff=0.8,title=0, azim=0, tracking=0, power_coefficient=0.3, cut_in_speed=2, cut_off_speed=15, technology='csi', system_loss=0.10 :param pop_size: Population size for the optimization :param gen: Generations to be run :param kwargs: :return: """ prob = pg.problem( Single_mixed_objective_optimization_function( self.route, self.start_time, self.speed, self.demand, self.ship, **kwargs)) algo = pg.algorithm(pg.pso(gen=gen)) pop = pg.population(prob, pop_size) pop = algo.evolve(pop) self.champion = pop.champion_x return pop.champion_f, pop.champion_x
import pygmo as po import numpy as np import myUDP import time band = 3 generations = 500 sizePop = 25 pathsave = '/Users/p277634/python/kaoModel/optimResult/' #pathsave = '' filenameTXT = 'pso_Bandfit_' + str(band) + '.txt' filenameNPZ = 'pso_Bandfit_' + str(band) + '.npz' # algorithm algo = po.algorithm(po.pso(gen=generations)) algo.set_verbosity(1) # problem prob = po.problem(myUDP.KMAOsimpleFitBand(band=band)) # population pop = po.population(prob=prob, size=sizePop, seed=22) # evolution start = time.time() popE = algo.evolve(pop) print('time evolution: ', time.time() - start) # save TXT fie with general description of the optimization bestFstr = 'champion fitness: ' + str( popE.champion_f[0]) + '; best fit possible: -1' bestChamp = 'champion decission vector'
def chi_optimize(method='pso', parallel=False, N_ind=100, N_gen=30, iset=0, show_results=False, dir='../data/', file_name='chi_fit'): # Load experimental data N_set = 2 ca_data = svu.loaddata('../data/herzog_data.pkl')[0] po_data = svu.loaddata('../data/fit_po.pkl')[0] lr_data = svu.loaddata('../data/fit_lra.pkl')[0] # Get boundary dictionary bounds_dict = models.model_bounds(model='chi') # Save effective bounds and scaling bounds, scaling = bounds_for_exploration(bounds_dict, normalized=False) # Prepare model parameters c0 = 5.0 # c0 = 15.0 params = np.asarray(np.r_[po_data[[0, 1, 0, 2, 3]], lr_data[[0, 1]], c0, iset]) args = (params, ca_data) #----------------------------------------------------------------------------------------------------------- # Effective evolution #----------------------------------------------------------------------------------------------------------- # Size parameters # N_var = problem_dimension(model='lra') N_individuals = N_ind N_var = problem_dimension(model='chi') N_generations = N_gen * N_var # Tolerances FTOL = 1e-6 XTOL = 1e-6 # prob = pg.problem(fit_problem('lra',args)) prob = pg.problem(fit_problem('chi', args)) # Optimization # NOTE: We keep each algorithm self contained here because different setting of parameters for evolution are # needed depending on the chose algorithm if method == 'pso': algo = pg.algorithm( pg.pso(gen=N_generations, variant=5, neighb_type=4, max_vel=0.8)) elif method == 'bee': algo = pg.algorithm(pg.bee_colony(gen=N_generations, limit=2)) elif method == 'de': algo = pg.algorithm(pg.de(gen=N_generations, ftol=FTOL, tol=XTOL)) # Single-node optimation to run on local machine / laptop # N_individuals = 100 # N_generations = 40 * N_var # verbosity = 20 if not parallel: verbosity = 20 algo.set_verbosity(verbosity) pop = pg.population(prob, size=N_individuals) pop = algo.evolve(pop) best_fitness = pop.get_f()[pop.best_idx()] print(best_fitness) x_rescaled = rescale_vector(pop.champion_x, model='chi', normalized=True, bounds=bounds, scaling=scaling) # Show results of fit if show_results: astro = models.Astrocyte( model='chi', d1=po_data[0], d2=po_data[1], d3=po_data[0], d5=po_data[2], a2=po_data[3], c0=c0, c1=0.5, rl=0.1, Ker=0.1, rc=lr_data[0], ver=lr_data[1], vbeta=x_rescaled[0], vdelta=x_rescaled[1], v3k=x_rescaled[2], r5p=x_rescaled[3], ICs=np.asarray([x_rescaled[6], x_rescaled[4], x_rescaled[5]])) options = su.solver_opts(t0=ca_data['time'][iset][0], tfin=ca_data['time'][iset][-1], dt=1e-4, atol=1e-8, rtol=1e-6, method="gsl_msadams") astro.integrate(algparams=options, normalized=True) ca_trace = ca_data['smoothed'][iset] plt.plot(ca_data['time'][0], ca_trace, 'k-', astro.sol['ts'], astro.sol['ca'], 'r-') plt.show() else: # Parallel version to run on cluster N_evolutions = 100 N_islands = 10 # Initiate optimization algo = pg.algorithm( pg.pso(gen=N_generations, variant=5, neighb_type=4, max_vel=0.8)) archi = pg.archipelago(n=N_islands, algo=algo, prob=prob, pop_size=N_individuals) archi.evolve(N_evolutions) archi.wait() imin = np.argmin(archi.get_champions_f()) x_rescaled = rescale_vector(archi.get_champions_x()[imin], model='chi', normalized=True, bounds=bounds, scaling=scaling) print archi.get_champions_f()[imin] print x_rescaled svu.savedata([x_rescaled], dir + file_name + '.pkl')
class WrapOptimSingleObjectiveUnconstraint(WrapOptim): def __init__(self): super().__init__() self.constraint_penalty = 1000 def get_nobj(self): return 1 def get_nic(self): return 0 def fitness(self, x): old_fitness = super().fitness(x) final_fitness = 0 for idx in range(super().get_nobj()): final_fitness += old_fitness[idx] * old_fitness[idx] for idx in range(super().get_nic()): if old_fitness[idx] > 0: final_fitness += old_fitness[idx] * old_fitness[ idx] * self.constraint_penalty return [final_fitness] prob = pg.problem(WrapOptimSingleObjectiveUnconstraint()) pop = pg.population(prob, size=nb_population) algo = pg.algorithm(uda=pg.pso(gen=50)) pop = algo.evolve(pop) print(pop)
def _setup_algorithm(self, parameters): alg = pg.pso(**self._alg_attrs) return alg
def run(self): algo = pg.algorithm(pg.pso(gen=self.generation)) pop = pg.population(self.problem, self.pop_size) pop = algo.evolve(pop) self.champion = pop.champion_x return pop.champion_f, pop.champion_x
def __call__(self, function): scanner_options = { 'sade': dict(gen=self.gen, variant=self.variant, variant_adptv=self.variant_adptv, ftol=self.ftol, xtol=self.xtol, memory=self.memory, seed=self.seed), 'gaco': dict(gen=self.gen, ker=self.ker, q=self.q, oracle=self.oracle, acc=self.acc, threshold=self.threshold, n_gen_mark=self.n_gen_mark, impstop=self.impstop, evalstop=self.evalstop, focus=self.focus, memory=self.memory, seed=self.seed), 'maco': dict(gen=self.gen, ker=self.ker, q=self.q, threshold=self.threshold, n_gen_mark=self.n_gen_mark, evalstop=self.evalstop, focus=self.focus, memory=self.memory, seed=self.seed), 'gwo': dict(gen=self.gen, seed=self.seed), 'bee_colony': dict(gen=self.gen, limit=self.limit, seed=self.seed), 'de': dict(gen=self.gen, F=self.F, CR=self.CR, variant=self.variant, ftol=self.ftol, xtol=self.xtol, seed=self.seed), 'sea': dict(gen=self.gen, seed=self.seed), 'sga': dict(gen=self.gen, cr=self.cr, eta_c=self.eta_c, m=self.m, param_m=self.param_m, param_s=self.param_s, crossover=self.crossover, mutation=self.mutation, selection=self.selection, seed=self.seed), 'de1220': dict(gen=self.gen, allowed_variants=self.allowed_variants, variant_adptv=self.variant_adptv, ftol=self.ftol, xtol=self.xtol, memory=self.memory, seed=self.seed), 'cmaes': dict(gen=self.gen, cc=self.cc, cs=self.cs, c1=self.c1, cmu=self.cmu, sigma0=self.sigma0, ftol=self.ftol, xtol=self.xtol, memory=self.memory, force_bounds=self.force_bounds, seed=self.seed), 'moead': dict(gen=self.gen, weight_generation=self.weight_generation, decomposition=self.decomposition, neighbours=self.neighbours, CR=self.CR, F=self.F, eta_m=self.eta_m, realb=self.realb, limit=self.limit, preserve_diversity=self.preserve_diversity, seed=self.seed), 'compass_search': dict(max_fevals=self.max_fevals, start_range=self.start_range, stop_range=self.stop_range, reduction_coeff=self.reduction_coeff), 'simulated_annealing': dict(Ts=self.Ts, Tf=self.Tf, n_T_adj=self.n_T_adj, n_range_adj=self.n_range_adj, bin_size=self.bin_size, start_range=self.start_range, seed=self.seed), 'pso': dict(gen=self.gen, omega=self.omega, eta1=self.eta1, eta2=self.eta2, max_vel=self.max_vel, variant=self.variant, neighb_type=self.neighb_type, neighb_param=self.neighb_param, memory=self.memory, seed=self.seed), 'pso_gen': dict(gen=self.gen, omega=self.omega, eta1=self.eta1, eta2=self.eta2, max_vel=self.max_vel, variant=self.variant, neighb_type=self.neighb_type, neighb_param=self.neighb_param, memory=self.memory, seed=self.seed), 'nsga2': dict(gen=self.gen, cr=self.cr, eta_c=self.eta_c, m=self.m, eta_m=self.eta_m, seed=self.seed), 'nspso': dict(gen=self.gen, omega=self.omega, c1=self.c1, c2=self.c2, chi=self.chi, v_coeff=self.v_coeff, leader_selection_range=self.leader_selection_range, diversity_mechanism=self.diversity_mechanism, memory=self.memory, seed=self.seed), 'mbh': dict(algo=self.algo, stop=self.stop, perturb=self.perturb, seed=self.seed), 'cstrs_self_adaptive': dict(iters=self.iters, algo=self.algo, seed=self.seed), 'ihs': dict(gen=self.gen, phmcr=self.phmcr, ppar_min=self.ppar_min, ppar_max=self.ppar_max, bw_min=self.bw_min, bw_max=self.bw_max, seed=self.seed), 'xnes': dict(gen=self.gen, eta_mu=self.eta_mu, eta_sigma=self.eta_sigma, eta_b=self.eta_b, sigma0=self.sigma0, ftol=self.ftol, xtol=self.xtol, memory=self.memory, force_bounds=self.force_bounds, seed=self.seed) } if self.log_data: xl = [] yl = [] log_data = self.log_data # class interf_function: def __init__(self, dim): self.dim = dim def fitness(self, x): x = np.expand_dims(x, axis=0) y = function(x) # x = x[0] y = y.tolist() if log_data: xl.append(x) yl.append(y) # print (x, y[0]) return y[0] if function.is_differentiable(): def gradient(self, x): x = np.expand_dims(x, axis=0) g = function(x) g = g.tolist() return g[0] def get_bounds(self): lb = [] ub = [] bounds = function.get_ranges() # warning # check for infinities for i in range(len(bounds)): lb.append(bounds[i, 0]) ub.append(bounds[i, 1]) r = (np.array(lb), np.array(ub)) return r # I need to call pygmo functions directly prob = pg.problem(interf_function(function)) # print (prob.get_thread_safety()) if self.scanner == "sade": # I need a dictionary with algorithms and options algo = pg.algorithm(pg.sade(**scanner_options[self.scanner])) elif self.scanner == "gaco": algo = pg.algorithm(pg.gaco(**scanner_options[self.scanner])) # elif self.scanner == "maco": # is not implemented though in webpage # looks it is # algo = pg.algorithm(pg.maco(**scanner_options[self.scanner])) elif self.scanner == "gwo": algo = pg.algorithm(pg.gwo(**scanner_options[self.scanner])) elif self.scanner == "bee_colony": algo = pg.algorithm(pg.bee_colony(**scanner_options[self.scanner])) elif self.scanner == "de": algo = pg.algorithm(pg.de(**scanner_options[self.scanner])) elif self.scanner == "sea": algo = pg.algorithm(pg.sea(**scanner_options[self.scanner])) elif self.scanner == "sga": algo = pg.algorithm(pg.sga(**scanner_options[self.scanner])) elif self.scanner == "de1220": algo = pg.algorithm(pg.de1220(**scanner_options[self.scanner])) elif self.scanner == "cmaes": algo = pg.algorithm(pg.cmaes(**scanner_options[self.scanner])) # elif self.scanner == "moead": #multiobjective algorithm # algo = pg.algorithm(pg.moead(**scanner_options[self.scanner])) elif self.scanner == "compass_search": algo = pg.algorithm( pg.compass_search(**scanner_options[self.scanner])) elif self.scanner == 'simulated_annealing': algo = pg.algorithm( pg.simulated_annealing(**scanner_options[self.scanner])) elif self.scanner == 'pso': algo = pg.algorithm(pg.pso(**scanner_options[self.scanner])) elif self.scanner == 'pso_gen': algo = pg.algorithm(pg.pso_gen(**scanner_options[self.scanner])) # elif self.scanner == 'nsga2': #multiobjective algorithm # algo = pg.algorithm(pg.nsga2(**scanner_options[self.scanner])) # elif self.scanner == 'nspso': is not implemented though in webpage # looks it is # algo = pg.algorithm(pg.nspso(**scanner_options[self.scanner])) elif self.scanner == 'mbh': if scanner_options[self.scanner]['algo'] == 'de': algo = pg.algorithm( pg.mbh(pg.algorithm(pg.de(**scanner_options['de'])))) # elif self.scanner == 'ihs': #does not work # algo = pg.algorithm(ihs(**scanner_options[self.scanner])) # elif self.scanner == 'xnes': #does not work # algo = pg.algorithm(xnes(**scanner_options[self.scanner])) # uda = algo.extract(xnes) else: print( 'The ' + self.scanner + ' algorithm is not implemented. The ' 'list of algorithms available is', algorithms) sys.exit() # add verbosing flag if self.verbose > 1: algo.set_verbosity(self.verbose) pop = pg.population(prob, self.size) if self.verbose > 9: print('prob', prob) opt = algo.evolve(pop) if self.verbose > 9: print('algo', algo) # best_x = np.expand_dims(opt.champion_x, axis=0) # best_fitness = np.expand_dims(opt.get_f()[opt.best_idx()], axis=0) best_x = np.expand_dims(opt.champion_x, axis=0) best_fitness = np.expand_dims(opt.champion_f, axis=0) if self.verbose > 0: print('best fit:', best_x, best_fitness) if self.log_data: x = np.squeeze(xl, axis=(1, )) y = np.squeeze(yl, axis=(2, )) if self.log_data: return (x, y) else: return (best_x, best_fitness)
def mySADE(n_trials, n_gen, p_size, new_parameters, n_servers, offset): # uda = pg.sade(gen=n_gen, variant=7, variant_adptv=1, memory=False, seed=1234, ftol=1e-3, xtol=1e-3) # pso from pygmo udas = [] udas.append( pg.pso(gen=n_gen, omega=0.7298, eta1=2.05, eta2=2.05, max_vel=0.5, variant=5, neighb_type=2, memory=True, seed=1234)) # pso from slides # udas.append( # pg.pso(gen=n_gen, omega=0.7298, eta1=1.49618, eta2=1.49618, memory=True, seed=1234, max_vel=0.5, variant=5, # neighb_type=2)) # # udas.append(pg.sade(gen=n_gen, variant=7, variant_adptv=1, memory=False, seed=1234, ftol=1e-3, xtol=1e-3)) # udas.append(pg.sade(gen=n_gen, variant=8, variant_adptv=1, memory=False, seed=1234, ftol=1e-3, xtol=1e-3)) # udas.append(pg.sade(gen=n_gen, variant=18, variant_adptv=1, memory=False, seed=1234, ftol=1e-3, xtol=1e-3)) # algo = pg.algorithm(pg.gaco(10, 13, 1.0, 1e9, 0.0, 1, 7, 100000, 100000, 0.0, 10, 0.9, False, 23)) # #MULTIOBJ UDAS # udas.append( # pg.moead(gen=n_gen, weight_generation="grid", decomposition="tchebycheff", neighbours=20, CR=1, F=.9, eta_m=20)) # udas.append( # pg.moead(gen=n_gen, weight_generation="low discrepancy", decomposition="tchebycheff", neighbours=20, CR=1, # F=.9, eta_m=20,)) # udas.append( # pg.moead(gen=n_gen, weight_generation="grid", decomposition="weighted", neighbours=20, CR=1, F=.9, eta_m=20)) # udas.append( # pg.moead(gen=n_gen, weight_generation="low discrepancy", decomposition="weighted", neighbours=20, CR=1, # F=.9, eta_m=20)) plotting = [] P = used_parameters global_results = [] print namestr(P, globals()) par_name = namestr(P, globals())[0] today = datetime.datetime.now().day print "Starting servers" servers = [] for i in range(n_servers): servers.append(ServerTorcs.ServerTorcs(port=3001 + i + offset)) servers[i].start() time.sleep(.5) print "Servers started" for index, uda in enumerate(udas): logs = [] algo = pg.algorithm(uda) new_algo_name = algo.get_name().replace(" ", "").replace(":", "") results_trial = [] time.sleep(1) print ('uda:', index) for j in range(0, n_trials): # prob1 = pg.problem(myProblem(n_servers, index)) prob1 = pg.problem( myProblem(n_servers, index + j, par_name, n_gen, p_size, today, new_algo_name, new_parameters, offset)) # prob1 = pg.problem(myProblemMultiobj(n_servers, index)) log_trial = [] algo.set_verbosity(1) pop = pg.population(prob1, p_size, seed=j + index) # pop_inj = [3.15392734e+01, 4.06351818e+03, 4.97105933e+03, 1.21724869e-02, # 8.46515570e+03, 4.20830027e+03, 3.36044504e+01, 8.29855857e+02, # 7.34442849e+03, 2.31965057e-01, 1.12100314e+02, 8.61982701e-04, # 7.69219306e+03, 1.64014121e+00, 9.21010307e+00, 3.05622329e+00, # 4.25427737e-02, 5.29581177e+03, 4.43502782e-01, 3.48692685e+01, # 6.78188600e+03, 7.64180124e+01, 4.51893080e-01, 1.00028542e-04, # 2.55765200e+01, 2.55946953e+00, 1.06115486e-01, 8.31605221e-02, # 3.73600771e-01, 5.80222129e-01, 9.95582187e-01, 8.34279341e+03, # 1.96224119e+02, 2.47433910e-02, 9.08202495e+00, 2.34373462e+00, # 1.72508422e-01, 2.45826790e-01, 1.25945279e+01, 7.14638162e-01, # 4.51873959e-01, -3.13286844e-01, 2.71382726e+00, 4.68865255e+02, # 2.15839339e+00, 2.91927274e+00, 2.22224571e+00, 1.57180463e+00, # 7.34361953e-01, 3.11895138e+03] # pop.push_back(pop_inj) algo.evolve(pop) log_trial.append(algo.extract(type(uda)).get_log()) log_trial = np.array(log_trial) results_trial.append(np.min(log_trial[:, log_trial.shape[1] - 1, 2])) # print "trial", j, "--", results_trial plotting.append(log_trial) logs.append(algo.extract(type(uda)).get_log()) logs = np.array(logs) # print "logs", logs avg_log = np.average(logs, 0) # print "avg_log", avg_log global_results.append(np.min(results_trial, 0)) plt.plot(avg_log[:, 1], avg_log[:, 2], label=algo.get_name() + str(index)) if n_trials > 1: for j, elem in enumerate(plotting): plt.plot(elem[0][:, 1], elem[0][:, 2], label=str(j)) # print "plotting", plotting # print "-------------------" # for elem in plotting: # print elem # for ele in elem: # print ele # for el in ele: # print el for i, key in enumerate(P): P[key] = pop.champion_x[i] with open(new_parameters + "_BEST_" + par_name + "_nGen" + str(n_gen) + "_pSize" + str(p_size) + "_circ" + str( n_servers) + "_" + new_algo_name + str(index + j) + "_today" + str(today) + ".txt", 'w') as outfile: json.dump(P, outfile) with open( new_parameters + "_GenBest_" + par_name + "_nGen" + str(n_gen) + "_pSize" + str(p_size) + "_circ" + str( n_servers) + "_" + new_algo_name + str(index + j) + "_today" + str( today) + ".txt", 'w') as outfile: outfile.write(str(algo.extract(type(uda)).get_log())) print("global results: ", global_results) for i, key in enumerate(P): P[key] = pop.champion_x[i] os.chdir(r"C:\Users\Vincenzo\Documents\GitHub\ComputazioneNaturale\snakeoil2015") print "champion_x", pop.champion_x print "champion_f", pop.champion_f with open("def_param.py", 'a') as outfile: outfile.write("\n") outfile.write(new_parameters + " = " + str(P)) with open(new_parameters + ".txt", 'w') as outfile: json.dump(P, outfile) # We then add details to the plot if n_trials < 2: plt.legend() plt.grid() plt.show()
def main(): #Hyperparameters #--------------- ind_best_weight = 1.19314 neigh_best_weight = 1.19314 intertia_weigth = 0.72134 #1 - gbest #2 - lbest #3 - Von Neumann #4 - Adaptive random neighb_topology = 4 #Number of K informants for the Adaptative Random neighborhood neighb_param = 3 #1 - Canonical (with inertia weight) #2 - Same social and cognitive rand. #3 - Same rand. for all components #4 - Only one rand. #5 - Canonical (with constriction fact.) #6 - Fully Informed (FIPS) pso_variant = 1 #Number of particles in the swarm swarm_size = 40 #Select problem and dimensions #application_window = tk.Tk() f_problem = int( input("What problem (F) do you want to optimize? (1 to 6): ")) dimensions = int(input("For how many dimensions? (1 to 500): ")) generations = int(input("Maximum number of iterations? (1 to 500): ")) sel_func = functions(f=f_problem, dim=dimensions) print('\n----------------------------------------------') print('\nFunction: ', sel_func.f.f_name) print('\nDimensions: ', dimensions) print('\nGenerations: ', generations) #Solver #------ print('\n----------------------------------------------') print('\nOptimization Running...') start = time.time() prob = pg.problem(sel_func) print('\n{}', prob) pop = pg.population(prob, size=swarm_size) algo = pg.algorithm( pg.pso(gen=generations, omega=intertia_weigth, eta1=neigh_best_weight, eta2=ind_best_weight, max_vel=1, variant=pso_variant, neighb_type=neighb_topology, neighb_param=neighb_param, memory=False, seed=123)) algo.set_verbosity(1) pop = algo.evolve(pop) log = algo.extract(pg.pso).get_log() best_fitness = pop.get_f()[ pop.best_idx()] # Getting the best individual in the population print('\n----------------------------------------------') print('\nResult:') print('\nBest fitness: ', best_fitness) # Get the best parameter set best_parameterset = pop.get_x()[pop.best_idx()] print('\nBest parameter set: ', best_parameterset) print('\nTime elapsed for optimization: ', time.time() - start, ' seconds\n') #Plot convergence curve (Iterations) x = [x[0] for x in log] y = [y[2] for y in log] z = [z[1] for z in log] fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x, y, color='lightblue', linewidth=1) ax.set_xlim(1, generations) plt.suptitle("Convergence curve by generation") plt.show() #For 2D if (dimensions == 2) and (f_problem != 5): #Plot last swarm and best particle in contour plot f1 = functions(f=f_problem, dim=dimensions) x = np.arange(f1.bounds[0][0], f1.bounds[1][1], 1) y = np.arange(f1.bounds[0][0], f1.bounds[1][1], 1) z = f1.contour h = plt.contourf(x, y, z) plt.plot(pop.get_x()[:, 0], pop.get_x()[:, 1], 'b+') plt.plot(pop.get_x()[pop.best_idx()][0], pop.get_x()[pop.best_idx()][1], 'r+') plt.show()
def ref_sim_pygmo(state, comuna, mov=0.2, qp=0, tsim=300, tci=None, movfunct='sawtooth'): # Region, comuna, movilidad durante cuarentena, periodo cuarenetena, tiempo simulacion, tiempo inicial cuarentena # Total number of inhabitants endpoint = "http://192.168.2.220:8080/covid19/findComunaByIdState?idState=" + state + "&&comuna=" + comuna r = requests.get(endpoint) #, params = {"w":"774508"}) mydict = r.json() info = pd.DataFrame(mydict) # Total number of infected people endpoint = "http://192.168.2.220:8080/covid19/getDatosMinSalSummary?state=" + state + "&comuna=" + comuna r = requests.get(endpoint) #, params = {"w":"774508"}) mydict = r.json() data = pd.DataFrame(mydict) data = data[data.data != 0] data = data.reset_index() #if not data.data.any(): # return tr = np.zeros(len(data.data)) for i in range(1, len(data.data), 1): diff = dt.datetime.strptime(data.labels[i], '%d/%m') - dt.datetime.strptime( data.labels[i - 1], '%d/%m') tr[i] = diff.days + tr[i - 1] #if(len(tr)==1): # return Cn = np.zeros(data.data.shape[0]) Cn[0] = data.data.iloc[0] for i in range(1, len(Cn), 1): Cn[i] = data.data[i] - data.data[i - 1] Ir = np.zeros(data.data.shape[0]) Ir[np.where(tr - 14 <= 0)] = data.data.iloc[np.where(tr - 14 <= 0)] for i in np.where(tr - 14 > 0)[0]: ind = np.where(tr - tr[i] + 14 < 0)[0] Ir[i] = data.data[i] - sum(Cn[0:ind[-1]]) S0 = info[info['cut'] == comuna].numPopulation.iloc[0] I0 = Ir[0] R0 = 0 h = 0.01 lb = [0.01, 0.1, 0.05, 1.5] ub = [3.5, 0.3, 0.1, 5.5] bounds = [lb, ub] # Create pygmo problem seirmodel = SEIRModel(Ir, tr, S0, I0, R0, h, mov, qp, movfunct, bounds) prob = pg.problem(seirmodel) print(prob) # Choose pygmo algorithm #algo = pg.algorithm(pg.bee_colony(gen = 20, limit = 20)) algo = pg.algorithm(pg.pso(gen=20)) # Create population: Number of particules in swarm pop = pg.population(prob, 10) pop = algo.evolve(pop) #print(pop.champion_f) err = pop.champion_f[0] xopt = pop.champion_x print('error ' + str(err)) print('rel_error ' + str(err / LA.norm(Ir))) sim = edosolve(S0, xopt[3] * I0, I0, R0, min(tr), tsim, h, xopt[0], xopt[1], xopt[2], mov, qp, tr[-1], movfunct) b_date = dt.datetime.strptime(data.labels.loc[0], '%d/%m') tout = range(int(tsim)) #idx=np.searchsorted(tr,tout) #sim['S'] = sim['S'][idx] #sim['E'] = sim['E'][idx] #sim['I'] = sim['I'][idx] #sim['R'] = sim['R'][idx] sim['t'] = tout return ({ 'Ir': Ir, 'tr': tr, 'params': xopt, 'err': err, 'sim': sim, 'init_date': b_date })
archi.wait() archi.wait_check() print(archi) import pygmo as pg # The user-defined problem udp = pg.schwefel(dim=20) # The pygmo problem prob = pg.problem(udp) # For a number of generation based algorithms we can use a similar script to run and average over 25 runs. udas = [ pg.sade(gen=500), pg.de(gen=500), pg.de1220(gen=500), pg.pso(gen=500), pg.bee_colony(gen=250, limit=20) ] for uda in udas: logs = [] for i in range(25): algo = pg.algorithm(uda) algo.set_verbosity(1) # regulates both screen and log verbosity pop = pg.population(prob, 20) pop = algo.evolve(pop) logs.append(algo.extract(type(uda)).get_log()) logs = np.array(logs) avg_log = np.average(logs, 0) plt.plot(avg_log[:, 1], avg_log[:, 2] - 418.9829 * 20, label=algo.get_name())
def create_variants(self, n, desc, category, constructor): def assign_2nd_alg(archipelago, algo): if category == 'rings': for island in archipelago.topology.every_other_island(): island.algorithm = algo elif hasattr(archipelago.topology, 'endpoints'): for island in archipelago.topology.endpoints: island.algorithm = algo elif isinstance(archipelago.topology, FullyConnectedTopology): for island in islice(archipelago.topology.islands, None, None, 2): island.algorithm = algo return archipelago def assign_algs(archipelago, algos): ''' Evenly partitions and assigns algorithms to islands. ''' for island,algo in zip(archipelago.topology.islands, cycle(algos)): island.algorithm = algo g = self.generations self.new_topology( desc='{}, de'.format(desc), category=category, algorithms=['de'], archipelago=Archipelago(constructor(de(gen=g),n))) self.new_topology( desc='{}, de1220'.format(desc), category=category, algorithms=['de1220'], archipelago=Archipelago(constructor(de1220(gen=g),n))) self.new_topology( desc='{}, sade'.format(desc), category=category, algorithms=['sade'], archipelago=Archipelago(constructor(sade(gen=g),n))) self.new_topology( desc='{}, ihs'.format(desc), category=category, algorithms=['ihs'], archipelago=Archipelago(constructor(ihs(gen=g),n))) self.new_topology( desc='{}, pso'.format(desc), category=category, algorithms=['pso'], archipelago=Archipelago(constructor(pso(gen=g),n))) self.new_topology( desc='{}, pso_gen'.format(desc), category=category, algorithms=['pso_gen'], archipelago=Archipelago(constructor(pso_gen(gen=g),n))) # self.new_topology( # desc='{}, simulated_annealing'.format(desc), # category=category, # algorithms=['simulated_annealing'], # archipelago=Archipelago(constructor(simulated_annealing(),n))) self.new_topology( desc='{}, bee_colony'.format(desc), category=category, algorithms=['bee_colony'], archipelago=Archipelago(constructor(bee_colony(gen=g),n))) self.new_topology( desc='{}, cmaes'.format(desc), category=category, algorithms=['cmaes'], archipelago=Archipelago(constructor(cmaes(gen=g),n))) self.new_topology( desc='{}, nsga2'.format(desc), category=category, algorithms=['nsga2'], archipelago=Archipelago(constructor(nsga2(gen=g),n))) self.new_topology( desc='{}, xnes'.format(desc), category=category, algorithms=['xnes'], archipelago=Archipelago(constructor(xnes(gen=g),n))) # de + nelder mead combo self.new_topology( desc='{}, de+nelder mead'.format(desc), category=category, algorithms=['de','neldermead'], archipelago=assign_2nd_alg(Archipelago(constructor(de(gen=g),n)), self.make_nelder_mead())) # de + praxis combo self.new_topology( desc='{}, de+praxis'.format(desc), category=category, algorithms=['de','praxis'], archipelago=assign_2nd_alg(Archipelago(constructor(de(gen=g),n)), self.make_praxis())) # de + nsga2 combo self.new_topology( desc='{}, de+nsga2'.format(desc), category=category, algorithms=['de','nsga2'], archipelago=assign_2nd_alg(Archipelago(constructor(de(gen=g),n)), nsga2(gen=g))) # de + de1220 combo self.new_topology( desc='{}, de+de1220'.format(desc), category=category, algorithms=['de','de1220'], archipelago=assign_2nd_alg(Archipelago(constructor(de(gen=g),n)), de1220(gen=g))) # de + sade combo self.new_topology( desc='{}, de+sade'.format(desc), category=category, algorithms=['de','sade'], archipelago=assign_2nd_alg(Archipelago(constructor(de(gen=g),n)), sade(gen=g))) # de + pso combo self.new_topology( desc='{}, de+pso'.format(desc), category=category, algorithms=['de','pso'], archipelago=assign_2nd_alg(Archipelago(constructor(de(gen=g),n)), pso(gen=g))) # extra configurations for fully connected topology if constructor is self.factory.createFullyConnected: self.new_topology( desc='{}, de+pso+praxis'.format(desc), category=category, algorithms=['de','pso','praxis'], archipelago=assign_algs(Archipelago(constructor(de(gen=g),n)), (de(gen=g), pso(gen=g), self.make_praxis()))) self.new_topology( desc='{}, de+pso+praxis+nsga2'.format(desc), category=category, algorithms=['de','pso','praxis','nsga2'], archipelago=assign_algs(Archipelago(constructor(de(gen=g),n)), (de(gen=g), pso(gen=g), self.make_praxis(), nsga2(gen=g)))) self.new_topology( desc='{}, de+pso+praxis+cmaes'.format(desc), category=category, algorithms=['de','pso','praxis','cmaes'], archipelago=assign_algs(Archipelago(constructor(de(gen=g),n)), (de(gen=g), pso(gen=g), self.make_praxis(), cmaes(gen=g)))) self.new_topology( desc='{}, de+pso+praxis+xnes'.format(desc), category=category, algorithms=['de','pso','praxis','xnes'], archipelago=assign_algs(Archipelago(constructor(de(gen=g),n)), (de(gen=g), pso(gen=g), self.make_praxis(), xnes(gen=g))))
def _setOptimizer(self, optimizer): if callable(optimizer) == True: # User-defined optimizer function pass elif isinstance(optimizer, str): # Pre-defined optimizer if optimizer == 'ga': gen = self.optimization_configuration['number_of_generations'] cr = self.optimization_configuration['crossover_rate'] mr = self.optimization_configuration['mutation_rate'] elitism = self.optimization_configuration['elitism'] ind = self.optimization_configuration['number_of_individuals'] #================================================================= crossover_type = self.optimization_configuration[ 'crossover_type'] mutation_type = self.optimization_configuration[ 'mutation_type'] selection_type = self.optimization_configuration[ 'selection_type'] selection_param = self.optimization_configuration[ 'selection_param'] #================================================================= self._pagmo_selected_algorithm = pg.sga self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'Best', 'Improvement' ] algo = pg.algorithm( pg.sga(gen=gen, cr=cr, eta_c=1., m=mr, param_m=1., param_s=selection_param, crossover=crossover_type, mutation=mutation_type, selection=selection_type)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('ga') if optimizer == 'sade': gen = self.optimization_configuration['number_of_generations'] de_ftol = self.optimization_configuration['ftol_de'] de_xtol = self.optimization_configuration['xtol_de'] ind = self.optimization_configuration['number_of_individuals'] #================================================================== self._pagmo_selected_algorithm = pg.de1220 self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'Best', 'F', 'CR', 'Variant', 'dx', 'df' ] algo = pg.algorithm( pg.de1220(gen=gen, ftol=de_ftol, xtol=de_xtol)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('sade') if optimizer == 'de': gen = self.optimization_configuration['number_of_generations'] cr = self.optimization_configuration['crossover_rate'] f_w = self.optimization_configuration['scale_factor'] de_variant = self.optimization_configuration['variant_de'] de_ftol = self.optimization_configuration['ftol_de'] de_xtol = self.optimization_configuration['xtol_de'] ind = self.optimization_configuration['number_of_individuals'] #================================================================== self._pagmo_selected_algorithm = pg.de self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'Best', 'F', 'CR', 'dx', 'df' ] algo = pg.algorithm( pg.de(gen=gen, F=f_w, CR=cr, variant=de_variant, ftol=de_ftol, xtol=de_xtol)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('de') if optimizer == 'pso': gen = self.optimization_configuration['number_of_generations'] omega = self.optimization_configuration['omega_pso'] eta1 = self.optimization_configuration['eta1_pso'] eta2 = self.optimization_configuration['eta2_pso'] vcoeff = self.optimization_configuration['max_v_pso'] pso_variant = self.optimization_configuration['variant_pso'] neighb_type = self.optimization_configuration[ 'neighborhood_type_pso'] neighb_param = self.optimization_configuration[ 'neighborhood_param_pso'] ind = self.optimization_configuration['number_of_individuals'] #================================================================== self._pagmo_selected_algorithm = pg.pso self._pagmo_selected_algorithm_log_columns = [ 'Gen', 'Fevals', 'gbest', 'Mean Vel.', 'Mean lbest', 'Avg. Dist.' ] algo = pg.algorithm( pg.pso(gen=gen, omega=omega, eta1=eta1, eta2=eta2, max_vel=vcoeff, variant=pso_variant)) #isl = pg.island(algo, self.optimization_problem, ind) self.optimization_mechanism = algo return ('pso') else: raise UnexpectedValueError("(decorated function, str)")
res = LA.norm(self.Ir - sol.I[idx]) return ([res]) def get_bounds(self): return (self.bounds) def set_bounds(self, bounds): self.bounds = bounds return (self.bounds) def get_name(self): return "SEIR Unsectorial" # PSO Normal algo = pg.algorithm(pg.pso(gen=20)) pop = pg.population(prob, 50) t0 = time() pop = algo.evolve(pop) t1 = time() print('Optimization takes %f seconds' % (t1 - t0)) print(pop.champion_f) print(pop.champion_x) # PSO Mejorada algo = pg.algorithm(pg.pso_gen(gen=50, memory=True, variant=6)) pop = pg.population(prob, 50) t0 = time() pop = algo.evolve(pop) t1 = time() print('Optimization takes %f seconds' % (t1 - t0))
#to then remove the worst individual #pop.erase(pop.get_worst_idx()) #at the end of it all we return the 'evolved' population return pop def get_name(self): return "Monte Carlo (Python)" def human_readable_extra(self): return "n_iter=" + str(self.__n_iter) if __name__ == '__main__': gp = GrowthOptimization() prob = pg.problem(gp) algo = pg.algorithm(pg.pso(gen=300)) #algo = MonteCarlo(100) try: if not runParallel: pop = pg.population(prob, 40) print(dir(pop)) pop = algo.evolve(pop) print(pop.champion_f) else: archi = pg.archipelago(n=16, algo=algo, prob=prob, pop_size=20, seed=32) archi.evolve()
grid, targetSpeed_mps=targetSpeed_mps, waypoints=numWaypoints, bounds=bounds, weights=weights, currentsGrid_u=currentsGrid_u, currentsGrid_v=currentsGrid_v, currentsTransform=currentsTransform_u, regionTransform=regionTransform, rewardGrid=rewardGrid, timeIn=timeOffset_s, interval=timeInterval_s, pixelsize_m=pixelsize_m)) algo = pg.algorithm( pg.pso(gen=generations, omega=hyperparams[1], eta1=hyperparams[2], eta2=hyperparams[3])) algo.set_verbosity(10) # Generate initial population if initPopFile is not None: # Load initial population from file pop = pg.population( prob, 0) # Ignore pool_size; filling population from file # Read file with open(initPopFile) as f: lines = [line.rstrip() for line in f] lines.reverse() # Process each line