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='{}, bee_colony'.format(desc), category=category, algorithms=['bee_colony'], archipelago=Archipelago(constructor(bee_colony(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 + 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)))
def test_non_population_based_migration(): import pygmo as pg from pygmo import de, nlopt, rosenbrock from sabaody.topology import TopologyFactory topology_factory = TopologyFactory(island_size=5, migrant_pool_size=5) topology = topology_factory.createBidirChain(de, number_of_islands=2) assert len(topology.island_ids) == 2 assert len(topology.endpoints) == 2 de_island = pg.island(algo=de(gen=10), prob=rosenbrock(3), size=topology.islands[0].size) nm = nlopt('neldermead') nm.selection = 'random' nm.replacement = 'random' nm_island = pg.island(algo=nm, prob=rosenbrock(3), size=topology.islands[1].size) from sabaody.migration import BestSPolicy, FairRPolicy selection_policy = BestSPolicy(migration_rate=2) replacement_policy = FairRPolicy() from sabaody.migration import MigrationPolicyEachToAll migration_policy = MigrationPolicyEachToAll() # get the candidates from the de island p_de = de_island.get_population() candidates, candidate_f = selection_policy.select(p_de) # try migrating to the nelder mead island p_nm = nm_island.get_population() replacement_policy.replace(p_nm, candidates, candidate_f) nm_island.set_population(p_nm) # finally, try to evolve it new_pop = nm_island.evolve(n=10)
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 run_island(island): import pygmo as pg from multiprocessing import cpu_count from pymemcache.client.base import Client mc_client = Client((island.mc_host, island.mc_port)) #udp = island.problem_factory() algorithm = pg.algorithm(pg.de()) #problem = pg.problem(udp) problem = island.problem_factory() # TODO: configure pop size i = pg.island(algo=algorithm, prob=problem, size=20) mc_client.set(island.domain_qualifier('island', str(island.id), 'status'), 'Running', 10000) mc_client.set(island.domain_qualifier('island', str(island.id), 'n_cores'), str(cpu_count()), 10000) #print('Starting island {} with {} cpus'.format(str(i.id), str(cpu_count()))) i.evolve() i.wait() import socket hostname = socket.gethostname() ip = [ l for l in ([ ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.") ][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)] ][0][1]]) if l ][0][0] return (ip, hostname, i.get_population().problem.get_fevals())
def full_index_refine(self, rec_basis, num_ap, n_isl=20, pop_size=50, gen_num=2000, pos_tol=(0.007, 0.014, 0.06), rb_tol=0.12): """ Return refinement problems archipelago rec_basis - preliminary reciprocal lattice basis vectors matrix num_ap = [num_ap_x, num_ap_y] - convergent beam numerical apertures in x- and y-axes n_isl - number of islands of one frame pop_size - population size gen_num - maximum generations number of the refinement algorithm pos_tol - relative sample position tolerance rb_tol - lattice basis vectors matrix tolerance """ archi = pygmo.archipelago() for frame_idx, frame_strks in enumerate(iter(self)): frame_basis = rec_basis.dot( self.exp_set.rotation_matrix(frame_idx)) prob = frame_strks.rot_index_refine(rec_basis=frame_basis, num_ap=num_ap, pos_tol=pos_tol, rb_tol=rb_tol) pops = [ pygmo.population(size=pop_size, prob=prob, b=pygmo.mp_bfe()) for _ in range(n_isl) ] for pop in pops: archi.push_back(algo=pygmo.de(gen_num), pop=pop) return archi
def test_bidir_chain(): ''' Tests the migration on a one way chain. ''' from sabaody.topology import TopologyFactory import pygmo as pg domain_qual = partial(getQualifiedName, 'com.how2cell.sabaody.test_bidir_chain_migration') problem = pg.problem(pg.rosenbrock(3)) topology_factory = TopologyFactory(island_size=3, domain_qualifier=domain_qual, mc_host='localhost', mc_port=11211) topology = topology_factory.createBidirChain(pg.de(gen=10), number_of_islands=5) assert len(topology.island_ids) == 5 assert len(topology.endpoints) == 2 from sabaody.migration_central import CentralMigrator, start_migration_service from sabaody.migration import MigrationPolicyEachToAll, BestSPolicy, FairRPolicy, sort_by_fitness try: process = start_migration_service() sleep(2) migrator = CentralMigrator(MigrationPolicyEachToAll(), BestSPolicy(migration_rate=1), FairRPolicy(), 'http://localhost:10100') from collections import OrderedDict for k in (1, 2): islands = OrderedDict( (i.id, pg.island(algo=i.algorithm, prob=problem, size=i.size)) for i in topology.islands) for island_id in islands.keys(): migrator.defineMigrantPool(island_id, 3) if k == 1: # test forward migration seed_first(islands, topology) else: # test reverse migration seed_last(islands, topology) for n in range(1, 5 + 1): assert count_hits(islands.values()) == n # perform migration for island_id, i in islands.items(): migrator.sendMigrants(island_id, i, topology) for island_id, i in islands.items(): deltas, src_ids = migrator.receiveMigrants( island_id, i, topology) migrator.purgeAll() finally: process.terminate()
def test1(): algo = pg.algorithm(pg.de(gen=1000, seed=126)) prob = pg.problem(toy_problem()) pop = pg.population(prob=prob, size=10) print(pop.champion_f) pop = algo.evolve(pop) print(pop.champion_f) # fine up to this point archi = pg.archipelago(n=6, algo=algo, prob=prob, pop_size=70) archi.evolve() archi.wait_check()
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.de(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 run_island(i): class Problem: def __init__(self, evaluator, lb, ub): from .utils import expect, check_vector # type: (Evaluator, array, array) -> None ''' Inits the problem with an objective evaluator (implementing the method evaluate), the parameter vector lower bound (a numpy array) and upper bound. Both bounds must have the same dimension. ''' check_vector(lb) check_vector(ub) expect(len(lb) == len(ub), 'Bounds mismatch') self.evaluator = evaluator self.lb = lb self.ub = ub def fitness(self, x): return evaluator.evaluate(x) def get_bounds(self): return (lb,ub) def get_name(self): return 'Sabaody udp' def get_extra_info(self): return 'Sabaody extra info' import pygmo as pg from multiprocessing import cpu_count from b2problem import B2Problem from params import getDefaultParamValues, getLowerBound, getUpperBound from pymemcache.client.base import Client mc_client = Client((i.mc_host,i.mc_port)) #udp = i.problem_factory() algorithm = pg.algorithm(pg.de()) problem = pg.problem(Problem(B2Problem(i.problem_factory), getLowerBound(), getUpperBound())) # TODO: configure pop size #a = pg.archipelago(n=cpu_count,algo=algorithm, prob=problem, pop_size=100) mc_client.set(i.domain_qualifier('island', str(i.id), 'status'), 'Running', 10000) mc_client.set(i.domain_qualifier('island', str(i.id), 'n_cores'), str(cpu_count()), 10000) print('Starting island {} with {} cpus'.format(str(i.id), str(cpu_count()))) #a.evolve(100) return 0
def benchmark_differential_evolution(): island = pg_island(algo=de(gen=10), prob=problem(rosenbrock(5)), size=10) N = 10 print('Differential Evolution (pop. size {})'.format( island.get_population().get_f().size)) for k in range(N): island.evolve() island.wait() d = sqrt( float(((island.get_population().champion_x - rosenbrock(5).best_known())**2).mean())) print('DE {:2}/{}: best fitness {:9.2f}, deviation {:9.2f}, fevals {}'. format(k, N, float(island.get_population().champion_f[0]), d, island.get_population().problem.get_fevals()))
def run_island(island, topology): import pygmo as pg from multiprocessing import cpu_count from pymemcache.client.base import Client from sabaody.migration import BestSPolicy, FairRPolicy from sabaody.migration_central import CentralMigrator mc_client = Client((island.mc_host, island.mc_port)) migrator = CentralMigrator('http://luna:10100') algorithm = pg.de(gen=10) problem = island.problem_constructor() # TODO: configure pop size i = pg.island(algo=algorithm, prob=problem, size=20) mc_client.set(island.domain_qualifier('island', str(island.id), 'status'), 'Running', 10000) mc_client.set(island.domain_qualifier('island', str(island.id), 'n_cores'), str(cpu_count()), 10000) rounds = 10 migration_log = [] for x in range(rounds): i.evolve() i.wait() # perform migration migrator.sendMigrants(island.id, i, topology) deltas, src_ids = migrator.receiveMigrants(island.id, i, topology) """ For Kafka Migration Enable below """ #migrator.send_migrants(island.id,i,topology,generation=x) #deltas,src_ids = migrator.receive_migrants(island.id,i,topology,generation=x) migration_log.append((float(pop.champion_f[0]), deltas, src_ids)) import socket hostname = socket.gethostname() ip = [ l for l in ([ ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.") ][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)] ][0][1]]) if l ][0][0] return (ip, hostname, island.id, migration_log, i.get_population().problem.get_fevals())
def solver(dimension, lower_bound, upper_bound, optim, bias, popsize): global algo global pop global niter global log global curve prob = pg.problem( rosenbrock_prob(dimension, lower_bound, upper_bound, optim, bias)) algo = pg.algorithm( pg.de(gen=3000, F=0.8, CR=0.9, variant=3, ftol=1e-06, xtol=1e-06)) algo.set_verbosity(1) pop = pg.population(prob, popsize) pop = algo.evolve(pop) log = algo.extract(pg.de).get_log() curve = [x[2] for x in log] niter = log[-1][0] return prob, algo, pop, log, niter, curve
def benchmark_differential_evolution(generations): island = pg_island( algo=de(gen=generations), prob=B2_UDP(getLowerBound(),getUpperBound(),'../../../../../sbml/b2.xml'), size=10) N = 50 import arrow time_start = arrow.utcnow() print('Differential Evolution (pop. size {})'.format(island.get_population().get_f().size)) for k in range(N): island.evolve() island.wait() delta_t = arrow.utcnow() - time_start print('DE {:2}/{}: best fitness {:9.2f}, fevals {}, duration {}'.format( k,N,float(island.get_population().champion_f[0]), island.get_population().problem.get_fevals(), delta_t))
def fit(self, function, with_global_optimization=True, quiet=False): if no_threeml: raise RuntimeError('No 3ML!') self._ps = PointSource(self._band, 0, 0, spectral_shape=function) self._model = Model(self._ps) self._xyl = XYLike('band_%s' % (self._band), self._normalized_time, self._flux, self._error) self._jl = JointLikelihood(self._model, DataList(self._xyl)) if with_global_optimization: pagmo_minimizer = GlobalMinimization("pagmo") my_algorithm = pygmo.algorithm(pygmo.de(gen=25)) # Create an instance of a local minimizer local_minimizer = LocalMinimization("ROOT") # Setup the global minimization pagmo_minimizer.setup( second_minimization=local_minimizer, algorithm=my_algorithm, islands=10, population_size=15, evolution_cycles=5) self._jl.set_minimizer(pagmo_minimizer) else: self._jl.set_minimizer('ROOT') try: _ = self._jl.fit(quiet=quiet) except: print('Fit FAILED') self._jl = None
async def optimize(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) hook_report = itemgetter('report')(hooks) algo = pg.algorithm(pg.de(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) if hook_report: hook_report(gbest) return gbest
print(archi) archi.evolve() 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],
""" As a second step, we have to create an algorithm to solve the problem. Many different algorithms are available through PyGMO, including heuristic methods and local optimizers. In this example, we will use the Differential Evolution (DE). Similarly to the UDP, it is also possible to create a User-Defined Algorithm (UDA), but in this tutorial we will use an algorithm readily available in PyGMO. [This webpage](See also https://esa.github.io/pygmo2/overview.html#list-of-algorithms) offers a list of all of the PyGMO optimisation algorithms that are available. See also [this tutorial](https://esa.github.io/pygmo2/tutorials/using_algorithm.html) on PyGMO algorithms. """ # Define number of generations number_of_generations = 1 # Fix seed current_seed = 171015 # Create Differential Evolution object by passing the number of generations as input de_algo = pygmo.de(gen=number_of_generations, seed=current_seed) # Create pygmo algorithm object algo = pygmo.algorithm(de_algo) # Print the algorithm's information print(algo) ## Initialise population """ A population in PyGMO is essentially a container for multiple individuals. Each individual has an associated decision vector which can change (evolution), the resulting fitness vector, and an unique ID to allow their tracking. The population is initialized starting from a specific problem to ensure that all individuals are compatible with the UDP. The default population size is 0. """ # Set population size pop_size = 1000
def run_island(id): class B2_UDP: def __init__(self, lb, ub): # type: (Evaluator, array, array) -> None ''' Inits the problem with an objective evaluator (implementing the method evaluate), the parameter vector lower bound (a numpy array) and upper bound. Both bounds must have the same dimension. ''' from sabaody.utils import check_vector, expect check_vector(lb) check_vector(ub) expect(len(lb) == len(ub), 'Bounds mismatch') self.lb = lb self.ub = ub from b2problem import B2Problem self.evaluator = B2Problem('b2.xml') def fitness(self, x): return (self.evaluator.evaluate(x), ) def get_bounds(self): return (self.lb, self.ub) def get_name(self): return 'Sabaody udp' def get_extra_info(self): return 'Sabaody extra info' def __getstate__(self): return {'lb': self.lb, 'ub': self.ub} def __setstate__(self, state): self.lb = state['lb'] self.ub = state['ub'] from b2problem import B2Problem self.evaluator = B2Problem('b2.xml') import pygmo as pg from pymemcache.client.base import Client mc_client = Client(('luna', 11211)) algorithm = pg.algorithm(pg.de(gen=1000)) from params import getLowerBound, getUpperBound problem = pg.problem(B2_UDP(getLowerBound(), getUpperBound())) i = pg.island(algo=algorithm, prob=problem, size=20) #mc_client.set(id.domain_qualifier('island', str(id), 'status'), 'Running', 10000) i.evolve() i.wait() import socket hostname = socket.gethostname() ip = [ l for l in ([ ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.") ][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)] ][0][1]]) if l ][0][0] return (ip, hostname)
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 main(): ########################################################## # CREATE PROBLEM ######################################### ########################################################## """ First, we define the Pygmo problem by using the UDP class defined above. Note that an instantiation of the UDP class must be passed as input to pygmo.problem() and NOT the class itself. It is also possible to use a PyGMO UDP, i.e. a problem that is already defined in PyGMO, but it will not be shown in this tutorial. See also: https://esa.github.io/pygmo2/tutorials/using_problem.html. """ # Instantiation of the UDP problem udp = HimmelblauOptimization(-5.0, 5.0, -5.0, 5.0) # Creation of the pygmo problem object prob = pygmo.problem(udp) # Print the problem's information print('\n########### PRINTING PROBLEM INFORMATION ###########\n') print(prob) ########################################################## # CREATE ALGORITHM ####################################### ########################################################## """ As a second step, we have to create an algorithm to solve the problem. Many different algorithms are available through PyGMO, including heuristic methods and local optimizers. In this example, we will use the Differential Evolution (DE). Similarly to the UDP, it is also possible to create a User-Defined Algorithm (UDA), but in this tutorial we will use an algorithm readily available in PyGMO. See also: https://esa.github.io/pygmo2/tutorials/using_algorithm.html. """ # Define number of generations number_of_generations = 1 # Fix seed current_seed = 171015 # Create Differential Evolution object by passing the number of generations as input # NOTE: specific inputs for different pygmo algorithms may vary, check each algorithm's documentation # See also https://esa.github.io/pygmo2/overview.html#list-of-algorithms de_algo = pygmo.de(gen=number_of_generations, seed=current_seed) # Create pygmo algorithm object algo = pygmo.algorithm(de_algo) # Print the algorithm's information print('\n########### PRINTING ALGORITHM INFORMATION ###########\n') print(algo) ########################################################## # INITIALIZE POPULATION ################################## ########################################################## """ A population in PyGMO is essentially a container for multiple individuals. Each individual has an associated decision vector which can change (evolution), the resulting fitness vector, and an unique ID to allow their tracking. The population is initialized starting from a specific problem to ensure that all individuals are compatible with the UDP. The default population size is 0. """ # Set population size pop_size = 1000 # Set seed current_seed = 171015 # Create population pop = pygmo.population(prob, size=pop_size, seed=current_seed) # Inspect population (this is going to be long, uncomment if desired) # print('\n########### PRINTING POPULATION INFORMATION ###########\n') # print(pop) ########################################################## # EVOLVE POPULATION ###################################### ########################################################## # Set number of evolutions number_of_evolutions = 100 # Initialize empty containers individuals_list = [] fitness_list = [] # Evolve population multiple times for i in range(number_of_evolutions): pop = algo.evolve(pop) individuals_list.append(pop.get_x()[pop.best_idx()]) fitness_list.append(pop.get_f()[pop.best_idx()]) # At the end of the evolution(s), we extract the best individual print('\n########### PRINTING CHAMPION INDIVIDUALS ###########\n') # Print its fitness value print('Fitness (= function) value: ', pop.champion_f) # Print its decision variable vector print('Decision variable vector: ', pop.champion_x) # Print the number of function evaluations (calls to the fitness function) print('Number of function evaluations: ', pop.problem.get_fevals()) # Print the difference wrt to the minimum location print('Difference wrt the minimum: ', pop.champion_x - np.array([3, 2])) ########################################################## # VISUALIZE OPTIMIZATION ################################# ########################################################## # Set font size for plots font = {'size': 18} matplotlib.rc('font', **font) # Extract best individuals for each generation best_x = [ind[0] for ind in individuals_list] best_y = [ind[1] for ind in individuals_list] # Extract problem bounds (x_min, y_min), (x_max, y_max) = udp.get_bounds() # Plot fitness over generations fig, ax = plt.subplots(figsize=(16, 4)) ax.plot(np.arange(0, number_of_evolutions), fitness_list, label='Function value') # Plot champion champion_n = np.argmin(np.array(fitness_list)) ax.scatter(champion_n, np.min(fitness_list), marker='x', color='r', label='All-time champion') # Prettify ax.set_xlim((0, number_of_evolutions)) ax.grid('major') ax.set_title('Best individual of each generation', fontweight='bold') ax.set_xlabel('Number of generation') ax.set_ylabel(r'Himmelblau function value $f(x,y)$') ax.legend(loc='upper right') plt.savefig('fitness_himmelblau.png', bbox_inches='tight') # Plot Himmelblau function grid_points = 100 x_vector = np.linspace(x_min, x_max, grid_points) y_vector = np.linspace(y_min, y_max, grid_points) x_grid, y_grid = np.meshgrid(x_vector, y_vector) z_grid = np.zeros((grid_points, grid_points)) for i in range(x_grid.shape[1]): for j in range(x_grid.shape[0]): z_grid[i, j] = himmelblau_function([x_grid[i, j], y_grid[i, j]]) # Create figure fig, ax = plt.subplots(figsize=(16, 10)) cs = ax.contour(x_grid, y_grid, z_grid, 50) # Plot best individuals of each generation ax.scatter(best_x, best_y, marker='x', color='r') # Prettify ax.set_xlim((x_min, x_max)) ax.set_ylim((y_min, y_max)) ax.set_title('Himmelblau function', fontweight='bold') ax.set_xlabel('X-coordinate') ax.set_ylabel('Y-coordinate') cbar = fig.colorbar(cs) cbar.ax.set_ylabel(r'Himmelblau function value $f(x,y)$') plt.savefig('contour_himmelblau.png', bbox_inches='tight') # Visualize only one minimum eps = 1E-3 x_min, x_max = (3 - eps, 3 + eps) y_min, y_max = (2 - eps, 2 + eps) grid_points = 100 x_vector = np.linspace(x_min, x_max, grid_points) y_vector = np.linspace(y_min, y_max, grid_points) x_grid, y_grid = np.meshgrid(x_vector, y_vector) z_grid = np.zeros((grid_points, grid_points)) for i in range(x_grid.shape[1]): for j in range(x_grid.shape[0]): z_grid[i, j] = himmelblau_function([x_grid[i, j], y_grid[i, j]]) fig, ax = plt.subplots(figsize=(16, 10)) cs = ax.contour(x_grid, y_grid, z_grid, 50) # Plot best individuals of each generation ax.scatter(best_x, best_y, marker='x', color='r', label='Best individual of each generation') ax.scatter(pop.champion_x[0], pop.champion_x[1], marker='x', color='k', label='Champion') # Prettify ax.xaxis.set_major_formatter(mtick.FormatStrFormatter('%1.5f')) ax.yaxis.set_major_formatter(mtick.FormatStrFormatter('%1.5f')) plt.xticks(rotation=45) ax.set_xlim((x_min, x_max)) ax.set_ylim((y_min, y_max)) ax.set_title('Vicinity of (3,2)', fontweight='bold') ax.set_xlabel('X-coordinate') ax.set_ylabel('Y-coordinate') cbar = fig.colorbar(cs) cbar.ax.set_ylabel(r'Himmelblau function value $f(x,y)$') ax.legend(loc='lower right') ax.grid('major') plt.savefig('one_minimum_himmelblau.png', bbox_inches='tight') ########################################################## # GRID SEARCH ############################################ ########################################################## # Set number of points number_of_nodes = 1000 # Extract problem bounds (x_min, y_min), (x_max, y_max) = udp.get_bounds() x_vector = np.linspace(x_min, x_max, number_of_nodes) y_vector = np.linspace(y_min, y_max, number_of_nodes) x_grid, y_grid = np.meshgrid(x_vector, y_vector) z_grid = np.zeros((number_of_nodes, number_of_nodes)) for i in range(x_grid.shape[1]): for j in range(x_grid.shape[0]): z_grid[i, j] = himmelblau_function([x_grid[i, j], y_grid[i, j]]) best_f = np.min(z_grid) best_ind = np.argmin(z_grid) best_x = (x_grid.flatten()[best_ind], y_grid.flatten()[best_ind]) print('\n########### RESULTS OF GRID SEARCH (' + str(number_of_nodes) + ' nodes per variable) ########### ') print( 'Best fitness with grid search (' + str(number_of_nodes) + ' points):', best_f) print('Decision variable vector: ', best_x) print('Number of function evaluations: ', number_of_nodes**2) print('Difference wrt the minimum: ', best_x - np.array([3, 2])) del number_of_nodes ########################################################## # MONTE-CARLO SEARCH ##################################### ########################################################## # Fix seed (for reproducibility) random.seed(current_seed) # Size of random number vector number_of_points = 1000 x_vector = random.random(number_of_points) x_vector *= (x_max - x_min) x_vector += x_min y_vector = random.random(number_of_points) y_vector *= (y_max - y_min) y_vector += y_min x_grid, y_grid = np.meshgrid(x_vector, y_vector) z_grid = np.zeros((number_of_points, number_of_points)) for i in range(x_grid.shape[1]): for j in range(x_grid.shape[0]): z_grid[i, j] = himmelblau_function([x_grid[i, j], y_grid[i, j]]) best_f = np.min(z_grid) best_ind = np.argmin(z_grid) best_x = (x_grid.flatten()[best_ind], y_grid.flatten()[best_ind]) print('\n########### RESULTS OF MONTE-CARLO SEARCH (' + str(number_of_points) + ' points per variable) ' + '########### ') print( 'Best fitness with grid search (' + str(number_of_points) + ' points):', best_f) print('Decision variable vector: ', best_x) print('Number of function evaluations: ', number_of_points**2) print('Difference wrt the minimum: ', best_x - np.array([3, 2])) del number_of_points # Show plot plt.show()
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')
from rbsetup import RBRun from numpy import array, save, savez, mean, std, nan_to_num, vstack from tempfile import gettempdir from os.path import join import json single_champions = [] N = 100 for i in range(N): with RBRun('luna', 11211) as run: print('Started run {} of {}'.format(i + 1, N)) from rbsetup import make_problem algorithm = pg.de(gen=10) problem = make_problem() i = pg.island(algo=algorithm, prob=problem, size=20) rounds = 10 c = [] for x in range(rounds): i.evolve() i.wait() c.append(float(i.get_population().champion_f[0])) print('round {}'.format(x)) print(i.get_population().champion_f) print(i.get_population().get_x()[0, :]) single_champions.append(array(c)) single_champions_stack = vstack(single_champions)
def make_algorithm(): return pg.de(gen=10)
bounds = {'S_LB':SPACE_L, 'S_UB':SPACE_U} obj = {'CLIENTS':clients, 'RADIUS':50.0, 'COSTS':1.0} area = 1000*1000 mp = wap_problem(area,bounds,obj) prob = pg.problem(mp) print(prob) sol_eval = SolutionEvaluer(mp) #t = [np.random.rand() for i in range(400)] # f = prob.fitness(t) # print(str(f)) # print(prob) gen = 10 F = 0.7 CR = 0.85 seed = 7 algo = pg.algorithm(pg.de(gen,F,CR)) #algo = pg.algorithm(pg.moead(gen=250)) #algo = pg.algorithm(pg.sga(gen = gen)) algo.set_verbosity(50) # # #SINGOLA EVOLUZIONE # pop = pg.population(prob, size=30, seed=seed) # start = time.time() # pop = algo.evolve(pop) # stop = time.time() - start # best = pop.get_x()[pop.best_idx()] # print("Champion's Fitness: \t"+str(pop.champion_f)+"\t time: "+str(stop)) # sol_eval.plot(best) # #MULTICORE archi = pg.archipelago(4, algo=algo, prob=prob, pop_size=30) archi.evolve(4) archi.wait()
for (clf_name, lb, ub, fun, args, random_seed) in optimizers: print(clf_name, fun, random_seed) np.random.seed(random_seed) # init=lhsu(lb,ub,pop_size) # latin hypercube sampling strategy # res = de(func=fun, bounds=tuple(zip(lb,ub)), args=args, maxiter=max_iter, # init=init, seed=run, disp=True, polish=False, # strategy='best1bin', tol=1e-6) # # xopt, fopt = res['x'], res['fun'] # sim = fun(xopt, *(X,y,'run',n_splits,random_seed)) # sim['ALGO'] = 'DE' #algo = pg.algorithm(pg.de1220(gen = max_iter, seed=random_seed)) algo = pg.algorithm( pg.de(gen=max_iter, variant=1, seed=random_seed)) #algo = pg.algorithm(pg.pso(gen = max_iter, seed=random_seed)) #algo = pg.algorithm(pg.ihs(gen = max_iter*pop_size, seed=random_seed)) #algo = pg.algorithm(pg.gwo(gen = max_iter, seed=random_seed)) #algo = pg.algorithm(pg.sea(gen = max_iter, seed=random_seed)) #algo = pg.algorithm(pg.sade(gen = max_iter, seed=random_seed)) #algo = pg.algorithm(pg.sga(gen = max_iter, m=0.10, crossover = "sbx", mutation = "gaussian", seed=random_seed)) #algo = pg.algorithm(pg.cmaes(gen = max_iter, force_bounds = True, seed=random_seed)) #algo = pg.algorithm(pg.xnes(gen = max_iter, memory=False, force_bounds = True, seed=random_seed)) #algo = pg.algorithm(pg.simulated_annealing(Ts=100., Tf=1e-5, n_T_adj = 100, seed=random_seed)) algo.set_verbosity(1) prob = pg.problem(evoML(args, fun, lb, ub)) pop = pg.population(prob, pop_size, seed=random_seed) pop = algo.evolve(pop) xopt = pop.champion_x
def run_DE_optmization_train_ml_methods(datasets, name_opt, \ de_run0 = 0, de_runf = 1, de_pop_size=50, de_max_iter=50, \ kf_n_splits=5, \ save_basename='host_guest_ml___', save_test_size = '', save_file_erro_train = True): ''' # lista com todos os possiveis algoritmos otmizadores para o DE list_opt_name = ['EN', 'XGB', 'DTC', 'VC', 'BAG', 'KNN', 'ANN', 'ELM', 'SVM', 'MLP', 'GB', 'KRR', 'CAT'] de_pop_size: tamanho da populacao de individuos de_max_iter: quantidade maxima de iteracoes do DE kf_n_splits: usado no K-fold de_run0: de_runf: ''' # save_path = './RESULTADOS/MACHINE_LEARNING/PKL/' try: os.mkdir('./RESULTADOS/MACHINE_LEARNING/') except: pass # try: # os.mkdir(save_path) # except: # pass for run in range(de_run0, de_runf): random_seed = run * 10 + 100 np.random.seed(random_seed) for dataset in datasets: #[:1]: # Definicao das variaveis associadas aos datasets target, y_ = dataset['target_names'], dataset['y_train'] dataset_name, X_ = dataset['name'], dataset['X_train'] n_samples, n_features = dataset['n_samples'], dataset['n_features'] task = dataset['task'] list_results_all = [] print('=' * 80 + '\n' + dataset_name + ': ' + target + '\n' + '=' * 80 + '\n') # defindo o target y conforme a task associada if task == 'classification': le = preprocessing.LabelEncoder() #le=preprocessing.LabelBinarizer() le.fit(y_) y = le.transform(y_) else: y = y_.copy() #TODO: precisei pegar o indice 0 para funcionar X = X_.copy() ##scale_X = MinMaxScaler(feature_range=(0.15,0.85)).fit(X_) #scale_X = MinMaxScaler(feature_range=(0,1)).fit(X_) #X= scale_X.transform(X_) ## scale_y = MinMaxScaler(feature_range=(0.15,0.85)).fit(y_) ## X,y = scale_X.transform(X_), scale_y.transform(y_) args = (X, y, 'eval', kf_n_splits, random_seed) # lista das opcoes de algoritmos selecionados da lista acima optimizers = [(name, *get_parameters(name), args, random_seed) for name in name_opt] for (clf_name, lb, ub, fun, args, random_seed) in optimizers: print() print(clf_name, '%test_size:', save_test_size) print() PATH = './RESULTADOS/MACHINE_LEARNING/' + str.upper( clf_name) + '/' try: os.mkdir(PATH) except: pass try: os.mkdir(PATH + 'CSV_ERROR_TRAIN/') except: pass try: os.mkdir(PATH + 'PKL/') except: pass list_results = [] #print(clf_name, random_seed) #print(clf_name, fun, random_seed) np.random.seed(random_seed) t0 = time.time() algo = pg.algorithm( pg.de(gen=de_max_iter, variant=1, seed=random_seed)) algo.set_verbosity(1) prob = pg.problem(evoML(args, fun, lb, ub)) pop = pg.population(prob, de_pop_size, seed=random_seed) pop = algo.evolve(pop) xopt = pop.champion_x sim = fun( xopt, *(X.to_numpy(), y, 'run', kf_n_splits, random_seed)) #TODO: verificar inserção do to_numpy() t1 = time.time() sim['ALGO'] = algo.get_name() sim['ACTIVE_VAR_NAMES'] = dataset['var_names'][ sim['ACTIVE_VAR']] if task == 'classification': sim['Y_TRAIN_TRUE'] = le.inverse_transform(sim['Y_TRUE']) sim['Y_TRAIN_PRED'] = le.inverse_transform(sim['Y_PRED']) else: # TODO: pq isso mds? sim['Y_TRAIN_TRUE'] = sim['Y_TRUE'] sim['Y_TRAIN_PRED'] = sim['Y_PRED'] sim['RUN'] = run #sim['Y_NAME']=yc sim['DATASET_NAME'] = dataset_name sim['time'] = t1 - t0 pd.Series(sim['ERROR_TRAIN']).to_csv( PATH + "CSV_ERROR_TRAIN/error_train_" + clf_name + "_%test_size_" + save_test_size + ".csv", header=False) # Erros no teste #TODO: precisei converter pra numpy pra dar certo. Conferir # erros no teste no evaluate? # mach = sim['ESTIMATOR'] # y_p = mach.predict(dataset['X_test'].to_numpy()) # y_t = dataset['y_test'] # r = RMSE(y_t, y_p) # r2 = MAPE(y_t, y_p) # r3 = RRMSE(y_t, y_p) # sim['ERROR_TEST'] = {'RMSE': r, 'MAPE': r2, 'RRMSE': r3} pk = ( PATH + 'PKL/' + save_basename + '_run_' + str("{:02d}".format(run)) + '_' + dataset_name + '_' + os.uname()[1] + '__' + str.lower(sim['EST_NAME']) + '__' + target + '__%test_size_' + save_test_size + #time.strftime("%Y_%m_%d_") + time.strftime("_%Hh_%Mm_%S")+ #'_loo'+ '.pkl') pk = pk[0].replace(' ', '_').replace("'", "") # pk=pk[0].replace(' ','_').replace("'","").lower() #TODO: precisei pegar o indice 0 para funcionar sim['name_pickle'] = pk list_results.append(sim) list_results_all.append(sim) # data = pd.DataFrame(list_results) # data.to_pickle(pk) pm = pk.replace('.pkl', '.dat') pickle.dump(sim['ESTIMATOR'], open(pm, "wb")) return list_results_all
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)")
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)) print(pop.champion_f) print(pop.champion_x) # Estudio algo = pg.algorithm(pg.de(gen=50)) 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) # Comparacion metodos: # PSO se demora menos que el bee_colony y llega a resultados simulares
import sampler_test_tool import numpy as np from scipy import optimize import vprofile, vmodel import pygmo as pg # from pygmo import * prob = pg.problem(sampler_test_tool.disp_func()) algo = pg.algorithm(pg.de(gen=1000)) algo.set_verbosity(10) pop = pg.population(prob, 20) pop = algo.evolve(pop) # from pygmo import * # algo = algorithm(de(gen = 500)) # algo.set_verbosity(100) # prob = problem(rosenbrock(10)) # pop = population(prob, 20) # pop = algo.evolve(pop)
def _setup_algorithm(self, parameters): alg = pg.de(**self._alg_attrs) return alg