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) 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(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 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)