def gen_pop(seed, algos, pop_size):
prob = pg.problem(sfunc_inst)
if nlopt and not seed:
algo = pg.algorithm(pg.nlopt(solver="cobyla"))
print('[swarms:]'.ljust(15, ' ') + 'On seed ' + str(seed) +
' creating ' + algo.get_name())
algo.extract(pg.nlopt).maxeval = nlopt
elif nlopt and seed == 1:
algo = pg.algorithm(pg.nlopt(solver="neldermead"))
print('[swarms:]'.ljust(15, ' ') + 'On seed ' + str(seed) +
' creating ' + algo.get_name())
algo.extract(pg.nlopt).maxeval = nlopt
else:
random.seed(seed)
algo = random.sample(algos, 1)[0]
print('[swarms:]'.ljust(15, ' ') + 'On seed ' + str(seed) +
' creating ' + algo.get_name())
algo.set_seed(seed)
pop = pg.population(prob, size=pop_size, seed=seed)
ser_pop = dump_pop(pop)
ser_algo = cpickle.dumps(algo)
return ser_algo, ser_pop
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 optimize(self, population, steps, seed=None):
algorithm_constructor = available_algorithms[self.algorithm_name][0]
if 'nlopt' in self.algorithm_name: # nlopt algorithms called differently.
_algorithm = algorithm_constructor()
_algorithm.maxeval = steps
self._algorithm = pygmo.algorithm(_algorithm)
else:
self._algorithm = pygmo.algorithm(algorithm_constructor(gen=steps, seed=seed, **self.algorithm_kwargs))
logger.info('(algorithm) using %s algorithm with steps: %d seed: %d' % (self.algorithm_name, steps, seed))
results = self._algorithm.evolve(population)
self._internal_problem.finalize()
return results
def _create_algorithm(algo_name, algo_options, origin):
"""Create a pygmo algorithm.
Todo:
- Pass the algo options through
"""
if origin == "nlopt":
algo = pg.algorithm(pg.nlopt(solver=algo_name))
elif origin == "pygmo":
pygmo_uda = getattr(pg, algo_name)
algo = pg.algorithm(pygmo_uda())
return algo
def _create_algorithm(algo_name, algo_options, origin):
"""Create a pygmo algorithm."""
if origin == "nlopt":
algo = pg.algorithm(pg.nlopt(solver=algo_name))
for option, val in algo_options.items():
setattr(algo.extract(pg.nlopt), option, val)
elif origin == "pygmo":
pygmo_uda = getattr(pg, algo_name)
algo_options = algo_options.copy()
if "popsize" in algo_options:
del algo_options["popsize"]
algo = pg.algorithm(pygmo_uda(**algo_options))
return algo
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 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 solve(self, otol=1e-5, zguess=None, seperate=False):
if seperate:
self.segments = self.pool.map(lambda seg: seg.solve(),
self.segments)
#[seg.solve() for seg in self.segments]
else:
# set optimisation params
self.otol = otol
# instantiate optimisation problem
prob = pg.problem(self)
# instantiate algorithm
algo = pg.ipopt()
algo.set_numeric_option("tol", self.otol)
algo = pg.algorithm(algo)
algo.set_verbosity(1)
# instantiate and evolve population
if zguess is None:
pop = pg.population(prob, 1)
else:
pop = pg.population(prob, 0)
pop.push_back(zguess)
pop = algo.evolve(pop)
# extract soltution
self.zopt = pop.champion_x
self.fitness(self.zopt)
# combine records
self.process_records()
def run_benchmark(cp, x_train, y_train, funset):
ib, params, bounds = define_cgp_system(
cp.getint('CGPPARAMS', 'n_nodes'),
x_train.shape[1] if len(x_train.shape) > 1 else 1,
y_train.shape[1] if len(y_train.shape) > 1 else 1, funset,
cp.getint('CGPPARAMS', 'max_back'))
cf = cost_function(x_train, y_train, params, bounds)
prob = pg.problem(cf)
algo = pg.algorithm(
pg.simulated_annealing(Ts=cp.getfloat('OPTIMPARAMS', 'Ts'),
Tf=cp.getfloat('OPTIMPARAMS', 'Tf'),
n_T_adj=cp.getint('OPTIMPARAMS', 'n_T_adj'),
n_range_adj=cp.getint('OPTIMPARAMS',
'n_range_adj'),
bin_size=cp.getint('OPTIMPARAMS', 'bin_size'),
start_range=cp.getfloat('OPTIMPARAMS',
'start_range')))
algo.set_verbosity(100)
pop = pg.population(prob, 1)
pop = algo.evolve(pop)
uda = algo.extract(pg.simulated_annealing)
return [x[2] for x in uda.get_log()]
def find_pulses(
cptm: ContinousPulseTransitionsMaker = ContinousPulseTransitionsMaker(
30, (5, 10), 20, 0.3
),
generations: int = DEFAULT_GENERATIONS,
population_size: int = DEFAULT_POPULATION_SIZE,
seed: int = DEFAULT_SEED,
) -> typing.Tuple[float, ...]:
udp = pg.problem(cptm)
algorithm = pg.algorithm(pg.gaco(gen=generations, seed=seed))
# algorithm.set_verbosity(1)
algorithm.set_verbosity(0)
population = pg.population(udp, population_size)
resulting_population = algorithm.evolve(population)
best_x = resulting_population.champion_x
best_fitness = resulting_population.champion_f
pulses = cptm._convert_x_to_pulses(best_x)
is_valid = best_fitness[1] <= 0 and best_fitness[2] <= 0
if is_valid:
print("Found valid solution.")
else:
msg = "WARNING: FOUND INVALID SOLUTION!"
if best_fitness[1] > 0:
msg += " Solution is too small."
else:
msg += " Solution is too big."
print(msg)
return pulses
def runTest(self):
from dcgpy import symbolic_regression, generate_koza_quintic, kernel_set_double, gd4cgp
import pygmo as pg
import pickle
X, Y = generate_koza_quintic()
# Interface for the UDPs
udp = symbolic_regression(points=X,
labels=Y,
rows=1,
cols=20,
levels_back=21,
arity=2,
kernels=kernel_set_double(
["sum", "diff", "mul", "pdiv"])(),
n_eph=2,
multi_objective=False,
parallel_batches=0)
prob = pg.problem(udp)
pop = pg.population(prob, 10)
# Interface for the UDAs
uda = gd4cgp(max_iter=10, lr=0.1, lr_min=1e-6)
algo = pg.algorithm(uda)
algo.set_verbosity(0)
# Testing some evolutions
pop = algo.evolve(pop)
# In parallel
archi = pg.archipelago(prob=prob, algo=algo, n=16, pop_size=4)
archi.evolve()
archi.wait_check()
# Pickling.
self.assertTrue(repr(algo) == repr(pickle.loads(pickle.dumps(algo))))
def run_example4():
import pygmo as pg
from pykep.examples import add_gradient, algo_factory
N = 20
# problem
udp = add_gradient(mga_lt_earth_mars_sundmann(nseg=N), with_grad=False)
prob = pg.problem(udp)
prob.c_tol = [1e-5] * prob.get_nc()
# algorithm
uda = algo_factory("snopt7", False)
uda2 = pg.mbh(uda, 5, 0.05)
algo = pg.algorithm(uda2)
algo.set_verbosity(1)
# 3 - Population
pop = pg.population(prob, 1)
# 4 - Solve the problem (evolve)
print("Running Monotonic Basin Hopping ....")
pop = algo.evolve(pop)
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(pop.champion_x)))
udp.udp_inner.plot(pop.champion_x)
def optimize(results, dir):
pg.mp_bfe.init_pool(50)
prob = pg.problem(MotGunOptimizationProblem(dir))
bfe = pg.bfe(pg.mp_bfe())
nsga2 = pg.nsga2()
nsga2.set_bfe(bfe)
algo = pg.algorithm(nsga2)
pop = pg.population(prob=prob, size=256, b=bfe)
iteration = 1
while True:
print(f"\033[31mITERATION: {iteration}\033[m")
plt.title(f'Iteration {iteration}')
plt.xlabel('Emittance (nm)')
plt.ylabel('Charge (fC)')
pg.plot_non_dominated_fronts(pop.get_f())
plt.savefig(results / f'{iteration}.png', dpi=300)
plt.clf()
assert len(pop.get_x()) == len(pop.get_f())
with open(results / f'iteration_{iteration}.txt', 'w+') as f:
f.write(
'[Mot Z Offset (mm), Phase (deg)] -> [Emittance 4D sqrt (nm), Charge (fC)]\n'
)
for i in range(len(pop.get_x())):
f.write('{} -> {}\n'.format(pop.get_x()[i], pop.get_f()[i]))
pop = algo.evolve(pop)
iteration += 1
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_example3():
import pygmo as pg
from pykep.examples import add_gradient, algo_factory
# problem
udp = add_gradient(mga_lt_EVMe(), with_grad=False)
prob = pg.problem(udp)
prob.c_tol = [1e-5] * prob.get_nc()
# algorithm
uda = algo_factory("snopt7", False)
uda2 = pg.mbh(uda, 5, 0.05)
algo = pg.algorithm(uda2)
algo.set_verbosity(1)
# 3 - Population
pop = pg.population(prob, 1)
# 4 - Solve the problem (evolve)
print("Running Monotonic Basin Hopping ....")
pop = algo.evolve(pop)
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(pop.champion_x)))
udp.udp_inner.plot(pop.champion_x)
def 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 _create_algorithm(algo_name, algo_options, origin):
"""Create a pygmo algorithm.
Todo:
- Pass the algo options through
"""
if origin == "nlopt":
algo = pg.algorithm(pg.nlopt(solver=algo_name))
for option, val in algo_options.items():
setattr(algo.extract(pg.nlopt), option, val)
elif origin == "pygmo":
pygmo_uda = getattr(pg, algo_name)
algo = pg.algorithm(pygmo_uda(**algo_options))
return algo
def run(dataset_train, dataset_test, cols, gen):
ss = dcgpy.kernel_set_double([
"sum", "diff", "mul", "pdiv", "sin", "cos", "tanh", "log", "exp",
"psqrt"
])
Xtrain, ytrain = dataset_train[:, :-1], dataset_train[:, -1]
Xtest, ytest = dataset_test[:, :-1], dataset_test[:, -1]
udp = dcgpy.symbolic_regression(points=Xtrain,
labels=ytrain[:, np.newaxis],
kernels=ss(),
rows=1,
cols=cols,
levels_back=21,
arity=2,
n_eph=3,
multi_objective=False,
parallel_batches=0)
uda = dcgpy.es4cgp(gen=gen) #, mut_n = 1)
algo = pg.algorithm(uda)
pop = pg.population(udp, 4)
pop = algo.evolve(pop)
return RMSE(udp.predict(Xtrain, pop.champion_x),
ytrain), RMSE(udp.predict(Xtest, pop.champion_x), ytest)
def main():
# instantiate dynamics
dyn = Dynamics()
# instantiate leg
leg = Leg(dyn, alpha=0, bound=True)
# set boudaries
t0 = 0
s0 = np.array([1000, 1000, *np.random.randn(4)], dtype=float)
l0 = np.random.randn(len(s0))
tf = 1000
sf = np.zeros(len(s0))
leg.set(t0, s0, l0, tf, sf)
# define problem
udp = Problem(leg, atol=1e-8, rtol=1e-8)
prob = pg.problem(udp)
# instantiate algorithm
uda = pg7.snopt7(True, "/usr/lib/libsnopt7_c.so")
uda.set_integer_option("Major iterations limit", 4000)
uda.set_integer_option("Iterations limit", 40000)
uda.set_numeric_option("Major optimality tolerance", 1e-2)
uda.set_numeric_option("Major feasibility tolerance", 1e-4)
algo = pg.algorithm(uda)
# instantiate population with one chromosome
pop = pg.population(prob, 1)
#pop = pg.population(prob, 0)
#pop.push_back([1000, *l0])
# optimise
pop = algo.evolve(pop)
def test2():
mma = pg.algorithm(pg.nlopt("mma"))
p_toy = pg.problem(toy_problem_2())
archi = pg.archipelago(n=6, algo=mma, prob=p_toy, pop_size=1)
archi.evolve()
archi.wait_check()
print("end of test2")
def _fit_impl(self, objective, parameters):
ndim = len(parameters.infos())
minimums = ndim * [-np.inf]
maximums = ndim * [+np.inf]
initials = np.empty((ndim, self._size))
# for i, pinfo in enumerate(parameters.infos().values()):
for i, name in enumerate(parameters.names()):
pinfo = parameters.infos()[name]
minimum = pinfo.minimum()
maximum = pinfo.maximum()
value = pinfo.initial_value()
scale = pinfo.initial_scale()
has_init = pinfo.has_initial()
init_min = value - 0.5 * scale if has_init else minimum
init_max = value + 0.5 * scale if has_init else maximum
init_min = max(init_min, minimum)
init_max = min(init_max, maximum)
initials[i, :] = random.uniform(init_min, init_max, self._size)
minimums[i] = minimum
maximums[i] = maximum
# print(parameters.names())
#exit()
prb = pg.problem(Problem(objective, parameters, minimums, maximums))
alg = pg.algorithm(self._setup_algorithm(parameters))
alg.set_verbosity(self._verbosity)
pop = pg.population(prb, size=self._size, seed=self._seed)
for i in range(self._size):
pop.set_x(i, initials[:, i])
pop = alg.evolve(pop)
solution = dict(mode=pop.champion_x)
result = make_fitter_result(objective, parameters, solutions=solution)
return result
def solver(dimension, lower_bound, upper_bound, optim, bias, popsize):
global algo
global pop
global niter
global log
global curve
prob = pg.problem(
rastrigin_prob(dimension, lower_bound, upper_bound, optim, bias))
algo = pg.algorithm(
pg.sga(gen=2000,
cr=0.9,
eta_c=2.0,
m=0.02,
param_m=1.0,
param_s=2,
crossover='binomial',
mutation='gaussian',
selection='truncated'))
algo.set_verbosity(1)
pop = pg.population(prob, popsize)
pop = algo.evolve(pop)
log = algo.extract(pg.sga).get_log()
curve = [x[2] for x in log]
niter = log[-1][0]
return prob, algo, pop, log, niter, curve
def main(argv):
help_message = 'test.py <inputfile> <outputfile>'
if len(argv) < 2:
print(help_message)
sys.exit(2)
else:
inputfile = argv[0]
outputfile = argv[1]
print("Reading data from " + inputfile)
# Setting up the user defined problem in pygmo
prob = pg.problem(TestOptimizer(inputfile))
solution_size = 8
# Start with an initial set of 100 sets
pop = pg.population(prob, size=solution_size)
# Set the algorithm to non-dominated sorting GA
algo = pg.algorithm(pg.nsga2(gen=40))
# Optimize
pop = algo.evolve(pop)
# This returns a set of optimal vectors and corresponding fitness values
fits, vectors = pop.get_f(), pop.get_x()
print("Writing output to " + outputfile)
jsonfile = pygeoj.load(filepath=inputfile)
num_districts = len(jsonfile)
counter = 0
for feature in jsonfile:
for sol in range(solution_size):
feature.properties = {"sol" + str(sol): str(vectors[sol][counter])}
counter += 1
# Save output
jsonfile.save(outputfile)
def genetic_algorithm(explr_p):
prob = pg.problem(GeneticAlgoProblem())
#sade = pg.sade(gen=1, ftol=1e-20, xtol=1e-20)
population_size = 5
if obj_fcn == 'griewank' or dim_x == 3:
total_evals = 500
elif obj_fcn == 'shekel' and dim_x == 20:
total_evals = 5000
else:
total_evals = 1000
generations = total_evals / population_size
optimizer = pg.cmaes(gen=generations, ftol=1e-20, xtol=1e-20)
algo = pg.algorithm(optimizer)
algo.set_verbosity(1)
pop = pg.population(prob, size=population_size)
pop = algo.evolve(pop)
print pop.champion_f
champion_x = pop.champion_x
uda = algo.extract(pg.cmaes)
log = np.array(uda.get_log())
n_fcn_evals = log[:, 1]
pop_best_at_generation = -log[:, 2]
evaled_x = None
evaled_y = pop_best_at_generation
max_y = [pop_best_at_generation[0]]
for y in pop_best_at_generation[1:]:
if y > max_y[-1]:
max_y.append(y)
else:
max_y.append(max_y[-1])
return evaled_x, evaled_y, max_y, 0
def nsga2(ppn):
print('*** NSGA-II ALGORITHM ***')
# INSTANCIATE A PYGMO PROBLEM CONSTRUCTING IT FROM A UDP
inittime = perf_counter()
prob = pg.problem(PPNOProblem(ppn))
generations = trials = nochanges = 0
best_f = best_x = None
# INSTANCIATE THE PYGMO ALGORITM NSGA-II
algo = pg.algorithm(pg.nsga2(gen=GENERATIONS_PER_TRIAL))
# INSTANCIATE A POPULATION
pop = pg.population(prob, size=POPULATION_SIZE)
while True:
# RUN THE EVOLUION
pop = algo.evolve(pop)
trials += 1
generations += GENERATIONS_PER_TRIAL
# EXTRACT RESULTS AND SEARCH THE BEST
fits, vectors = pop.get_f(), pop.get_x()
new_f = new_x = None
for fit, vector in zip(fits, vectors):
# VALID SOLUTION
if fit[1] <= 0:
if isinstance(new_f, type(None)):
new_f = fit
new_x = vector
elif new_f[0] > fit[0]:
new_f = fit
new_x = vector
if not isinstance(new_f, type(None)):
if isinstance(best_f, type(None)):
best_f = new_f
best_x = new_x
else:
if best_f[0] > new_f[0]:
best_f = new_f
best_x = new_x
nochanges = 0
else:
nochanges += 1
if not isinstance(best_f, type(None)):
print('Generations: %i ' % (generations), end='')
print('Cost: %.2f Pressure deficit: %0.3f ' %
(best_f[0], best_f[1]))
if (perf_counter() - inittime) >= MAX_TIME:
print('Maximum evolution time was reached.')
break
elif trials >= MAX_TRIALS:
print('Maximum number of trials was reached.')
break
elif nochanges >= MAX_NO_CHANGES:
print('Objective function value was repeated %i times.' %
(nochanges))
break
return (best_f, best_x)
def solve(self, otol=1e-5):
# set optimisation params
self.otol = otol
# instantiate optimisation problem
prob = pg.problem(self)
# instantiate algorithm
algo = pg.ipopt()
algo.set_numeric_option("tol", self.otol)
algo = pg.algorithm(algo)
algo.set_verbosity(1)
# instantiate and evolve population
pop = pg.population(prob, 1)
pop = algo.evolve(pop)
# extract soltution
self.zopt = pop.champion_x
self.fitness(self.zopt)
# process records
self.process_records()
return self
def 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 sade(problem, population_size, params):
'''
Execute the Pygmo SADE algorithm on an
optimisation problem with the population size
and parameters specified. The SADE possible
set of parameters are:
* variant: mutation variant:
1 -> best/1/exp 10 -> rand/2/bin
2 -> rand/1/exp 11 -> rand/3/exp
3 -> rand-to-best/1/exp 12 -> rand/3/bin
4 -> best/2/exp 13 -> best/3/exp
5 -> rand/2/exp 14 -> best/3/bin
6 -> best/1/bin 15 -> rand-to-current/2/exp
7 -> rand/1/bin 16 -> rand-to-current/2/bin
8 -> rand-to-best/1/bin 17 -> rand-to-best-and-current/2/exp
9 -> best/2/bin 18 -> rand-to-best-and-current/2/bin
* variant_adptv: scale factor F and crossover rate CR
adaptation scheme to be used
* 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
SADE 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"]
variant = params["variant"]
variant_adptv = params["variant_adptv"]
ftol = params["ftol"]
xtol = params["xtol"]
algo = pg.algorithm(
pg.sade(gen=nb_generation,
variant=variant,
variant_adptv=variant_adptv,
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.sade)
log = uda.get_log()
return (log, duration, solution.champion_f, solution.champion_x)
def optimize_pagmo():
solo_mgar = solo_mgar_udp([7000, 8000])
for i in range(6000):
prob = pg.problem(solo_mgar)
pop = pg.population(prob=prob, size=32)
alg = pg.algorithm(pg.sade(memory=True, gen=1))
pop = alg.evolve(pop)
print(i, pop.champion_f, solo_mgar.fitness(pop.champion_x))
def method_a():
algo = pg.algorithm(uda=pg.nlopt('auglag'))
algo.extract(pg.nlopt).local_optimizer = pg.nlopt('var2')
algo.set_verbosity(
200) # in this case this correspond to logs each 200 objevals
pop = pg.population(prob=UdpConstrained(), size=1)
pop.problem.c_tol = [1E-6] * 6
pop = algo.evolve(pop)
def method_b():
algo = pg.algorithm(uda=pg.mbh(pg.nlopt("slsqp"), stop=20, perturb=.2))
print(algo)
algo.set_verbosity(
1) # in this case this correspond to logs each 1 call to slsqp
pop = pg.population(prob=UdpConstrained(), size=1)
pop.problem.c_tol = [1E-6] * 6
pop = algo.evolve(pop)
def user_defined_problem():
prob = pg.problem(sphere_function(3))
print(prob)
algo = pg.algorithm(pg.bee_colony(gen = 200, limit = 20))
pop = pg.population(prob, 10)
pop = algo.evolve(pop)
print(pop.champion_f)
print(pop)
def test_pagmo(joint_likelihood_bn090217206_nai):
pagmo = GlobalMinimization("PAGMO")
minuit = LocalMinimization("minuit")
algo = pygmo.algorithm(pygmo.bee_colony(gen=100))
pagmo.setup(islands=4, population_size=20, evolution_cycles=1, second_minimization=minuit, algorithm=algo)
do_analysis(joint_likelihood_bn090217206_nai, pagmo)
def algo_factory(name, original_screen_output=True):
if name is "slsqp":
uda = pg.nlopt('slsqp')
uda.xtol_rel = 1e-5
uda.ftol_rel = 0
algo = pg.algorithm(uda)
algo.set_verbosity(1)
return algo
elif name is "ipopt":
if original_screen_output:
pl = 5
else:
pl = 0
uda = pg.ipopt()
uda.set_integer_option("print_level", pl)
uda.set_integer_option("acceptable_iter", 4)
uda.set_integer_option("max_iter", 150)
uda.set_numeric_option("tol", 1e-8)
uda.set_numeric_option("dual_inf_tol", 1e-8)
uda.set_numeric_option("constr_viol_tol", 1e-8)
uda.set_numeric_option("compl_inf_tol", 1e-8)
uda.set_numeric_option("acceptable_tol", 1e-3)
uda.set_numeric_option("acceptable_dual_inf_tol", 1e-2)
uda.set_numeric_option("acceptable_constr_viol_tol", 1e-6)
uda.set_numeric_option("acceptable_compl_inf_tol", 1e-6)
algo = pg.algorithm(uda)
return algo
elif name is "snopt7":
import pygmo_plugins_nonfree as pg7
uda = pg7.snopt7(original_screen_output,
"/usr/local/lib/libsnopt7_c.so")
uda.set_integer_option("Major iterations limit", 2000)
uda.set_integer_option("Iterations limit", 200000)
uda.set_numeric_option("Major optimality tolerance", 1e-2)
uda.set_numeric_option("Major feasibility tolerance", 1e-9)
algo = pg.algorithm(uda)
return algo
def quick_start_demo():
# 1 - Instantiate a pygmo problem constructing it from a UDP
# (user defined problem).
prob = pg.problem(pg.schwefel(30))
# 2 - Instantiate a pagmo algorithm
algo = pg.algorithm(pg.sade(gen=100))
# 3 - Instantiate an archipelago with 16 islands having each 20 individuals
archi = pg.archipelago(16, algo=algo, prob=prob, pop_size=20)
# 4 - Run the evolution in parallel on the 16 separate islands 10 times.
archi.evolve(10)
# 5 - Wait for the evolutions to be finished
archi.wait()
# 6 - Print the fitness of the best solution in each island
res = [isl.get_population().champion_f for isl in archi]
print(res)
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)
