def genetic_algorithm(explr_p): prob = pg.problem(GeneticAlgoProblem()) #sade = pg.sade(gen=1, ftol=1e-20, xtol=1e-20) population_size = 5 if obj_fcn == 'griewank' or dim_x == 3: total_evals = 500 elif obj_fcn == 'shekel' and dim_x == 20: total_evals = 5000 else: total_evals = 1000 generations = total_evals / population_size optimizer = pg.cmaes(gen=generations, ftol=1e-20, xtol=1e-20) algo = pg.algorithm(optimizer) algo.set_verbosity(1) pop = pg.population(prob, size=population_size) pop = algo.evolve(pop) print pop.champion_f champion_x = pop.champion_x uda = algo.extract(pg.cmaes) log = np.array(uda.get_log()) n_fcn_evals = log[:, 1] pop_best_at_generation = -log[:, 2] evaled_x = None evaled_y = pop_best_at_generation max_y = [pop_best_at_generation[0]] for y in pop_best_at_generation[1:]: if y > max_y[-1]: max_y.append(y) else: max_y.append(max_y[-1]) return evaled_x, evaled_y, max_y, 0
def cma_es(problem, population_size, params): ''' Execute the Pygmo CMA_ES algorithm on an optimisation problem with the population size and parameters specified. The CMA_ES possible set of parameters are: * sigma0: initial step size * ftol: stopping criteria on the function tolerance * xtol: stopping criteria on the step tolerance Parameters ---------- - problem: the problem to optimise. It must comply to the Pygmo requirements, i.e. being an instance of an UDP class - population_size: The size of the population - params: dictionnary of parameters for the CMA_ES algorithm Return ------ - log: the logs of the execution of the optimisation problem with the population size - duration: the total duration of the resolution of the problem ''' # Extract algorithm parameters nb_generation = params["nb_generation"] sigma0 = params["sigma0"] ftol = params["ftol"] xtol = params["xtol"] algo = pg.algorithm( pg.cmaes(gen=nb_generation, sigma0=sigma0, ftol=ftol, xtol=xtol)) algo.set_verbosity(1) solution = pg.population(problem, size=population_size, b=None) startt = datetime.now() solution = algo.evolve(solution) duration = (datetime.now() - startt) uda = algo.extract(pg.cmaes) log = uda.get_log() return (log, duration, solution.champion_f, solution.champion_x)
def run_example1(impulses=4): import pykep as pk import pygmo as pg import numpy as np from matplotlib import pyplot as plt from pykep.examples import add_gradient, algo_factory # problem udp = add_gradient(pk.trajopt.pl2pl_N_impulses( start=pk.planet.jpl_lp('earth'), target=pk.planet.jpl_lp('venus'), N_max=impulses, tof=[100., 1000.], vinf=[0., 4], phase_free=False, multi_objective=False, t0=[pk.epoch(0), pk.epoch(1000)]), with_grad=False) prob = pg.problem(udp) # algorithm uda = pg.cmaes(gen=1000, force_bounds=True) algo = pg.algorithm(uda) algo.set_verbosity(10) # population pop = pg.population(prob, 20) # solve the problem pop = algo.evolve(pop) # inspect the solution udp.udp_inner.plot(pop.champion_x) plt.ion() plt.show() udp.udp_inner.pretty(pop.champion_x)
def minimize(self, fun, bounds, guess=None, sdevs=0.3, rg=Generator(MT19937()), store=None): gen = int(self.max_eval_num(store) / self.popsize + 1) algo = pg.algorithm( pg.cmaes(gen=gen, force_bounds=True, sigma0=np.mean(sdevs), seed=int(rg.uniform(0, 2**32 - 1)))) udp = pygmo_udp(fun, bounds) prob = pg.problem(udp) pop = pg.population(prob, self.popsize) if not guess is None: scale = np.multiply(0.5 * (bounds.ub - bounds.lb), sdevs) for i in range(self.popsize): xi = np.random.normal(guess, scale) xi = np.maximum(np.minimum(xi, bounds.ub), bounds.lb) pop.set_x(i, xi) pop = algo.evolve(pop) return pop.champion_x, pop.champion_f, pop.problem.get_fevals()
def cmaes(objective_function, gen=1000, cc=-1, cs=-1, c1=-1, cmu=-1, sigma0=0.5, ftol=1e-06, xtol=1e-06, memory=False, force_bounds=True, pop_size=15): """ Covariance Matrix Evolutionary Strategy (CMA-ES) Parameters - gen (int) – number of generations - cc (float) – backward time horizon for the evolution path (by default is automatically assigned) - cs (float) – makes partly up for the small variance loss in case the indicator is zero (by default is automatically assigned) - c1 (float) – learning rate for the rank-one update of the covariance matrix (by default is automatically assigned) - cmu (float) – learning rate for the rank-mu update of the covariance matrix (by default is automatically assigned) - sigma0 (float) – initial step-size - ftol (float) – stopping criteria on the x tolerance - xtol (float) – stopping criteria on the f tolerance - memory (bool) – when true the adapted parameters are not reset between successive calls to the evolve method - force_bounds (bool) – when true the box bounds are enforced. The fitness will never be called outside the bounds but the covariance matrix adaptation mechanism will worsen - pop_size (int) – the number of individuals """ logs = [] problem = pg.problem(objective_function) algorithm = pg.algorithm( pg.cmaes(gen=gen, cc=cc, cs=cs, c1=c1, cmu=cmu, sigma0=sigma0, ftol=ftol, xtol=xtol, force_bounds=force_bounds, memory=memory)) algorithm.set_verbosity(50) solution = pg.population(prob=problem, size=pop_size, b=None, seed=None) solution = algorithm.evolve(solution) """ get_logs output is a list of tuples with the following structure: - Gen (int), generation number - Fevals (int), number of functions evaluation made - Best (float), the best fitness function currently in the population - dx (float), the norm of the distance to the population mean of the mutant vectors - df (float), the population flatness evaluated as the distance between the fitness of the best and of the worst individual - sigma (float), the current step-size """ logs = np.array(algorithm.extract(pg.cmaes).get_log())[:, ( 1, 2)] # taking only function evaluations and best fitness algo_ = algorithm.get_name() function_ = objective_function.get_name() return { 'champion solution': solution.champion_f, 'champion coordinates': solution.champion_x, 'log': logs, 'algorithm': algo_, 'problem': function_ }
import time generations = 500 sizePop = 25 library = 1 #pathsave = '/home/oscar/Documents/PythonProjects/kuramotoAO/optimizationResults/' pathsave = '/Users/p277634/python/kaoModel/optimResult/' filenameTXT = 'CMAES_constrins.txt' filenameNPZ = 'CMAES_constrins.npz' # algorithm algo = po.algorithm(po.cmaes(gen=generations, force_bounds=True, ftol=1e-4, xtol=1e-4)) algo.set_verbosity(5) # problem prob = po.problem(myUDPkaos.KAOsimpleSimuConstr(lib=library)) # population pop = po.population(prob=prob,size=sizePop) # evolution start = time.time() popE = algo.evolve(pop) print('time evolution: ',time.time()-start) # save TXT fie with general description of the optimization
""" import pygmo as po import numpy as np import myUDP import time generations = 400 sizePop = 15 #pathsave = '/home/oscar/Documents/PythonProjects/kuramotoAO/optimizationResults/' pathsave = '/Users/p277634/python/kaoModel/optimResult/' filenameTXT = 'CMAES_cabral.txt' filenameNPZ = 'CMAES_cabral.npz' # algorithm algo = po.algorithm( po.cmaes(gen=generations, force_bounds=True, ftol=1e-4, xtol=1e-4)) algo.set_verbosity(5) # problem prob = po.problem(myUDP.kMcabral()) # population pop = po.population(prob=prob, size=sizePop) # 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'
udp = mga(seq=seq, t0=[-1000., 0.], tof=[[30, 400], [100, 470], [30, 400], [400, 2000], [1000, 6000]], vinf=3., tof_encoding='direct', orbit_insertion=True, e_target=0.98, rp_target=108950000) udp = mga(seq=seq, t0=[-1000., 0.], tof=7000., vinf=3., tof_encoding='eta', orbit_insertion=True, e_target=0.98, rp_target=108950000) #udp = mga(seq=seq, t0=[-1000., 0.], tof=[[130,200], [430,470], [30, 70], [900, 1200], [4000, 5000]], vinf=0., alpha_encoding=False) prob = pg.problem(udp) uda = pg.cmaes(1500, force_bounds=True, sigma0=0.5, ftol=1e-4) #uda = pg.sade(4500) algo = pg.algorithm(uda) algo.set_verbosity(10) res = list() # for i in range(100): pop = pg.population(prob, 100) pop = algo.evolve(pop) res.append(pop.champion_f)
# In[72]: pop = pg.population(prob,1) ax = prob.plot(pop.champion_x) plt.show() print (prob.pretty(pop.champion_x)) # Evolution et inspection d'une bonne solution # In[73]: algo = pg.algorithm(pg.cmaes(gen = 2500, force_bounds = True)) # sans force_bounds = True j'obtenais des erreurs l = list() for i in range (10) : pop = pg.population(prob,10) pop = algo.evolve(pop) print (pop.champion_f) l.append((pop.champion_f,pop.champion_x)) l = sorted(l, key = lambda x: x[0]) print (l) print (l[0]) # In[74]:
import pygmo as pg import numpy as np prob = pg.problem(pg.cec2014(prob_id=5, dim=10)) algo = pg.algorithm(pg.cmaes(gen=100)) archi = pg.archipelago(8, algo=algo, prob=prob, pop_size=20) archi.evolve(1000) archi.wait() res = [isl.get_population().champion_f for isl in archi] res = np.array(res) print(f"Problem {5}: {res.mean()}")
def _setup_algorithm(self, parameters): alg = pg.cmaes(**self._alg_attrs) return alg
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 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 fit_data(data, init=None, optlib="scipy", algo="L-BFGS-B", grad=True, printfinal=None, printsteps=None): if printfinal is None: printfinal = True if init is None: init = data.init print(init) print(like_model(init, data)) data.printsteps = printsteps data.stepnum = 0 if optlib == "scipy": def neg_like_model(params, pdata): return -like_model(params, pdata) tinit = time.time() result = optimize.minimize(neg_like_model, init, args=(data,), method=algo, bounds=data.bounds, options={'disp':True}) paramsbest = result.x elif optlib == "pygmo": boundslower = [data.bounds[i][0] for i in range(len(data.bounds))] boundsupper = [data.bounds[i][1] for i in range(len(data.bounds))] class profit_udp: def fitness(self, x): return [-like_model(x, data=data)] def get_bounds(self): return boundslower, boundsupper class profit_udp_grad: def fitness(self, x): return [-like_model(x, data=data)] def get_bounds(self): return boundslower, boundsupper def gradient(self, x): return pg.estimate_gradient(lambda x: self.fitness(x), x) algocmaes = algo == "cmaes" algonlopt = not algocmaes if algocmaes: uda = pg.cmaes() elif algonlopt: uda = pg.nlopt(algo) algo = pg.algorithm(uda) # algo.extract(pg.nlopt).ftol_rel = 1e-6 if algonlopt: algo.extract(pg.nlopt).ftol_abs = 1e-3 algo.set_verbosity(0) if grad: prob = pg.problem(profit_udp_grad()) else: prob = pg.problem(profit_udp()) pop = pg.population(prob=prob, size=0) if algocmaes: npop = 5 npushed = 0 while npushed < npop: try: pop.push_back(init + np.random.normal(np.zeros(np.sum(data.tofit)), data.sigmas[data.tofit])) npushed += 1 except: pass else: pop.push_back(init) tinit = time.time() result = algo.evolve(pop) paramsbest = result.champion_x else: raise ValueError("Unknown optimization library " + optlib) timerun = time.time() - tinit if printfinal: print("Elapsed time: {:.1f}".format(timerun)) verbosity = data.verbose data.verbose = True print("Final likelihood:") like_model(paramsbest, data) data.verbose = verbosity print("Parameter names: " + ",".join(["{:10s}".format(i) for i in data.names[data.tofit]])) print("Scaled parameters: " + ",".join(["{:.4e}".format(i) for i in paramsbest])) # TODO: These should be methods in the data object paramstransformed = paramsbest * data.sigmas[data.tofit] print("Parameters (logged): " + ",".join(["{:.4e}".format(i) for i in paramstransformed])) paramslinear = copy.copy(paramstransformed) paramslinear[data.tolog[data.tofit]] = 10 ** paramslinear[data.tolog[data.tofit]] print("Parameters (unlogged): " + ",".join(["{:.4e}".format(i) for i in paramslinear])) return paramsbest, paramstransformed, paramslinear, timerun, data