def __init__(self, optimizer, problem, termination):
self.optimizer = optimizer
self.problem = problem
self.termination = termination
self.logger = Logger(self)
self._count_cfc = 0
self._count_ffc = 0
self._generations = 0
self.logger.add_binding('_count_cfc', 'count_cfc')
self.logger.add_binding('_count_ffc', 'count_ffc')
self.logger.add_binding('_generations', 'generations')
def __init__(self, mu, lambd):
self._mu = mu
self._lambd = lambd
self.logger = Logger(self)
self.logger.add_const_binding('_mu', 'mu')
self.logger.add_const_binding('_lambd', 'lambda')
self.logger.add_binding('_best_fitness', 'best_fitness')
self.logger.add_binding('_worst_fitness', 'worst_fitness')
self.logger.add_binding('_mean_fitness', 'mean_fitness')
self.logger.add_binding('_selected_children', 'selected_children')
self.logger.add_binding('_count_constraint_infeasibles', 'infeasibles')
self._count_constraint_infeasibles = 0
self._count_repaired = 0
class EvolutionStrategy(object):
def __init__(self, mu, lambd):
self._mu = mu
self._lambd = lambd
self.logger = Logger(self)
self.logger.add_const_binding('_mu', 'mu')
self.logger.add_const_binding('_lambd', 'lambda')
self.logger.add_binding('_best_fitness', 'best_fitness')
self.logger.add_binding('_worst_fitness', 'worst_fitness')
self.logger.add_binding('_mean_fitness', 'mean_fitness')
self.logger.add_binding('_selected_children', 'selected_children')
self.logger.add_binding('_count_constraint_infeasibles', 'infeasibles')
self._count_constraint_infeasibles = 0
self._count_repaired = 0
def ask_pending_solutions(self):
pass
def tell_feasibility(self, feasibility_information):
pass
def ask_valid_solutions(self):
pass
def tell_fitness(self, fitnesses):
pass
def ask_posteriori_solutions(self):
pass
def tell_a_posteriori_feasibility(self, apos_feasibility):
pass
class Simulator(object):
name = "evopy: framework for experimention in evolutionary computing"
description = "Single-threaded Simulator"
description_short = "Simulator"
def __init__(self, optimizer, problem, termination):
self.optimizer = optimizer
self.problem = problem
self.termination = termination
self.logger = Logger(self)
self._count_cfc = 0
self._count_ffc = 0
self._generations = 0
self.logger.add_binding('_count_cfc', 'count_cfc')
self.logger.add_binding('_count_ffc', 'count_ffc')
self.logger.add_binding('_generations', 'generations')
def _information(self):
print ("-" * 80) + "\n" + self.name +"\n" + ("-" * 80)
print "simulator: " + self.description
print "optimizer: " + self.optimizer.description
print "problem: " + self.problem.description
print "-" * 80
def simulate(self):
self._information()
while(True):
# Simulator and optimizer handling constraints
all_feasible = False
while(not all_feasible):
# ASK for solutions (feasbile and infeasible)
solutions = self.optimizer.ask_pending_solutions()
# CHECK solutions for feasibility
feasibility =\
lambda solution, position :\
(solution, self.problem.is_feasible(position))
feasibility_information = []
for solution in solutions:
self._count_cfc += 1
information = vsplit(solution, solution.shape[0])
position = information[0]
feasibility_information.append(feasibility(solution, position))
# TELL feasibility, returns True if all feasible,
# returns False if extra checks
all_feasible =\
self.optimizer.tell_feasibility(feasibility_information)
# ASK for valid solutions (feasible)
valid_solutions = self.optimizer.ask_valid_solutions()
# CHECK fitness
fitnesses = []
fitness = lambda solution : (solution, self.problem.fitness(solution[0]))
for solution in valid_solutions:
fitnesses.append(fitness(solution))
self._count_ffc += 1
# TELL fitness, return optimum
optimum, optimum_fitness = self.optimizer.tell_fitness(fitnesses)
# A-POSTERIORI information for confusion matrix
if('ask_a_posteriori_solutions' in dir(self.optimizer)):
apos_feasibility =\
lambda (position, meta_feasibility) :\
(position, meta_feasibility, self.problem.is_feasible(position))
apos_solutions = self.optimizer.ask_a_posteriori_solutions()
feasibility_info = []
for solution in apos_solutions:
information = vsplit(solution[0], solution[0].shape[0])
position = information[0]
meta_feasibility = solution[1]
feasibility_info.append(apos_feasibility((position, meta_feasibility)))
self.optimizer.tell_a_posteriori_feasibility(feasibility_info)
# UPDATE OWN STATS
self._generations += 1
self.logger.log()
self._count_cfc = 0
self._count_ffc = 0
print "%.20f" % (optimum_fitness)
# TERMINATION
if(self.termination.terminate(optimum_fitness, self._generations)):
break
return self
