def test_truncation_parents_selection():
""" Test (mu + lambda), i.e., parents competing with offspring
Create parent and offspring populations such that each has an "best" individual that will be selected by
truncation selection.
"""
parents = [
Individual([0, 0, 0], decoder=IdentityDecoder(), problem=MaxOnes()),
Individual([1, 1, 0], decoder=IdentityDecoder(), problem=MaxOnes())
]
parents = Individual.evaluate_population(parents)
offspring = [
Individual([0, 0, 1], decoder=IdentityDecoder(), problem=MaxOnes()),
Individual([1, 1, 1], decoder=IdentityDecoder(), problem=MaxOnes())
]
offspring = Individual.evaluate_population(offspring)
truncated = ops.truncation_selection(offspring, 2, parents=parents)
assert len(truncated) == 2
assert parents[1] in truncated
assert offspring[1] in truncated
def fitness(self, net, proc, id_for_printing=-1):
total_weights = net.num_edges()
total_delays = net.num_edges()
total_thresholds = net.num_nodes()
dec = [8] * total_weights + [4] * total_delays + [7] * total_thresholds
leap_decoder = BinaryToIntDecoder(*dec)
problem = NetworkProblem(net, proc, self)
genome_len = 8 * total_weights + 4 * total_delays + 7 * total_thresholds
parents = Individual.create_population(
10,
initialize=create_binary_sequence(genome_len),
decoder=leap_decoder,
problem=problem)
parents = Individual.evaluate_population(parents)
max_generation = 10
#stdout_probe = probe.FitnessStatsCSVProbe(context, stream=sys.stdout)
generation_counter = util.inc_generation(context=context)
while generation_counter.generation() < max_generation:
offspring = pipe(
parents, ops.tournament_selection, ops.clone,
mutate_bitflip, ops.uniform_crossover, ops.evaluate,
ops.pool(size=len(parents))) #, # accumulate offspring
#stdout_probe)
parents = offspring
generation_counter() # increment to the next generation
best = probe.best_of_gen(parents).decode()
set_weights(best, net)
return self.get_fitness_score(net, proc, id_for_printing)
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_tournament_selection():
""" This simple binary tournament_selection selection """
# Make a population where binary tournament_selection has an obvious reproducible choice
pop = [
Individual([0, 0, 0], decoder=IdentityDecoder(), problem=MaxOnes()),
Individual([1, 1, 1], decoder=IdentityDecoder(), problem=MaxOnes())
]
# We first need to evaluate all the individuals so that truncation selection has fitnesses to compare
pop = Individual.evaluate_population(pop)
best = next(ops.tournament_selection(pop))
pass
def test_truncation_selection():
""" Basic truncation selection test"""
pop = [
Individual([0, 0, 0], decoder=IdentityDecoder(), problem=MaxOnes()),
Individual([0, 0, 1], decoder=IdentityDecoder(), problem=MaxOnes()),
Individual([1, 1, 0], decoder=IdentityDecoder(), problem=MaxOnes()),
Individual([1, 1, 1], decoder=IdentityDecoder(), problem=MaxOnes())
]
# We first need to evaluate all the individuals so that truncation selection has fitnesses to compare
pop = Individual.evaluate_population(pop)
truncated = ops.truncation_selection(pop, 2)
assert len(truncated) == 2
# Just to make sure, check that the two best individuals from the original population are in the selected population
assert pop[2] in truncated
assert pop[3] in truncated
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_lexical_maximization():
"""
Tests the lexical_parsimony() for maximization problems
"""
problem = MaxOnes()
# fitness=3, len(genome)=6
pop = [Individual(np.array([0, 0, 0, 1, 1, 1]), problem=problem)]
# fitness=2, len(genome)=2
pop.append(Individual(np.array([1, 1]), problem=problem))
# fitness=3, len(genome)=3
pop.append(Individual(np.array([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 3 genomes
assert np.all(best[0].genome == [1, 1, 1])