def test_koza_maximization():
"""
Tests the koza_parsimony() function for maximization problems
"""
problem = SpheroidProblem(maximize=True)
pop = []
# We set up three individuals in ascending order of fitness of
# [0, 1, 2]
pop.append(Individual(np.array([0]), problem=problem))
pop.append(Individual(np.array([1]), problem=problem))
pop.append(Individual(np.array([0, 0, 1, 1]), problem=problem))
pop = Individual.evaluate_population(pop)
# Now truncate down to the "best" that should be the third one
best = ops.truncation_selection(pop, size=1)
assert np.all(best[0].genome == [0, 0, 1, 1])
# This is just to look at the influence of the parsimony pressure on
# the order of the individual. You should observe that the order is now
# ([0,0,1,1], [0], [1]) because now their biased fitnesses are respectively
# (-2, -1, 0)
pop.sort(key=koza_parsimony(penalty=1))
# Ok, now we want to turn on parsimony pressure, which should knock the
# really really really long genome out of the running for "best"
best = ops.truncation_selection(pop, size=1, key=koza_parsimony(penalty=1))
assert np.all(best[0].genome == [1])
def test_koza_minimization():
"""
Tests the koza_parsimony() function for _minimization_ problems.
"""
problem = SpheroidProblem(maximize=False)
pop = []
# First individual has a fitness of three but len(genome) of 4
pop.append(Individual(np.array([0, 1, 1, 1]), problem=problem))
# Second has a fitness of 4, but len(genome) of 1
pop.append(Individual(np.array([2]), problem=problem))
pop = Individual.evaluate_population(pop)
best = ops.truncation_selection(pop, size=1, key=koza_parsimony(penalty=1))
assert np.all(best[0].genome == [2])
def test_lexical_minimization():
"""
Tests lexical_parsimony() for minimization problems
"""
problem = SpheroidProblem(maximize=False)
pop = []
# fitness=4, len(genome)=1
pop.append(Individual(np.array([2]), problem=problem))
# fitness=4, len(genome)=4
pop.append(Individual(np.array([1, 1, 1, 1]), problem=problem))
pop = Individual.evaluate_population(pop)
best = ops.truncation_selection(pop, size=1, key=lexical_parsimony)
# prefers the shorter of the genomes with equivalent fitness
assert np.all(best[0].genome == [2])
def test_truncation_selection_with_nan2():
"""If truncation selection encounters a NaN and non-NaN fitness
while minimizing, the non-NaN wins.
"""
problem = SpheroidProblem(maximize=False)
pop = []
pop.append(Individual(np.array([0]), problem=problem))
pop.append(Individual(np.array([1]), problem=problem))
pop = Individual.evaluate_population(pop)
# First *normal* selection should yield the 0 as the "best"
best = ops.truncation_selection(pop, size=1)
assert pop[0] == best[0]
# But now let's set that best to a NaN, which *should* force the other
# individual to be selected.
pop[0].fitness = nan
best = ops.truncation_selection(pop, size=1)
assert pop[1] == best[0]
# Handbook of EC, B1.3:2
context['leap']['std'] *= .85
if __name__ == '__main__':
# Define the real value bounds for initializing the population. In this case,
# we define a genome of four bounds.
# the (-5.12,5.12) was what was originally used for this problem in
# Ken De Jong's 1975 dissertation, so was used for historical reasons.
bounds = [(-5.12, 5.12), (-5.12, 5.12), (-5.12, 5.12), (-5.12, 5.12)]
parents = Individual.create_population(
5,
initialize=create_real_vector(bounds),
decoder=IdentityDecoder(),
problem=SpheroidProblem(maximize=False))
# Evaluate initial population
parents = Individual.evaluate_population(parents)
context['leap']['std'] = 2
# We use the provided context, but we could roll our own if we
# wanted to keep separate contexts. E.g., island models may want to have
# their own contexts.
generation_counter = util.inc_generation(context=context,
callbacks=(anneal_std, ))
# print initial, random population
print_population(parents, generation=0)
# main
##############################
if __name__ == '__main__':
# file_probe = probe.AttributesCSVProbe(context, stream=sys.stdout, do_fitness=True, do_genome=True)
topology = nx.complete_graph(3)
nx.draw(topology)
l = 2
bounds = (0, 1)
def transform(problem):
return TranslatedProblem.random(ScaledProblem(problem, new_bounds=bounds), (-0.5, 0.5), l)
# Island-specific fitness functions
problems = [ transform(SpheroidProblem(maximize=False)),
transform(RastriginProblem(maximize=False)),
transform(AckleyProblem(maximize=False))
]
# Probes and visualization
genotype_probes, fitness_probes = viz_plots(problems, modulo=10)
subpop_probes = list(zip(genotype_probes, fitness_probes))
def get_island(context):
"""Closure that returns a callback for retrieving the current island
ID during logging."""
return lambda _: context['leap']['current_subpopulation']
pop_size = 10
ea = multi_population_ea(generations=1000,