def test_organism_basic(self):
"""Exercise basic organism functionality.
"""
same_genome = MutableSeq("1234", self.alphabet)
same_organism = Organism.Organism(same_genome, fitness_calculator)
dif_genome = MutableSeq("1111", self.alphabet)
dif_organism = Organism.Organism(dif_genome, fitness_calculator)
assert str(self.organism) == str(same_organism), \
"Comparison doesn't work for identical organisms."
assert str(self.organism) != str(dif_organism), \
"Comparison doesn't work for different organism."
def find_schemas(self, fitness, num_schemas):
"""Find the given number of unique schemas using a genetic algorithm
Arguments:
o fitness - A callable object (ie. function) which will evaluate
the fitness of a motif.
o num_schemas - The number of unique schemas with good fitness
that we want to generate.
"""
start_population = \
Organism.function_population(self.motif_generator.random_motif,
self.initial_population,
fitness)
finisher = SimpleFinisher(num_schemas, self.min_generations)
# set up the evolver and do the evolution
evolver = GenerationEvolver(start_population, self.selector)
evolved_pop = evolver.evolve(finisher.is_finished)
# convert the evolved population into a PatternRepository
schema_info = {}
for org in evolved_pop:
# convert the Genome from a MutableSeq to a Seq so that
# the schemas are just strings (and not array("c")s)
seq_genome = org.genome.toseq()
schema_info[str(seq_genome)] = org.fitness
return PatternRepository(schema_info)
def main(num_queens):
print "Calculating for %s queens..." % num_queens
num_orgs = 1000
print "Generating an initial population of %s organisms..." % num_orgs
queen_alphabet = QueensAlphabet(num_queens)
start_population = Organism.random_population(queen_alphabet, num_queens, num_orgs, queens_fitness)
print "Evolving the population and searching for a solution..."
mutator = QueensMutation(mutation_rate=0.05)
crossover = QueensCrossover(queens_fitness, crossover_prob=0.2, max_crossover_size=4)
repair = QueensRepair()
# rw_selector = RouletteWheelSelection(mutator, crossover, repair)
t_selector = TournamentSelection(mutator, crossover, repair, 5)
start_time = time.ctime(time.time())
evolver = GenerationEvolver(start_population, t_selector)
evolved_pop = evolver.evolve(queens_solved)
end_time = time.ctime(time.time())
unique_solutions = []
for organism in evolved_pop:
if organism.fitness == num_queens:
if organism not in unique_solutions:
unique_solutions.append(organism)
if VERBOSE:
print "Search started at %s and ended at %s" % (start_time, end_time)
for organism in unique_solutions:
print "We did it!", organism
display_board(organism.genome)
def find_schemas(self, fitness, num_schemas):
"""Find the given number of unique schemas using a genetic algorithm
Arguments:
- fitness - A callable object (ie. function) which will evaluate
the fitness of a motif.
- num_schemas - The number of unique schemas with good fitness
that we want to generate.
"""
start_population = \
Organism.function_population(self.motif_generator.random_motif,
self.initial_population,
fitness)
finisher = SimpleFinisher(num_schemas, self.min_generations)
# set up the evolver and do the evolution
evolver = GenerationEvolver(start_population, self.selector)
evolved_pop = evolver.evolve(finisher.is_finished)
# convert the evolved population into a PatternRepository
schema_info = {}
for org in evolved_pop:
# convert the Genome from a MutableSeq to a Seq so that
# the schemas are just strings (and not array("c")s)
seq_genome = org.genome.toseq()
schema_info[str(seq_genome)] = org.fitness
return PatternRepository(schema_info)
def test_provide_fitness(self):
"""Test that providing a pre-calculated fitness works.
"""
def fitness_calc(genome):
raise ValueError("Should not have been executed.")
genome = self.organism.genome
# make sure not supplying fitness works
try:
new_org = Organism.Organism(genome, fitness_calc)
raise AssertionError("Did not calculate fitness when expected.")
except ValueError:
pass
# make sure supplying fitness works
new_org = Organism.Organism(genome, fitness_calc, 50)
def test_function_population(self):
"""Create a population using a function to generate genomes.
"""
num_orgs = 10
new_pop = Organism.function_population(genome_generator,
num_orgs, fitness_calculator)
self.assertEqual(len(new_pop), num_orgs, "Expected %s organisms, "
"got %s" % (num_orgs, len(new_pop)))
for org in new_pop:
self.assertIsInstance(org, Organism.Organism,
"Expected to get an organism, got %r" % org)
exp_fit = fitness_calculator(org.genome)
self.assertEqual(org.fitness, exp_fit, "Expected fitness of %s, "
"got %s" % (org.fitness, exp_fit))
def test_function_population(self):
"""Create a population using a function to generate genomes.
"""
num_orgs = 10
new_pop = Organism.function_population(genome_generator, num_orgs,
fitness_calculator)
assert len(new_pop) == num_orgs, "Expected %s organisms, got %s" \
% (num_orgs, len(new_pops))
for org in new_pop:
assert isinstance(org, Organism.Organism), \
"Expected to get an organism, got %r" % org
exp_fit = fitness_calculator(org.genome)
assert org.fitness == exp_fit, \
"Expected fitness of %s, got %s" % (org.fitness, exp_fit)
def test_function_population(self):
"""Create a population using a function to generate genomes.
"""
num_orgs = 10
new_pop = Organism.function_population(genome_generator,
num_orgs, fitness_calculator)
assert len(new_pop) == num_orgs, "Expected %s organisms, got %s" \
% (num_orgs, len(new_pops))
for org in new_pop:
assert isinstance(org, Organism.Organism), \
"Expected to get an organism, got %r" % org
exp_fit = fitness_calculator(org.genome)
assert org.fitness == exp_fit, \
"Expected fitness of %s, got %s" % (org.fitness, exp_fit)
def test_function_population(self):
"""Create a population using a function to generate genomes.
"""
num_orgs = 10
new_pop = Organism.function_population(genome_generator, num_orgs,
fitness_calculator)
self.assertEqual(
len(new_pop), num_orgs, "Expected %s organisms, "
"got %s" % (num_orgs, len(new_pop)))
for org in new_pop:
self.assertIsInstance(org, Organism.Organism,
"Expected to get an organism, got %r" % org)
exp_fit = fitness_calculator(org.genome)
self.assertEqual(
org.fitness, exp_fit, "Expected fitness of %s, "
"got %s" % (org.fitness, exp_fit))
def test_random_population_types(self):
"""Creating a random population with different types of alphabets.
"""
class DoubleAlphabet:
letters = [1.0, 2.0]
class CharacterAlphabet:
letters = ["a", "b"]
class IntegerAlphabet:
letters = [1, 2]
def test_fitness(genome):
return 2
all_alphabets = [DoubleAlphabet(), CharacterAlphabet(),
IntegerAlphabet()]
for alphabet in all_alphabets:
new_pop = Organism.random_population(alphabet, 5, 10,
test_fitness)
def test_random_population_types(self):
"""Creating a random population with different types of alphabets.
"""
class DoubleAlphabet:
letters = [1.0, 2.0]
class CharacterAlphabet:
letters = ["a", "b"]
class IntegerAlphabet:
letters = [1, 2]
def test_fitness(genome):
return 2
all_alphabets = [DoubleAlphabet(), CharacterAlphabet(),
IntegerAlphabet()]
for alphabet in all_alphabets:
new_pop = Organism.random_population(alphabet, 5, 10,
test_fitness)
def test_random_population(self):
"""Create a population randomly from a alphabet.
"""
num_orgs = 10
genome_size = 5
new_pop = Organism.random_population(self.alphabet, genome_size,
num_orgs, fitness_calculator)
assert len(new_pop) == num_orgs, "Expected %s organisms, got %s" \
% (num_orgs, len(new_pops))
for org in new_pop:
assert isinstance(org, Organism.Organism), \
"Expected to get an organism, got %r" % org
exp_fit = fitness_calculator(org.genome)
assert org.fitness == exp_fit, \
"Expected fitness of %s, got %s" % (org.fitness, exp_fit)
assert len(org.genome) == genome_size, \
"Expected genome size of %s, got %s" % (len(org.genome),
genome_size)
def test_random_population(self):
"""Create a population randomly from a alphabet.
"""
num_orgs = 10
genome_size = 5
new_pop = Organism.random_population(self.alphabet, genome_size,
num_orgs, fitness_calculator)
self.assertEqual(len(new_pop), num_orgs, "Expected %s organisms, "
"got %s " % (num_orgs, len(new_pop)))
for org in new_pop:
self.assertIsInstance(org, Organism.Organism,
"Expected to get an organism, got %r" % org)
exp_fit = fitness_calculator(org.genome)
self.assertEqual(org.fitness, exp_fit, "Expected fitness of %s, "
"got %s" % (org.fitness, exp_fit))
self.assertEqual(len(org.genome), genome_size, "Expected genome "
"size of %s, got %s"
% (len(org.genome), genome_size))
def test_random_population(self):
"""Create a population randomly from a alphabet.
"""
num_orgs = 10
genome_size = 5
new_pop = Organism.random_population(self.alphabet, genome_size,
num_orgs, fitness_calculator)
assert len(new_pop) == num_orgs, "Expected %s organisms, got %s" \
% (num_orgs, len(new_pops))
for org in new_pop:
assert isinstance(org, Organism.Organism), \
"Expected to get an organism, got %r" % org
exp_fit = fitness_calculator(org.genome)
assert org.fitness == exp_fit, \
"Expected fitness of %s, got %s" % (org.fitness, exp_fit)
assert len(org.genome) == genome_size, \
"Expected genome size of %s, got %s" % (len(org.genome),
genome_size)
def main(num_queens):
print "Calculating for %s queens..." % num_queens
num_orgs = 1000
print "Generating an initial population of %s organisms..." % num_orgs
queen_alphabet = QueensAlphabet(num_queens)
start_population = Organism.random_population(queen_alphabet, num_queens,
num_orgs, queens_fitness)
print "Evolving the population and searching for a solution..."
mutator = QueensMutation(mutation_rate=0.05)
crossover = QueensCrossover(queens_fitness,
crossover_prob=.2,
max_crossover_size=4)
repair = QueensRepair()
# rw_selector = RouletteWheelSelection(mutator, crossover, repair)
t_selector = TournamentSelection(mutator, crossover, repair, 5)
start_time = time.ctime(time.time())
evolver = GenerationEvolver(start_population, t_selector)
evolved_pop = evolver.evolve(queens_solved)
end_time = time.ctime(time.time())
unique_solutions = []
for organism in evolved_pop:
if organism.fitness == num_queens:
if organism not in unique_solutions:
unique_solutions.append(organism)
if VERBOSE:
print "Search started at %s and ended at %s" % (start_time, end_time)
for organism in unique_solutions:
print "We did it!", organism
display_board(organism.genome)
def test_random_population(self):
"""Create a population randomly from a alphabet.
"""
num_orgs = 10
genome_size = 5
new_pop = Organism.random_population(self.alphabet, genome_size,
num_orgs, fitness_calculator)
self.assertEqual(
len(new_pop), num_orgs, "Expected %s organisms, "
"got %s " % (num_orgs, len(new_pop)))
for org in new_pop:
self.assertIsInstance(org, Organism.Organism,
"Expected to get an organism, got %r" % org)
exp_fit = fitness_calculator(org.genome)
self.assertEqual(
org.fitness, exp_fit, "Expected fitness of %s, "
"got %s" % (org.fitness, exp_fit))
self.assertEqual(
len(org.genome), genome_size, "Expected genome "
"size of %s, got %s" % (len(org.genome), genome_size))
def setUp(self):
self.alphabet = TestAlphabet()
self.genome = MutableSeq("1234", self.alphabet)
self.organism = Organism.Organism(self.genome, fitness_calculator)
