Thhe following examples illustrate how to use the different, built-in, evolutionary computations.
from random import Random
from time import time
from ecspy import ec
from ecspy import observers
from ecspy import terminators
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Binary(benchmarks.Schwefel(2), dimension_bits=30)
stat_file = open('ga_statistics.csv', 'w')
ind_file = open('ga_individuals.csv', 'w')
ea = ec.GA(prng)
ea.observer = observers.file_observer
ea.terminator = terminators.evaluation_termination
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=100,
maximize=problem.maximize,
bounder=problem.bounder,
max_evaluations=30000,
statistics_file=stat_file,
individuals_file=ind_file,
num_elites=1)
stat_file.close()
ind_file.close()
if do_plot:
best = max(final_pop)
print('%s Example (%s) Best Solution: \n%s' % (ea.__class__.__name__, problem.__class__.__name__, str(best)))
realbest = problem.binary_to_real(best.candidate)
realfit = best.fitness
print('Converted as --> %s : %f' % (str(realbest), realfit))
import itertools
import pylab
import mpl_toolkits.mplot3d.axes3d as axes3d
from ecspy import analysis
# Create the points using the original Ackley function.
num_points = 40
points = []
for lb, ub in zip(problem.bounder.lower_bound, problem.bounder.upper_bound):
points.append([(i / float(num_points)) * (ub - lb) + lb for i in range(num_points)])
points = itertools.product(*points)
x = []
y = []
for p in points:
x.append(p[0])
y.append(p[1])
z = problem.benchmark.evaluator([[a, b] for a, b in zip(x, y)], {})
fig = pylab.figure()
ax = axes3d.Axes3D(fig)
ax.scatter3D(x, y, z)
ax.scatter3D([realbest[0]], [realbest[1]], [realfit], color='r')
realopt = problem.benchmark.global_optimum
ax.scatter3D([realopt[0]], [realopt[1]], problem.benchmark.evaluator([realopt], {}), color='g')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Fitness')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
analysis.generation_plot('ga_statistics.csv', errorbars=False)
return ea
if __name__ == '__main__':
main()
from random import Random
from time import time
from ecspy import ec
from ecspy import terminators
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Rosenbrock(2)
ea = ec.ES(prng)
ea.terminator = [terminators.evaluation_termination, terminators.diversity_termination]
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=100,
bounder=problem.bounder,
maximize=problem.maximize,
max_evaluations=30000,
mutation_rate=0.2,
use_one_fifth_rule=True)
if do_plot:
best = max(final_pop)
print('%s Example (%s) Best Solution: \n%s' % (ea.__class__.__name__, problem.__class__.__name__, str(best)))
import itertools
import pylab
import mpl_toolkits.mplot3d.axes3d as axes3d
num_points = 40
points = []
for lb, ub in zip(problem.bounder.lower_bound, problem.bounder.upper_bound):
points.append([(i / float(num_points)) * (ub - lb) + lb for i in range(num_points)])
points = itertools.product(*points)
x = []
y = []
for p in points:
x.append(p[0])
y.append(p[1])
z = problem.evaluator([[a, b] for a, b in zip(x, y)], {})
fig = pylab.figure()
ax = axes3d.Axes3D(fig)
ax.scatter3D(x, y, z)
ax.scatter3D([best.candidate[0]], [best.candidate[1]], [best.fitness], color='r')
ax.scatter3D([problem.global_optimum[0]], [problem.global_optimum[1]], problem.evaluator([problem.global_optimum], {}), color='g')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Fitness')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()
from random import Random
from time import time
from ecspy import ec
from ecspy import terminators
from ecspy import observers
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Griewank(2)
ea = ec.DEA(prng)
ea.terminator = terminators.evaluation_termination
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=100,
bounder=problem.bounder,
maximize=problem.maximize,
max_evaluations=30000)
if do_plot:
best = max(final_pop)
print('%s Example (%s) Best Solution: \n%s' % (ea.__class__.__name__, problem.__class__.__name__, str(best)))
import itertools
import pylab
import mpl_toolkits.mplot3d.axes3d as axes3d
num_points = 60
points = []
for lb, ub in zip(problem.bounder.lower_bound, problem.bounder.upper_bound):
points.append([(i / float(num_points)) * (ub - lb) + lb for i in range(num_points)])
points = itertools.product(*points)
x = []
y = []
for p in points:
x.append(p[0])
y.append(p[1])
z = problem.evaluator([[a, b] for a, b in zip(x, y)], {})
fig = pylab.figure()
ax = axes3d.Axes3D(fig)
ax.scatter3D(x, y, z)
ax.scatter3D([best.candidate[0]], [best.candidate[1]], [best.fitness], color='r')
ax.scatter3D([problem.global_optimum[0]], [problem.global_optimum[1]], problem.evaluator([problem.global_optimum], {}), color='g')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Fitness')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()
from random import Random
from time import time
from ecspy import ec
from ecspy import terminators
from ecspy import observers
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Rastrigin(2)
ea = ec.EDA(prng)
ea.terminator = terminators.evaluation_termination
final_pop = ea.evolve(evaluator=problem.evaluator,
generator=problem.generator,
pop_size=1000,
bounder=problem.bounder,
max_evaluations=30000,
num_selected=500,
num_offspring=1000,
num_elites=1)
if do_plot:
best = max(final_pop)
print('%s Example (%s) Best Solution: \n%s' % (ea.__class__.__name__, problem.__class__.__name__, str(best)))
import itertools
import pylab
import mpl_toolkits.mplot3d.axes3d as axes3d
num_points = 40
points = []
for lb, ub in zip(problem.bounder.lower_bound, problem.bounder.upper_bound):
points.append([(i / float(num_points)) * (ub - lb) + lb for i in range(num_points)])
points = itertools.product(*points)
x = []
y = []
for p in points:
x.append(p[0])
y.append(p[1])
z = problem.evaluator([[a, b] for a, b in zip(x, y)], {})
fig = pylab.figure()
ax = axes3d.Axes3D(fig)
ax.scatter3D(x, y, z)
ax.scatter3D([best.candidate[0]], [best.candidate[1]], [best.fitness], color='r')
ax.scatter3D([problem.global_optimum[0]], [problem.global_optimum[1]], problem.evaluator([problem.global_optimum], {}), color='g')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Fitness')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()
from random import Random
from time import time
from ecspy import ec
from ecspy import terminators
from ecspy import selectors
from ecspy import replacers
from ecspy import variators
from ecspy import observers
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Ackley(2)
ea = ec.EvolutionaryComputation(prng)
ea.selector = selectors.tournament_selection
ea.variator = [variators.uniform_crossover, variators.gaussian_mutation]
ea.replacer = replacers.steady_state_replacement
ea.terminator = terminators.generation_termination
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=100,
bounder=problem.bounder,
maximize=problem.maximize,
tourn_size=7,
num_selected=2,
max_generations=300,
mutation_rate=0.2)
if do_plot:
best = max(final_pop)
print('%s Example (%s) Best Solution: \n%s' % (ea.__class__.__name__, problem.__class__.__name__, str(best)))
import itertools
import pylab
import mpl_toolkits.mplot3d.axes3d as axes3d
num_points = 60
points = []
for lb, ub in zip(problem.bounder.lower_bound, problem.bounder.upper_bound):
points.append([(i / float(num_points)) * (ub - lb) + lb for i in range(num_points)])
points = itertools.product(*points)
x = []
y = []
for p in points:
x.append(p[0])
y.append(p[1])
z = problem.evaluator([[a, b] for a, b in zip(x, y)], {})
fig = pylab.figure()
ax = axes3d.Axes3D(fig)
ax.scatter3D(x, y, z)
ax.scatter3D([best.candidate[0]], [best.candidate[1]], [best.fitness], color='r')
ax.scatter3D([problem.global_optimum[0]], [problem.global_optimum[1]], problem.evaluator([problem.global_optimum], {}), color='g')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Fitness')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()
from time import time
from random import Random
from ecspy import terminators
from ecspy import topologies
from ecspy import swarm
from ecspy import ec
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Sphere(2)
ea = swarm.PSO(prng)
ea.terminator = terminators.evaluation_termination
ea.topology = topologies.ring_topology
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=100,
bounder=problem.bounder,
maximize=problem.maximize,
max_evaluations=30000,
neighborhood_size=5)
if do_plot:
best = max(final_pop)
print('%s Example (%s) Best Solution: \n%s' % (ea.__class__.__name__, problem.__class__.__name__, str(best)))
import itertools
import pylab
import mpl_toolkits.mplot3d.axes3d as axes3d
num_points = 40
points = []
for lb, ub in zip(problem.bounder.lower_bound, problem.bounder.upper_bound):
points.append([(i / float(num_points)) * (ub - lb) + lb for i in range(num_points)])
points = itertools.product(*points)
x = []
y = []
for p in points:
x.append(p[0])
y.append(p[1])
z = problem.evaluator([[a, b] for a, b in zip(x, y)], {})
fig = pylab.figure()
ax = axes3d.Axes3D(fig)
ax.scatter3D(x, y, z)
ax.scatter3D([best.candidate[0]], [best.candidate[1]], [best.fitness], color='r')
ax.scatter3D([problem.global_optimum[0]], [problem.global_optimum[1]], problem.evaluator([problem.global_optimum], {}), color='g')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Fitness')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()
from random import Random
from time import time
from ecspy import emo
from ecspy import variators
from ecspy import terminators
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Kursawe(3)
ea = emo.NSGA2(prng)
ea.variator = [variators.blend_crossover, variators.gaussian_mutation]
ea.terminator = terminators.generation_termination
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
pop_size=100,
maximize=problem.maximize,
bounder=problem.bounder,
max_generations=80)
if do_plot:
final_arc = ea.archive
print('%s Example (%s) Best Solutions: \n' % (ea.__class__.__name__, problem.__class__.__name__))
for f in final_arc:
print(f)
import pylab
x = []
y = []
for f in final_arc:
x.append(f.fitness[0])
y.append(f.fitness[1])
pylab.scatter(x, y, color='b')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()
from random import Random
from time import time
from ecspy import ec
from ecspy import emo
from ecspy import terminators
from ecspy import benchmarks
def main(do_plot=True, prng=None):
if prng is None:
prng = Random()
prng.seed(time())
problem = benchmarks.Kursawe(3)
ea = emo.PAES(prng)
ea.terminator = terminators.evaluation_termination
final_pop = ea.evolve(generator=problem.generator,
evaluator=problem.evaluator,
bounder=problem.bounder,
maximize=problem.maximize,
max_evaluations=30000,
max_archive_size=100,
num_grid_divisions=4)
if do_plot:
final_arc = ea.archive
print('%s Example (%s) Best Solutions: \n' % (ea.__class__.__name__, problem.__class__.__name__))
for f in final_arc:
print(f)
import pylab
x = []
y = []
for f in final_arc:
x.append(f.fitness[0])
y.append(f.fitness[1])
pylab.scatter(x, y, color='b')
pylab.savefig('%s Example (%s).pdf' % (ea.__class__.__name__, problem.__class__.__name__), format='pdf')
pylab.show()
return ea
if __name__ == '__main__':
main()