def run(n_restarts=5):
from PyGMO import algorithm, island, population
prob = earthToMars()
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
# algo.screen_output = True
algo2 = algorithm.mbh(algo, n_restarts, 0.005)
algo2.screen_output = True
pop = population(prob)
pop.push_back((320.33563525584435, 0.0016748335274261476, 0.0013627675495311467, 0.0))
pop.push_back((301.93091863294785, 0.0016076262089444425, 0.0015896115913838728, 0.0))
pop.push_back((301.93091863294785, 0.0016076262089444425, 0.0015896115913838728, 0.0))
pop.push_back((420.2372419060117, 0.010494326408284994, 0.0044382506954818565, 0.0))
pop.push_back((411.21323621411335, 0.008748839048462907, 0.0033290148214346503, 0.0))
pop.push_back((395.8283718212657, 0.006450877568564355, 0.002069880891910152, 0.0))
pop.push_back((319.95400029222867, 0.0016702166037494744, 0.0013676901851197968, 0.0))
pop.push_back((319.5113399461457, 0.00166499548529299, 0.0013736935829129556, 0.0))
pop.push_back((320.0969905134936, 0.001671977113629641, 0.001365741362825864, 0.0))
pop.push_back((324.8947207784664, 0.0017420256877963634, 0.0013024051696600683, 0.0))
isl = island(algo2,pop)
print("Running Monotonic Basin Hopping .... this will take a while.")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
return isl.population.champion.x
def run(n_restarts=5):
from PyGMO import algorithm, island, population
prob = earthToMars()
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
# algo.screen_output = True
algo2 = algorithm.mbh(algo, n_restarts, 0.005)
algo2.screen_output = True
pop = population(prob)
pop.push_back((-3.810404036178629e-05, 8.036667366434322e-05, 0, -0.00011631957922519811, -0.0003960700040113729, 0, 0.00014343900668268246, -0.00039460589468829016, 0, 0.0004133243825183847, -0.0002676479632615287, 0, -6.353773946676955e-05, -0.0004027302771161609, 0, -0.00019483461157664088, -0.0003938299142410649, 0, 0.0003740376551173652, -0.00045439735580127933, 0, 0.00026271994456226056, -4.17413726080276e-05, 0, 0.0004025294016016401, 9.22186764465555e-05, 0, 0.0004379362102351141, -8.202101747983173e-05, 0, 2.0842990495214604e-05, -1.927554372930426e-05, 0, -2.392388475139966e-05, -6.3420840462436174e-06, 0))
pop.push_back((0.00018354551497353738, 0.0002897005581203533, 0, 9.385407683672441e-05, -0.0004375546286935724, 0, -0.00017406053466786356, -0.0004055793819144533, 0, 7.811816626063441e-05, -0.00028869842254392053, 0, 0.000280132941671916, -0.00045467528344872834, 0, 0.00031161406626870487, -0.0004418005074233615, 0, 0.00016912620000403375, -0.00045156036938030775, 0, 0.00043500734938167605, -4.4611940286304056e-05, 0, 0.00023373694896547512, 4.622353180355802e-06, 0, 0.00043504614537196785, -0.00042017445674379463, 0, 0.00016822207354911628, 0.00010574669088542543, 0, 2.1129649656070842e-05, 0.00020199652091584146, 0))
# pop.push_back((301.93091863294785, 0.0016076262089444425, 0.0015896115913838728, 0.0))
# pop.push_back((420.2372419060117, 0.010494326408284994, 0.0044382506954818565, 0.0))
# pop.push_back((411.21323621411335, 0.008748839048462907, 0.0033290148214346503, 0.0))
# pop.push_back((395.8283718212657, 0.006450877568564355, 0.002069880891910152, 0.0))
# pop.push_back((319.95400029222867, 0.0016702166037494744, 0.0013676901851197968, 0.0))
# pop.push_back((319.5113399461457, 0.00166499548529299, 0.0013736935829129556, 0.0))
# pop.push_back((320.0969905134936, 0.001671977113629641, 0.001365741362825864, 0.0))
# pop.push_back((324.8947207784664, 0.0017420256877963634, 0.0013024051696600683, 0.0))
isl = island(algo2,pop)
print("Running Monotonic Basin Hopping .... this will take a while.")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
return isl.population.champion.x
def run_test():
from PyGMO import problem, algorithm, island
from numpy import mean, std
number_of_trials = 200
number_of_individuals = 20
number_of_generations = 500
prob_list = [problem.schwefel(10), problem.rastrigin(10), problem.rosenbrock(10), problem.ackley(10), problem.griewank(10)]
algo_list = [algorithm.pso(number_of_generations), algorithm.de(number_of_generations,0.8,0.8,2),algorithm.sa_corana(number_of_generations*number_of_individuals,1,0.1), algorithm.ihs(number_of_generations*number_of_individuals), algorithm.sga(number_of_generations,0.8,0.1)]
for prob in prob_list:
print('\nTesting problem: ' + str(type(prob)) + ', Dimension: ' + str(prob.dimension))
for algo in algo_list:
print(' ' + str(algo))
best = []
best_x = []
for i in range(0,number_of_trials):
isl = island(algo,prob,number_of_individuals)
isl.evolve(1)
isl.join()
best.append(isl.population.champion.f)
best_x.append(isl.population.champion.x)
print(' Best:\t' + str(min(best)[0]))
print(' Mean:\t' + str(mean(best)))
print(' Std:\t' + str(std(best)))
def run_example3(): from PyGMO import algorithm, island prob = mga_lt_EVMe() algo = algorithm.scipy_slsqp(max_iter = 500, acc =1e-5) #algo = algorithm.snopt(major_iter=2000, opt_tol=1e-3, feas_tol=1e-9) algo2 = algorithm.mbh(algo,5,0.05) algo2.screen_output = True isl = island(algo2,prob,1) print "Running Monotonic Basin Hopping ...." isl.evolve(1); isl.join() print "Is the solution found a feasible trajectory? " + str(prob.feasibility_x(isl.population.champion.x)) prob.plot(isl.population.champion.x)
def run_example1(n_restarts=5):
from PyGMO import algorithm, island
prob = earthToMars()
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
algo2 = algorithm.mbh(algo, 5, 0.05)
algo2.screen_output = True
isl = island(algo2, prob, 1)
print("Running Monotonic Basin Hopping .... this will take a while.")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
return isl.population.champion.x
def run_example1(): from PyGMO import algorithm, island prob = mga_lt_earth_mars(nseg=15) prob.high_fidelity(True) algo = algorithm.scipy_slsqp(max_iter = 500, acc=1e-5) #algo = algorithm.snopt(major_iter=1000, opt_tol=1e-6, feas_tol=1e-11) algo2 = algorithm.mbh(algo,5,0.05) algo2.screen_output = True isl = island(algo2,prob,1) print "Running Monotonic Basin Hopping .... this will take a while" isl.evolve(1); isl.join() print "Is the solution found a feasible trajectory? " + str(prob.feasibility_x(isl.population.champion.x)) prob.plot(isl.population.champion.x)
def run_example1(n_restarts=5):
prob = mga_lt_earth_mars(nseg=15)
prob.high_fidelity(True)
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
algo2 = algorithm.mbh(algo, n_restarts, 0.05)
algo2.screen_output = True
isl = island(algo2, prob, 1)
print("Running Monotonic Basin Hopping .... this will take a while.")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
prob.plot(isl.population.champion.x)
def run_example3():
from PyGMO import algorithm, island
prob = mga_lt_EVMe()
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
# algo = algorithm.snopt(major_iter=500, opt_tol=1e-3, feas_tol=1e-9)
algo2 = algorithm.mbh(algo, 5, 0.05)
algo2.screen_output = True
isl = island(algo2, prob, 1)
print("Running Monotonic Basin Hopping ....")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
prob.plot(isl.population.champion.x)
def run_example1():
from PyGMO import algorithm, island
prob = mga_lt_earth_mars(nseg=15)
prob.high_fidelity(True)
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
#algo = algorithm.snopt(major_iter=1000, opt_tol=1e-6, feas_tol=1e-11)
algo2 = algorithm.mbh(algo, 5, 0.05)
algo2.screen_output = True
isl = island(algo2, prob, 1)
print "Running Monotonic Basin Hopping .... this will take a while"
isl.evolve(1)
isl.join()
print "Is the solution found a feasible trajectory? " + str(
prob.feasibility_x(isl.population.champion.x))
prob.plot(isl.population.champion.x)
def run_example4(sim,n_restarts=5):
from PyGMO import algorithm, island
prob = rocketMars1()
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
# algo = algorithm.ipopt(max_iter=500, constr_viol_tol=1e-5,dual_inf_tol=1e-5,compl_inf_tol=1e-5)
# algo.screen_output = True
algo2 = algorithm.mbh(algo, n_restarts, 0.05)
algo2.screen_output = True
isl = island(algo2, prob, 1)
print("Running Monotonic Basin Hopping .... this will take a while.")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
return isl.population.champion.x
def run_test(n_trials=200, pop_size = 20, n_gen = 500):
number_of_trials = n_trials
number_of_individuals = pop_size
number_of_generations = n_gen
prob_list = [problem.schwefel(dim = 10),
problem.michalewicz(dim = 10),
problem.rastrigin(dim = 10),
problem.rosenbrock(dim = 10),
problem.ackley(dim = 10),
problem.griewank(dim = 10)]
if __extensions__['gtop']:
prob_list.append(problem.cassini_1())
prob_list.append(problem.cassini_2())
prob_list.append(problem.gtoc_1())
prob_list.append(problem.rosetta())
prob_list.append(problem.messenger_full())
prob_list.append(problem.tandem(prob_id = 6, max_tof = 10))
algo_list = [algorithm.pso(gen = number_of_generations),
algorithm.de(gen = number_of_generations,xtol=1e-30, ftol=1e-30),
algorithm.jde(gen = number_of_generations, variant_adptv=2,xtol=1e-30, ftol=1e-30),
algorithm.de_1220(gen = number_of_generations, variant_adptv=2,xtol=1e-30, ftol=1e-30),
algorithm.sa_corana(iter = number_of_generations*number_of_individuals,Ts = 1,Tf = 0.01),
algorithm.ihs(iter = number_of_generations*number_of_individuals),
algorithm.sga(gen = number_of_generations),
algorithm.cmaes(gen = number_of_generations,xtol=1e-30, ftol=1e-30),
algorithm.bee_colony(gen = number_of_generations/2)]
print('\nTrials: ' + str(n_trials) + ' - Population size: ' + str(pop_size) + ' - Generations: ' + str(n_gen))
for prob in prob_list:
print('\nTesting problem: ' + prob.get_name() + ', Dimension: ' + str(prob.dimension) )
print('With Population Size: ' + str(pop_size) )
for algo in algo_list:
print(' ' + str(algo))
best = []
best_x = []
for i in range(0,number_of_trials):
isl = island(algo,prob,number_of_individuals)
isl.evolve(1)
isl.join()
best.append(isl.population.champion.f)
best_x.append(isl.population.champion.x)
print(' Best:\t' + str(min(best)[0]))
print(' Mean:\t' + str(mean(best)))
print(' Std:\t' + str(std(best)))
def run_example4():
from PyGMO import algorithm, island, population
N = 20
prob = mga_lt_earth_mars_sundmann(nseg=N)
algo = algorithm.scipy_slsqp(max_iter=500, acc=1e-5)
# algo = algorithm.snopt(major_iter=1000, opt_tol=1e-6, feas_tol=1e-11)
algo2 = algorithm.mbh(algo, 5, 0.05)
algo2.screen_output = True
isl = island(algo2, prob, 1)
print("Running Monotonic Basin Hopping ....")
isl.evolve(1)
isl.join()
print("Is the solution found a feasible trajectory? " +
str(prob.feasibility_x(isl.population.champion.x)))
print(isl.population.champion.x)
prob.plot(isl.population.champion.x)
def __init__(self, algo1, algo2, prob, pop_size=20, min_trials=20, p = 0.05, max_runs=200):
"""
Upon construction of the class object the race is initialized and launched.
USAGE: r = PyGMO.race2algos(algo1, algo2, prob, pop_size=20, min_trials=20, p = 0.05, max_runs=200):
* algo1: first algorithm in the race
* algo2: second algorithm in the race
* prob: problem (i.e. the "track" the algos are racing upon)
* pop_size: population size of the island where the algos will perform evolution
* min_trials: minimum number of runs to compare the algorithms
* p: confidence level
* max_runs: maximum number of races ....
"""
from random import randint
from copy import deepcopy
from sys import stdout
self.algo1=algo1
self.algo2=algo2
self.prob=prob
self.res1 = []
self.res2 = []
self.pop_size = pop_size
self.p = 0
self.z = 0
self.p_req = p
print "Racing the algorithms ..."
for i in range(max_runs):
stdout.write("\rRuns: %i" % i); stdout.flush()
#We reset the random number generators of the algorithm
algo1.reset_rngs(randint(0,9999999)); algo2.reset_rngs(randint(0,9999999))
#We create an island with 20 individuals. This also initalizes its population at random within the box bounds
isl1 = island(algo1,prob,self.pop_size)
#We copy the island and change its algo. Like this we make sure the two algorithms
#will evolve the same inital population (good practice)
isl2 = deepcopy(isl1)
isl2.algorithm = algo2
#We start the evolution (in parallel as we do not call the method join())
isl1.evolve(1); isl2.evolve(1)
#Here join is called implicitly as we try to access one of the islands during evolution
self.res1.append(isl1.population.champion.f[0])
self.res2.append(isl2.population.champion.f[0])
#We check that the race is over (only after having accumulated at least min_trials samples)
if (i>min_trials):
if (self.are_different(self.res1,self.res2)):
break
def example_1(n_trials=25, variant_adptv=1, memory=True): from PyGMO import problem, algorithm, island, archipelago from PyGMO.topology import fully_connected from numpy import mean, median results = list() prob = problem.messenger_full() de_variants = [11,13,15,17] algos = [algorithm.jde(gen=50,variant=v, memory=memory, variant_adptv=variant_adptv) for v in de_variants] for trial in range(n_trials): archi = archipelago(topology=fully_connected()) for algo in algos: archi.push_back(island(algo,prob,25)) print "Trial N: " + str(trial) archi.evolve(30) results.append(min([isl.population.champion.f[0] for isl in archi])) return (mean(results), median(results), min(results), max(results))
def run_test(n_trials=200, pop_size = 20, n_gen = 500):
"""
This function runs some tests on the algorthm. Use it to verify the correct installation
of PyGMO.
USAGE: PyGMO.run_test(n_trials=200, pop_size = 20, n_gen = 500)
* n_trials: each algorithm will be called n_trials times on the same problem to then evaluate best, mean and std
* pop_size: this determines the population size
* n_gen: this regulates the maximim number of function evaluation
"""
from PyGMO import problem, algorithm, island
from numpy import mean, std
number_of_trials = n_trials
number_of_individuals = pop_size
number_of_generations = n_gen
prob_list = [problem.schwefel(dim = 10), problem.rastrigin(dim = 10), problem.rosenbrock(dim = 10), problem.ackley(dim = 10), problem.griewank(dim = 10), problem.levy5(10)]
if __extensions__['gtop']:
prob_list.append(problem.cassini_1())
prob_list.append(problem.gtoc_1())
prob_list.append(problem.cassini_2())
prob_list.append(problem.messenger_full())
algo_list = [algorithm.pso(gen = number_of_generations), algorithm.mde_pbx(gen = number_of_generations, xtol=1e-30, ftol=1e-30), algorithm.de(gen = number_of_generations,xtol=1e-30, ftol=1e-30), algorithm.jde(gen = number_of_generations, memory=False,xtol=1e-30, ftol=1e-30), algorithm.de_1220(gen = number_of_generations, memory=False,xtol=1e-30, ftol=1e-30), algorithm.sa_corana(iter = number_of_generations*number_of_individuals,Ts = 1,Tf = 0.01), algorithm.ihs(iter = number_of_generations*number_of_individuals), algorithm.sga(gen = number_of_generations), algorithm.cmaes(gen = number_of_generations,xtol=1e-30, ftol=1e-30, memory=False), algorithm.bee_colony(gen = number_of_generations/2)]
print('\nTrials: ' + str(n_trials) + ' - Population size: ' + str(pop_size) + ' - Generations: ' + str(n_gen))
for prob in prob_list:
print('\nTesting problem: ' + prob.get_name() + ', Dimension: ' + str(prob.dimension) )
print('With Population Size: ' + str(pop_size) )
for algo in algo_list:
print(' ' + str(algo))
best = []
best_x = []
for i in range(0,number_of_trials):
isl = island(algo,prob,number_of_individuals)
isl.evolve(1)
isl.join()
best.append(isl.population.champion.f)
best_x.append(isl.population.champion.x)
print(' Best:\t' + str(min(best)[0]))
print(' Mean:\t' + str(mean(best)))
print(' Std:\t' + str(std(best)))
def run_test():
from PyGMO import problem, algorithm, island
from numpy import mean, std
number_of_trials = 200
number_of_individuals = 20
number_of_generations = 500
prob_list = [
problem.schwefel(10),
problem.rastrigin(10),
problem.rosenbrock(10),
problem.ackley(10),
problem.griewank(10)
]
algo_list = [
algorithm.pso(number_of_generations),
algorithm.de(number_of_generations, 0.8, 0.8, 2),
algorithm.sa_corana(number_of_generations * number_of_individuals, 1,
0.1),
algorithm.ihs(number_of_generations * number_of_individuals),
algorithm.sga(number_of_generations, 0.8, 0.1)
]
for prob in prob_list:
print('\nTesting problem: ' + str(type(prob)) + ', Dimension: ' +
str(prob.dimension))
for algo in algo_list:
print(' ' + str(algo))
best = []
best_x = []
for i in range(0, number_of_trials):
isl = island(algo, prob, number_of_individuals)
isl.evolve(1)
isl.join()
best.append(isl.population.champion.f)
best_x.append(isl.population.champion.x)
print(' Best:\t' + str(min(best)[0]))
print(' Mean:\t' + str(mean(best)))
print(' Std:\t' + str(std(best)))
def do_test_migr_setup(self, pop_xs, out_pop_xs, top, n_evolves):
""" Generic procedure for testing whether the state of populations in 'pop_xs',
after performing 'n_evolve' migration steps is equal to the expected 'out_pop_xs', given topology 'top'. """
prob = problem.identity()
alg = algorithm.null()
pops = []
for xs in pop_xs:
pop = population(prob)
for x in xs:
pop.push_back(x)
pops.append(pop)
archi = archipelago(distribution_type=distribution_type.broadcast, migration_direction=migration_direction.destination)
for pop in pops:
archi.push_back(island(alg, pop, s_policy=migration.best_s_policy(), r_policy=migration.fair_r_policy()))
archi.topology = top
archi.evolve_batch(n_evolves, 1, False)
out_xs = []
for ii, isl in enumerate(archi, 1):
out_xs.append(tuple(sorted([i.cur_f for i in isl.population])))
out_xs = tuple(out_xs)
self.assertEqual(out_xs, out_pop_xs)
def problem_solver(n_trials=25):
from PyGMO import problem, algorithm, island, archipelago
from PyGMO.topology import fully_connected
from numpy import mean, median
import csv
results = list()
prob = problem.cassini_2()
de_variants = [11, 13, 15, 17]
f_variants = [0, 0.2, 0.5, 0.8, 1]
cr_variants = [0.3, 0.9]
np_variants = [10, 25, 50]
for f in f_variants:
for cr in cr_variants:
for np in np_variants:
algos = [algorithm.de(gen=np, f=f, cr=cr) for v in de_variants]
for trial in range(n_trials):
archi = archipelago(topology=fully_connected())
for algo in algos:
archi.push_back(island(algo, prob, 25))
archi.evolve(30)
results.append(
min([isl.population.champion.f[0] for isl in archi]))
with open('results.csv', 'a') as out:
out.write('%f;' % f)
out.write('%f;' % cr)
out.write('%f;' % np)
out.write('\n')
out.write('%f;' % mean(results))
out.write('%f;' % median(results))
out.write('%f;' % min(results))
out.write('%f;' % max(results))
out.write('\n')
out.close()
def test_aco():
from PyGMO import problem, algorithm, island
from numpy import mean, std
number_of_islands = 5
number_of_individuals = 30
number_of_generations = 50
w = [ [0,1,100,1], [1,0,1,100], [100,1,0,1], [1, 100, 1, 0]]
prob_list = [problem.tsp(w)]
algo_list = [algorithm.aco(number_of_generations)]
for j in range(0,len(prob_list)):
print('Testing problem: ' + str(type(prob_list[j])) + ', Dimension: ' + str(prob_list[j].dimension))
for algo in algo_list:
print(' Testing algorithm: ' + str(algo))
best = []
best_x = []
for i in range(0,number_of_islands):
isl = island(prob_list[j],algo,number_of_individuals)
isl.evolve(1)
isl.join()
best.append(isl.population.champion.f)
best_x.append(isl.population.champion.x)
print(' Best fitness:\t' + str(best[i]))
print(' Best solution:\t' + str(best_x[i]))
def problem_solver(n_trials=25):
from PyGMO import problem, algorithm, island, archipelago
from PyGMO.topology import fully_connected
from numpy import mean, median
import csv
results = list()
prob = problem.cassini_2()
de_variants = [11,13,15,17]
f_variants = [0, 0.2, 0.5, 0.8, 1]
cr_variants = [0.3, 0.9]
np_variants = [10, 25, 50]
for f in f_variants:
for cr in cr_variants:
for np in np_variants:
algos = [algorithm.de(gen=np, f=f, cr=cr) for v in de_variants]
for trial in range(n_trials):
archi = archipelago(topology=fully_connected())
for algo in algos:
archi.push_back(island(algo,prob,25))
archi.evolve(30)
results.append(min([isl.population.champion.f[0] for isl in archi]))
with open('results.csv', 'a') as out:
out.write('%f;' % f)
out.write('%f;' % cr)
out.write('%f;' % np)
out.write('\n')
out.write('%f;' % mean(results))
out.write('%f;' % median(results))
out.write('%f;' % min(results))
out.write('%f;' % max(results))
out.write('\n')
out.close()
def test_aco():
from PyGMO import problem, algorithm, island
from numpy import mean, std
number_of_islands = 5
number_of_individuals = 30
number_of_generations = 50
w = [[0, 1, 100, 1], [1, 0, 1, 100], [100, 1, 0, 1], [1, 100, 1, 0]]
prob_list = [problem.tsp(w)]
algo_list = [algorithm.aco(number_of_generations)]
for j in range(0, len(prob_list)):
print('Testing problem: ' + str(type(prob_list[j])) + ', Dimension: ' +
str(prob_list[j].dimension))
for algo in algo_list:
print(' Testing algorithm: ' + str(algo))
best = []
best_x = []
for i in range(0, number_of_islands):
isl = island(prob_list[j], algo, number_of_individuals)
isl.evolve(1)
isl.join()
best.append(isl.population.champion.f)
best_x.append(isl.population.champion.x)
print(' Best fitness:\t' + str(best[i]))
print(' Best solution:\t' + str(best_x[i]))
def single_test(algo,toal_evals=1200, pop_size = 20):
number_of_individuals = pop_size
'''
if(algo.get_name() in ('Particle Swarm optimization','Artificial Bee Colony optimization' )):
number_of_generations = n_gen/2
else:
number_of_generations = n_gen
'''
prob = gauss_problem_stochastic(dim=3, seed=123456)
isl = island(algo,prob,number_of_individuals)
#best = []
#best_x = []
#for i in range(0,number_of_generations):
while isl.problem.get_evals() < total_evals:
isl.evolve(1)
isl.join()
#best.append( (isl.problem.get_evals(),isl.population.champion.f[0]) )
#best_x.append(isl.population.champion.x)
else:
print isl.problem.get_evals()
#print(' Best:\t' + str(min(best)[0]))
#print(' Mean:\t' + str(mean(best)))
#print(' Std:\t' + str(std(best)))
#print isl.population.champion.f
#print isl.population.champion.x
#print '!>',prob.human_readable_extra()
#plot_best(best)
return isl.problem.get_history()
text = """\tProblem dimension: %s
Implemented function: f1 = x1, f2 = g * ( 1 - math.sqrt(x1/g) ) (ZDT1)""" % str(self.__dim)
return text
# <codecell>
if __name__ == '__main__':
print("############### NSGA-II ##########################")
algo = algorithm.nsga_II(gen = 250)
prob1 = schaffer_function()
print(prob1)
pop = population(prob1,100)
isl = island(algo,pop)
isl.evolve(1)
isl.population.plot_pareto_fronts()
# <codecell>
prob2 = zdt_1()
print(prob2)
pop2 = population(prob2,100)
isl2 = island(algo,pop2)
isl2.evolve(1)
isl2.population.plot_pareto_fronts()
def run_eval(lib_name,algos):
import pylab
import numpy
for name,algo in algos:
collect_all_x = []
collect_all_f = []
collect_best_f_so_far = []
collect_all_dx = []
print name,"\t\tRun:",
for i in range(repeats):
if (i%10) == 0:
print i,
if lib_name == "PyGMO":
#---------------------------------------------------
prob = PyGMO_GaussNoise_Problem(dim,lb,ub)
isl = island(algo,prob,pop_size)
pop = isl.population
best = [pop.champion.f]
best_x = [pop.champion.x]
all_x = [p.cur_x for p in pop]
all_f = [p.cur_f for p in pop]
for _ in range(number_of_generations):
pop = algo.evolve(pop)
best.append(pop.champion.f)
best_x.append(pop.champion.x)
all_x.extend([p.cur_x for p in pop])
all_f.extend([p.cur_f for p in pop])
#print pop.champion.f
optimum = prob.get_optimum()
#-----------------------------------------------------
elif lib_name == "inspyred":
#-----------------------------------------------------
ea = algo
ea.terminator = inspyred.ec.terminators.evaluation_termination
problem = Inspyred_GaussNoise_Problem(dim,lb,ub)
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=30,
bounder=problem.bounder,
maximize=problem.maximize,
max_evaluations=total_evaluations)
all_x = problem.all_x
all_f = problem.all_f
optimum = problem.global_optimum
#-----------------------------------------------------
else:
raise RuntimeError("Unknown lib_name")
all_dx = numpy.sum((numpy.array(all_x) - optimum)**2,axis=1)
best_f_so_far = [all_f[0]]
for f in all_f[1:]:
best_f_so_far.append(min(f,best_f_so_far[-1]))
'''
if(i == 0):
pylab.plot(best_f_so_far)
pylab.plot(all_f)
pylab.plot(all_dx)
pylab.show()
'''
collect_all_x.append(all_x)
collect_all_f.append(all_f)
collect_all_dx.append( all_dx)
collect_best_f_so_far.append(best_f_so_far)
print "." #end repeats
#get into numpy form, remove last dimension that comes from
#multiobjective optimization compatibility
collect_all_f = numpy.squeeze(numpy.array(collect_all_f))
collect_best_f_so_far = numpy.squeeze(numpy.array(collect_best_f_so_far))
collect_all_dx = numpy.array(collect_all_dx)
#do calculations, all on best_f_so_far other than distance
median_bf = numpy.median(collect_best_f_so_far,axis=0)
stddev_bf = numpy.std(collect_best_f_so_far,axis=0)
under_minusone_bf = numpy.sum( collect_best_f_so_far < -1 , axis=0)/50.0
distance = numpy.median(collect_all_dx,axis=0)
file_array = numpy.c_[median_bf,stddev_bf,under_minusone_bf,distance]
new_name = name+"_"+str(repeats)+"reps.txt"
fname = os.path.join(data_dir,new_name)
numpy.savetxt(fname,file_array)
print create_count,exec_count
return text
# <codecell>
if __name__ == '__main__':
print("############### Differential Evolution ##########################")
algo = algorithm.de(gen = 500)
results_de_schaffer = []
results_de_sphere = []
for i in range(30):
prob = schaffer_function_n2()
#print("\nSchaffer Function")
#print(prob)
isl = island(algo,prob,50)
#print("Before optimisation: " + str(isl.population.champion.f[0]) )
isl.evolve(10)
results_de_schaffer.append( isl.population.champion.f[0] )
#print("After optimisation: " + str( isl.population.champion.f[0]) + '\n')
#print("="*70 + '\n')
#print("Sphere Function")
prob2 = sphere_function(dim=100)
#print(prob2)
isl2 = island(algo,prob2,50)
#print("Before optimisation: " + str(isl2.population.champion.f[0]))
isl2.evolve(10)
results_de_sphere.append( isl2.population.champion.f[0] )
#print("After optimisation: " + str(isl2.population.champion.f[0]))
print("\nSchaffer Function:\n")
print(xtile(results_de_schaffer, hi = max(results_de_schaffer), lo=min(results_de_schaffer), show="%.10f") )
