def main(): population = create_initial_population() population = Evolver.sort_by_fitness(population) print('Initial population:') print_population(population) fitness_evolution = [(0, fitnesses(population))] try: for n in range(iteration): population = Evolver.evolve(population) print(n, fitnesses(population), end=" \r") if (n + 1) % (iteration // 4) == 0: fitness_evolution += [(n + 1, fitnesses(population))] except KeyboardInterrupt: pass finally: print('Final population:') print_population(population) plot_fitness_distributions(fitness_evolution) plt.show()
def generate(self): logging.info( "***generate(generations, population, all_possible_genes, dataset)***" ) t_start = datetime.datetime.now() t = time.time() evolver = Evolver(self.params) genomes = evolver.create_population(self.population) ofile = open(self.path + '/result.csv', "w") writer = csv.writer(ofile, delimiter=',') table_head = list() for p in self.params: table_head.append(str(p)) table_head.append("accuracy") row = table_head writer.writerow(row) # Evolve the generation. for i in range(self.generations): logging.info("***Now in generation %d of %d***" % (i + 1, self.generations)) self.print_genomes(genomes) # Train and get accuracy for networks/genomes. self.train_genomes(genomes, writer) # Get the average accuracy for this generation. average_accuracy = self.get_average_accuracy(genomes) # Print out the average accuracy each generation. logging.info("Generation average: %.2f%%" % (average_accuracy * 100)) logging.info('-' * 80) # Evolve, except on the last iteration. if i != self.generations - 1: genomes = evolver.evolve(genomes) # Sort our final population according to performance. genomes = sorted(genomes, key=lambda x: x.accuracy, reverse=True) # Print out the top 5 networks/genomes. self.print_genomes(genomes[:5]) ofile.close() total = time.time() - t m, s = divmod(total, 60) h, m = divmod(m, 60) d, h = divmod(h, 24) t_stop = datetime.datetime.now() file = open(self.path + '/total_time.txt', 'w') file.write('Start : ' + str(t_start) + '\n') file.write('Stop : ' + str(t_stop) + '\n') file.write('Total :' + "%d days, %d:%02d:%02d" % (d, h, m, s) + '\n') file.close()
def get_evolver_and_sketch(source_image, output_folder, num_triangles, save_frequency, color_type, start_from=None, continue_run=False, randomized=False): im = Image.open(source_image) im = im.convert(mode=color_type) assert not (start_from and continue_run ), "you should only use start_from or continue_run, not both" sketch = None e = None if continue_run: # find the latest file in the folder file_names = glob.glob( os.path.join(output_folder, "intermediate_???.txt")) best = -1 for filename in file_names: num = int(filename[-7:-4]) if num > best: best = num if best >= 0: filename = os.path.join(output_folder, "intermediate_%03d.txt" % best) module_logger.info( "Restarting evolution based on found file 'intermediate_%03d.txt'", best) sketch = Sketch.read(filename) e = Evolver(im, output_folder, num_triangles, save_frequency, color_type=color_type, save_index=best + 1) # Preferred is to load from the auto-save, but in case it died while saving the above will still work filename = os.path.join(output_folder, "auto_save.txt") if os.path.exists(filename): sketch = Sketch.read(filename) if sketch is None: utils.clean_dir(output_folder) if start_from: sketch = Sketch.read(start_from) else: if randomized: seeder = RandomSeeder(im, output_folder, num_triangles, color_type) else: seeder = Seeder(im, output_folder, num_triangles, color_type) sketch = seeder.run() e = Evolver(im, output_folder, num_triangles, save_frequency, color_type=color_type) return e, sketch
class Test_Model(Model): def __init__(self, args, rng): super(Test_Model, self).__init__(args, rng) def get_summary(self): print "Running test model" def get_output(self): print self.evolver.current_code print "Model done" def run(self): trnas = 8 aarss = 8 phi = 0.9 mu = .01 msg_mu = .1 pop = 100 trna_names = ["tra_" + str(i) for i in xrange(trnas)] codon_names = ["codon_" + str(i) for i in xrange(trnas)] aars_names = ["aars_" + str(i) for i in xrange(aarss)] aa_names = ["aa_" + str(i) for i in xrange(aarss)] site_names = ["site_" + str(i) for i in xrange(aarss)] trna_space = Bit_TRNA_Space(trna_names, codon_names) aars_space = Id_AARS_Space(aars_names, aa_names) trna = range(trnas) trna[1] = 0 trna[2] = 0 code = Code(trna, range(aarss), trna_space, aars_space) site_types = Ring_Site_Types(phi, zip(aa_names, np.arange(0, 1, .125)), zip(site_names, np.arange(0, 1, .125)), [1] * len(site_names)) self.evolver = Evolver( code, site_types, mu, get_ring_mutation_matrix(len(codon_names), msg_mu), pop, self.rng) mut = Code_Mutator(code, mu) trna[0] = 1 code2 = Code(trna, range(aarss), trna_space, aars_space) #print mut.mutation_probability(code2) #print [trna_space.mutation_probability(0, i, mu) for i in xrange(8)] # mut = Code_Mutator(code, mu) # code_dict = mut.get_one_gene_mutation_probabilities() #for code in code_dict: # print code, code_dict[code] for i in xrange(10000): self.evolver.step_time()
class Test_Model(Model): def __init__(self, args, rng): super(Test_Model, self).__init__(args, rng) def get_summary(self): print "Running test model" def get_output(self): print self.evolver.current_code print "Model done" def run(self): trnas = 8 aarss = 8 phi = 0.9 mu = .01 msg_mu = .1 pop = 100 trna_names = ["tra_" + str(i) for i in xrange(trnas)] codon_names = ["codon_" + str(i) for i in xrange(trnas)] aars_names = ["aars_" + str(i) for i in xrange(aarss)] aa_names = ["aa_" + str(i) for i in xrange(aarss)] site_names = ["site_" + str(i) for i in xrange(aarss)] trna_space = Bit_TRNA_Space(trna_names, codon_names) aars_space = Id_AARS_Space(aars_names, aa_names) trna = range(trnas) trna[1] = 0 trna[2] = 0 code = Code(trna, range(aarss), trna_space, aars_space) site_types = Ring_Site_Types(phi, zip(aa_names, np.arange(0, 1, .125)), zip(site_names, np.arange(0, 1, .125)), [1] * len(site_names)) self.evolver = Evolver(code, site_types, mu, get_ring_mutation_matrix(len(codon_names), msg_mu), pop, self.rng) mut = Code_Mutator(code, mu) trna[0] = 1 code2 = Code(trna, range(aarss), trna_space, aars_space) #print mut.mutation_probability(code2) #print [trna_space.mutation_probability(0, i, mu) for i in xrange(8)] # mut = Code_Mutator(code, mu) # code_dict = mut.get_one_gene_mutation_probabilities() #for code in code_dict: # print code, code_dict[code] for i in xrange(10000): self.evolver.step_time()
def test_sort_by_fitness_gives_entities_descending_order_by_fitness(): entity_1 = Mock(fitness=1) entity_2 = Mock(fitness=2) entity_3 = Mock(fitness=3) population = Evolver.sort_by_fitness([entity_1, entity_3, entity_2]) assert population == [entity_3, entity_2, entity_1] assert [entity.fitness for entity in population] == [3, 2, 1]
def generate(generations, population, all_possible_genes, dataset): """Generate a network with the genetic algorithm. Args: generations (int): Number of times to evolve the population population (int): Number of networks in each generation all_possible_genes (dict): Parameter choices for networks dataset (str): Dataset to use for training/evaluating """ logging.info( "***generate(generations, population, all_possible_genes, dataset)***") evolver = Evolver(all_possible_genes) genomes = evolver.create_population(population) # Evolve the generation. for i in range(generations): logging.info("***Now in generation %d of %d***" % (i + 1, generations)) print_genomes(genomes) # Train and get accuracy for networks/genomes. train_genomes(genomes, dataset) # Get the average accuracy for this generation. average_accuracy = get_average_accuracy(genomes) # Print out the average accuracy each generation. logging.info("Generation average: %.2f%%" % (average_accuracy * 100)) logging.info('-' * 80) #----------- # Evolve, except on the last iteration. if i != generations - 1: # Evolve! genomes = evolver.evolve(genomes) # Sort our final population according to performance. genomes = sorted(genomes, key=lambda x: x.accuracy, reverse=True) # Print out the top 5 networks/genomes. print_genomes(genomes[:5])
def generate(generations, population, all_possible_genes, dataset): """Generate a network with the genetic algorithm. Args: generations (int): Number of times to evolve the population population (int): Number of networks in each generation all_possible_genes (dict): Parameter choices for networks dataset (str): Dataset to use for training/evaluating """ logging.info("***generate(generations, population, all_possible_genes, dataset)***") evolver = Evolver(all_possible_genes) genomes = evolver.create_population(population) # Evolve the generation. for i in range( generations ): logging.info("***Now in generation %d of %d***" % (i + 1, generations)) print_genomes(genomes) # Train and get accuracy for networks/genomes. train_genomes(genomes, dataset) # Get the average accuracy for this generation. average_accuracy = get_average_accuracy(genomes) # Print out the average accuracy each generation. logging.info("Generation average: %.2f%%" % (average_accuracy * 100)) logging.info('-'*80) #----------- # Evolve, except on the last iteration. if i != generations - 1: # Evolve! genomes = evolver.evolve(genomes) # Sort our final population according to performance. genomes = sorted(genomes, key=lambda x: x.accuracy, reverse=True) # Print out the top 5 networks/genomes. print_genomes(genomes[:5])
class Evolver_Test(unittest.TestCase): def setUp(self): self.aars_space = AARS_Space(range(2), np.diag([1] * 2), get_uniform_mutation_matrix(2, .01)) # mu is zero so that there is only 3 potential codes available # and so the code is forced to handle mutants with a fixation # probability of zero. self.trna_space = TRNA_Space(range(2), np.diag([1] * 2), np.diag([1] * 2), get_uniform_mutation_matrix(2, .01)) pchem_vals = [.30, .70] self.site_types = Ring_Site_Types(.05, zip(range(2), pchem_vals), zip(range(2), pchem_vals), [1] * 2) message_mutation_matrix = get_uniform_mutation_matrix(2, .01) #print message_mutation_matrix.shape #print np.matrix([[.5, .5], [.5, .5]]).shape self.code = Code([1], [1], self.trna_space, self.aars_space) rng = Random() rng.seed(42) self.evolver = Evolver(self.code, self.site_types, message_mutation_matrix, 100, rng) def test_overall_fitness(self): """ Check if Eq5 SellaArdell 06 is implemented correctly. """ self.assertAlmostEqual(.5 ** 2, self.evolver._overall_fitness([.5, .5])) def test_transition_probabilities(self): self.assertTrue(False, "Still need to implement this test.") def test_step_time(self): self.evolver.step_time() self.assertEqual(self.evolver._current_code, self.code)
def setUp(self): self.aars_space = AARS_Space(range(2), np.diag([1] * 2), get_uniform_mutation_matrix(2, .01)) # mu is zero so that there is only 3 potential codes available # and so the code is forced to handle mutants with a fixation # probability of zero. self.trna_space = TRNA_Space(range(2), np.diag([1] * 2), np.diag([1] * 2), get_uniform_mutation_matrix(2, .01)) pchem_vals = [.30, .70] self.site_types = Ring_Site_Types(.05, zip(range(2), pchem_vals), zip(range(2), pchem_vals), [1] * 2) message_mutation_matrix = get_uniform_mutation_matrix(2, .01) #print message_mutation_matrix.shape #print np.matrix([[.5, .5], [.5, .5]]).shape self.code = Code([1], [1], self.trna_space, self.aars_space) rng = Random() rng.seed(42) self.evolver = Evolver(self.code, self.site_types, message_mutation_matrix, 100, rng)
def main(): comm = MPI.COMM_WORLD size = comm.Get_size() if size == 1: print("Can not evolve on single node, 2 nodes required at least!") sys.exit(-1) parser = argparse.ArgumentParser(description='Distributed evolver') parser.add_argument( '-p', "--popsize", default=(size - 1), type=int, help='population size (default: equals to node count-1 [%d])' % (size - 1)) parser.add_argument('-e', "--epochs", default=1, type=int, help='epochs count (default: 1)') parser.add_argument("-i", "--input", required=True, help='input bitmap') args = parser.parse_args() per_node = int(np.rint(args.popsize / (size - 1))) pop_size = per_node * (size - 1) global sample, reduced_sample im = Image.open(args.input) sample = np.array(im)[:, :, :3] sample = rgb2gray(sample) / 255.0 reduced_sample = block_reduce(sample, kernel_size, func=np.mean) smpl = reduced_sample * 255 img = smpl.astype(np.uint8) Image.fromarray(img).save("sample.png") evo = Evolver(args.epochs, pop_size, 0.5, 0.15, generator, fitness, breeder, mutator, process_alpha) rank = comm.Get_rank() if rank == 0: if pop_size != args.popsize: print( "Population size adjusted to %d [%d per node x %d nodes + master]" % (pop_size, per_node, size - 1)) evo.master() else: evo.slave()
def test_breed_population_gives_the_breed_of_each_entity(): Entity = EntityBreadingWithOffspringSuffix new_population = Evolver.breed([Entity("one"), Entity("other")]) assert "oneoffspring" in new_population assert "otheroffspring" in new_population assert len(new_population) == 2
import pygame from arm import Arm from conf import generations, population_size, screen_size from evolver import Evolver from painter import Painter from pie import Pie from rod import Rod from testlab import TestLab, TestLabParams from vec import Vec pygame.init() testlab_params = TestLabParams(anchor=Vec(50, screen_size / 2), target=Vec(screen_size - 40, screen_size / 2), world_bounds=Vec(screen_size, screen_size)) evolver = Evolver(generations, population_size, testlab_params) testlab = TestLab( testlab_params, evolver.evolve(), Pie(), ) painter = Painter(pygame.display.set_mode((screen_size, screen_size))) clock = pygame.time.Clock() running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False testlab.update()
def test_evolve_empty_population_gives_empty_one(): assert Evolver.evolve([]) == []
def test_select_high_fitness_entities_gives_the_first_half_of_the_population(): Entity = Mock first_half = [Entity(), Entity(), Entity()] second_half = [Entity(), Entity(), Entity()] assert first_half != second_half assert Evolver.select_high_fitness_entities(first_half + second_half) == first_half
os.unlink(file_name) plt.savefig(file_name) if __name__ == '__main__': pool_size = 128 iterations = 1280 new_brain_percent = .1 brains = [] iter = 0 stats_per_iteration = [] evolver = Evolver() while len(brains) < pool_size: brains.append(Brain()) for loop in range(iterations): plot(stats_per_iteration) iter += 1 mutants = [] while (len(brains) + len(mutants)) < pool_size: if random() < new_brain_percent: mutants.append(Brain()) else: parent_brain = sample(brains, 1)[0] mutant = parent_brain.getNewMutant(mutation_chance=.2, max_mutation=.5)
def run_repo_model(): """ This function instantiates a model and can be used to gather results Argument 1 (int): Amount of iterations to run model Argument 2 (bool): Whether to generate the java files created during the simulation Argument 3 (int): Amount of simulations of the model to run """ iterations = int(sys.argv[1]) if len(sys.argv) > 1 else DEFAULT_ITERATIONS simulations = int( sys.argv[3]) if len(sys.argv) > 1 else DEFAULT_SIMULATIONS PROBABILITIES['create_class'] = float( sys.argv[4]) if len(sys.argv) > 4 else PROBABILITIES['create_class'] PROBABILITIES['create_method'] = float( sys.argv[5]) if len(sys.argv) > 5 else PROBABILITIES['create_method'] PROBABILITIES['call_method'] = float( sys.argv[6]) if len(sys.argv) > 6 else PROBABILITIES['call_method'] PROBABILITIES['update_method'] = float( sys.argv[7]) if len(sys.argv) > 7 else PROBABILITIES['update_method'] PROBABILITIES['delete_method'] = float( sys.argv[8]) if len(sys.argv) > 8 else PROBABILITIES['delete_method'] print(sys.argv) print(PROBABILITIES) assert (EXP_CONDITION in ['reproduce', 'no_rec', 'delete_state', 'MSR']) print( 'Going to run {} simulations, with condition: {}, fitness method: {} and number of steps: {}' .format(simulations, EXP_CONDITION, FITNESS_METHOD, iterations)) # Set add/delete probability if EXP_CONDITION == 'delete_state': add_prob = ADD_STATE else: add_prob = 1 print('Statements are added with prob: {} and deleted with: {}'.format( add_prob, 1 - add_prob)) # Create the output file filename = create_outputfile(iterations, add_prob) if LOGGING: os.makedirs('./vid', exist_ok=True) for sim in range(simulations): print('Simulation {} of {}'.format(sim + 1, simulations)) model = Evolver(iterations, FITNESS_METHOD, PROBABILITIES, EXP_CONDITION, add_prob, LOGGING) # model = Evolver() print('Model instantiated...\n') print('Running model...') start_time = time.time() model.run_model() print('Model run completed..!\nTook {} seconds.\n'.format(time.time() - start_time)) gen = True if len(sys.argv) > 2 and sys.argv[2] == 'True' else False gather_results(model, gen) filename = append_outputfile_try(model, sim, filename, iterations, add_prob)
def test_evolve_gives_population_with_greater_fitness_sorted_by_fitness(): Entity = EntityBreadingOffspringWithDoubleFitness assert Evolver.evolve([Entity(-1), Entity(-3), Entity(3)]) == [Entity(6), Entity(3), Entity(-1)]